@seontechnologies/playwright-utils 3.10.0

package/dist/esm/log/outputs/log-to-file.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logToFile = logToFile;
+const fs = __importStar(require("node:fs"));
+const context_1 = require("./context");
+const add_test_header_1 = require("./add-test-header");
+const create_log_file_path_1 = require("./create-log-file-path");
+const config_1 = require("../config");
+const format_message_1 = require("../formatters/format-message");
+const node_path_1 = __importDefault(require("node:path"));
+// Tracks which files have been written to in the current test run
+const writtenFiles = new Set();
+/** Tracks which files have been written to in the current test run
+ * Returns true if this is the first write to this file in the current run */
+const trackFirstWrite = (filePath) => {
+    if (writtenFiles.has(filePath))
+        return false;
+    writtenFiles.add(filePath);
+    return true;
+};
+/** Strip ANSI color codes from a string, for better readability in a text file */
+const stripAnsiCodes = (str) => {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\u001b\[\d{1,2}m/g, '');
+};
+/** Appends a newline to the file if the message doesn't already start with one */
+const appendNewlineIfNeeded = async (filePath, message) => {
+    if (message && !message.startsWith('\n')) {
+        try {
+            await fs.promises.appendFile(filePath, '\n');
+            return true;
+        }
+        catch (error) {
+            console.error(`Error writing newline to log file: ${filePath}`, error);
+            return false;
+        }
+    }
+    return true;
+};
+/** Create a header for a new log file */
+const writeLogFileHeader = async (filePath, header) => {
+    try {
+        // Check if this is the first write to the file
+        if (trackFirstWrite(filePath)) {
+            // Create directory if it doesn't exist
+            const dir = node_path_1.default.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Write header to the file
+            await fs.promises.writeFile(filePath, header);
+        }
+    }
+    catch (error) {
+        console.error(`Error writing log header: ${error}`);
+    }
+};
+/** Writes the header if this is the first write to the file */
+const writeHeaderIfNecessary = async (filePath, context, cleanMessage) => {
+    if (trackFirstWrite(filePath)) {
+        try {
+            // Create header content
+            const header = [
+                '='.repeat(80),
+                `Test Log: ${context.testName || 'Consolidated Test Log'}`,
+                `Test File: ${context.testFile || 'Multiple Files'}`,
+                `Started: ${new Date().toISOString()}`,
+                '='.repeat(80),
+                ''
+            ].join('\n');
+            await writeLogFileHeader(filePath, header);
+            // Append a newline after the header if needed
+            return await appendNewlineIfNeeded(filePath, cleanMessage);
+        }
+        catch (error) {
+            console.error(`Error writing header to log file: ${filePath}`, error);
+            return false;
+        }
+    }
+    return true;
+};
+/** Appends the fully formatted message to the file */
+const appendFormattedMessage = async (filePath, formattedMessage) => {
+    try {
+        await fs.promises.appendFile(filePath, formattedMessage + '\n');
+        return true;
+    }
+    catch (error) {
+        console.error(`Error writing to log file: ${filePath}`, error);
+        return false;
+    }
+};
+/**
+ * Writes a message to a log file.
+ * This function decomposes the process into small steps:
+ * 1. Clean the message.
+ * 2. Write the header if necessary.
+ * 3. Format the message.
+ * 4. Append the formatted message to the file.
+ *
+ * @param filePath - The path to the log file.
+ * @param message - The raw log message.
+ * @param context - The logging context.
+ * @returns A promise that resolves to true if the operation was successful.
+ */
+const writeToLogFile = async (filePath, message, context) => {
+    // Step 1: Clean the message.
+    const cleanMessage = stripAnsiCodes(message);
+    // Step 2: Write header if this is the first write.
+    const headerOk = await writeHeaderIfNecessary(filePath, context, cleanMessage);
+    if (!headerOk)
+        return false;
+    // Step 3: Format the message. (formatLogMessage is assumed pure)
+    const formattedMessage = (0, format_message_1.formatLogMessage)(cleanMessage, context);
+    // Step 4: Append the formatted message.
+    return await appendFormattedMessage(filePath, formattedMessage);
+};
+/**
+ * Logs a message to the file system, handling both organized and consolidated logging modes.
+ *
+ * This function manages the complete file logging process:
+ * 1. Prepares the message by stripping ANSI codes
+ * 2. Resolves test context information and adds appropriate headers
+ * 3. Determines the proper file path based on logging configuration
+ *    - For organized logs: Creates test-specific log files in dated folders
+ *    - For consolidated logs: Writes to a single shared log file
+ * 4. Formats and writes the message with proper timestamps and context
+ *
+ * The behavior is controlled by the global logging configuration and per-call options.
+ *
+ * @param message - The message content to log to the file
+ * @param _level - The log level (info, debug, etc.) - reserved for future filtering capabilities
+ * @param options - Configuration options that can override global settings:
+ *                  Can use boolean or detailed object configuration for flexibility
+ * @returns Promise<boolean> - Resolves to true if logging was successful, false otherwise
+ */
+async function logToFile(message, _level = 'info', // not being used at the moment, but for consistent api with console and future proofing
+options = {}) {
+    // Strip ANSI color codes from message
+    message = stripAnsiCodes(message);
+    // Get and populate test context information
+    const { testFile } = (0, context_1.populateTestOptions)(options);
+    // Add test headers when needed
+    const { message: updatedMessage } = (0, add_test_header_1.addTestHeader)(undefined, message, options, testFile);
+    // Skip file logging if not enabled
+    const config = (0, config_1.getLoggingConfig)();
+    // Check if fileLogging is false or if it's an object with enabled=false
+    if (config.fileLogging === false ||
+        (typeof config.fileLogging === 'object' &&
+            config.fileLogging.enabled === false)) {
+        return false;
+    }
+    // Get context with configuration and test information
+    const context = (0, context_1.getLogContext)(options);
+    // Create the log file path based on context - this determines folder structure
+    // IMPORTANT: We're intentionally using the original options here, not extracting from section headers
+    // to avoid creating folders for each section in a test
+    const filePath = (0, create_log_file_path_1.createLogFilePath)(context);
+    // Write to the log file
+    return writeToLogFile(filePath, updatedMessage, context);
+}
+//# sourceMappingURL=log-to-file.js.map

