doc2vec 1.0.5 → 1.1.0

package/dist/logger copy.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Enhanced Logger for structured and consistent logging
+ * Compatible with CommonJS and ESM environments
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = exports.LogLevel = exports.Logger = void 0;
+/**
+ * Logger levels with their corresponding numeric values
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 100] = "NONE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Basic color functions that don't rely on external packages
+ */
+const colors = {
+    gray: (text) => `\x1b[90m${text}\x1b[0m`,
+    blue: (text) => `\x1b[34m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    red: (text) => `\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    reset: (text) => `\x1b[0m${text}\x1b[0m`
+};
+/**
+ * Enhanced Logger class with color-coding, timestamp, and formatting
+ */
+class Logger {
+    /**
+     * Create a new Logger instance
+     *
+     * @param moduleName Name of the module using this logger
+     * @param config Logger configuration options
+     */
+    constructor(moduleName, config) {
+        this.moduleName = moduleName;
+        this.config = {
+            level: LogLevel.INFO,
+            useTimestamp: true,
+            useColor: true,
+            prettyPrint: true,
+            ...config
+        };
+    }
+    /**
+     * Format a log message with timestamp, level, and module information
+     *
+     * @param level Log level for this message
+     * @param message The message to log
+     * @param args Additional arguments to include
+     * @returns Formatted log message
+     */
+    formatMessage(level, message, args = []) {
+        const timestamp = this.config.useTimestamp ?
+            `[${new Date().toISOString()}] ` : '';
+        const modulePrefix = this.moduleName ?
+            `[${this.moduleName}] ` : '';
+        const levelFormatted = `[${level.padEnd(5)}]`;
+        let formattedMessage = `${timestamp}${levelFormatted} ${modulePrefix}${message}`;
+        if (args.length > 0) {
+            const argsString = args.map(arg => {
+                if (arg instanceof Error) {
+                    return `\n--- Error Details ---\nMessage: ${arg.message}\nStack:\n${arg.stack}\n--- End Error ---`;
+                }
+                else if (this.config.prettyPrint && typeof arg === 'object' && arg !== null) {
+                    try {
+                        return JSON.stringify(arg, null, 2);
+                    }
+                    catch (e) {
+                        return "[Unserializable Object]";
+                    }
+                }
+                else {
+                    return String(arg);
+                }
+            }).join('\n');
+            if (this.config.prettyPrint) {
+                formattedMessage += `\n${argsString}`;
+            }
+            else {
+                formattedMessage += ` ${args.map(String).join(' ')}`;
+            }
+        }
+        return formattedMessage;
+    }
+    /**
+     * Apply color to a message based on log level
+     *
+     * @param level Log level
+     * @param message Message to color
+     * @returns Colored message
+     */
+    colorize(level, message) {
+        if (!this.config.useColor)
+            return message;
+        switch (level) {
+            case LogLevel.DEBUG:
+                return colors.gray(message);
+            case LogLevel.INFO:
+                return colors.blue(message);
+            case LogLevel.WARN:
+                return colors.yellow(message);
+            case LogLevel.ERROR:
+                return colors.red(message);
+            default:
+                return message;
+        }
+    }
+    /**
+     * Log a debug message
+     *
+     * @param message Message to log
+     * @param args Additional arguments
+     */
+    debug(message, ...args) {
+        if (this.config.level <= LogLevel.DEBUG) {
+            const formattedMessage = this.formatMessage('DEBUG', message, args);
+            console.log(this.colorize(LogLevel.DEBUG, formattedMessage));
+        }
+    }
+    /**
+     * Log an info message
+     *
+     * @param message Message to log
+     * @param args Additional arguments
+     */
+    info(message, ...args) {
+        if (this.config.level <= LogLevel.INFO) {
+            const formattedMessage = this.formatMessage('INFO', message, args);
+            console.log(this.colorize(LogLevel.INFO, formattedMessage));
+        }
+    }
+    /**
+     * Log a warning message
+     *
+     * @param message Message to log
+     * @param args Additional arguments
+     */
+    warn(message, ...args) {
+        if (this.config.level <= LogLevel.WARN) {
+            const formattedMessage = this.formatMessage('WARN', message, args);
+            console.warn(this.colorize(LogLevel.WARN, formattedMessage));
+        }
+    }
+    /**
+     * Log an error message
+     *
+     * @param message Message to log
+     * @param args Additional arguments
+     */
+    error(message, ...args) {
+        if (this.config.level <= LogLevel.ERROR) {
+            const formattedMessage = this.formatMessage('ERROR', message, args);
+            console.error(this.colorize(LogLevel.ERROR, formattedMessage));
+        }
+    }
+    /**
+     * Create a child logger with a more specific module name
+     *
+     * @param subModule Name of the sub-module
+     * @returns New logger instance
+     */
+    child(subModule) {
+        return new Logger(`${this.moduleName}:${subModule}`, this.config);
+    }
+    /**
+     * Format a section header to clearly separate logical parts of execution
+     *
+     * @param title Section title
+     * @returns Logger instance for chaining
+     */
+    section(title) {
+        if (this.config.level <= LogLevel.INFO) {
+            const separator = '='.repeat(Math.max(80 - title.length - 4, 10));
+            const message = `${separator} ${title} ${separator}`;
+            console.log(this.colorize(LogLevel.INFO, message));
+        }
+        return this;
+    }
+    /**
+     * Create a progress indicator
+     *
+     * @param title Title of the operation
+     * @param total Total number of items to process
+     * @returns Object with update and complete methods
+     */
+    progress(title, total) {
+        let current = 0;
+        const startTime = Date.now();
+        const update = (increment = 1, message) => {
+            if (this.config.level > LogLevel.INFO)
+                return;
+            current += increment;
+            const percentage = Math.min(Math.floor((current / total) * 100), 100);
+            const elapsed = (Date.now() - startTime) / 1000;
+            let rate = current / elapsed;
+            let timeRemaining = '';
+            if (rate > 0 && current < total) {
+                const remainingSecs = (total - current) / rate;
+                timeRemaining = `, ETA: ${Math.floor(remainingSecs / 60)}m ${Math.floor(remainingSecs % 60)}s`;
+            }
+            const progressBar = this.createProgressBar(percentage);
+            const statusMsg = message ? ` - ${message}` : '';
+            console.log(this.colorize(LogLevel.INFO, this.formatMessage('INFO', `${title}: ${progressBar} ${percentage}% (${current}/${total}${timeRemaining})${statusMsg}`)));
+        };
+        const complete = (message = 'Completed') => {
+            if (this.config.level > LogLevel.INFO)
+                return;
+            const elapsed = (Date.now() - startTime) / 1000;
+            const rate = total / elapsed;
+            console.log(this.colorize(LogLevel.INFO, this.formatMessage('INFO', `${title}: ${this.createProgressBar(100)} 100% (${total}/${total}) - ${message} in ${elapsed.toFixed(2)}s (${rate.toFixed(2)} items/sec)`)));
+        };
+        return { update, complete };
+    }
+    /**
+     * Create a visual progress bar
+     *
+     * @param percentage Completion percentage
+     * @returns Visual progress bar
+     */
+    createProgressBar(percentage) {
+        const width = 20;
+        const completeChars = Math.floor((percentage / 100) * width);
+        const incompleteChars = width - completeChars;
+        let bar = '[';
+        if (this.config.useColor) {
+            bar += colors.green('='.repeat(completeChars));
+            bar += ' '.repeat(incompleteChars);
+        }
+        else {
+            bar += '='.repeat(completeChars);
+            bar += ' '.repeat(incompleteChars);
+        }
+        bar += ']';
+        return bar;
+    }
+}
+exports.Logger = Logger;
+// Create a default logger instance
+const defaultLogger = new Logger('app');
+exports.defaultLogger = defaultLogger;

