analogger 1.29.3 → 1.30.0

package/ana-logger.d.cts

@@ -6,6 +6,7 @@ declare const __AnaLogger: typeof ____AnaLogger;
  */
 declare class ____AnaLogger {
     static "__#1@#instances": any[];
+    static Console: any;
     static ALIGN: {
         LEFT: string;
         RIGHT: string;
@@ -54,22 +55,10 @@ declare class ____AnaLogger {
     originalFormatFunction: string;
     errorTargetHandler: any;
     errorUserTargetHandler: any;
-    rawLog: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    rawInfo: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    rawWarn: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    rawError: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
+    rawLog: any;
+    rawInfo: any;
+    rawWarn: any;
+    rawError: any;
     ALIGN: {
         LEFT: string;
         RIGHT: string;
@@ -110,7 +99,7 @@ declare class ____AnaLogger {
     isBrowser(): boolean;
     resetLogger(): void;
     resetOptions(): void;
-    setOptions({ contextLenMax, idLenMax, lidLenMax, symbolLenMax, messageLenMax, hideLog, hideError, hideHookMessage, hidePassingTests, logToDom, logToFile, logMaxSize, logMaxArchives, logIndexArchive, addArchiveTimestamp, addArchiveIndex, compressArchives, compressionLevel, logToRemote, logToRemoteUrl, logToRemoteBinaryUrl, loopback, requiredLogLevel, oneConsolePerContext, silent, enableDate, protocol, host, port, pathname, binarypathname }?: any): void;
+    setOptions({ contextLenMax, idLenMax, lidLenMax, symbolLenMax, messageLenMax, hideLog, hideError, hideHookMessage, hidePassingTests, logToDom, logToFile, logMaxSize, logMaxArchives, logIndexArchive, addArchiveTimestamp, addArchiveIndex, compressArchives, compressionLevel, logToRemote, logToRemoteUrl, logToRemoteBinaryUrl, loopback, requiredLogLevel, oneConsolePerContext, silent, enableDate, protocol, host, port, pathname, binarypathname, loadHtmlToImage }?: any): void;
     EOL: string;
     getOptions(): {
         hideHookMessage: boolean;
@@ -347,6 +336,29 @@ declare class ____AnaLogger {
     info(...args: any[]): void;
     warn(...args: any[]): void;
     table(...args: any[]): void;
+    /**
+     * Takes a screenshot of the specified DOM element.
+     *
+     * @param {Object} context - The context for the screenshot.
+     * @param {string} context.selector - The CSS selector of the element to capture.
+     * @param {number} context.quality - The quality of the screenshot (0 to 1).
+     * @param {number} context.canvasHeight - The height of the canvas.
+     * @param {number} context.canvasWidth - The width of the canvas.
+     * @param {("Png"|"Jpeg"|"Svg"|"Blob"|"Canvas"|"PixelData")} context.imageType - The type of the image
+     * @param {number} context.width Width in pixels to be applied to DOM node before rendering.
+     * @param {number} context.height Height in pixels to be applied to the DOM node before rendering.
+     * @param {number} context.pixelRatio
+     */
+    takeScreenshot(context?: {
+        selector: string;
+        quality: number;
+        canvasHeight: number;
+        canvasWidth: number;
+        imageType: ("Png" | "Jpeg" | "Svg" | "Blob" | "Canvas" | "PixelData");
+        width: number;
+        height: number;
+        pixelRatio: number;
+    }): Promise<any>;
     alert(...args: any[]): void;
     assert(condition: any, expected?: boolean, ...args: any[]): boolean;
     /**

package/browser/ana-logger.d.mts

@@ -0,0 +1,488 @@
+export namespace DEFAULT_LOG_TARGETS {
+    const ALL: string;
+    const USER: string;
+}
+export namespace DEFAULT_LOG_LEVELS {
+    export const FATAL: number;
+    export const ERROR: number;
+    export const WARN: number;
+    export const INFO: number;
+    export const LOG: number;
+    export const DEBUG: number;
+    const ALL_1: number;
+    export { ALL_1 as ALL };
+    export const OFF: number;
+    export const INHERIT: number;
+}
+export namespace DEFAULT_LOG_CONTEXTS {
+    export namespace DEFAULT {
+        export const contextName: string;
+        import logLevel = DEFAULT_LOG_LEVELS.LOG;
+        export { logLevel };
+        export const symbol: string;
+    }
+    export namespace LOG_1 {
+        const contextName_1: string;
+        export { contextName_1 as contextName };
+        import logLevel_1 = DEFAULT_LOG_LEVELS.LOG;
+        export { logLevel_1 as logLevel };
+        const symbol_1: string;
+        export { symbol_1 as symbol };
+    }
+    export { LOG_1 as LOG };
+    export namespace DEBUG_1 {
+        const contextName_2: string;
+        export { contextName_2 as contextName };
+        import logLevel_2 = DEFAULT_LOG_LEVELS.DEBUG;
+        export { logLevel_2 as logLevel };
+    }
+    export { DEBUG_1 as DEBUG };
+    export namespace INFO_1 {
+        const contextName_3: string;
+        export { contextName_3 as contextName };
+        import logLevel_3 = DEFAULT_LOG_LEVELS.INFO;
+        export { logLevel_3 as logLevel };
+        export const color: string;
+        const symbol_2: string;
+        export { symbol_2 as symbol };
+    }
+    export { INFO_1 as INFO };
+    export namespace WARN_1 {
+        const contextName_4: string;
+        export { contextName_4 as contextName };
+        import logLevel_4 = DEFAULT_LOG_LEVELS.WARN;
+        export { logLevel_4 as logLevel };
+        const color_1: string;
+        export { color_1 as color };
+        const symbol_3: string;
+        export { symbol_3 as symbol };
+    }
+    export { WARN_1 as WARN };
+    export namespace ERROR_1 {
+        const contextName_5: string;
+        export { contextName_5 as contextName };
+        import logLevel_5 = DEFAULT_LOG_LEVELS.ERROR;
+        export { logLevel_5 as logLevel };
+    }
+    export { ERROR_1 as ERROR };
+    export namespace CRITICAL {
+        const contextName_6: string;
+        export { contextName_6 as contextName };
+        const logLevel_6: any;
+        export { logLevel_6 as logLevel };
+    }
+}
+export default __AnaLogger;
+export const anaLogger: any;
+export const AnaLogger: typeof ____AnaLogger;
+export type PLUGIN_TYPE = {
+    LOCAL: string;
+    GLOBAL: string;
+};
+export type PLUGIN_PROPERTIES_TYPE = {
+    /**
+     * AnaLogger's real method name that is set to the AnaLogger instance *
+     */
+    methodName: string;
+    /**
+     * AnaLogger method that will be called when invoking the plugin
+     */
+    callback: Function;
+    /**
+     * Whether the plugin is accessible to the AnaLogger class or an instance
+     */
+    type: PLUGIN_TYPE;
+};
+declare const __AnaLogger: typeof ____AnaLogger;
+/**
+ * @module ____AnaLogger
+ * @class ____AnaLogger
+ */
+declare class ____AnaLogger {
+    static "__#1@#instances": any[];
+    static Console: any;
+    static ALIGN: {
+        LEFT: string;
+        RIGHT: string;
+    };
+    static ENVIRONMENT_TYPE: {
+        BROWSER: string;
+        NODE: string;
+        OTHER: string;
+    };
+    static instanceCount: number;
+    static pluginTable: {};
+    static generateInstance(): ____AnaLogger;
+    /**
+     * Returns an AnaLogger instance
+     * @returns {null}
+     */
+    static getInstance(num?: number): null;
+    /**
+     * Returns first existing AnaLogger instance,
+     * otherwise create a new instance
+     * @returns {*|____AnaLogger}
+     */
+    static generateMainInstance(): any | ____AnaLogger;
+    /**
+     * Override console.log and console.error
+     */
+    static startLogger(): void;
+    static stopLogger(): void;
+    constructor({ name }?: {
+        name?: string;
+    });
+    system: string;
+    instanceId: string;
+    instanceName: string;
+    logIndex: number;
+    logCounter: number;
+    activeTargets: any[];
+    indexColor: number;
+    format: string;
+    keepLog: boolean;
+    logHistory: any[];
+    $containers: any;
+    options: {
+        hideHookMessage: boolean;
+    };
+    originalFormatFunction: string;
+    errorTargetHandler: any;
+    errorUserTargetHandler: any;
+    rawLog: any;
+    rawInfo: any;
+    rawWarn: any;
+    rawError: any;
+    ALIGN: {
+        LEFT: string;
+        RIGHT: string;
+    };
+    ENVIRONMENT_TYPE: {
+        BROWSER: string;
+        NODE: string;
+        OTHER: string;
+    };
+    getName(): string;
+    getId(): string;
+    keepLogHistory(): void;
+    releaseLogHistory(): void;
+    resetLogHistory(): void;
+    addToLogHistory(obj: any): void;
+    /**
+     * Returns log entries
+     * @note This method should return the list of objects rather than
+     * the array of text
+     * @param join
+     * @param symbol
+     * @returns {string|*[]}
+     */
+    getLogHistory(join?: boolean, symbol?: string): string | any[];
+    getRawLogHistory(): any[];
+    hasSeenLid(lid: any): boolean;
+    forceEnvironment(system: any): void;
+    forcedSystem: any;
+    /**
+     * Tell whether we are in a Node environment
+     * @returns {boolean}
+     */
+    isNode(): boolean;
+    /**
+     * Tell whether the logger runs from a browser
+     * @returns {boolean}
+     */
+    isBrowser(): boolean;
+    resetLogger(): void;
+    resetOptions(): void;
+    setOptions({ contextLenMax, idLenMax, lidLenMax, symbolLenMax, messageLenMax, hideLog, hideError, hideHookMessage, hidePassingTests, logToDom, logToFile, logMaxSize, logMaxArchives, logIndexArchive, addArchiveTimestamp, addArchiveIndex, compressArchives, compressionLevel, logToRemote, logToRemoteUrl, logToRemoteBinaryUrl, loopback, requiredLogLevel, oneConsolePerContext, silent, enableDate, protocol, host, port, pathname, binarypathname }?: any): void;
+    getOptions(): {
+        hideHookMessage: boolean;
+    };
+    truncateMessage(input?: string, { fit, align, ellipsis }?: {
+        fit?: number;
+        align?: string;
+        ellipsis?: string;
+    }): string;
+    /**
+     * Format inputs
+     * @see Override {@link setLogFormat}
+     * @param contextName
+     * @param id
+     * @param message
+     * @param lid
+     * @param symbol
+     * @returns {string}
+     */
+    onBuildLog({ contextName, message, lid, symbol }?: {
+        contextName: any;
+        message?: string;
+        lid?: string;
+        symbol?: string;
+    }): string;
+    onErrorForUserTarget(context: any, ...args: any[]): void;
+    onError(context: any, ...args: any[]): void;
+    /**
+     * Forward input to real console log
+     * @param args
+     */
+    onDisplayLog(...args: any[]): void;
+    assistStask(error: any): any;
+    /**
+     * Forward input to real console log
+     * @param args
+     */
+    onDisplayError(...args: any[]): void;
+    /**
+     * Set log template
+     * @param format
+     */
+    setLogFormat(format: any): boolean;
+    resetLogFormatter(): void;
+    setErrorHandler(handler: any): void;
+    setErrorHandlerForUserTarget(handler: any): void;
+    isContextValid(context: any): any;
+    /**
+     * Set context properties for default context
+     * @param context
+     */
+    setDefaultContext(context: any): void;
+    /**
+     * Generate a default context with a default color
+     * @returns {*|{}}
+     */
+    generateDefaultContext(): any | {};
+    /**
+     * Generate a new context based on the default context.
+     * The only difference with default is that a different color will be assigned to that context automatically
+     * @returns {*|{}}
+     */
+    generateNewContext(): any | {};
+    generateErrorContext(): any;
+    /**
+     * Redefine a context
+     * @param contextName
+     * @param context
+     */
+    setContext(contextName: any, context?: {}): void;
+    getContext(contextName: any): any;
+    /**
+     * Load the context names that should be available to the environment.
+     * They are defined by the user.
+     * @see Context definitions {@link ./example/more/contexts-def.cjs}
+     * @param contextTable
+     */
+    setContexts(contextTable: any): void;
+    getContexts(): readonly any[];
+    setTargets(targetTable?: {}): void;
+    addTargets(targets: any): void;
+    getTargets(): Readonly<{}>;
+    /**
+     * Set one or more active targets
+     * @param targets
+     */
+    setActiveTargets(targets?: any): void;
+    getActiveTarget(): any[];
+    /**
+     * Set only one active target
+     * NOTE: Kept for backward compatibility.
+     * Use setActiveTargets instead
+     * @param target
+     */
+    setActiveTarget(target: any): void;
+    setLogLevel(name: any, level: any): void;
+    getLogLevel(name: any): any;
+    setLogLevels(levels: any): void;
+    getLogLevels(): Readonly<{}>;
+    isTargetAllowed(target: any): boolean;
+    /**
+     * Add many sections (columns) to a given DOM line
+     * @param $line
+     * @param context
+     * @param text
+     */
+    setColumns($line: any, context: any, text: any): void;
+    /**
+     * Check that the div has not too many entries
+     * @param $view
+     */
+    removeDomOldEntries: ($view: any) => number;
+    /**
+     * Scroll to bottom if div is already at the bottom
+     * @param $view
+     */
+    scrollDivToBottom: ($view: any) => void;
+    checkOnLoggingToDom(context: any, param2: any): any;
+    /**
+     * Add a line to the Analogger div.
+     * Remove older lines if exceeding limit.
+     * @param $view
+     * @param $line
+     * @param context
+     * @param addType
+     * @param message
+     * @param text
+     * @param args
+     */
+    addLineToDom($view: any, $line: any, { context, addType, message, text, args }: {
+        context: any;
+        addType: any;
+        message: any;
+        text: any;
+        args: any;
+    }): void;
+    showRemovedNotification(context: any): void;
+    timerAddLineToDomID: any;
+    writeLogToDom(context: any, fullText: any, { addType, message, args }?: {
+        addType?: string;
+        message?: string;
+        args?: any;
+    }): void;
+    writeLogToFile(text: any): void;
+    writeLogToRemote(...data: any[]): any;
+    /**
+     * Send data to the registered remote server
+     * @param raw
+     * @param context
+     * @param done
+     */
+    uploadDataToRemote(raw: any, context?: any, done?: any): any;
+    stringifyEntry(arg: any): string;
+    /**
+     * If a variable is too complex for the logger, stringify it
+     */
+    convertEntry(arg: any): any;
+    convertArgumentsToText(args: any): string;
+    writeToConsole(output: any, context: any): void;
+    /**
+     * Parse the context. If one of its keys has the same name as a registered plugin,
+     * the system will invoke the plugin (the value of the key must be anything truthy).
+     * @param context
+     * @param extras
+     * @returns {undefined|boolean}
+     */
+    checkPlugins(context: any, { message, text, args, logCounter }: {
+        message: any;
+        text: any;
+        args: any;
+        logCounter: any;
+    }): undefined | boolean;
+    /**
+     * If the context contain a key onLogging that is a function,
+     * execute
+     * @param context
+     * @param data
+     * @param extras
+     * @param callbackName
+     * @returns {*}
+     */
+    checkOnLogging(context: any, data: any, extras: any, callbackName: any): any;
+    /**
+     * Display log following template
+     * @param context
+     */
+    processOutput(context?: {}, ...args: any[]): void;
+    /**
+     * Check that a parameter uses the expected AnaLogger format.
+     * For this, the first parameter should be an object that contains at least
+     * a logging id (lid), a target, a contextName, etc
+     * @param options
+     * @returns {boolean}
+     */
+    isExtendedOptionsPassed(options: any): boolean;
+    /**
+     * Convert a string into a Context object if possible
+     * TODO: To implement in next version
+     * @param str
+     * @returns {string}
+     */
+    extractContextFromInput(str: any): string;
+    listSymbols(): void;
+    applySymbolByName(context: any): void;
+    /**
+     * Convert the first parameter of a console.log to a Context object
+     * @param options
+     * @param defaultContext
+     * @returns {*|{}}
+     */
+    convertToContext(options: any, defaultContext: any): any | {};
+    /**
+     * console.log with options set on the first parameter to dictate console log behaviours
+     * @param options
+     * @param args
+     */
+    log(options: any, ...args: any[]): void;
+    error(options: any, ...args: any[]): void;
+    overrideError(): void;
+    attachConsole(): boolean;
+    overrideConsole({ log, info, warn, error }?: {
+        log?: boolean;
+        info?: boolean;
+        warn?: boolean;
+        error?: boolean;
+    }): void;
+    removeOverrideError(): void;
+    removeOverride({ log, info, warn, error }?: {
+        log?: boolean;
+        info?: boolean;
+        warn?: boolean;
+        error?: boolean;
+    }): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    table(...args: any[]): void;
+    takeScreenshotWithImageCapture(): Promise<any>;
+    takeScreenshot(): void;
+    alert(...args: any[]): void;
+    assert(condition: any, expected?: boolean, ...args: any[]): boolean;
+    /**
+     * Set standard Analogger format
+     * @example
+     * // Output Example
+     * // [14:01:06]    DEFAULT: (1060) ⚡  " ✔ My log ..."
+     * @param activeTarget
+     * @param override
+     * @returns {boolean}
+     */
+    applyAnalogFormatting({ activeTarget, override }?: {
+        activeTarget?: string;
+        override?: boolean;
+    }): boolean;
+    applyPredefinedFormat(name?: string, { activeTarget, override }?: {
+        activeTarget?: string;
+        override?: boolean;
+    }): boolean;
+    convertToUrl({ protocol, host, port, pathname }?: {
+        protocol?: string;
+        host?: string;
+        port?: number;
+        pathname?: string;
+    }): string;
+    generateLogToRemoteUrl(logToRemoteUrl?: any, { pathname }?: {
+        pathname?: string;
+    }): string | String;
+    /**
+     * Install a plugin against the active instance
+     * @param methodName
+     * @param callback
+     * @param pluginName
+     */
+    addPlugin(methodName: any, callback: any, pluginName?: string): void;
+    /**
+     * Install a plugin against the class (an instantiation with new is needed)
+     * @param methodName
+     * @param callback
+     * @param pluginName
+     */
+    addGlobalPlugin(methodName: any, callback: any, pluginName: any): void;
+    getPluginList(): string[];
+    /**
+     * At the moment, this method behaviour is equivalent to an eventual isPluginRegistered method
+     * @param name
+     * @returns {boolean}
+     */
+    validatePlugin(name: any): boolean;
+    #private;
+}
+declare namespace PLUGIN_TYPE {
+    const LOCAL: string;
+    const GLOBAL: string;
+}