package/dist/esm/log/outputs/log-to-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-to-file.js","sourceRoot":"","sources":["../../../../src/log/outputs/log-to-file.ts"],"names":[],"mappings":"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"}

package/dist/esm/log/test-step.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Method decorator for class methods to wrap them in a test.step with logging
+ *
+ * @param stepName - Optional name for the step, defaults to method name
+ *
+ * @example
+ * // Page object with decorated methods
+ * class MyPage {
+ *   // Uses method name as step name
+ *   @methodTestStep()
+ *   async login() {
+ *     // Method implementation
+ *   }
+ *
+ *   // Custom step name
+ *   @methodTestStep("Search for products")
+ *   async search(term: string) {
+ *     // Method implementation
+ *   }
+ * }
+ *
+ */
+export declare function methodTestStep(stepName?: string): (target: any, // The original method being decorated
+context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => Promise<any>;
+/**
+ * Function decorator to wrap any function in a test.step with logging
+ *
+ * @param stepName - Name for the step
+ * @param fn - The function to wrap
+ *
+ * @example
+ * // Define a function with the decorator
+ * const searchProducts = functionTestStep("Search for products", async (term: string) => {
+ *   // Function implementation
+ * })
+ *
+ * // Call it normally
+ * const results = await searchProducts("laptop")
+ */
+export declare function functionTestStep<T extends any[], R>(stepName: string, // Unlike methodTestStep, this is required (no method name to fall back to)
+fn: (...args: T) => Promise<R> | R): (...args: T) => Promise<R>;
+//# sourceMappingURL=test-step.d.ts.map

package/dist/esm/log/test-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-step.d.ts","sourceRoot":"","sources":["../../../src/log/test-step.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,IAI5C,QAAQ,GAAG,EAAE,sCAAsC;AACnD,SAAS,2BAA2B,MAOI,MAAM,GAAG,EAAE,GAAG,MAAM,GAAG,EAAE,kBA8BpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,EACjD,QAAQ,EAAE,MAAM,EAAE,2EAA2E;AAC7F,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAoB5B"}

package/dist/esm/log/test-step.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methodTestStep = methodTestStep;
+exports.functionTestStep = functionTestStep;
+/** Test step decorator and function wrapper for logging
+ * Provides decorators that can be used to wrap methods or functions in test steps */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const test_1 = require("@playwright/test");
+const log_1 = require("./log");
+/**
+ * Method decorator for class methods to wrap them in a test.step with logging
+ *
+ * @param stepName - Optional name for the step, defaults to method name
+ *
+ * @example
+ * // Page object with decorated methods
+ * class MyPage {
+ *   // Uses method name as step name
+ *   @methodTestStep()
+ *   async login() {
+ *     // Method implementation
+ *   }
+ *
+ *   // Custom step name
+ *   @methodTestStep("Search for products")
+ *   async search(term: string) {
+ *     // Method implementation
+ *   }
+ * }
+ *
+ */
+function methodTestStep(stepName) {
+    // This is a higher-order function that returns the actual decorator function
+    // It allows us to pass in parameters (stepName) to customize our decorator
+    return function methodDecorator(target, // The original method being decorated
+    context // Gives us metadata about the method (like its name)
+    ) {
+        // Store the original method name to use as default step name if none provided
+        const methodName = context.name;
+        // This is the function that will replace the original method
+        // It wraps the original method with our logging and test.step functionality
+        return async function replacementMethod(...args) {
+            // 'this' is the class instance (e.g., TodoPage) when the method is called
+            // We need to preserve this context for the original method to work properly
+            // Use provided stepName or fall back to the method's name
+            const name = stepName || methodName;
+            // Get the class name for better logging context (e.g., 'TodoPage')
+            // This helps trace the step back to its exact source in our page objects
+            const className = this.constructor ? this.constructor.name : 'Unknown';
+            // Combine them for a descriptive step name in test reports
+            const fullStepName = `${name} (${className})`;
+            // Wrap execution in Playwright's test.step for proper test reporting
+            // This makes steps appear in Playwright's HTML reporter with timing info
+            return test_1.test.step(fullStepName, async () => {
+                try {
+                    // Call the original method with the correct 'this' context
+                    // This is crucial - without it, the original method wouldn't have
+                    // access to the class properties and methods (like this.page)
+                    const result = await target.call(this, ...args);
+                    return result;
+                }
+                catch (error) {
+                    // Enhanced error handling - we log the error before re-throwing it
+                    // This creates a clean error trace in both our logs and test reports
+                    await log_1.log.error(`Step failed: ${fullStepName} - ${error}`);
+                    throw error; // Re-throw to maintain normal test failure behavior
+                }
+            });
+        };
+    };
+}
+/**
+ * Function decorator to wrap any function in a test.step with logging
+ *
+ * @param stepName - Name for the step
+ * @param fn - The function to wrap
+ *
+ * @example
+ * // Define a function with the decorator
+ * const searchProducts = functionTestStep("Search for products", async (term: string) => {
+ *   // Function implementation
+ * })
+ *
+ * // Call it normally
+ * const results = await searchProducts("laptop")
+ */
+function functionTestStep(stepName, // Unlike methodTestStep, this is required (no method name to fall back to)
+fn // The function to wrap (instead of decorating a method)
+) {
+    // Return a new function with the same signature as the original function
+    // But enhanced with step logging and error handling
+    return async function (...args) {
+        // Unlike methodTestStep, we don't need to handle 'this' context
+        // Because we're working with standalone functions, not class methods
+        // Wrap execution in Playwright's test.step for proper test reporting
+        return test_1.test.step(stepName, async () => {
+            try {
+                // Simply call the original function with the provided arguments
+                // No need for .call() since we don't need to manage 'this'
+                return await fn(...args);
+            }
+            catch (error) {
+                // Enhanced error handling with consistent logging
+                await log_1.log.error(`Step failed: ${stepName} - ${error}`);
+                throw error; // Re-throw to maintain normal test failure behavior
+            }
+        });
+    };
+}
+//# sourceMappingURL=test-step.js.map

package/dist/esm/log/test-step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-step.js","sourceRoot":"","sources":["../../../src/log/test-step.ts"],"names":[],"mappings":";;AA4BA,wCA0CC;AAiBD,4CAuBC;AA9GD;qFACqF;AACrF,uDAAuD;AACvD,2CAAuC;AACvC,+BAA2B;AAE3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,cAAc,CAAC,QAAiB;IAC9C,6EAA6E;IAC7E,2EAA2E;IAC3E,OAAO,SAAS,eAAe,CAC7B,MAAW,EAAE,sCAAsC;IACnD,OAAoC,CAAC,qDAAqD;;QAE1F,8EAA8E;QAC9E,MAAM,UAAU,GAAG,OAAO,CAAC,IAAc,CAAA;QAEzC,6DAA6D;QAC7D,4EAA4E;QAC5E,OAAO,KAAK,UAAU,iBAAiB,CAAY,GAAG,IAAW;YAC/D,0EAA0E;YAC1E,4EAA4E;YAE5E,0DAA0D;YAC1D,MAAM,IAAI,GAAG,QAAQ,IAAI,UAAU,CAAA;YACnC,mEAAmE;YACnE,yEAAyE;YACzE,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAA;YACtE,2DAA2D;YAC3D,MAAM,YAAY,GAAG,GAAG,IAAI,KAAK,SAAS,GAAG,CAAA;YAE7C,qEAAqE;YACrE,yEAAyE;YACzE,OAAO,WAAI,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,IAAI,EAAE;gBACxC,IAAI,CAAC;oBACH,2DAA2D;oBAC3D,kEAAkE;oBAClE,8DAA8D;oBAC9D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAA;oBAC/C,OAAO,MAAM,CAAA;gBACf,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,mEAAmE;oBACnE,qEAAqE;oBACrE,MAAM,SAAG,CAAC,KAAK,CAAC,gBAAgB,YAAY,MAAM,KAAK,EAAE,CAAC,CAAA;oBAC1D,MAAM,KAAK,CAAA,CAAC,oDAAoD;gBAClE,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC,CAAA;IACH,CAAC,CAAA;AACH,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,gBAAgB,CAC9B,QAAgB,EAAE,2EAA2E;AAC7F,EAAkC,CAAC,wDAAwD;;IAE3F,yEAAyE;IACzE,oDAAoD;IACpD,OAAO,KAAK,WAAW,GAAG,IAAO;QAC/B,gEAAgE;QAChE,qEAAqE;QAErE,qEAAqE;QACrE,OAAO,WAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;YACpC,IAAI,CAAC;gBACH,gEAAgE;gBAChE,2DAA2D;gBAC3D,OAAO,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAA;YAC1B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,kDAAkD;gBAClD,MAAM,SAAG,CAAC,KAAK,CAAC,gBAAgB,QAAQ,MAAM,KAAK,EAAE,CAAC,CAAA;gBACtD,MAAM,KAAK,CAAA,CAAC,oDAAoD;YAClE,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC,CAAA;AACH,CAAC"}

package/dist/esm/log/types.d.ts

@@ -0,0 +1,81 @@
+/** Log level types for different severity of messages */
+export type LogLevel = 'info' | 'step' | 'success' | 'warning' | 'error' | 'debug';
+/** Log level hierarchy for filtering (lowest to highest priority) */
+export declare const LOG_LEVEL_PRIORITY: Record<LogLevel, number>;
+/** Options for formatting log messages */
+export type FormatOptions = {
+    timestamps: boolean;
+    colorize: boolean;
+    maxLineLength: number;
+    prefix?: string;
+    addNewLine?: boolean;
+};
+/** Global Configuration options for the logging utility
+ * Supports both simple boolean values and detailed configuration objects */
+export type LoggingConfig = {
+    console?: boolean | {
+        enabled: boolean;
+        colorize?: boolean;
+        timestamps?: boolean;
+    };
+    fileLogging?: boolean | {
+        enabled: boolean;
+        outputDir?: string;
+        defaultTestFolder?: string;
+        stripAnsiCodes?: boolean;
+        timestamp?: boolean;
+        prependTestFile?: boolean;
+        forceConsolidated?: boolean;
+    };
+    workerID?: boolean | {
+        enabled: boolean;
+        format?: string;
+    };
+    sourceFileTracking?: boolean | {
+        enabled: boolean;
+        showInLogs?: boolean;
+    };
+    format?: {
+        prefix?: string;
+        addNewLine?: boolean;
+        maxLineLength?: number;
+    };
+    context?: Record<string, unknown>;
+    testFile?: string;
+    testName?: string;
+    level?: LogLevel;
+    testStep?: boolean | string;
+};
+/** Parameters for the log fixture */
+export type LogParams = {
+    /** Log level to use (info, step, success, warning, error, debug) */
+    level?: LogLevel;
+    /** Message to log */
+    message: string;
+    /** Whether to log to console (simplified boolean option for backward compatibility) */
+    console?: boolean;
+    /** Additional options for more complex logging configuration */
+    options?: Partial<LoggingConfig>;
+    /** Test file name for file logging context */
+    testFile?: string;
+    /** Test name for file logging context */
+    testName?: string;
+};
+export type LogContext = {
+    config: LoggingConfig;
+    options: LoggingConfig;
+    testFile?: string;
+    testName?: string;
+    workerIDEnabled: boolean;
+    workerIDFormat: string;
+};
+/** Configuration for formatting messages based on log level */
+type FormatConfig = {
+    prefix: string;
+    suffix: string;
+    color: string;
+};
+/** Map of log levels to their formatting configuration */
+export type FormatConfigMap = Record<LogLevel, FormatConfig>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/log/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/log/types.ts"],"names":[],"mappings":"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"}

package/dist/esm/log/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_LEVEL_PRIORITY = void 0;
+/** Log level hierarchy for filtering (lowest to highest priority) */
+exports.LOG_LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    step: 2,
+    success: 3,
+    warning: 4,
+    error: 5
+};
+//# sourceMappingURL=types.js.map

