@maz-ui/node 4.1.7 → 4.2.1-alpha.9

package/README.md

@@ -11,11 +11,13 @@ npm install @maz-ui/node
 ## Features
 
 - 🚀 **Promise-based command execution** with detailed logging
-- 🎨 **Colored console logging** with multiple log levels
+- 🎨 **Elegant console logging** powered by [consola](https://github.com/unjs/consola)
+- 📊 **Configurable log levels** (0-5) with fancy formatting
 - ⚡ **TypeScript support** with full type safety
 - 📦 **Lightweight** - minimal dependencies
-- 🔧 **Configurable** - customizable logging behavior
+- 🔧 **Highly configurable** - custom loggers with different levels and reporters
 - 🛡️ **Error handling** - comprehensive error management
+- 🎯 **Multiple log types** - info, debug, trace, start, ready, fail, box
 
 ## Usage
 
@@ -59,97 +61,226 @@ interface ExecOptions {
 
 ### Logger
 
-Colored console logging with multiple levels and error handling.
+Elegant console logging powered by [consola](https://github.com/unjs/consola) with configurable log levels and fancy formatting.
 
 ```typescript
 import { logger } from '@maz-ui/node'
 
 // Basic logging
 logger.log('Regular message')
+logger.info('Information message')
 logger.success('Operation completed successfully!')
 logger.warn('Warning message')
 logger.error('Error occurred', errorObject)
 
+// Development logging (requires level >= 4)
+logger.debug('Debug information')
+logger.trace('Detailed trace information')
+
+// Status logging
+logger.ready('System is ready!')
+logger.fail('Operation failed')
+logger.fatal('Fatal error occurred')
+
 // Special formatters
 logger.brand('🎨 Maz-UI Brand Message') // Blue bright
-logger.divider() // Prints separator line
+logger.box('Important Message in a Box')
+logger.divider() // Prints separator line (adapts to terminal width)
 logger.eot() // End of transmission (empty line)
-
-// With error objects
-try {
-  throw new Error('Something went wrong')
-}
-catch (error) {
-  logger.error('Operation failed:', error)
-}
+logger.clear() // Clear console
+logger.silent('This message is always silent')
+logger.verbose('Verbose information')
+
+// Dynamic log level control using semantic names
+logger.setLevel('debug') // Enable debug logs
+logger.setLevel('silent') // Disable all logs
+logger.setLevel('verbose') // Enable all logs with maximum verbosity
+logger.setLevel('default') // Back to default (level 3)
 ```
 
 #### Logger Methods
 
-- **`log(...message)`** - Standard console log
-- **`success(...message)`** - Green colored success messages
-- **`warn(message, error?)`** - Yellow colored warnings
-- **`error(message, error?)`** - Red colored error messages
+All methods accept `InputLogObject | any` and additional arguments for flexibility.
+
+##### Core Logging Methods
+
+- **`log(...args)`** - Standard console log (level 2)
+- **`info(...args)`** - Information messages (level 3)
+- **`success(...args)`** - Success messages with green styling (level 3)
+- **`warn(...args)`** - Warning messages with yellow styling (level 1)
+- **`error(...args)`** - Error messages with red styling (level 0)
+- **`debug(...args)`** - Debug messages (level 4)
+- **`trace(...args)`** - Trace messages for detailed debugging (level 5)
+- **`verbose(...args)`** - Verbose messages (highest level)
+- **`fatal(...args)`** - Fatal error messages (level 0)
+- **`silent(...args)`** - Silent messages (never shown)
+
+##### Status Methods
+
+- **`ready(...args)`** - Ready/completion indicator (level 3)
+- **`fail(...args)`** - Failure messages (level 0)
+
+##### Formatting Methods
+
+- **`box(...args)`** - Display message in a fancy box
 - **`brand(message)`** - Blue bright branded messages
-- **`divider()`** - Prints a separator line
+- **`divider()`** - Prints a separator line that adapts to terminal width
 - **`eot()`** - Prints an empty line (end of transmission)
+- **`clear()`** - Clear the console
+
+##### Configuration Methods
+
+- **`setLevel(level)`** - Change log level dynamically using semantic names:
+  - `'silent'` - No logs (-∞)
+  - `'error'` - Fatal and Error only (0)
+  - `'warning'` - Warnings and above (1)
+  - `'normal'` - Normal logs and above (2)
+  - `'default'` - Informational logs (3)
+  - `'debug'` - Debug logs and above (4)
+  - `'trace'` - All logs including trace (5)
+  - `'verbose'` - Maximum verbosity (+∞)
+
+#### Log Levels
+
+The logger supports semantic log levels for better readability. Default is `'default'` (level 3).
+
+| Level       | Value | Description                  |
+| ----------- | ----- | ---------------------------- |
+| `'silent'`  | -∞    | No logs displayed            |
+| `'error'`   | 0     | Fatal and Error only         |
+| `'warning'` | 1     | Warnings and above           |
+| `'normal'`  | 2     | Normal logs and above        |
+| `'default'` | 3     | Informational logs (default) |
+| `'debug'`   | 4     | Debug logs and above         |
+| `'trace'`   | 5     | All logs including trace     |
+| `'verbose'` | +∞    | Maximum verbosity            |
+
+```typescript
+import { logger } from '@maz-ui/node'
+
+// Change level at runtime
+logger.setLevel('debug')
+logger.debug('Debug info') // Now visible
+
+logger.setLevel('error') // Only errors
+logger.log('Regular log') // Won't be displayed
+
+logger.setLevel('silent') // Disable all logs
+logger.error('Error message') // Won't be displayed
+
+logger.setLevel('verbose') // Maximum verbosity
+logger.trace('Trace message') // Will be displayed
+```
+
+#### Custom Logger Instances
+
+Create custom logger instances with different configurations:
+
+```typescript
+import { createLogger } from '@maz-ui/node'
+
+// Create a debug logger
+const debugLogger = createLogger({
+  level: 4, // or use the numeric level directly
+  tag: 'debug'
+})
+
+debugLogger.debug('Debug information')
+debugLogger.trace('Detailed trace')
+
+// Create a minimal logger for CI environments
+const ciLogger = createLogger({
+  level: 2 // normal level
+})
+
+// Create a silent logger
+const silentLogger = createLogger({
+  level: Number.NEGATIVE_INFINITY
+})
+
+// Create a verbose logger for development
+const devLogger = createLogger({
+  level: Number.POSITIVE_INFINITY
+})
+
+// Then use setLevel with semantic names
+debugLogger.setLevel('verbose')
+ciLogger.setLevel('error')
+```
 
 ## Advanced Examples
 
 ### Custom Logger Integration
 
 ```typescript
-import type { Logger } from '@maz-ui/node'
-import { execPromise, logger } from '@maz-ui/node'
+import { createLogger, execPromise } from '@maz-ui/node'
 
-// Create custom logger with additional functionality
-const customLogger: Logger = {
-  ...logger,
-  log: (...args) => {
-    // eslint-disable-next-line no-console
-    console.log('[CUSTOM]', ...args)
-  }
-}
+// Create custom logger for specific use case
+const buildLogger = createLogger({
+  level: 3, // default level
+  tag: 'build'
+})
 
 // Use with execPromise
 await execPromise('npm test', {
-  logger: customLogger,
+  logger: buildLogger,
   packageName: 'test-suite'
 })
+
+// Create a logger for different environments
+const isCI = process.env.CI === 'true'
+const envLogger = createLogger({
+  level: isCI ? 2 : 4 // normal in CI, debug in dev
+})
 ```
 
 ### Build Script Example
 
 ```typescript
-import { execPromise, logger } from '@maz-ui/node'
+import { createLogger, execPromise } from '@maz-ui/node'
 
 async function buildProject() {
-  logger.brand('🚀 Starting build process...')
+  const logger = createLogger({
+    level: 3, // default level
+    tag: 'build'
+  })
+
+  logger.box('🚀 Starting build process')
   logger.divider()
 
   try {
     // Install dependencies
+    logger.info('Installing dependencies...')
     await execPromise('npm install', {
       packageName: 'setup',
-      noStdout: true
+      noStdout: true,
+      logger
     })
+    logger.ready('Dependencies installed')
 
     // Run tests
+    logger.info('Running tests...')
     await execPromise('npm test', {
       packageName: 'test',
-      noStdout: true
+      noStdout: true,
+      logger
     })
+    logger.ready('Tests passed')
 
     // Build project
+    logger.info('Building project...')
     await execPromise('npm run build', {
-      packageName: 'build'
+      packageName: 'build',
+      logger
     })
+    logger.ready('Build completed')
 
     logger.eot()
     logger.success('✅ Build completed successfully!')
   }
   catch (error) {
-    logger.error('❌ Build failed:', error)
+    logger.fail('❌ Build failed')
+    logger.error(error)
     process.exit(1)
   }
 }
@@ -160,9 +291,13 @@ buildProject()
 ### CI/CD Integration
 
 ```typescript
-import { execPromise, logger } from '@maz-ui/node'
+import { createLogger, execPromise } from '@maz-ui/node'
 
 async function ciPipeline() {
+  const logger = createLogger({
+    level: 2 // normal level for CI
+  })
+
   const steps = [
     { name: 'Lint', command: 'npm run lint' },
     { name: 'Test', command: 'npm test' },
@@ -170,20 +305,23 @@ async function ciPipeline() {
     { name: 'Package', command: 'npm pack' }
   ]
 
-  logger.brand('🔄 CI Pipeline Started')
+  logger.box('🔄 CI Pipeline Started')
   logger.divider()
 
   for (const step of steps) {
-    logger.log(`⏳ Running ${step.name}...`)
+    logger.info(`Running ${step.name}...`)
 
     try {
       await execPromise(step.command, {
         packageName: step.name.toLowerCase(),
-        noStdout: true
+        noStdout: true,
+        logger
       })
+      logger.ready(`${step.name} completed`)
     }
     catch (error) {
-      logger.error(`❌ ${step.name} failed:`, error)
+      logger.fail(`${step.name} failed`)
+      logger.error(error)
       process.exit(1)
     }
   }
@@ -191,6 +329,8 @@ async function ciPipeline() {
   logger.eot()
   logger.success('🎉 All pipeline steps completed!')
 }
+
+ciPipeline()
 ```
 
 ## API Reference
@@ -222,7 +362,7 @@ All logger methods automatically handle error objects using `getErrorMessage` ut
 
 ## Dependencies
 
-- **colorette** - Terminal colors
+- **consola** - Elegant console logging with fancy formatting
 - **@maz-ui/utils** - Error message formatting
 - **Node.js built-ins** - child_process for command execution
 

package/dist/index.d.mts

@@ -1,15 +1,46 @@
-declare const logger: {
+import { ConsolaOptions, InputLogObject, ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaOptions } from 'consola';
+
+declare const LogLevelMap: {
+    silent: number;
+    error: number;
+    warning: number;
+    normal: number;
+    default: number;
+    debug: number;
+    trace: number;
+    verbose: number;
+};
+declare function createLogger(options?: LoggerOptions): {
+    start: (message: InputLogObject | any, ...args: any[]) => void;
+    log: (message: InputLogObject | any, ...args: any[]) => void;
+    warn: (message: InputLogObject | any, ...args: any[]) => void;
+    error: (message: InputLogObject | any, ...args: any[]) => void;
+    box: (message: InputLogObject | any, ...args: any[]) => void;
+    fail: (message: InputLogObject | any, ...args: any[]) => void;
+    success: (message: InputLogObject | any, ...args: any[]) => void;
+    info: (message: InputLogObject | any, ...args: any[]) => void;
+    debug: (message: InputLogObject | any, ...args: any[]) => void;
+    trace: (message: InputLogObject | any, ...args: any[]) => void;
+    verbose: (message: InputLogObject | any, ...args: any[]) => void;
+    fatal: (message: InputLogObject | any, ...args: any[]) => void;
+    ready: (message: InputLogObject | any, ...args: any[]) => void;
+    silent: (message: InputLogObject | any, ...args: any[]) => void;
     divider: () => void;
     eot: () => void;
     brand: (message: string) => void;
-    log: (...message: unknown[]) => void;
-    success: (...message: string[]) => void;
-    error: (message: string, error?: unknown) => void;
-    warn: (message: string, error?: unknown) => void;
+    clear: () => void;
+    addReporter: (reporter: ConsolaReporter) => ConsolaInstance;
+    removeReporter: (reporter: ConsolaReporter) => ConsolaInstance | ConsolaReporter[];
+    setLevel: (level: LogLevel) => void;
 };
-type Logger = typeof logger;
+declare const logger: Logger;
+
+type LoggerOptions = Partial<ConsolaOptions>;
+type LogLevel = keyof typeof LogLevelMap;
+type Logger = ReturnType<typeof createLogger>;
 
-declare function execPromise(command: string, { logger, packageName, noSuccess, noStdout, noStderr }?: {
+declare function execPromise(command: string, { logger, packageName, noSuccess, noStdout, noStderr, }?: {
     logger?: Logger;
     packageName?: string;
     noSuccess?: boolean;
@@ -20,5 +51,5 @@ declare function execPromise(command: string, { logger, packageName, noSuccess,
     stderr: string;
 }>;
 
-export { execPromise, logger };
-export type { Logger };
+export { createLogger, execPromise, logger };
+export type { LogLevel, Logger, LoggerOptions };

package/dist/index.d.ts

@@ -1,15 +1,46 @@
-declare const logger: {
+import { ConsolaOptions, InputLogObject, ConsolaReporter, ConsolaInstance } from 'consola';
+export { ConsolaOptions } from 'consola';
+
+declare const LogLevelMap: {
+    silent: number;
+    error: number;
+    warning: number;
+    normal: number;
+    default: number;
+    debug: number;
+    trace: number;
+    verbose: number;
+};
+declare function createLogger(options?: LoggerOptions): {
+    start: (message: InputLogObject | any, ...args: any[]) => void;
+    log: (message: InputLogObject | any, ...args: any[]) => void;
+    warn: (message: InputLogObject | any, ...args: any[]) => void;
+    error: (message: InputLogObject | any, ...args: any[]) => void;
+    box: (message: InputLogObject | any, ...args: any[]) => void;
+    fail: (message: InputLogObject | any, ...args: any[]) => void;
+    success: (message: InputLogObject | any, ...args: any[]) => void;
+    info: (message: InputLogObject | any, ...args: any[]) => void;
+    debug: (message: InputLogObject | any, ...args: any[]) => void;
+    trace: (message: InputLogObject | any, ...args: any[]) => void;
+    verbose: (message: InputLogObject | any, ...args: any[]) => void;
+    fatal: (message: InputLogObject | any, ...args: any[]) => void;
+    ready: (message: InputLogObject | any, ...args: any[]) => void;
+    silent: (message: InputLogObject | any, ...args: any[]) => void;
     divider: () => void;
     eot: () => void;
     brand: (message: string) => void;
-    log: (...message: unknown[]) => void;
-    success: (...message: string[]) => void;
-    error: (message: string, error?: unknown) => void;
-    warn: (message: string, error?: unknown) => void;
+    clear: () => void;
+    addReporter: (reporter: ConsolaReporter) => ConsolaInstance;
+    removeReporter: (reporter: ConsolaReporter) => ConsolaInstance | ConsolaReporter[];
+    setLevel: (level: LogLevel) => void;
 };
-type Logger = typeof logger;
+declare const logger: Logger;
+
+type LoggerOptions = Partial<ConsolaOptions>;
+type LogLevel = keyof typeof LogLevelMap;
+type Logger = ReturnType<typeof createLogger>;
 
-declare function execPromise(command: string, { logger, packageName, noSuccess, noStdout, noStderr }?: {
+declare function execPromise(command: string, { logger, packageName, noSuccess, noStdout, noStderr, }?: {
     logger?: Logger;
     packageName?: string;
     noSuccess?: boolean;
@@ -20,5 +51,5 @@ declare function execPromise(command: string, { logger, packageName, noSuccess,
     stderr: string;
 }>;
 
-export { execPromise, logger };
-export type { Logger };
+export { createLogger, execPromise, logger };
+export type { LogLevel, Logger, LoggerOptions };

package/dist/index.mjs

@@ -1,25 +1,58 @@
 import { exec } from 'node:child_process';
-import { getErrorMessage } from '@maz-ui/utils/helpers/getErrorMessage';
-import { yellow, red, green, blueBright } from 'colorette';
+import process from 'node:process';
+import { blueBright } from 'colorette';
+import { createConsola } from 'consola';
 
-const log = console.log;
-const logger = {
-  divider: () => log("----------------------------------------"),
-  eot: () => log(),
-  brand: (message) => log(blueBright(message)),
-  log: (...message) => log(...message),
-  success: (...message) => log(...message.map((m) => green(m))),
-  error: (message, error) => {
-    const errorMessage = error ? getErrorMessage(error) : "";
-    log(red(message), errorMessage ? red(errorMessage) : "");
-  },
-  warn: (message, error) => {
-    const errorMessage = error ? getErrorMessage(error) : "";
-    log(yellow(message), errorMessage ? yellow(errorMessage) : "");
-  }
+const LogLevelMap = {
+  silent: Number.NEGATIVE_INFINITY,
+  error: 0,
+  warning: 1,
+  normal: 2,
+  default: 3,
+  debug: 4,
+  trace: 5,
+  verbose: Number.POSITIVE_INFINITY
 };
+function createLogger(options) {
+  const consola = createConsola({
+    ...options,
+    level: options?.level ?? LogLevelMap.default
+  });
+  return {
+    start: (message, ...args) => consola.start(message, ...args),
+    log: (message, ...args) => consola.log(message, ...args),
+    warn: (message, ...args) => consola.warn(message, ...args),
+    error: (message, ...args) => consola.error(message, ...args),
+    box: (message, ...args) => consola.box(message, ...args),
+    fail: (message, ...args) => consola.fail(message, ...args),
+    success: (message, ...args) => consola.success(message, ...args),
+    info: (message, ...args) => consola.info(message, ...args),
+    debug: (message, ...args) => consola.debug(message, ...args),
+    trace: (message, ...args) => consola.trace(message, ...args),
+    verbose: (message, ...args) => consola.verbose(message, ...args),
+    fatal: (message, ...args) => consola.fatal(message, ...args),
+    ready: (message, ...args) => consola.ready(message, ...args),
+    silent: (message, ...args) => consola.silent(message, ...args),
+    divider: () => console.log("-".repeat(process.stdout.columns ?? 20)),
+    eot: () => console.log(),
+    brand: (message) => console.log(blueBright(message)),
+    clear: () => console.clear(),
+    addReporter: (reporter) => consola.addReporter(reporter),
+    removeReporter: (reporter) => consola.removeReporter(reporter),
+    setLevel: (level) => {
+      consola.level = LogLevelMap[level];
+    }
+  };
+}
+const logger = createLogger();
 
-async function execPromise(command, { logger: logger$1, packageName, noSuccess, noStdout, noStderr } = {}) {
+async function execPromise(command, {
+  logger: logger$1,
+  packageName,
+  noSuccess,
+  noStdout,
+  noStderr
+} = {}) {
   const internalLogger = logger$1 ?? logger;
   const packageNameStr = packageName ? `[${packageName}]` : "";
   return await new Promise((resolve, reject) => {
@@ -43,4 +76,4 @@ async function execPromise(command, { logger: logger$1, packageName, noSuccess,
   });
 }
 
-export { execPromise, logger };
+export { createLogger, execPromise, logger };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maz-ui/node",
   "type": "module",
-  "version": "4.1.7",
+  "version": "4.2.1-alpha.9",
   "description": "Node utilities for Maz-UI library",
   "author": "Louis Mazel <me@loicmazuel.com>",
   "license": "MIT",
@@ -38,16 +38,9 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit --skipLibCheck",
-    "lint": "cross-env NODE_ENV=production eslint .",
-    "lint:fix": "pnpm lint --fix"
-  },
   "dependencies": {
-    "@maz-ui/utils": "4.1.7",
-    "colorette": "^2.0.20"
+    "colorette": "^2.0.20",
+    "consola": "^3.4.2"
   },
   "devDependencies": {
     "unbuild": "^3.6.1"
@@ -57,5 +50,11 @@
       "eslint --fix"
     ]
   },
-  "gitHead": "e40beabe5a0c9bcc7ccad56258058e12e9aa5336"
-}
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "typecheck": "tsc --noEmit --skipLibCheck",
+    "lint": "cross-env NODE_ENV=production eslint .",
+    "lint:fix": "pnpm lint --fix"
+  }
+}