@garrix82/reactgenie-lib 1.3.0

package/dist/logger.js

@@ -0,0 +1,597 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureLogger = configureLogger;
+exports.logger = exports.default = void 0;
+exports.setLogLevel = setLogLevel;
+exports.setLoggerTelemetryBridge = setLoggerTelemetryBridge;
+var _reactNative = require("react-native");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // Environment-aware logger utility
+// Uses react-native-logs for React Native, winston for Node.js/web, console as fallback
+// Determine environment first
+// Treat Node as its own runtime even if react-native Platform.OS is ios/android in tests
+const getRuntimeProcess = () => {
+  const globalObj = globalThis;
+  return globalObj?.process ?? null;
+};
+const isNodeEnvironment = Boolean(getRuntimeProcess()?.versions?.node);
+const isReactNative = _reactNative.Platform.OS !== 'web' && !isNodeEnvironment;
+const isWeb = _reactNative.Platform.OS === 'web';
+
+// Try to require libraries based on environment
+let rnLogs = null;
+let winston = null;
+
+// Only try to require react-native-logs in React Native environments
+if (isReactNative) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    rnLogs = require('react-native-logs');
+  } catch (e) {
+    rnLogs = null;
+  }
+}
+
+// For winston, use runtime detection without static requires
+const getWinston = () => {
+  if (winston !== null) return winston;
+  if (!isNodeEnvironment) return null;
+  try {
+    // Use eval to dynamically construct the require call
+    // This prevents static analysis from finding 'winston' in require()
+    const winstonModule = eval('require')('winston');
+    winston = winstonModule;
+    return winston;
+  } catch (e) {
+    winston = null;
+    return null;
+  }
+};
+// Read desired log level from env/config
+function getDefaultLogLevel() {
+  const env = getRuntimeProcess()?.env ?? {};
+  const level = env.REACT_APP_LOG_LEVEL || env.EXPO_PUBLIC_LOG_LEVEL || env.LOG_LEVEL;
+  if (!level) return isNodeEnvironment || isWeb ? 'info' : 'warn';
+  const normalized = level.toLowerCase();
+  if (['error', 'warn', 'info', 'debug', 'silent'].includes(normalized)) {
+    return normalized;
+  }
+  return 'info';
+}
+let currentLevel = getDefaultLogLevel();
+let runtimeLoggerConfig = {};
+let loggerTelemetryBridge = null;
+const pad2 = n => String(n).padStart(2, '0');
+const formatLocalDate = (date = new Date()) => `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+const buildDailyFileName = (date = new Date()) => `logs-${formatLocalDate(date)}.log`;
+const getEnvConfig = () => {
+  return getRuntimeProcess()?.env ?? {};
+};
+const isValidLogLevel = level => {
+  return typeof level === 'string' && ['error', 'warn', 'info', 'debug', 'silent'].includes(level);
+};
+const isFileLoggingEnabled = () => {
+  if (typeof runtimeLoggerConfig.enableFileLogging === 'boolean') {
+    return runtimeLoggerConfig.enableFileLogging;
+  }
+  const env = getEnvConfig();
+  const raw = env.REACT_APP_ENABLE_WINSTON_FILE || env.EXPO_PUBLIC_ENABLE_WINSTON_FILE || env.REACT_APP_ENABLE_FILE_LOGS || env.EXPO_PUBLIC_ENABLE_FILE_LOGS || env.LOG_FILE_ENABLED;
+  if (raw === undefined) return true;
+  return raw === 'true' || raw === '1';
+};
+const getConfiguredLogDir = () => {
+  if (runtimeLoggerConfig.logFileDir && runtimeLoggerConfig.logFileDir.trim()) {
+    return runtimeLoggerConfig.logFileDir;
+  }
+  const env = getEnvConfig();
+  return env.REACT_APP_LOG_FILE_DIR || env.EXPO_PUBLIC_LOG_FILE_DIR || env.LOG_FILE_DIR || '.';
+};
+const formatLogLine = (level, args) => {
+  const ts = new Date().toISOString();
+  const serialize = value => {
+    if (value instanceof Error) {
+      const stack = value.stack ? `\n${value.stack}` : '';
+      return `${value.message}${stack}`;
+    }
+    if (typeof value === 'string') return value;
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  };
+  const payload = args.map(serialize).join(' ');
+  return `${ts} [${level.toUpperCase()}] ${payload}\n`;
+};
+let fileSink = undefined;
+let remoteSink = undefined;
+const getConfiguredRemoteUrl = () => {
+  if (runtimeLoggerConfig.remoteUrl && runtimeLoggerConfig.remoteUrl.trim()) {
+    return runtimeLoggerConfig.remoteUrl;
+  }
+  const env = getEnvConfig();
+  return env.REACT_APP_LOG_REMOTE_URL || env.EXPO_PUBLIC_LOG_REMOTE_URL || env.LOG_REMOTE_URL || '';
+};
+const getConfiguredRemoteToken = () => {
+  if (runtimeLoggerConfig.remoteToken && runtimeLoggerConfig.remoteToken.trim()) {
+    return runtimeLoggerConfig.remoteToken;
+  }
+  const env = getEnvConfig();
+  return env.REACT_APP_LOG_INGEST_TOKEN || env.EXPO_PUBLIC_LOG_INGEST_TOKEN || env.LOG_INGEST_TOKEN || '';
+};
+const isRemoteLoggingEnabled = () => {
+  if (typeof runtimeLoggerConfig.remoteEnabled === 'boolean') {
+    return runtimeLoggerConfig.remoteEnabled && Boolean(getConfiguredRemoteUrl());
+  }
+  const remoteUrl = getConfiguredRemoteUrl();
+  if (!remoteUrl) return false;
+  const env = getEnvConfig();
+  const raw = env.REACT_APP_ENABLE_REMOTE_LOGS || env.EXPO_PUBLIC_ENABLE_REMOTE_LOGS || env.LOG_REMOTE_ENABLED;
+  if (raw === undefined) return true;
+  return raw === 'true' || raw === '1';
+};
+const serializeArgForJson = value => {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+};
+const buildRemotePayload = (level, args) => {
+  const normalizedArgs = args.map(arg => serializeArgForJson(arg));
+  const firstArg = normalizedArgs[0];
+  const message = typeof firstArg === 'string' ? firstArg : normalizedArgs.map(arg => typeof arg === 'string' ? arg : JSON.stringify(arg)).join(' ');
+  return {
+    timestamp: new Date().toISOString(),
+    level,
+    message: message || '[empty]',
+    source: isWeb ? 'web' : 'mobile',
+    runtime: isNodeEnvironment ? 'node' : 'client',
+    args: normalizedArgs
+  };
+};
+const buildTelemetryMessage = args => {
+  if (!Array.isArray(args) || args.length === 0) return "[empty]";
+  const [first] = args;
+  if (typeof first === "string" && first.trim()) return first;
+  return args.map(arg => {
+    if (arg instanceof Error) return arg.message;
+    if (typeof arg === "string") return arg;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ").trim() || "[empty]";
+};
+const emitTelemetryBridge = (level, args) => {
+  if (!loggerTelemetryBridge) return;
+  const errorArg = args.find(arg => arg instanceof Error);
+  const context = {
+    level,
+    runtime: isNodeEnvironment ? "node" : isWeb ? "web" : "native"
+  };
+  if (errorArg && typeof loggerTelemetryBridge.captureException === "function") {
+    loggerTelemetryBridge.captureException(errorArg, context);
+    return;
+  }
+  if (typeof loggerTelemetryBridge.captureMessage === "function") {
+    loggerTelemetryBridge.captureMessage(buildTelemetryMessage(args), level, context);
+  }
+};
+const getRemoteSink = () => {
+  if (remoteSink !== undefined) return remoteSink ?? null;
+  if (!isRemoteLoggingEnabled()) {
+    remoteSink = null;
+    return null;
+  }
+  if (typeof fetch !== 'function') {
+    remoteSink = null;
+    return null;
+  }
+  const url = getConfiguredRemoteUrl();
+  const token = getConfiguredRemoteToken();
+  let sendChain = Promise.resolve();
+  const sendOne = async (level, args) => {
+    const headers = {
+      'content-type': 'application/json'
+    };
+    if (token) {
+      headers['x-log-token'] = token;
+    }
+    const payload = buildRemotePayload(level, args);
+    await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload)
+    });
+  };
+  remoteSink = {
+    write: (level, args) => {
+      sendChain = sendChain.then(() => sendOne(level, args)).catch(() => {});
+    }
+  };
+  return remoteSink;
+};
+const invalidateDerivedLoggerState = () => {
+  fileSink = undefined;
+  remoteSink = undefined;
+};
+const getNodeFileSink = () => {
+  if (!isNodeEnvironment) return null;
+  let fs = null;
+  let path = null;
+  try {
+    fs = eval('require')('fs');
+    path = eval('require')('path');
+  } catch {
+    return null;
+  }
+  let currentDate = '';
+  let filePath = '';
+  const ensureFilePath = () => {
+    const today = formatLocalDate(new Date());
+    if (today === currentDate && filePath) return;
+    currentDate = today;
+    const logDir = getConfiguredLogDir() || '.';
+    const cwd = getRuntimeProcess()?.cwd?.() ?? '.';
+    const resolvedDir = path.resolve(cwd, logDir);
+    if (!fs.existsSync(resolvedDir)) {
+      try {
+        fs.mkdirSync(resolvedDir, {
+          recursive: true
+        });
+      } catch {/* ignore */}
+    }
+    filePath = path.join(resolvedDir, buildDailyFileName(new Date()));
+  };
+  return {
+    write: (level, args) => {
+      try {
+        ensureFilePath();
+        fs.appendFile(filePath, formatLogLine(level, args), () => {});
+      } catch {
+        // ignore file logging errors
+      }
+    }
+  };
+};
+const getExpoFileSystem = () => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('expo-file-system/legacy');
+  } catch {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      return require('expo-file-system');
+    } catch {
+      return null;
+    }
+  }
+};
+const getExpoFileSink = () => {
+  const FileSystem = getExpoFileSystem();
+  if (!FileSystem || typeof FileSystem.writeAsStringAsync !== 'function') return null;
+  const baseDir = FileSystem.documentDirectory || FileSystem.cacheDirectory;
+  if (!baseDir) return null;
+  const encoding = FileSystem.EncodingType?.UTF8 ?? 'utf8';
+  const normalizeDir = dir => dir.replace(/\/?$/, '/');
+  const logDir = getConfiguredLogDir();
+  const subDir = logDir && logDir !== '.' ? logDir.replace(/^\.\/+/, '').replace(/\/+$/, '') : '';
+  const basePath = subDir ? `${normalizeDir(baseDir)}${subDir}/` : normalizeDir(baseDir);
+  let currentDate = '';
+  let fileUri = '';
+  let writeChain = Promise.resolve();
+  const ensureFileUri = async () => {
+    const today = formatLocalDate(new Date());
+    if (today === currentDate && fileUri) return;
+    currentDate = today;
+    fileUri = `${basePath}${buildDailyFileName(new Date())}`;
+    if (subDir) {
+      try {
+        await FileSystem.makeDirectoryAsync(basePath, {
+          intermediates: true
+        });
+      } catch {/* ignore */}
+    }
+    try {
+      const info = await FileSystem.getInfoAsync(fileUri);
+      if (!info?.exists) {
+        await FileSystem.writeAsStringAsync(fileUri, '', {
+          encoding
+        });
+      }
+    } catch {
+      try {
+        await FileSystem.writeAsStringAsync(fileUri, '', {
+          encoding
+        });
+      } catch {/* ignore */}
+    }
+  };
+  const appendLine = async line => {
+    await ensureFileUri();
+    try {
+      await FileSystem.writeAsStringAsync(fileUri, line, {
+        encoding,
+        append: true
+      });
+      return;
+    } catch {
+      // fall through to read/append fallback
+    }
+    try {
+      const existing = await FileSystem.readAsStringAsync(fileUri, {
+        encoding
+      });
+      await FileSystem.writeAsStringAsync(fileUri, `${existing}${line}`, {
+        encoding
+      });
+    } catch {
+      // ignore
+    }
+  };
+  return {
+    write: (level, args) => {
+      const line = formatLogLine(level, args);
+      writeChain = writeChain.then(() => appendLine(line)).catch(() => {});
+    }
+  };
+};
+const getFileSink = () => {
+  if (fileSink !== undefined) return fileSink ?? null;
+  if (!isFileLoggingEnabled()) {
+    fileSink = null;
+    return null;
+  }
+  const nodeSink = getNodeFileSink();
+  if (nodeSink) {
+    fileSink = nodeSink;
+    return nodeSink;
+  }
+  const expoSink = getExpoFileSink();
+  if (expoSink) {
+    fileSink = expoSink;
+    return expoSink;
+  }
+  fileSink = null;
+  return null;
+};
+
+// Create logger instance based on environment - LAZY LOADING
+let rnLogger = null;
+let winstonLogger = null;
+
+// Lazy initialization functions
+const getRnLogger = () => {
+  if (rnLogger !== null) return rnLogger;
+  if (!isReactNative || !rnLogs) return null;
+  try {
+    const {
+      logger: createLogger
+    } = rnLogs;
+    const config = {
+      severity: currentLevel,
+      transport: (msg, level, _options) => {
+        const prefix = `[${level.toUpperCase()}]`;
+        switch (level) {
+          case 'error':
+            // eslint-disable-next-line no-console
+            console.error(prefix, ...msg);
+            break;
+          case 'warn':
+            // eslint-disable-next-line no-console
+            console.warn(prefix, ...msg);
+            break;
+          case 'info':
+            // eslint-disable-next-line no-console
+            console.log(prefix, ...msg);
+            break;
+          case 'debug':
+            // eslint-disable-next-line no-console
+            console.debug ? console.debug(prefix, ...msg) : console.log(prefix, ...msg);
+            break;
+          default:
+            // eslint-disable-next-line no-console
+            console.log(prefix, ...msg);
+        }
+      },
+      transportOptions: {
+        colors: {
+          error: 'red',
+          warn: 'yellow',
+          info: 'blue',
+          debug: 'gray'
+        }
+      }
+    };
+    rnLogger = createLogger(config);
+    return rnLogger;
+  } catch (e) {
+    rnLogger = null;
+    return null;
+  }
+};
+const getWinstonLogger = () => {
+  if (winstonLogger !== null) return winstonLogger;
+  if (!isNodeEnvironment) return null;
+  const winston = getWinston();
+  if (!winston) return null;
+  try {
+    const {
+      createLogger,
+      format,
+      transports
+    } = winston;
+    const transportInstances = [new transports.Console({
+      level: currentLevel
+    })];
+    winstonLogger = createLogger({
+      level: currentLevel,
+      format: format.combine(format.timestamp(), format.errors({
+        stack: true
+      }), format.splat(), format.json()),
+      transports: transportInstances
+    });
+    return winstonLogger;
+  } catch (e) {
+    winstonLogger = null;
+    return null;
+  }
+};
+
+// Initialize RN logger immediately if in React Native
+if (isReactNative) {
+  getRnLogger();
+}
+function setLogLevel(level) {
+  currentLevel = level;
+  // Update logger severity if available
+  const rnLogger = getRnLogger();
+  if (rnLogger && rnLogger.setSeverity) {
+    rnLogger.setSeverity(level);
+  }
+  const winstonLogger = getWinstonLogger();
+  if (winstonLogger) {
+    winstonLogger.level = level;
+  }
+}
+function configureLogger(config = {}) {
+  runtimeLoggerConfig = _objectSpread(_objectSpread({}, runtimeLoggerConfig), config);
+  if (isValidLogLevel(config.level)) {
+    currentLevel = config.level;
+  }
+  invalidateDerivedLoggerState();
+
+  // Keep active logger instances aligned with the updated effective level.
+  const rnLogger = getRnLogger();
+  if (rnLogger && rnLogger.setSeverity) {
+    rnLogger.setSeverity(currentLevel);
+  }
+  const winstonLogger = getWinstonLogger();
+  if (winstonLogger) {
+    winstonLogger.level = currentLevel;
+  }
+}
+function setLoggerTelemetryBridge(bridge) {
+  loggerTelemetryBridge = bridge ?? null;
+}
+function levelPriority(l) {
+  switch (l) {
+    case 'silent':
+      return 0;
+    case 'error':
+      return 1;
+    case 'warn':
+      return 2;
+    case 'info':
+      return 3;
+    case 'debug':
+      return 4;
+    default:
+      return 3;
+  }
+}
+
+// Lightweight logger API used across the app
+const logger = exports.logger = {
+  error: (...args) => {
+    if (levelPriority(currentLevel) >= levelPriority('error')) {
+      const rnLogger = getRnLogger();
+      if (rnLogger) {
+        rnLogger.error(...args);
+      } else {
+        const winstonLogger = getWinstonLogger();
+        if (winstonLogger) {
+          winstonLogger.error(...args);
+        } else {
+          // eslint-disable-next-line no-console
+          console.error('[error]', ...args);
+        }
+      }
+      const sink = getFileSink();
+      if (sink) sink.write('error', args);
+      const remote = getRemoteSink();
+      if (remote) remote.write('error', args);
+      emitTelemetryBridge("error", args);
+    }
+  },
+  warn: (...args) => {
+    if (levelPriority(currentLevel) >= levelPriority('warn')) {
+      const rnLogger = getRnLogger();
+      if (rnLogger) {
+        rnLogger.warn(...args);
+      } else {
+        const winstonLogger = getWinstonLogger();
+        if (winstonLogger) {
+          winstonLogger.warn(...args);
+        } else {
+          // eslint-disable-next-line no-console
+          console.warn('[warn]', ...args);
+        }
+      }
+      const sink = getFileSink();
+      if (sink) sink.write('warn', args);
+      const remote = getRemoteSink();
+      if (remote) remote.write('warn', args);
+      emitTelemetryBridge("warn", args);
+    }
+  },
+  info: (...args) => {
+    if (levelPriority(currentLevel) >= levelPriority('info')) {
+      const rnLogger = getRnLogger();
+      if (rnLogger) {
+        rnLogger.info(...args);
+      } else {
+        const winstonLogger = getWinstonLogger();
+        if (winstonLogger) {
+          winstonLogger.info(...args);
+        } else {
+          // eslint-disable-next-line no-console
+          console.log('[info]', ...args);
+        }
+      }
+      const sink = getFileSink();
+      if (sink) sink.write('info', args);
+      const remote = getRemoteSink();
+      if (remote) remote.write('info', args);
+    }
+  },
+  debug: (...args) => {
+    if (levelPriority(currentLevel) >= levelPriority('debug')) {
+      const rnLogger = getRnLogger();
+      if (rnLogger) {
+        rnLogger.debug(...args);
+      } else {
+        const winstonLogger = getWinstonLogger();
+        if (winstonLogger) {
+          winstonLogger.debug(...args);
+        } else {
+          // eslint-disable-next-line no-console
+          console.debug ? console.debug('[debug]', ...args) : console.log('[debug]', ...args);
+        }
+      }
+      const sink = getFileSink();
+      if (sink) sink.write('debug', args);
+      const remote = getRemoteSink();
+      if (remote) remote.write('debug', args);
+    }
+  }
+};
+var _default = exports.default = logger;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_reactNative","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","getRuntimeProcess","globalObj","globalThis","process","isNodeEnvironment","Boolean","versions","node","isReactNative","Platform","OS","isWeb","rnLogs","winston","getWinston","winstonModule","eval","getDefaultLogLevel","env","level","REACT_APP_LOG_LEVEL","EXPO_PUBLIC_LOG_LEVEL","LOG_LEVEL","normalized","toLowerCase","includes","currentLevel","runtimeLoggerConfig","loggerTelemetryBridge","pad2","n","padStart","formatLocalDate","date","Date","getFullYear","getMonth","getDate","buildDailyFileName","getEnvConfig","isValidLogLevel","isFileLoggingEnabled","enableFileLogging","raw","REACT_APP_ENABLE_WINSTON_FILE","EXPO_PUBLIC_ENABLE_WINSTON_FILE","REACT_APP_ENABLE_FILE_LOGS","EXPO_PUBLIC_ENABLE_FILE_LOGS","LOG_FILE_ENABLED","undefined","getConfiguredLogDir","logFileDir","trim","REACT_APP_LOG_FILE_DIR","EXPO_PUBLIC_LOG_FILE_DIR","LOG_FILE_DIR","formatLogLine","args","ts","toISOString","serialize","Error","stack","message","JSON","stringify","payload","map","join","toUpperCase","fileSink","remoteSink","getConfiguredRemoteUrl","remoteUrl","REACT_APP_LOG_REMOTE_URL","EXPO_PUBLIC_LOG_REMOTE_URL","LOG_REMOTE_URL","getConfiguredRemoteToken","remoteToken","REACT_APP_LOG_INGEST_TOKEN","EXPO_PUBLIC_LOG_INGEST_TOKEN","LOG_INGEST_TOKEN","isRemoteLoggingEnabled","remoteEnabled","REACT_APP_ENABLE_REMOTE_LOGS","EXPO_PUBLIC_ENABLE_REMOTE_LOGS","LOG_REMOTE_ENABLED","serializeArgForJson","name","parse","buildRemotePayload","normalizedArgs","arg","firstArg","timestamp","source","runtime","buildTelemetryMessage","Array","isArray","first","emitTelemetryBridge","errorArg","find","context","captureException","captureMessage","getRemoteSink","fetch","url","token","sendChain","Promise","resolve","sendOne","headers","method","body","write","then","catch","invalidateDerivedLoggerState","getNodeFileSink","fs","path","currentDate","filePath","ensureFilePath","today","logDir","cwd","resolvedDir","existsSync","mkdirSync","recursive","appendFile","getExpoFileSystem","getExpoFileSink","FileSystem","writeAsStringAsync","baseDir","documentDirectory","cacheDirectory","encoding","EncodingType","UTF8","normalizeDir","dir","replace","subDir","basePath","fileUri","writeChain","ensureFileUri","makeDirectoryAsync","intermediates","info","getInfoAsync","exists","appendLine","line","append","existing","readAsStringAsync","getFileSink","nodeSink","expoSink","rnLogger","winstonLogger","getRnLogger","logger","createLogger","config","severity","transport","msg","_options","prefix","console","error","warn","log","debug","transportOptions","colors","getWinstonLogger","format","transports","transportInstances","Console","combine","errors","splat","json","setLogLevel","setSeverity","configureLogger","setLoggerTelemetryBridge","bridge","levelPriority","l","exports","sink","remote","_default","default"],"sources":["../src/logger.ts"],"sourcesContent":["// Environment-aware logger utility\n// Uses react-native-logs for React Native, winston for Node.js/web, console as fallback\n\nimport { Platform } from 'react-native';\n\n// Determine environment first\n// Treat Node as its own runtime even if react-native Platform.OS is ios/android in tests\nconst getRuntimeProcess = (): {\n  versions?: { node?: string };\n  env?: Record<string, string | undefined>;\n  cwd?: () => string;\n} | null => {\n  const globalObj = globalThis as any;\n  return globalObj?.process ?? null;\n};\n\nconst isNodeEnvironment = Boolean(getRuntimeProcess()?.versions?.node);\nconst isReactNative = Platform.OS !== 'web' && !isNodeEnvironment;\nconst isWeb = Platform.OS === 'web';\n\n// Try to require libraries based on environment\nlet rnLogs: any = null;\nlet winston: any = null;\n\n// Only try to require react-native-logs in React Native environments\nif (isReactNative) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    rnLogs = require('react-native-logs');\n  } catch (e) {\n    rnLogs = null;\n  }\n}\n\n// For winston, use runtime detection without static requires\nconst getWinston = () => {\n  if (winston !== null) return winston;\n  if (!isNodeEnvironment) return null;\n\n  try {\n    // Use eval to dynamically construct the require call\n    // This prevents static analysis from finding 'winston' in require()\n    const winstonModule = eval('require')('winston');\n    winston = winstonModule;\n    return winston;\n  } catch (e) {\n    winston = null;\n    return null;\n  }\n};\n\nexport type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'silent';\nexport type LoggerRuntimeConfig = {\n  level?: LogLevel;\n  enableFileLogging?: boolean;\n  logFileDir?: string;\n  remoteEnabled?: boolean;\n  remoteUrl?: string;\n  remoteToken?: string;\n};\n\nexport type LoggerTelemetryBridge = {\n  captureException?: (error: Error, context?: Record<string, unknown>) => void;\n  captureMessage?: (\n    message: string,\n    level?: \"error\" | \"warn\" | \"info\" | \"debug\",\n    context?: Record<string, unknown>\n  ) => void;\n};\n\n// Read desired log level from env/config\nfunction getDefaultLogLevel(): LogLevel {\n  const env = getRuntimeProcess()?.env ?? {};\n  const level = env.REACT_APP_LOG_LEVEL || env.EXPO_PUBLIC_LOG_LEVEL || env.LOG_LEVEL;\n  if (!level) return (isNodeEnvironment || isWeb) ? 'info' : 'warn';\n  const normalized = level.toLowerCase();\n  if (['error', 'warn', 'info', 'debug', 'silent'].includes(normalized)) {\n    return normalized as LogLevel;\n  }\n  return 'info';\n}\n\nlet currentLevel: LogLevel = getDefaultLogLevel();\nlet runtimeLoggerConfig: LoggerRuntimeConfig = {};\nlet loggerTelemetryBridge: LoggerTelemetryBridge | null = null;\n\nconst pad2 = (n: number) => String(n).padStart(2, '0');\nconst formatLocalDate = (date = new Date()) =>\n  `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;\nconst buildDailyFileName = (date = new Date()) => `logs-${formatLocalDate(date)}.log`;\n\nconst getEnvConfig = () => {\n  return getRuntimeProcess()?.env ?? {};\n};\n\nconst isValidLogLevel = (level: unknown): level is LogLevel => {\n  return typeof level === 'string' && ['error', 'warn', 'info', 'debug', 'silent'].includes(level);\n};\n\nconst isFileLoggingEnabled = () => {\n  if (typeof runtimeLoggerConfig.enableFileLogging === 'boolean') {\n    return runtimeLoggerConfig.enableFileLogging;\n  }\n  const env = getEnvConfig();\n  const raw =\n    env.REACT_APP_ENABLE_WINSTON_FILE ||\n    env.EXPO_PUBLIC_ENABLE_WINSTON_FILE ||\n    env.REACT_APP_ENABLE_FILE_LOGS ||\n    env.EXPO_PUBLIC_ENABLE_FILE_LOGS ||\n    env.LOG_FILE_ENABLED;\n  if (raw === undefined) return true;\n  return raw === 'true' || raw === '1';\n};\n\nconst getConfiguredLogDir = () => {\n  if (runtimeLoggerConfig.logFileDir && runtimeLoggerConfig.logFileDir.trim()) {\n    return runtimeLoggerConfig.logFileDir;\n  }\n  const env = getEnvConfig();\n  return env.REACT_APP_LOG_FILE_DIR || env.EXPO_PUBLIC_LOG_FILE_DIR || env.LOG_FILE_DIR || '.';\n};\n\nconst formatLogLine = (level: LogLevel, args: any[]) => {\n  const ts = new Date().toISOString();\n  const serialize = (value: any) => {\n    if (value instanceof Error) {\n      const stack = value.stack ? `\\n${value.stack}` : '';\n      return `${value.message}${stack}`;\n    }\n    if (typeof value === 'string') return value;\n    try {\n      return JSON.stringify(value);\n    } catch {\n      return String(value);\n    }\n  };\n  const payload = args.map(serialize).join(' ');\n  return `${ts} [${level.toUpperCase()}] ${payload}\\n`;\n};\n\ntype FileSink = { write: (level: LogLevel, args: any[]) => void };\nlet fileSink: FileSink | null | undefined = undefined;\ntype RemoteSink = { write: (level: LogLevel, args: any[]) => void };\nlet remoteSink: RemoteSink | null | undefined = undefined;\n\nconst getConfiguredRemoteUrl = () => {\n  if (runtimeLoggerConfig.remoteUrl && runtimeLoggerConfig.remoteUrl.trim()) {\n    return runtimeLoggerConfig.remoteUrl;\n  }\n  const env = getEnvConfig();\n  return env.REACT_APP_LOG_REMOTE_URL || env.EXPO_PUBLIC_LOG_REMOTE_URL || env.LOG_REMOTE_URL || '';\n};\n\nconst getConfiguredRemoteToken = () => {\n  if (runtimeLoggerConfig.remoteToken && runtimeLoggerConfig.remoteToken.trim()) {\n    return runtimeLoggerConfig.remoteToken;\n  }\n  const env = getEnvConfig();\n  return env.REACT_APP_LOG_INGEST_TOKEN || env.EXPO_PUBLIC_LOG_INGEST_TOKEN || env.LOG_INGEST_TOKEN || '';\n};\n\nconst isRemoteLoggingEnabled = () => {\n  if (typeof runtimeLoggerConfig.remoteEnabled === 'boolean') {\n    return runtimeLoggerConfig.remoteEnabled && Boolean(getConfiguredRemoteUrl());\n  }\n  const remoteUrl = getConfiguredRemoteUrl();\n  if (!remoteUrl) return false;\n  const env = getEnvConfig();\n  const raw =\n    env.REACT_APP_ENABLE_REMOTE_LOGS ||\n    env.EXPO_PUBLIC_ENABLE_REMOTE_LOGS ||\n    env.LOG_REMOTE_ENABLED;\n  if (raw === undefined) return true;\n  return raw === 'true' || raw === '1';\n};\n\nconst serializeArgForJson = (value: any): any => {\n  if (value instanceof Error) {\n    return {\n      name: value.name,\n      message: value.message,\n      stack: value.stack,\n    };\n  }\n  if (value === null || value === undefined) return value;\n  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;\n  try {\n    return JSON.parse(JSON.stringify(value));\n  } catch {\n    return String(value);\n  }\n};\n\nconst buildRemotePayload = (level: LogLevel, args: any[]) => {\n  const normalizedArgs = args.map((arg) => serializeArgForJson(arg));\n  const firstArg = normalizedArgs[0];\n  const message =\n    typeof firstArg === 'string'\n      ? firstArg\n      : normalizedArgs.map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' ');\n\n  return {\n    timestamp: new Date().toISOString(),\n    level,\n    message: message || '[empty]',\n    source: isWeb ? 'web' : 'mobile',\n    runtime: isNodeEnvironment ? 'node' : 'client',\n    args: normalizedArgs,\n  };\n};\n\nconst buildTelemetryMessage = (args: any[]): string => {\n  if (!Array.isArray(args) || args.length === 0) return \"[empty]\";\n  const [first] = args;\n  if (typeof first === \"string\" && first.trim()) return first;\n  return args\n    .map((arg) => {\n      if (arg instanceof Error) return arg.message;\n      if (typeof arg === \"string\") return arg;\n      try {\n        return JSON.stringify(arg);\n      } catch {\n        return String(arg);\n      }\n    })\n    .join(\" \")\n    .trim() || \"[empty]\";\n};\n\nconst emitTelemetryBridge = (\n  level: \"error\" | \"warn\" | \"info\" | \"debug\",\n  args: any[]\n) => {\n  if (!loggerTelemetryBridge) return;\n\n  const errorArg = args.find((arg) => arg instanceof Error) as Error | undefined;\n  const context = { level, runtime: isNodeEnvironment ? \"node\" : isWeb ? \"web\" : \"native\" };\n\n  if (errorArg && typeof loggerTelemetryBridge.captureException === \"function\") {\n    loggerTelemetryBridge.captureException(errorArg, context);\n    return;\n  }\n\n  if (typeof loggerTelemetryBridge.captureMessage === \"function\") {\n    loggerTelemetryBridge.captureMessage(buildTelemetryMessage(args), level, context);\n  }\n};\n\nconst getRemoteSink = (): RemoteSink | null => {\n  if (remoteSink !== undefined) return remoteSink ?? null;\n  if (!isRemoteLoggingEnabled()) {\n    remoteSink = null;\n    return null;\n  }\n  if (typeof fetch !== 'function') {\n    remoteSink = null;\n    return null;\n  }\n\n  const url = getConfiguredRemoteUrl();\n  const token = getConfiguredRemoteToken();\n  let sendChain = Promise.resolve();\n\n  const sendOne = async (level: LogLevel, args: any[]) => {\n    const headers: Record<string, string> = {\n      'content-type': 'application/json',\n    };\n    if (token) {\n      headers['x-log-token'] = token;\n    }\n\n    const payload = buildRemotePayload(level, args);\n    await fetch(url, {\n      method: 'POST',\n      headers,\n      body: JSON.stringify(payload),\n    });\n  };\n\n  remoteSink = {\n    write: (level, args) => {\n      sendChain = sendChain.then(() => sendOne(level, args)).catch(() => {});\n    },\n  };\n  return remoteSink;\n};\n\nconst invalidateDerivedLoggerState = () => {\n  fileSink = undefined;\n  remoteSink = undefined;\n};\n\nconst getNodeFileSink = (): FileSink | null => {\n  if (!isNodeEnvironment) return null;\n  let fs: any = null;\n  let path: any = null;\n  try {\n    fs = eval('require')('fs');\n    path = eval('require')('path');\n  } catch {\n    return null;\n  }\n\n  let currentDate = '';\n  let filePath = '';\n  const ensureFilePath = () => {\n    const today = formatLocalDate(new Date());\n    if (today === currentDate && filePath) return;\n    currentDate = today;\n    const logDir = getConfiguredLogDir() || '.';\n    const cwd = getRuntimeProcess()?.cwd?.() ?? '.';\n    const resolvedDir = path.resolve(cwd, logDir);\n    if (!fs.existsSync(resolvedDir)) {\n      try { fs.mkdirSync(resolvedDir, { recursive: true }); } catch { /* ignore */ }\n    }\n    filePath = path.join(resolvedDir, buildDailyFileName(new Date()));\n  };\n\n  return {\n    write: (level, args) => {\n      try {\n        ensureFilePath();\n        fs.appendFile(filePath, formatLogLine(level, args), () => {});\n      } catch {\n        // ignore file logging errors\n      }\n    },\n  };\n};\n\nconst getExpoFileSystem = () => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-var-requires\n    return require('expo-file-system/legacy');\n  } catch {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-var-requires\n      return require('expo-file-system');\n    } catch {\n      return null;\n    }\n  }\n};\n\nconst getExpoFileSink = (): FileSink | null => {\n  const FileSystem = getExpoFileSystem();\n  if (!FileSystem || typeof FileSystem.writeAsStringAsync !== 'function') return null;\n\n  const baseDir = FileSystem.documentDirectory || FileSystem.cacheDirectory;\n  if (!baseDir) return null;\n  const encoding = FileSystem.EncodingType?.UTF8 ?? 'utf8';\n\n  const normalizeDir = (dir: string) => dir.replace(/\\/?$/, '/');\n  const logDir = getConfiguredLogDir();\n  const subDir = logDir && logDir !== '.' ? logDir.replace(/^\\.\\/+/, '').replace(/\\/+$/, '') : '';\n  const basePath = subDir ? `${normalizeDir(baseDir)}${subDir}/` : normalizeDir(baseDir);\n\n  let currentDate = '';\n  let fileUri = '';\n  let writeChain = Promise.resolve();\n\n  const ensureFileUri = async () => {\n    const today = formatLocalDate(new Date());\n    if (today === currentDate && fileUri) return;\n    currentDate = today;\n    fileUri = `${basePath}${buildDailyFileName(new Date())}`;\n    if (subDir) {\n      try { await FileSystem.makeDirectoryAsync(basePath, { intermediates: true }); } catch { /* ignore */ }\n    }\n    try {\n      const info = await FileSystem.getInfoAsync(fileUri);\n      if (!info?.exists) {\n        await FileSystem.writeAsStringAsync(fileUri, '', { encoding });\n      }\n    } catch {\n      try { await FileSystem.writeAsStringAsync(fileUri, '', { encoding }); } catch { /* ignore */ }\n    }\n  };\n\n  const appendLine = async (line: string) => {\n    await ensureFileUri();\n    try {\n      await FileSystem.writeAsStringAsync(fileUri, line, {\n        encoding,\n        append: true,\n      });\n      return;\n    } catch {\n      // fall through to read/append fallback\n    }\n    try {\n      const existing = await FileSystem.readAsStringAsync(fileUri, { encoding });\n      await FileSystem.writeAsStringAsync(fileUri, `${existing}${line}`, { encoding });\n    } catch {\n      // ignore\n    }\n  };\n\n  return {\n    write: (level, args) => {\n      const line = formatLogLine(level, args);\n      writeChain = writeChain.then(() => appendLine(line)).catch(() => {});\n    },\n  };\n};\n\nconst getFileSink = (): FileSink | null => {\n  if (fileSink !== undefined) return fileSink ?? null;\n  if (!isFileLoggingEnabled()) {\n    fileSink = null;\n    return null;\n  }\n  const nodeSink = getNodeFileSink();\n  if (nodeSink) {\n    fileSink = nodeSink;\n    return nodeSink;\n  }\n  const expoSink = getExpoFileSink();\n  if (expoSink) {\n    fileSink = expoSink;\n    return expoSink;\n  }\n  fileSink = null;\n  return null;\n};\n\n// Create logger instance based on environment - LAZY LOADING\nlet rnLogger: any = null;\nlet winstonLogger: any = null;\n\n// Lazy initialization functions\nconst getRnLogger = () => {\n  if (rnLogger !== null) return rnLogger;\n  if (!isReactNative || !rnLogs) return null;\n\n  try {\n    const { logger: createLogger } = rnLogs;\n\n    const config = {\n      severity: currentLevel,\n      transport: (msg: any, level: string, _options: any) => {\n        const prefix = `[${level.toUpperCase()}]`;\n        switch (level) {\n          case 'error':\n            // eslint-disable-next-line no-console\n            console.error(prefix, ...msg);\n            break;\n          case 'warn':\n            // eslint-disable-next-line no-console\n            console.warn(prefix, ...msg);\n            break;\n          case 'info':\n            // eslint-disable-next-line no-console\n            console.log(prefix, ...msg);\n            break;\n          case 'debug':\n            // eslint-disable-next-line no-console\n            console.debug ? console.debug(prefix, ...msg) : console.log(prefix, ...msg);\n            break;\n          default:\n            // eslint-disable-next-line no-console\n            console.log(prefix, ...msg);\n        }\n      },\n      transportOptions: {\n        colors: {\n          error: 'red',\n          warn: 'yellow',\n          info: 'blue',\n          debug: 'gray',\n        },\n      },\n    };\n\n    rnLogger = createLogger(config);\n    return rnLogger;\n  } catch (e) {\n    rnLogger = null;\n    return null;\n  }\n};\n\nconst getWinstonLogger = () => {\n  if (winstonLogger !== null) return winstonLogger;\n  if (!isNodeEnvironment) return null;\n\n  const winston = getWinston();\n  if (!winston) return null;\n\n  try {\n    const { createLogger, format, transports } = winston;\n    const transportInstances: any[] = [new transports.Console({ level: currentLevel })];\n\n    winstonLogger = createLogger({\n      level: currentLevel,\n      format: format.combine(\n        format.timestamp(),\n        format.errors({ stack: true }),\n        format.splat(),\n        format.json()\n      ),\n      transports: transportInstances,\n    });\n    return winstonLogger;\n  } catch (e) {\n    winstonLogger = null;\n    return null;\n  }\n};\n\n// Initialize RN logger immediately if in React Native\nif (isReactNative) {\n  getRnLogger();\n}\n\nexport function setLogLevel(level: LogLevel) {\n  currentLevel = level;\n  // Update logger severity if available\n  const rnLogger = getRnLogger();\n  if (rnLogger && rnLogger.setSeverity) {\n    rnLogger.setSeverity(level);\n  }\n  const winstonLogger = getWinstonLogger();\n  if (winstonLogger) {\n    winstonLogger.level = level;\n  }\n}\n\nexport function configureLogger(config: LoggerRuntimeConfig = {}) {\n  runtimeLoggerConfig = {\n    ...runtimeLoggerConfig,\n    ...config,\n  };\n\n  if (isValidLogLevel(config.level)) {\n    currentLevel = config.level;\n  }\n\n  invalidateDerivedLoggerState();\n\n  // Keep active logger instances aligned with the updated effective level.\n  const rnLogger = getRnLogger();\n  if (rnLogger && rnLogger.setSeverity) {\n    rnLogger.setSeverity(currentLevel);\n  }\n  const winstonLogger = getWinstonLogger();\n  if (winstonLogger) {\n    winstonLogger.level = currentLevel;\n  }\n}\n\nexport function setLoggerTelemetryBridge(bridge?: LoggerTelemetryBridge | null) {\n  loggerTelemetryBridge = bridge ?? null;\n}\n\nfunction levelPriority(l: LogLevel) {\n  switch (l) {\n    case 'silent': return 0;\n    case 'error': return 1;\n    case 'warn': return 2;\n    case 'info': return 3;\n    case 'debug': return 4;\n    default: return 3;\n  }\n}\n\n// Lightweight logger API used across the app\nexport const logger = {\n  error: (...args: any[]) => {\n    if (levelPriority(currentLevel) >= levelPriority('error')) {\n      const rnLogger = getRnLogger();\n      if (rnLogger) {\n        rnLogger.error(...args);\n      } else {\n        const winstonLogger = getWinstonLogger();\n        if (winstonLogger) {\n          winstonLogger.error(...args);\n        } else {\n          // eslint-disable-next-line no-console\n          console.error('[error]', ...args);\n        }\n      }\n      const sink = getFileSink();\n      if (sink) sink.write('error', args);\n      const remote = getRemoteSink();\n      if (remote) remote.write('error', args);\n      emitTelemetryBridge(\"error\", args);\n    }\n  },\n  warn: (...args: any[]) => {\n    if (levelPriority(currentLevel) >= levelPriority('warn')) {\n      const rnLogger = getRnLogger();\n      if (rnLogger) {\n        rnLogger.warn(...args);\n      } else {\n        const winstonLogger = getWinstonLogger();\n        if (winstonLogger) {\n          winstonLogger.warn(...args);\n        } else {\n          // eslint-disable-next-line no-console\n          console.warn('[warn]', ...args);\n        }\n      }\n      const sink = getFileSink();\n      if (sink) sink.write('warn', args);\n      const remote = getRemoteSink();\n      if (remote) remote.write('warn', args);\n      emitTelemetryBridge(\"warn\", args);\n    }\n  },\n  info: (...args: any[]) => {\n    if (levelPriority(currentLevel) >= levelPriority('info')) {\n      const rnLogger = getRnLogger();\n      if (rnLogger) {\n        rnLogger.info(...args);\n      } else {\n        const winstonLogger = getWinstonLogger();\n        if (winstonLogger) {\n          winstonLogger.info(...args);\n        } else {\n          // eslint-disable-next-line no-console\n          console.log('[info]', ...args);\n        }\n      }\n      const sink = getFileSink();\n      if (sink) sink.write('info', args);\n      const remote = getRemoteSink();\n      if (remote) remote.write('info', args);\n    }\n  },\n  debug: (...args: any[]) => {\n    if (levelPriority(currentLevel) >= levelPriority('debug')) {\n      const rnLogger = getRnLogger();\n      if (rnLogger) {\n        rnLogger.debug(...args);\n      } else {\n        const winstonLogger = getWinstonLogger();\n        if (winstonLogger) {\n          winstonLogger.debug(...args);\n        } else {\n          // eslint-disable-next-line no-console\n          console.debug ? console.debug('[debug]', ...args) : console.log('[debug]', ...args);\n        }\n      }\n      const sink = getFileSink();\n      if (sink) sink.write('debug', args);\n      const remote = getRemoteSink();\n      if (remote) remote.write('debug', args);\n    }\n  }\n};\n\nexport default logger;\n"],"mappings":"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","ignoreList":[]}