package/dist/esm/log/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/log/types.ts"],"names":[],"mappings":";;;AASA,qEAAqE;AACxD,QAAA,kBAAkB,GAA6B;IAC1D,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;CACT,CAAA"}

package/dist/esm/log/utils/async.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Wraps a synchronous function in a Promise and resolves after I/O processing
+ * Used for asynchronous console logging
+ */
+export declare const asPromise: (fn: () => void) => Promise<void>;
+//# sourceMappingURL=async.d.ts.map

package/dist/esm/log/utils/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../../../src/log/utils/async.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,IAAI,KAAG,OAAO,CAAC,IAAI,CAMnD,CAAA"}

package/dist/esm/log/utils/async.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asPromise = void 0;
+/**
+ * Wraps a synchronous function in a Promise and resolves after I/O processing
+ * Used for asynchronous console logging
+ */
+const asPromise = (fn) => new Promise((resolve) => {
+    fn();
+    // Use setImmediate to ensure I/O processing completes
+    // before the promise resolves
+    setImmediate(() => resolve());
+});
+exports.asPromise = asPromise;
+//# sourceMappingURL=async.js.map

package/dist/esm/log/utils/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../../../src/log/utils/async.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACI,MAAM,SAAS,GAAG,CAAC,EAAc,EAAiB,EAAE,CACzD,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;IACtB,EAAE,EAAE,CAAA;IACJ,sDAAsD;IACtD,8BAA8B;IAC9B,YAAY,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAA;AAC/B,CAAC,CAAC,CAAA;AANS,QAAA,SAAS,aAMlB"}