package/dist/logger.js

@@ -61,13 +61,29 @@ class Logger {
         const modulePrefix = this.moduleName ?
             `[${this.moduleName}] ` : '';
         const levelFormatted = `[${level.padEnd(5)}]`;
-        const formattedMessage = `${timestamp}${levelFormatted} ${modulePrefix}${message}`;
+        let formattedMessage = `${timestamp}${levelFormatted} ${modulePrefix}${message}`;
         if (args.length > 0) {
+            const argsString = args.map(arg => {
+                if (arg instanceof Error) {
+                    return `\n--- Error Details ---\nMessage: ${arg.message}\nStack:\n${arg.stack}\n--- End Error ---`;
+                }
+                else if (this.config.prettyPrint && typeof arg === 'object' && arg !== null) {
+                    try {
+                        return JSON.stringify(arg, null, 2);
+                    }
+                    catch (e) {
+                        return "[Unserializable Object]";
+                    }
+                }
+                else {
+                    return String(arg);
+                }
+            }).join('\n');
             if (this.config.prettyPrint) {
-                return `${formattedMessage}\n${args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg).join('\n')}`;
+                formattedMessage += `\n${argsString}`;
             }
             else {
-                return `${formattedMessage} ${args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : arg).join(' ')}`;
+                formattedMessage += ` ${args.map(String).join(' ')}`;
             }
         }
         return formattedMessage;

package/doc2vec.ts

@@ -1469,10 +1469,9 @@ class Doc2Vec {
     
         let browser: Browser | null = null;
         try {
-             browser = await puppeteer.launch({
+            browser = await puppeteer.launch({
                 args: ['--no-sandbox', '--disable-setuid-sandbox'],
             });
-
             const page: Page = await browser.newPage();
             logger.debug(`Navigating to ${url}`);
             await page.goto(url, { waitUntil: 'networkidle2', timeout: 60000 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "doc2vec",
-    "version": "1.0.5",
+    "version": "1.1.0",
     "type": "commonjs",
     "description": "",
     "main": "doc2vec.ts",