freelii-passkey-kit/types/src/logging/LoggingService.js

A helper library for creating and using smart wallet accounts on the Stellar blockchain.

// Check if we're in a browser environment
const isBrowser = typeof window !== 'undefined';
let logger;
// Create a browser-compatible console logger
function createBrowserLogger(name = 'passkey-kit') {
    const prefix = `[${name}]`;
    return {
        info: (msg, ...args) => console.info(prefix, msg, ...args),
        error: (msg, ...args) => console.error(prefix, msg, ...args),
        warn: (msg, ...args) => console.warn(prefix, msg, ...args),
        debug: (msg, ...args) => console.debug(prefix, msg, ...args),
        child: (obj) => createBrowserLogger(`${name}:${Object.keys(obj).join(':')}`)
    };
}
function isPinoLogger(obj) {
    return obj &&
        typeof obj === 'object' &&
        typeof obj.info === 'function' &&
        typeof obj.error === 'function' &&
        typeof obj.warn === 'function' &&
        typeof obj.debug === 'function' &&
        typeof obj.child === 'function';
}
export class LoggingService {
    static async init(config) {
        if (isPinoLogger(config)) {
            logger = config;
            return;
        }
        // Always use browser logger first as fallback
        logger = createBrowserLogger(config.name || 'passkey-kit');
        // Only try pino in Node.js environment and if it's available
        if (!isBrowser) {
            try {
                // Check if pino is available without importing it
                const pinoModule = await import('pino').catch(() => null);
                if (!pinoModule)
                    return;
                const prettyModule = await import('pino-pretty').catch(() => null);
                const { Transform } = await import('stream').catch(() => ({ Transform: null }));
                if (pinoModule && prettyModule && Transform) {
                    const pinoInstance = pinoModule.default || pinoModule;
                    const prettyInstance = prettyModule.default || prettyModule;
                    const streams = [];
                    const level = config.level || 'info';
                    const prettyStream = prettyInstance({ colorize: true });
                    streams.push({ stream: prettyStream, level });
                    Object.entries(config.transports || {}).forEach(([, stream]) => {
                        streams.push({ stream, level });
                    });
                    logger = pinoInstance({ name: config.name || 'passkey-kit', level }, pinoInstance.multistream(streams));
                }
            }
            catch (error) {
                // Keep browser logger fallback
            }
        }
    }
    static get() {
        if (!logger) {
            logger = createBrowserLogger('passkey-kit');
            // Only try pino in Node.js environment
            if (!isBrowser) {
                import('pino').then(async (pinoModule) => {
                    try {
                        const pinoInstance = pinoModule.default || pinoModule;
                        const prettyModule = await import('pino-pretty');
                        const prettyInstance = prettyModule.default || prettyModule;
                        logger = pinoInstance({ name: 'passkey-kit' }, pinoInstance.multistream([
                            { stream: prettyInstance({ colorize: true }) }
                        ]));
                    }
                    catch (error) {
                        // Keep existing browser logger
                    }
                }).catch(() => {
                    // Keep existing browser logger
                });
            }
        }
        return logger;
    }
}
export function createCustomTransport(transform) {
    if (isBrowser) {
        // In browser, return a simple writable stream-like object
        return {
            write: (chunk) => console.log(chunk),
            retrieveLogs: () => {
                throw new Error('retrieveLogs not implemented for browser transport');
            }
        };
    }
    const transport = transform;
    // Add optional retrieveLogs method if not present
    if (!transport.retrieveLogs) {
        transport.retrieveLogs = () => {
            throw new Error('retrieveLogs not implemented for this transport');
        };
    }
    return transport;
}