package/dist/esm/log/utils/flag.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utility function to extract boolean flag values from various formats.
+ * Used to standardize how boolean flags are handled across the logging system.
+ *
+ * @param flag - The flag value which can be a boolean, an object with an enabled property, or undefined
+ * @param defaultValue - The default value to use if flag is undefined or doesn't have an enabled property
+ * @returns A single boolean value
+ */
+export declare function isEnabled(flag: boolean | {
+    enabled?: boolean;
+} | undefined, defaultValue?: boolean): boolean;
+//# sourceMappingURL=flag.d.ts.map

package/dist/esm/log/utils/flag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag.d.ts","sourceRoot":"","sources":["../../../../src/log/utils/flag.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,GAAG;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EACjD,YAAY,UAAO,GAClB,OAAO,CAIT"}

package/dist/esm/log/utils/flag.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnabled = isEnabled;
+/**
+ * Utility function to extract boolean flag values from various formats.
+ * Used to standardize how boolean flags are handled across the logging system.
+ *
+ * @param flag - The flag value which can be a boolean, an object with an enabled property, or undefined
+ * @param defaultValue - The default value to use if flag is undefined or doesn't have an enabled property
+ * @returns A single boolean value
+ */
+function isEnabled(flag, defaultValue = true) {
+    if (typeof flag === 'boolean')
+        return flag;
+    if (flag && typeof flag.enabled === 'boolean')
+        return flag.enabled;
+    return defaultValue;
+}
+//# sourceMappingURL=flag.js.map

package/dist/esm/log/utils/flag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag.js","sourceRoot":"","sources":["../../../../src/log/utils/flag.ts"],"names":[],"mappings":";;AAQA,8BAOC;AAfD;;;;;;;GAOG;AACH,SAAgB,SAAS,CACvB,IAAiD,EACjD,YAAY,GAAG,IAAI;IAEnB,IAAI,OAAO,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IAC1C,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC,OAAO,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC,OAAO,CAAA;IAClE,OAAO,YAAY,CAAA;AACrB,CAAC"}

package/dist/esm/log/utils/options.d.ts

@@ -0,0 +1,14 @@
+/** Options handling for the logging system */
+import type { LogLevel, LoggingConfig } from '../types';
+export declare const defaultLoggingConfig: LoggingConfig;
+/** Get level-specific formatting options */
+export declare const getLevelFormatOptions: (level: LogLevel) => Record<string, unknown>;
+/** Merge default options with per-call options and format options for the specific log level */
+export declare const mergeOptions: (options: Partial<LoggingConfig> | undefined, level: LogLevel) => LoggingConfig;
+/** Convert a unified configuration to LoggingConfig format
+ * This ensures we can still use the simple LoggingConfig interface with booleans */
+export declare const toLoggingConfig: (config: Partial<LoggingConfig>) => Partial<LoggingConfig>;
+/** Unified configuration function that handles both global and local settings
+ * Always uses global scope by default, regardless of context */
+export declare const configure: (options: Partial<LoggingConfig>, scope?: "global" | "local") => void;
+//# sourceMappingURL=options.d.ts.map

package/dist/esm/log/utils/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../src/log/utils/options.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAIvD,eAAO,MAAM,oBAAoB,EAAE,aAGlC,CAAA;AAED,4CAA4C;AAC5C,eAAO,MAAM,qBAAqB,GAChC,OAAO,QAAQ,KACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAWxB,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,YAAY,GACvB,SAAS,OAAO,CAAC,aAAa,CAAC,YAAK,EACpC,OAAO,QAAQ,KACd,aAaF,CAAA;AAED;oFACoF;AACpF,eAAO,MAAM,eAAe,GAC1B,QAAQ,OAAO,CAAC,aAAa,CAAC,KAC7B,OAAO,CAAC,aAAa,CA2BvB,CAAA;AAED;gEACgE;AAChE,eAAO,MAAM,SAAS,GACpB,SAAS,OAAO,CAAC,aAAa,CAAC,EAC/B,QAAO,QAAQ,GAAG,OAAkB,KACnC,IAeF,CAAA"}

package/dist/esm/log/utils/options.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configure = exports.toLoggingConfig = exports.mergeOptions = exports.getLevelFormatOptions = exports.defaultLoggingConfig = void 0;
+const config_1 = require("../config");
+// Default logging options that apply to all log calls
+exports.defaultLoggingConfig = {
+    console: true,
+    fileLogging: false
+};
+/** Get level-specific formatting options */
+const getLevelFormatOptions = (level) => {
+    const formatMap = {
+        info: { prefix: 'ℹ' },
+        step: { addNewLine: true },
+        success: { prefix: '✓' },
+        warning: { prefix: '⚠' },
+        error: { prefix: '✖' },
+        debug: { prefix: '🔍' }
+    };
+    return formatMap[level] || {};
+};
+exports.getLevelFormatOptions = getLevelFormatOptions;
+/** Merge default options with per-call options and format options for the specific log level */
+const mergeOptions = (options = {}, level) => {
+    // Get level-specific formatting
+    const levelFormat = (0, exports.getLevelFormatOptions)(level);
+    // Merge options with a functional approach
+    return {
+        ...exports.defaultLoggingConfig,
+        ...options,
+        format: {
+            ...levelFormat,
+            ...(options.format || {})
+        }
+    };
+};
+exports.mergeOptions = mergeOptions;
+/** Convert a unified configuration to LoggingConfig format
+ * This ensures we can still use the simple LoggingConfig interface with booleans */
+const toLoggingConfig = (config) => {
+    const result = {};
+    // Handle console setting
+    if (typeof config.console === 'boolean') {
+        result.console = config.console;
+    }
+    else if (config.console?.enabled !== undefined) {
+        result.console = config.console.enabled;
+    }
+    // Handle fileLogging setting
+    if (typeof config.fileLogging === 'boolean') {
+        result.fileLogging = config.fileLogging;
+    }
+    else if (config.fileLogging?.enabled !== undefined) {
+        result.fileLogging = config.fileLogging.enabled;
+    }
+    // Handle workerID setting - this one is actually already compatible
+    result.workerID = config.workerID;
+    // Copy over other LoggingConfig properties
+    if (config.format)
+        result.format = config.format;
+    if (config.context)
+        result.context = config.context;
+    if (config.testFile)
+        result.testFile = config.testFile;
+    if (config.testName)
+        result.testName = config.testName;
+    return result;
+};
+exports.toLoggingConfig = toLoggingConfig;
+/** Unified configuration function that handles both global and local settings
+ * Always uses global scope by default, regardless of context */
+const configure = (options, scope = 'global') => {
+    // Always use global scope by default, can be overridden with explicit 'local'
+    const effectiveScope = scope;
+    // Convert unified config to LoggingConfig for internal use
+    const LoggingConfig = (0, exports.toLoggingConfig)(options);
+    // Update defaultLoggingConfig regardless of scope
+    // This ensures that mergeOptions() will use the updated defaults
+    Object.assign(exports.defaultLoggingConfig, LoggingConfig);
+    if (effectiveScope === 'global') {
+        // For global config, use the configureLogging function
+        (0, config_1.configureLogging)(options);
+    }
+};
+exports.configure = configure;
+//# sourceMappingURL=options.js.map