@lichens-innovation/react-native-common 3.10.0 → 3.11.1

package/dist/index.js

@@ -1,10 +1,4667 @@
-export * from './components';
-export * from './config';
-export * from './hooks';
-export * from './i18n';
-export * from './logger';
-export * from './services';
-export * from './store';
-export * from './theme';
-export * from './utils';
+'use strict';
+
+var reactNativePaper = require('react-native-paper');
+var tsCommon = require('@lichens-innovation/ts-common');
+var jsxRuntime = require('react/jsx-runtime');
+var bottomSheet = require('@gorhom/bottom-sheet');
+var reactNative = require('react-native');
+var native = require('@react-navigation/native');
+var react = require('react');
+var Sentry = require('@sentry/react-native');
+var reactNativeLogs = require('react-native-logs');
+var expoFileSystem = require('expo-file-system');
+var FileSystemLegacy = require('expo-file-system/legacy');
+var reactNativeMmkv = require('react-native-mmkv');
+var mobx = require('mobx');
+var Constants = require('expo-constants');
+var Device = require('expo-device');
+var Updates2 = require('expo-updates');
+var reactI18next = require('react-i18next');
+var expoCamera = require('expo-camera');
+var i18next = require('i18next');
+var Clipboard = require('@react-native-clipboard/clipboard');
+var mobxReactLite = require('mobx-react-lite');
+var SyntaxHighlighter = require('react-native-syntax-highlighter');
+var mobxPersistStore = require('mobx-persist-store');
+var reactNativeElementDropdown = require('react-native-element-dropdown');
+var expoRouter = require('expo-router');
+var Sharing = require('expo-sharing');
+var buffer = require('buffer');
+var uuid = require('react-native-uuid');
+var reactNativeGestureHandler = require('react-native-gesture-handler');
+var list = require('@legendapp/list');
+var usehooks = require('@uidotdev/usehooks');
+var dateFns = require('date-fns');
+var filesize = require('filesize');
+var ui = require('expo-router/ui');
+var reactNativeSafeAreaContext = require('react-native-safe-area-context');
+var Animated = require('react-native-reanimated');
+var axios = require('axios');
+var legacy_js = require('@noble/hashes/legacy.js');
+var utils_js = require('@noble/hashes/utils.js');
+var immer = require('immer');
+var DocumentPicker = require('expo-document-picker');
+var dateFnsTz = require('date-fns-tz');
+var Handlebars = require('handlebars');
+var netinfo = require('@react-native-community/netinfo');
+var SQLite = require('expo-sqlite');
+var expoSpeechRecognition = require('expo-speech-recognition');
+var ImagePicker = require('expo-image-picker');
+var reactQuery = require('@tanstack/react-query');
+var expoApplication = require('expo-application');
+var Localization = require('expo-localization');
+var Zeroconf = require('react-native-zeroconf');
+var Location = require('expo-location');
+var WifiManager = require('react-native-wifi-reborn');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Sentry__namespace = /*#__PURE__*/_interopNamespace(Sentry);
+var FileSystemLegacy__namespace = /*#__PURE__*/_interopNamespace(FileSystemLegacy);
+var Constants__default = /*#__PURE__*/_interopDefault(Constants);
+var Device__namespace = /*#__PURE__*/_interopNamespace(Device);
+var Updates2__namespace = /*#__PURE__*/_interopNamespace(Updates2);
+var i18next__default = /*#__PURE__*/_interopDefault(i18next);
+var Clipboard__default = /*#__PURE__*/_interopDefault(Clipboard);
+var SyntaxHighlighter__default = /*#__PURE__*/_interopDefault(SyntaxHighlighter);
+var Sharing__namespace = /*#__PURE__*/_interopNamespace(Sharing);
+var uuid__default = /*#__PURE__*/_interopDefault(uuid);
+var Animated__default = /*#__PURE__*/_interopDefault(Animated);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var DocumentPicker__namespace = /*#__PURE__*/_interopNamespace(DocumentPicker);
+var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
+var SQLite__namespace = /*#__PURE__*/_interopNamespace(SQLite);
+var ImagePicker__namespace = /*#__PURE__*/_interopNamespace(ImagePicker);
+var Localization__namespace = /*#__PURE__*/_interopNamespace(Localization);
+var Zeroconf__default = /*#__PURE__*/_interopDefault(Zeroconf);
+var Location__namespace = /*#__PURE__*/_interopNamespace(Location);
+var WifiManager__default = /*#__PURE__*/_interopDefault(WifiManager);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/pretty-bytes/index.js
+var require_pretty_bytes = __commonJS({
+  "node_modules/pretty-bytes/index.js"(exports$1, module) {
+    var BYTE_UNITS = [
+      "B",
+      "kB",
+      "MB",
+      "GB",
+      "TB",
+      "PB",
+      "EB",
+      "ZB",
+      "YB"
+    ];
+    var BIBYTE_UNITS = [
+      "B",
+      "kiB",
+      "MiB",
+      "GiB",
+      "TiB",
+      "PiB",
+      "EiB",
+      "ZiB",
+      "YiB"
+    ];
+    var BIT_UNITS = [
+      "b",
+      "kbit",
+      "Mbit",
+      "Gbit",
+      "Tbit",
+      "Pbit",
+      "Ebit",
+      "Zbit",
+      "Ybit"
+    ];
+    var BIBIT_UNITS = [
+      "b",
+      "kibit",
+      "Mibit",
+      "Gibit",
+      "Tibit",
+      "Pibit",
+      "Eibit",
+      "Zibit",
+      "Yibit"
+    ];
+    var toLocaleString = (number, locale, options2) => {
+      let result = number;
+      if (typeof locale === "string" || Array.isArray(locale)) {
+        result = number.toLocaleString(locale, options2);
+      } else if (locale === true || options2 !== void 0) {
+        result = number.toLocaleString(void 0, options2);
+      }
+      return result;
+    };
+    module.exports = (number, options2) => {
+      if (!Number.isFinite(number)) {
+        throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+      }
+      options2 = Object.assign({ bits: false, binary: false }, options2);
+      const UNITS = options2.bits ? options2.binary ? BIBIT_UNITS : BIT_UNITS : options2.binary ? BIBYTE_UNITS : BYTE_UNITS;
+      if (options2.signed && number === 0) {
+        return ` 0 ${UNITS[0]}`;
+      }
+      const isNegative = number < 0;
+      const prefix = isNegative ? "-" : options2.signed ? "+" : "";
+      if (isNegative) {
+        number = -number;
+      }
+      let localeOptions;
+      if (options2.minimumFractionDigits !== void 0) {
+        localeOptions = { minimumFractionDigits: options2.minimumFractionDigits };
+      }
+      if (options2.maximumFractionDigits !== void 0) {
+        localeOptions = Object.assign({ maximumFractionDigits: options2.maximumFractionDigits }, localeOptions);
+      }
+      if (number < 1) {
+        const numberString2 = toLocaleString(number, options2.locale, localeOptions);
+        return prefix + numberString2 + " " + UNITS[0];
+      }
+      const exponent = Math.min(Math.floor(options2.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
+      number /= Math.pow(options2.binary ? 1024 : 1e3, exponent);
+      if (!localeOptions) {
+        number = number.toPrecision(3);
+      }
+      const numberString = toLocaleString(Number(number), options2.locale, localeOptions);
+      const unit = UNITS[exponent];
+      return prefix + numberString + " " + unit;
+    };
+  }
+});
+var getBatteryIcon = (level) => {
+  if (tsCommon.isNullish(level)) return "battery-alert-variant-outline";
+  if (level >= 90) return "battery";
+  if (level >= 75) return "battery-60";
+  if (level >= 60) return "battery-50";
+  if (level >= 45) return "battery-40";
+  if (level >= 30) return "battery-30";
+  if (level >= 15) return "battery-20";
+  if (level > 0) return "battery-10";
+  return "battery-arrow-down-outline";
+};
+var getBatteryColor = (batteryLevel) => {
+  return tsCommon.isNullish(batteryLevel) ? "gray" : tsCommon.getColorForPercentage(batteryLevel / 100);
+};
+var BatteryLevel = ({ batteryLevel, size = 32 }) => {
+  const batteryColor = getBatteryColor(batteryLevel);
+  const batteryIcon = getBatteryIcon(batteryLevel);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Icon, { source: batteryIcon, size, color: batteryColor });
+};
+
+// src/components/bottom-sheet/bottom-sheet.constants.ts
+var DEFAULT_SHEET_SNAP_POINTS = ["55%", "65%", "75%"];
+var DefaultBackdrop = (props) => /* @__PURE__ */ jsxRuntime.jsx(bottomSheet.BottomSheetBackdrop, { disappearsOnIndex: -1, appearsOnIndex: 0, ...props });
+
+// src/theme/dark-colors-scheme.ts
+var DARK_COLORS_SCHEME = {
+  primary: "rgb(170, 212, 114)",
+  onPrimary: "rgb(32, 54, 0)",
+  primaryContainer: "rgb(49, 79, 0)",
+  onPrimaryContainer: "rgb(197, 240, 139)",
+  secondary: "rgb(185, 209, 101)",
+  onSecondary: "rgb(42, 53, 0)",
+  secondaryContainer: "rgb(62, 76, 0)",
+  onSecondaryContainer: "rgb(212, 237, 126)",
+  tertiary: "rgb(167, 212, 116)",
+  onTertiary: "rgb(30, 55, 0)",
+  tertiaryContainer: "rgb(45, 80, 0)",
+  onTertiaryContainer: "rgb(194, 241, 141)",
+  error: "rgb(255, 180, 171)",
+  onError: "rgb(105, 0, 5)",
+  errorContainer: "rgb(147, 0, 10)",
+  onErrorContainer: "rgb(255, 180, 171)",
+  background: "rgb(27, 28, 24)",
+  onBackground: "rgb(227, 227, 219)",
+  surface: "rgb(27, 28, 24)",
+  onSurface: "rgb(227, 227, 219)",
+  surfaceVariant: "rgb(68, 72, 61)",
+  onSurfaceVariant: "rgb(197, 200, 185)",
+  outline: "rgb(143, 146, 133)",
+  outlineVariant: "rgb(68, 72, 61)",
+  shadow: "rgb(0, 0, 0)",
+  scrim: "rgb(0, 0, 0)",
+  inverseSurface: "rgb(227, 227, 219)",
+  inverseOnSurface: "rgb(48, 49, 44)",
+  inversePrimary: "rgb(69, 104, 18)",
+  elevation: {
+    level0: "transparent",
+    level1: "rgb(34, 37, 29)",
+    level2: "rgb(38, 43, 31)",
+    level3: "rgb(43, 48, 34)",
+    level4: "rgb(44, 50, 35)",
+    level5: "rgb(47, 54, 37)"
+  },
+  surfaceDisabled: "rgba(227, 227, 219, 0.12)",
+  onSurfaceDisabled: "rgba(227, 227, 219, 0.38)",
+  backdrop: "rgba(46, 50, 40, 0.4)"
+};
+
+// src/theme/light-colors-scheme.ts
+var LIGHT_COLORS_SCHEME = {
+  primary: "rgb(69, 104, 18)",
+  onPrimary: "rgb(255, 255, 255)",
+  primaryContainer: "rgb(197, 240, 139)",
+  onPrimaryContainer: "rgb(17, 32, 0)",
+  secondary: "rgb(83, 102, 0)",
+  onSecondary: "rgb(255, 255, 255)",
+  secondaryContainer: "rgb(212, 237, 126)",
+  onSecondaryContainer: "rgb(23, 30, 0)",
+  tertiary: "rgb(67, 105, 21)",
+  onTertiary: "rgb(255, 255, 255)",
+  tertiaryContainer: "rgb(194, 241, 141)",
+  onTertiaryContainer: "rgb(15, 32, 0)",
+  error: "rgb(186, 26, 26)",
+  onError: "rgb(255, 255, 255)",
+  errorContainer: "rgb(255, 218, 214)",
+  onErrorContainer: "rgb(65, 0, 2)",
+  background: "rgb(253, 252, 245)",
+  onBackground: "rgb(27, 28, 24)",
+  surface: "rgb(253, 252, 245)",
+  onSurface: "rgb(27, 28, 24)",
+  surfaceVariant: "rgb(225, 228, 213)",
+  onSurfaceVariant: "rgb(68, 72, 61)",
+  outline: "rgb(117, 121, 108)",
+  outlineVariant: "rgb(197, 200, 185)",
+  shadow: "rgb(0, 0, 0)",
+  scrim: "rgb(0, 0, 0)",
+  inverseSurface: "rgb(48, 49, 44)",
+  inverseOnSurface: "rgb(242, 241, 233)",
+  inversePrimary: "rgb(170, 212, 114)",
+  elevation: {
+    level0: "transparent",
+    level1: "rgb(244, 245, 234)",
+    level2: "rgb(238, 240, 227)",
+    level3: "rgb(233, 236, 220)",
+    level4: "rgb(231, 234, 218)",
+    level5: "rgb(227, 231, 213)"
+  },
+  surfaceDisabled: "rgba(27, 28, 24, 0.12)",
+  onSurfaceDisabled: "rgba(27, 28, 24, 0.38)",
+  backdrop: "rgba(46, 50, 40, 0.4)"
+};
+
+// src/theme/theme.ts
+var DEFAULT_SPACING = 8;
+var spacing = (units = 1) => units * DEFAULT_SPACING;
+var roundness = 2;
+var DARK_THEME = {
+  ...reactNativePaper.MD3DarkTheme,
+  colors: {
+    ...reactNativePaper.MD3DarkTheme.colors,
+    ...DARK_COLORS_SCHEME
+  },
+  spacing,
+  roundness
+};
+var LIGHT_THEME = {
+  ...reactNativePaper.MD3LightTheme,
+  colors: {
+    ...reactNativePaper.MD3LightTheme.colors,
+    ...LIGHT_COLORS_SCHEME
+  },
+  spacing,
+  roundness
+};
+var navigationAdaptedThemes = reactNativePaper.adaptNavigationTheme({
+  reactNavigationLight: native.DefaultTheme,
+  reactNavigationDark: native.DarkTheme,
+  materialLight: LIGHT_THEME,
+  materialDark: DARK_THEME
+});
+var { DarkTheme, LightTheme } = navigationAdaptedThemes;
+var NAVIGATION_DARK = { ...DarkTheme, fonts: { ...native.DarkTheme.fonts } };
+var NAVIGATION_LIGHT = { ...LightTheme, fonts: { ...native.DefaultTheme.fonts } };
+var useAppTheme = () => reactNativePaper.useTheme();
+var useIsDarkMode = () => {
+  const theme = useAppTheme();
+  return theme.dark;
+};
+var DefaultSheetBackground = ({ style }) => {
+  const { colors } = useAppTheme();
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [style, { backgroundColor: colors.background }] });
+};
+var mmkvStorage = new reactNativeMmkv.MMKV();
+var setItem = (key, data) => {
+  if (data instanceof ArrayBuffer) {
+    mmkvStorage.set(key, data);
+  } else if (typeof data === "boolean" || typeof data === "number" || typeof data === "string") {
+    mmkvStorage.set(key, data);
+  } else {
+    mmkvStorage.set(key, JSON.stringify(data));
+  }
+};
+var getItem = (key, defaultValue) => {
+  if (defaultValue instanceof Uint8Array) {
+    return mmkvStorage.getBuffer(key) ?? defaultValue;
+  }
+  if (typeof defaultValue === "boolean") {
+    return mmkvStorage.getBoolean(key) ?? defaultValue;
+  }
+  if (typeof defaultValue === "number") {
+    return mmkvStorage.getNumber(key) ?? defaultValue;
+  }
+  const stringValue = mmkvStorage.getString(key);
+  if (stringValue === void 0 || stringValue === null) return defaultValue;
+  if (typeof defaultValue === "string") {
+    return stringValue;
+  }
+  try {
+    return JSON.parse(stringValue);
+  } catch {
+    return stringValue;
+  }
+};
+var removeItem = (key) => {
+  mmkvStorage.delete(key);
+};
+var storage = {
+  setItem,
+  getItem,
+  removeItem
+};
+var mmkvStorageForMobxPersist = {
+  setItem: (key, value) => {
+    mmkvStorage.set(key, value);
+    return Promise.resolve();
+  },
+  getItem: (key) => {
+    const value = mmkvStorage.getString(key);
+    return Promise.resolve(value ?? null);
+  },
+  removeItem: (key) => {
+    mmkvStorage.delete(key);
+    return Promise.resolve();
+  }
+};
+
+// src/config/env.config.ts
+var isSentryActivated = () => storage.getItem("SENTRY_ACTIVATED", "") === "true";
+var getSentryDns = () => storage.getItem("SENTRY_DNS", "") ?? "";
+var MAX_LOG_ENTRIES = 10 * 1e3;
+var CommonLogsStore = class {
+  constructor() {
+    this.logEntries = [];
+    mobx.makeAutoObservable(this);
+  }
+  get allLogsAsText() {
+    return this.logEntries.map((log) => log.msg).filter((log) => !!log).join("\n");
+  }
+  addLog(logEntry) {
+    this.logEntries.push(logEntry);
+    if (this.logEntries.length > MAX_LOG_ENTRIES) {
+      this.logEntries.shift();
+    }
+  }
+  clearLogs() {
+    this.logEntries = [];
+  }
+  filterLogs(filterText) {
+    const lowerCaseFilterText = filterText.toLowerCase();
+    return this.logEntries.filter((log) => log.msg.toLowerCase().includes(lowerCaseFilterText));
+  }
+};
+var commonLogsStore = new CommonLogsStore();
+var commonLogsStoreTransport = (props) => {
+  commonLogsStore.addLog(props);
+};
+var isRealDevice = () => {
+  return Device__namespace.isDevice;
+};
+var isEmulator = () => {
+  return !Device__namespace.isDevice;
+};
+var getDeviceType = () => {
+  const isReal = isRealDevice();
+  return reactNative.Platform.select({
+    ios: isReal ? "iOS Device" : "iOS Simulator",
+    android: isReal ? "Android Device" : "Android Emulator",
+    default: isReal ? `${reactNative.Platform.OS} Real Device` : `${reactNative.Platform.OS} Emulator`
+  });
+};
+var getAppIdentifier = () => {
+  const bundleId = reactNative.Platform.select({
+    ios: Constants__default.default.expoConfig?.ios?.bundleIdentifier,
+    android: Constants__default.default.expoConfig?.android?.package,
+    default: "Unknown"
+  });
+  const id = bundleId?.split(".").pop();
+  return id ?? "";
+};
+var isProduction = () => {
+  return Updates2__namespace.channel === "production";
+};
+var isPreview = () => {
+  return Updates2__namespace.channel === "preview";
+};
+var isDevelopment = () => {
+  return __DEV__ || !Updates2__namespace.channel;
+};
+var getEnvVarsSource = () => {
+  if (Constants__default.default.executionEnvironment === "storeClient") {
+    return "EAS (Production)";
+  }
+  return "Local Development";
+};
+var validateGetRandomValues = () => {
+  if (!crypto?.getRandomValues) {
+    logger.error("[validateGetRandomValues] crypto.getRandomValues is not available as a global environment function");
+    return false;
+  }
+  const typeOfGetRandomValues = typeof crypto.getRandomValues;
+  if (typeOfGetRandomValues !== "function") {
+    logger.error(`[validateGetRandomValues] crypto.getRandomValues is not a function: ${typeOfGetRandomValues}`);
+    return false;
+  }
+  logger.debug("[validateGetRandomValues] global crypto getRandomValues is available as a global environment function");
+  return true;
+};
+
+// src/logger/logger.types.ts
+var LOG_LEVELS = {
+  debug: 0,
+  log: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+
+// src/logger/logger.ts
+reactNative.LogBox.ignoreLogs([/^ErrorBoundary /, /Support for defaultProps will be removed from function components/]);
+var appName = getAppIdentifier();
+var logFilenamePrefix = `app-logs-${appName}`;
+var logFilenamePattern = `${logFilenamePrefix}-{date-today}.txt`;
+var filePath = expoFileSystem.Paths.document.uri;
+if (!filePath) {
+  throw new Error("Failed to initialize logger: document directory path is unavailable");
+}
+var LoggerWrapper = class {
+  constructor(config) {
+    this._logger = reactNativeLogs.logger.createLogger(config);
+  }
+  debug(message, ...args) {
+    this._logger.debug(message, ...args);
+  }
+  log(message, ...args) {
+    this._logger.log(message, ...args);
+  }
+  info(message, ...args) {
+    this._logger.info(message, ...args);
+  }
+  warn(message, ...args) {
+    this._logger.warn(message, ...args);
+  }
+  error(message, ...args) {
+    this._logger.error(message, ...args);
+  }
+};
+var getTransports = () => {
+  const transports = [reactNativeLogs.fileAsyncTransport, commonLogsStoreTransport];
+  if (!isDevelopment() && isSentryActivated()) {
+    Sentry__namespace.init({
+      dsn: getSentryDns(),
+      // We can add more context data to events (IP address, cookies, user, etc.)
+      // @see https://docs.sentry.io/platforms/react-native/data-management/data-collected/
+      sendDefaultPii: true
+    });
+    transports.push(reactNativeLogs.sentryTransport);
+  }
+  if (isDevelopment()) {
+    transports.push(reactNativeLogs.mapConsoleTransport);
+  }
+  return transports;
+};
+var logger = new LoggerWrapper({
+  severity: "debug",
+  transport: getTransports(),
+  levels: {
+    debug: LOG_LEVELS.debug,
+    log: LOG_LEVELS.log,
+    info: LOG_LEVELS.info,
+    warn: LOG_LEVELS.warn,
+    error: LOG_LEVELS.error
+  },
+  async: true,
+  asyncFunc: reactNative.InteractionManager.runAfterInteractions,
+  dateFormat: (date) => `${date.toISOString()} `,
+  printLevel: true,
+  fixedExtLvlLength: true,
+  printDate: true,
+  enabled: true,
+  transportOptions: {
+    // @see https://github.com/mowispace/react-native-logs?tab=readme-ov-file#sentrytransport
+    SENTRY: Sentry__namespace,
+    errorLevels: "error",
+    // @see https://github.com/mowispace/react-native-logs?tab=readme-ov-file#mapconsoletransport
+    mapLevels: {
+      debug: "debug",
+      log: "log",
+      info: "info",
+      warn: "warn",
+      error: "error"
+    },
+    // @see https://github.com/mowispace/react-native-logs?tab=readme-ov-file#fileasynctransport
+    FS: FileSystemLegacy__namespace,
+    fileNameDateType: "iso",
+    fileName: logFilenamePattern,
+    filePath
+  }
+});
+var isLogFile = (fileName) => {
+  return fileName.startsWith(logFilenamePrefix);
+};
+var isLogFileItem = (item) => {
+  return item instanceof expoFileSystem.File && isLogFile(item.name);
+};
+var byMostRecentFirstComparator = (a, b) => {
+  return (b.modificationTime ?? 0) - (a.modificationTime ?? 0);
+};
+var loadAllLogFilesInfo = async () => {
+  try {
+    const pathInfo = expoFileSystem.Paths.info(filePath);
+    if (!pathInfo.exists) {
+      return [];
+    }
+    const directory = new expoFileSystem.Directory(filePath);
+    const items = directory.list();
+    const logFiles = items.filter(isLogFileItem);
+    const fileInfos = logFiles.map((file) => {
+      const info = file.info();
+      return {
+        exists: info.exists,
+        isDirectory: false,
+        size: info.size ?? 0,
+        modificationTime: info.modificationTime ?? 0,
+        uri: file.uri
+      };
+    }).filter((info) => info.exists);
+    return fileInfos.sort(byMostRecentFirstComparator);
+  } catch (e) {
+    logger.error("Error loading files:", e);
+    return [];
+  }
+};
+var loadCurrentLogsFileUri = async () => {
+  const fileInfos = await loadAllLogFilesInfo();
+  return fileInfos[0]?.uri ?? "";
+};
+var deleteAllLogFiles = async () => {
+  try {
+    const pathInfo = expoFileSystem.Paths.info(filePath);
+    if (!pathInfo.exists) {
+      return;
+    }
+    const directory = new expoFileSystem.Directory(filePath);
+    const items = directory.list();
+    const logFiles = items.filter(isLogFileItem);
+    const errors = [];
+    for (const file of logFiles) {
+      try {
+        file.delete();
+      } catch (e) {
+        errors.push(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Failed to delete ${errors.length} log file(s): ${errors.map((e) => e.message).join("; ")}`);
+    }
+  } catch (e) {
+    logger.error("Error deleting files:", e);
+    throw e;
+  }
+};
+
+// src/components/bottom-sheet/use-bottom-sheet-toggler.ts
+var useBottomSheetToggler = () => {
+  const bottomSheetModalRef = react.useRef(null);
+  const [isBottomSheetOpen, setIsBottomSheetOpen] = react.useState(false);
+  const showBottomSheet = () => {
+    setIsBottomSheetOpen(true);
+    bottomSheetModalRef.current?.present();
+  };
+  const hideBottomSheet = () => {
+    logger.debug("[useBottomSheetToggler] hideBottomSheet");
+    setIsBottomSheetOpen(false);
+    bottomSheetModalRef.current?.dismiss();
+  };
+  const onBackButtonPress = () => {
+    if (!isBottomSheetOpen || !bottomSheetModalRef.current) {
+      return false;
+    }
+    logger.debug("[useBottomSheetToggler] onBackButtonPress: closing bottom sheet");
+    hideBottomSheet();
+    return true;
+  };
+  react.useEffect(() => {
+    if (!isBottomSheetOpen) return;
+    const backHandler = reactNative.BackHandler.addEventListener("hardwareBackPress", onBackButtonPress);
+    return () => backHandler.remove();
+  }, [isBottomSheetOpen]);
+  return {
+    bottomSheetModalRef,
+    showBottomSheet,
+    hideBottomSheet,
+    isBottomSheetOpen
+  };
+};
+var LARGE_SCREEN_WIDTH = 600;
+var MAX_DIALOG_WIDTH = 500;
+var useDialogStyles = () => {
+  const { width: deviceWidth } = reactNative.useWindowDimensions();
+  const width = deviceWidth > LARGE_SCREEN_WIDTH ? MAX_DIALOG_WIDTH : void 0;
+  const alignSelf = width ? "center" : void 0;
+  return {
+    width,
+    alignSelf
+  };
+};
+var DialogCloseOnly = ({
+  icon,
+  title,
+  content,
+  onClose,
+  isVisible,
+  ...rest
+}) => {
+  const { style: dialogStyleProp, ...dialogProps } = rest;
+  const styles7 = useStyles();
+  const { t } = reactI18next.useTranslation();
+  const hasIcon = !!icon;
+  const hasTitle = !!title;
+  const hasContent = !!content;
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog, { style: [styles7.dialog, dialogStyleProp], visible: true, onDismiss: onClose, ...dialogProps, children: [
+    hasIcon && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Icon, { icon }),
+    hasTitle && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Title, { children: title }),
+    hasContent && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Content, { children: content }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Actions, { children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "contained", onPress: onClose, children: t("common:close") }) })
+  ] }) });
+};
+var useStyles = () => {
+  const { width, alignSelf } = useDialogStyles();
+  return reactNative.StyleSheet.create({
+    dialog: {
+      width,
+      alignSelf
+    }
+  });
+};
+var BARCODE_TYPES = [
+  "aztec",
+  "ean13",
+  "ean8",
+  "qr",
+  "pdf417",
+  "upc_e",
+  "datamatrix",
+  "code39",
+  "code93",
+  "itf14",
+  "codabar",
+  "code128",
+  "upc_a"
+];
+var getPermissionMessage = (hasPermission) => {
+  if (tsCommon.isNullish(hasPermission)) {
+    return i18next__default.default.t("common:barcodeScanner.requestingCameraPermission");
+  }
+  return hasPermission ? i18next__default.default.t("common:barcodeScanner.cameraAccessGranted") : i18next__default.default.t("common:barcodeScanner.noCameraAccess");
+};
+var requestCameraPermissions = async () => {
+  try {
+    const { status } = await expoCamera.Camera.requestCameraPermissionsAsync();
+    return status === "granted";
+  } catch (e) {
+    logger.error("[BarcodeScanner] Failed to request camera permissions", e);
+    return false;
+  }
+};
+var BarcodeScanner = ({ onBarcodeScanned }) => {
+  const styles7 = useStyles2();
+  const { t } = reactI18next.useTranslation();
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.cameraContainer, children: /* @__PURE__ */ jsxRuntime.jsx(
+      expoCamera.CameraView,
+      {
+        style: [reactNative.StyleSheet.absoluteFillObject, styles7.camera],
+        onBarcodeScanned,
+        barcodeScannerSettings: { barcodeTypes: BARCODE_TYPES },
+        facing: "back"
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", style: styles7.instruction, children: t("common:barcodeScanner.scanBarcodeInstruction") })
+  ] });
+};
+var DIALOG_HEADER_AND_FOOTER_HEIGHT = 200;
+var MAX_CAMERA_HEIGHT = 560;
+var useStyles2 = () => {
+  const theme = useAppTheme();
+  const { height } = reactNative.useWindowDimensions();
+  return reactNative.StyleSheet.create({
+    cameraContainer: {
+      alignSelf: "center",
+      width: "100%",
+      height: Math.min(height - DIALOG_HEADER_AND_FOOTER_HEIGHT, MAX_CAMERA_HEIGHT)
+    },
+    camera: {
+      borderWidth: 2,
+      borderColor: theme.colors.primary,
+      borderStyle: "dashed"
+    },
+    instruction: {
+      textAlign: "center"
+    }
+  });
+};
+var BarcodeScannerDialog = ({
+  isVisible,
+  title,
+  onClose,
+  onBarcodeScanned,
+  ...rest
+}) => {
+  const [hasPermission, setHasPermission] = react.useState();
+  react.useEffect(() => {
+    requestCameraPermissions().then(setHasPermission);
+  }, []);
+  if (!isVisible) {
+    return null;
+  }
+  if (!hasPermission) {
+    const message = getPermissionMessage(hasPermission);
+    return /* @__PURE__ */ jsxRuntime.jsx(DialogCloseOnly, { isVisible: true, title, onClose, content: message, ...rest });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DialogCloseOnly,
+    {
+      isVisible: true,
+      title,
+      onClose,
+      content: /* @__PURE__ */ jsxRuntime.jsx(BarcodeScanner, { onBarcodeScanned }),
+      ...rest
+    }
+  );
+};
+var DialogOkCancel = ({
+  icon,
+  title,
+  description,
+  onOk,
+  onCancel,
+  isVisible,
+  ...rest
+}) => {
+  const { style: dialogStyleProp, ...dialogProps } = rest;
+  const styles7 = useStyles3();
+  const { t } = reactI18next.useTranslation();
+  const hasIcon = !!icon;
+  const hasTitle = !!title;
+  const hasTitleString = typeof title === "string";
+  const hasDescription = !!description;
+  const hasDescriptionString = typeof description === "string";
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog, { style: [styles7.dialog, dialogStyleProp], visible: true, onDismiss: onCancel, ...dialogProps, children: [
+    hasIcon && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Icon, { icon }),
+    hasTitle && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Title, { children: hasTitleString ? /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { children: title }) : title }),
+    hasDescription && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Content, { children: hasDescriptionString ? /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { children: description }) : description }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog.Actions, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { onPress: onCancel, children: t("common:cancel") }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { style: styles7.button, mode: "contained", onPress: onOk, children: t("common:ok") })
+    ] })
+  ] }) });
+};
+var useStyles3 = () => {
+  const { width, alignSelf } = useDialogStyles();
+  return reactNative.StyleSheet.create({
+    button: {
+      width: 60
+    },
+    dialog: {
+      width,
+      alignSelf
+    }
+  });
+};
+var DialogSingleTextInput = ({
+  title,
+  description,
+  value,
+  onChange,
+  errorMessage,
+  placeholder,
+  onOk,
+  onCancel,
+  isVisible,
+  ...rest
+}) => {
+  const { style: dialogStyleProp, ...dialogProps } = rest;
+  const styles7 = useStyles4();
+  const { t } = reactI18next.useTranslation();
+  const [selection, setSelection] = react.useState();
+  const [inputValue, setInputValue] = react.useState(value);
+  const hasTitle = !!title;
+  const hasTitleString = typeof title === "string";
+  const hasDescription = !!description;
+  const hasDescriptionString = typeof description === "string";
+  const hasError = !!errorMessage;
+  const isInputPopulated = inputValue.trim().length > 0;
+  const isOkEnabled = !hasError && isInputPopulated;
+  const onChangeText = (text) => {
+    setInputValue(text);
+    onChange(text);
+  };
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog, { ...dialogProps, style: [styles7.dialog, dialogStyleProp], visible: true, onDismiss: onCancel, children: [
+    hasTitle && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Title, { children: hasTitleString ? /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { children: title }) : title }),
+    hasDescription && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Content, { children: hasDescriptionString ? /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { children: description }) : description }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNativePaper.TextInput,
+        {
+          mode: "outlined",
+          value: inputValue,
+          onChangeText,
+          selection,
+          onSelectionChange: (e) => setSelection(e.nativeEvent.selection),
+          placeholder,
+          error: hasError
+        }
+      ),
+      hasError && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodyMedium", style: styles7.errorText, children: errorMessage })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog.Actions, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { onPress: onCancel, children: t("common:cancel") }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { style: styles7.button, mode: "contained", onPress: () => onOk(inputValue), disabled: !isOkEnabled, children: t("common:ok") })
+    ] })
+  ] }) });
+};
+var useStyles4 = () => {
+  const theme = useAppTheme();
+  const { width, alignSelf } = useDialogStyles();
+  return reactNative.StyleSheet.create({
+    button: {
+      width: 60
+    },
+    dialog: {
+      width,
+      alignSelf
+    },
+    errorText: {
+      marginTop: theme.spacing(1),
+      color: theme.colors.error
+    }
+  });
+};
+var setClipboardTextContent = async (value = "") => {
+  try {
+    logger.info("[setClipboardTextContent] setting value", `${value.substring(0, 20)}...`);
+    Clipboard__default.default.setString(value);
+  } catch (e) {
+    logger.error("[setClipboardTextContent] error", e);
+  }
+};
+
+// src/components/snack-bar/snackbar.constants.ts
+var SnackbarDurationsMs = {
+  SHORT: 2.5 * 1e3,
+  MEDIUM: 5 * 1e3,
+  LONG: 10 * 1e3
+};
+var DEFAULT_DURATION = SnackbarDurationsMs.SHORT;
+var SnackbarContext = react.createContext({
+  showSnackbarMessage: (_msg, _duration = DEFAULT_DURATION) => {
+  }
+});
+var useSnackbar = () => react.useContext(SnackbarContext);
+var SnackbarProvider = ({ children }) => {
+  const [message, setMessage] = react.useState("");
+  const [duration, setDuration] = react.useState(DEFAULT_DURATION);
+  const [isVisible, setVisibility] = react.useState(false);
+  const showSnackbarMessage = react.useCallback(
+    (msg, duration2 = DEFAULT_DURATION) => {
+      setVisibility(false);
+      reactNative.InteractionManager.runAfterInteractions(() => {
+        setMessage(msg);
+        setDuration(duration2);
+        setVisibility(true);
+      });
+    },
+    [setVisibility]
+  );
+  react.useEffect(() => {
+    if (!isVisible) return;
+    const timeoutId = setTimeout(() => setVisibility(false), duration);
+    return () => clearTimeout(timeoutId);
+  }, [isVisible, duration, setVisibility]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(SnackbarContext.Provider, { value: { showSnackbarMessage }, children: [
+    children,
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Snackbar, { visible: isVisible, onDismiss: () => setVisibility(false), duration: reactNativePaper.Snackbar.DURATION_LONG, children: message })
+  ] });
+};
+var DEFAULT_DARK_MODE = true;
+var CommonStore = class {
+  constructor() {
+    this.isDarkMode = DEFAULT_DARK_MODE;
+    this.appStatus = "active";
+    mobx.makeAutoObservable(this);
+    mobxPersistStore.makePersistable(this, {
+      name: "CommonStore",
+      properties: ["isDarkMode"],
+      storage: mmkvStorageForMobxPersist
+    }).then(() => {
+      logger.info("[CommonStore] Hydration complete");
+    });
+    this.appStateSubscription = reactNative.AppState.addEventListener("change", (nextAppState) => {
+      if (nextAppState === this.appStatus) return;
+      mobx.runInAction(() => {
+        logger.info(`[CommonStore] App state changed to ${nextAppState}`);
+        this.appStatus = nextAppState;
+      });
+    });
+  }
+  toggleDarkMode() {
+    this.isDarkMode = !this.isDarkMode;
+  }
+  setIsDarkMode(isDarkMode) {
+    this.isDarkMode = isDarkMode;
+  }
+  dispose() {
+    this.appStateSubscription?.remove();
+  }
+};
+var commonStore = new CommonStore();
+var getMonospaceFontName = () => {
+  return reactNative.Platform.select({
+    ios: "Menlo",
+    default: "monospace"
+  });
+};
+
+// src/components/syntax/styles/dark.ts
+var dark_default = {
+  hljs: {
+    display: "block",
+    overflowX: "auto",
+    padding: "0.5em",
+    background: "black",
+    color: "#ddd"
+  },
+  "hljs-keyword": {
+    color: "white",
+    fontWeight: "bold"
+  },
+  "hljs-selector-tag": {
+    color: "white",
+    fontWeight: "bold"
+  },
+  "hljs-literal": {
+    color: "white",
+    fontWeight: "bold"
+  },
+  "hljs-section": {
+    color: "white",
+    fontWeight: "bold"
+  },
+  "hljs-link": {
+    color: "white"
+  },
+  "hljs-subst": {
+    color: "#ddd"
+  },
+  "hljs-string": {
+    color: "#d88"
+  },
+  "hljs-title": {
+    color: "#d88",
+    fontWeight: "bold"
+  },
+  "hljs-name": {
+    color: "#d88",
+    fontWeight: "bold"
+  },
+  "hljs-type": {
+    color: "#d88",
+    fontWeight: "bold"
+  },
+  "hljs-attribute": {
+    color: "#d88"
+  },
+  "hljs-symbol": {
+    color: "#d88"
+  },
+  "hljs-bullet": {
+    color: "#d88"
+  },
+  "hljs-built_in": {
+    color: "#d88"
+  },
+  "hljs-addition": {
+    color: "#d88"
+  },
+  "hljs-variable": {
+    color: "#d88"
+  },
+  "hljs-template-tag": {
+    color: "#d88"
+  },
+  "hljs-template-variable": {
+    color: "#d88"
+  },
+  "hljs-comment": {
+    color: "#777"
+  },
+  "hljs-quote": {
+    color: "#777"
+  },
+  "hljs-deletion": {
+    color: "#777"
+  },
+  "hljs-meta": {
+    color: "#777"
+  },
+  "hljs-doctag": {
+    fontWeight: "bold"
+  },
+  "hljs-strong": {
+    fontWeight: "bold"
+  },
+  "hljs-emphasis": {
+    fontStyle: "italic"
+  }
+};
+
+// src/components/syntax/styles/light.ts
+var light_default = {
+  hljs: {
+    display: "block",
+    overflowX: "auto",
+    padding: "0.5em",
+    color: "#000",
+    background: "#f8f8ff"
+  },
+  "hljs-comment": {
+    color: "#408080",
+    fontStyle: "italic"
+  },
+  "hljs-quote": {
+    color: "#408080",
+    fontStyle: "italic"
+  },
+  "hljs-keyword": {
+    color: "#954121"
+  },
+  "hljs-selector-tag": {
+    color: "#954121"
+  },
+  "hljs-literal": {
+    color: "#954121"
+  },
+  "hljs-subst": {
+    color: "#954121"
+  },
+  "hljs-number": {
+    color: "#40a070"
+  },
+  "hljs-string": {
+    color: "#219161"
+  },
+  "hljs-doctag": {
+    color: "#219161"
+  },
+  "hljs-selector-id": {
+    color: "#19469d"
+  },
+  "hljs-selector-class": {
+    color: "#19469d"
+  },
+  "hljs-section": {
+    color: "#19469d"
+  },
+  "hljs-type": {
+    color: "#19469d"
+  },
+  "hljs-params": {
+    color: "#00f"
+  },
+  "hljs-title": {
+    color: "#458",
+    fontWeight: "bold"
+  },
+  "hljs-tag": {
+    color: "#000080",
+    fontWeight: "normal"
+  },
+  "hljs-name": {
+    color: "#000080",
+    fontWeight: "normal"
+  },
+  "hljs-attribute": {
+    color: "#000080",
+    fontWeight: "normal"
+  },
+  "hljs-variable": {
+    color: "#008080"
+  },
+  "hljs-template-variable": {
+    color: "#008080"
+  },
+  "hljs-regexp": {
+    color: "#b68"
+  },
+  "hljs-link": {
+    color: "#b68"
+  },
+  "hljs-symbol": {
+    color: "#990073"
+  },
+  "hljs-bullet": {
+    color: "#990073"
+  },
+  "hljs-built_in": {
+    color: "#0086b3"
+  },
+  "hljs-builtin-name": {
+    color: "#0086b3"
+  },
+  "hljs-meta": {
+    color: "#999",
+    fontWeight: "bold"
+  },
+  "hljs-deletion": {
+    background: "#fdd"
+  },
+  "hljs-addition": {
+    background: "#dfd"
+  },
+  "hljs-emphasis": {
+    fontStyle: "italic"
+  },
+  "hljs-strong": {
+    fontWeight: "bold"
+  }
+};
+var CodeTag = ({ children, style, ...props }) => {
+  const styles7 = useStyles5();
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.ScrollView, { horizontal: true, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles7.codeText, style], ...props, children }) });
+};
+var useStyles5 = () => {
+  return reactNative.StyleSheet.create({
+    codeText: {
+      fontFamily: getMonospaceFontName()
+    }
+  });
+};
+var PreTag = ({ children, style, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.ScrollView, { horizontal: true, style, ...props, children });
+var SyntaxColoring = mobxReactLite.observer(({ code, language, maxCodeLength }) => {
+  const style = commonStore.isDarkMode ? dark_default : light_default;
+  const isSyntaxHighlightingEnabled = !maxCodeLength || code.length < maxCodeLength;
+  if (isSyntaxHighlightingEnabled) {
+    return /* @__PURE__ */ jsxRuntime.jsx(SyntaxHighlighter__default.default, { language, style, PreTag, CodeTag, children: code });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.ScrollView, { horizontal: true, showsHorizontalScrollIndicator: true, children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { style: styles.codeText, numberOfLines: 0, children: code }) });
+});
+var styles = reactNative.StyleSheet.create({
+  codeText: {
+    fontFamily: getMonospaceFontName()
+  }
+});
+var DialogSyntaxColorResult = ({
+  icon,
+  title,
+  code,
+  language,
+  maxCodeLength,
+  onClose,
+  isVisible,
+  ...dialogProps
+}) => {
+  const styles7 = useStyles6();
+  const { showSnackbarMessage } = useSnackbar();
+  const { t } = reactI18next.useTranslation();
+  const hasIcon = !!icon;
+  const hasTitle = !!title;
+  const onCopy = () => {
+    setClipboardTextContent(code);
+    showSnackbarMessage(t("common:copiedToClipboard"));
+  };
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog, { visible: true, onDismiss: onClose, style: styles7.dialog, ...dialogProps, children: [
+    hasIcon && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Icon, { icon }),
+    hasTitle && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Title, { children: title }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.ScrollArea, { children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.ScrollView, { children: /* @__PURE__ */ jsxRuntime.jsx(SyntaxColoring, { code, language, maxCodeLength }) }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog.Actions, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "outlined", onPress: onCopy, icon: "content-copy", children: t("common:copy") }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "contained", onPress: onClose, children: t("common:close") })
+    ] })
+  ] }) });
+};
+var useStyles6 = () => {
+  const { width, alignSelf } = useDialogStyles();
+  const { height } = reactNative.useWindowDimensions();
+  return reactNative.StyleSheet.create({
+    dialog: {
+      maxHeight: height * 0.8,
+      width,
+      alignSelf
+    }
+  });
+};
+
+// src/components/drop-down-selector/drop-down-selector.utils.ts
+var getTextColor = ({ theme, isFocused, isDisabled }) => {
+  const { onSurfaceDisabled, primary, secondary } = theme.colors;
+  if (isDisabled) {
+    return onSurfaceDisabled;
+  }
+  if (isFocused) {
+    return primary;
+  }
+  return secondary;
+};
+var getLabelColor = ({ theme, isError, isDisabled, isFocusedAndEnabled }) => {
+  const { error, onSurfaceDisabled, primary, onSurface } = theme.colors;
+  if (isError) {
+    return error;
+  }
+  if (isDisabled) {
+    return onSurfaceDisabled;
+  }
+  if (isFocusedAndEnabled) {
+    return primary;
+  }
+  return onSurface;
+};
+var getBorderColor = ({ theme, isError, isDisabled, isFocused }) => {
+  const { error, surfaceDisabled, primary, outline } = theme.colors;
+  if (isError) {
+    return error;
+  }
+  if (isDisabled) {
+    return surfaceDisabled;
+  }
+  if (isFocused) {
+    return primary;
+  }
+  return outline;
+};
+var DropDownSelectorLeftIcon = ({
+  icon,
+  color,
+  size = 20
+}) => {
+  if (!icon) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Icon, { source: icon, size, color });
+};
+var DropDownSelectorItem = ({ item, selected, textColor }) => {
+  const isSelected = selected === true;
+  const styles7 = useStyles7({ isSelected });
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.itemContainer, children: [
+    item.icon && /* @__PURE__ */ jsxRuntime.jsx(DropDownSelectorLeftIcon, { icon: item.icon, color: textColor }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { style: { color: textColor }, children: item.label })
+  ] });
+};
+var useStyles7 = ({ isSelected }) => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    itemContainer: {
+      flexDirection: "row",
+      alignItems: "center",
+      paddingVertical: theme.spacing(1),
+      paddingHorizontal: theme.spacing(1),
+      gap: theme.spacing(1),
+      backgroundColor: isSelected ? theme.colors.surfaceVariant : theme.colors.surface
+    }
+  });
+};
+var DropDownSelector = ({
+  label,
+  value,
+  onChange,
+  isError,
+  options: options2,
+  placeholder,
+  searchPlaceholder,
+  disabled
+}) => {
+  const [isFocused, setIsFocused] = react.useState(false);
+  const hasLabel = !!label;
+  const theme = useAppTheme();
+  const isDisabled = disabled === true;
+  const textColor = getTextColor({ theme, isFocused, isDisabled });
+  const styles7 = useStyles8({ isFocused, disabled, isError, textColor });
+  const selectedItem = options2.find((option) => option.value === value);
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { children: [
+    hasLabel && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", style: styles7.dropdownTitle, children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNativeElementDropdown.Dropdown,
+      {
+        style: styles7.dropdown,
+        autoScroll: false,
+        placeholderStyle: styles7.placeholderStyle,
+        selectedTextStyle: styles7.selectedTextStyle,
+        data: options2,
+        search: false,
+        searchPlaceholder,
+        maxHeight: 300,
+        labelField: "label",
+        valueField: "value",
+        placeholder: isFocused ? "" : placeholder,
+        value,
+        disable: disabled,
+        onFocus: () => setIsFocused(true),
+        onBlur: () => setIsFocused(false),
+        onChange: ({ value: value2 }) => {
+          onChange(value2);
+          setIsFocused(false);
+        },
+        renderItem: (item, selected) => /* @__PURE__ */ jsxRuntime.jsx(DropDownSelectorItem, { item, selected, textColor }),
+        renderLeftIcon: () => /* @__PURE__ */ jsxRuntime.jsx(DropDownSelectorLeftIcon, { icon: selectedItem?.icon, color: textColor })
+      }
+    )
+  ] });
+};
+var useStyles8 = ({ isFocused, disabled, isError, textColor }) => {
+  const theme = useAppTheme();
+  const { surface, surfaceDisabled } = theme.colors;
+  const isDisabled = disabled === true;
+  const isFocusedAndEnabled = isFocused && !isDisabled;
+  const labelColor = getLabelColor({ theme, isError: !!isError, isDisabled, isFocusedAndEnabled });
+  const borderColor = getBorderColor({ theme, isError: !!isError, isDisabled, isFocused });
+  const borderWidth = isFocusedAndEnabled ? 2 : 1;
+  const backgroundColor = isDisabled ? surfaceDisabled : "transparent";
+  return reactNative.StyleSheet.create({
+    dropdownTitle: {
+      position: "absolute",
+      top: -theme.spacing(1),
+      left: theme.spacing(1),
+      backgroundColor: surface,
+      paddingHorizontal: theme.spacing(0.75),
+      color: labelColor,
+      zIndex: 1
+    },
+    dropdown: {
+      height: 50,
+      borderColor,
+      borderWidth,
+      borderRadius: theme.roundness,
+      paddingHorizontal: theme.spacing(1),
+      backgroundColor
+    },
+    placeholderStyle: {
+      color: textColor
+    },
+    selectedTextStyle: {
+      color: textColor,
+      paddingLeft: theme.spacing(1)
+    }
+  });
+};
+
+// src/services/files/native-file-system.types.ts
+var EncodingType = /* @__PURE__ */ ((EncodingType2) => {
+  EncodingType2["UTF8"] = "utf8";
+  EncodingType2["Base64"] = "base64";
+  return EncodingType2;
+})(EncodingType || {});
+
+// src/services/files/native-file-system.ts
+var NativeFileSystem = class {
+  constructor() {
+    this.documentDirectory = expoFileSystem.Paths.document.uri;
+    this.cacheDirectory = expoFileSystem.Paths.cache.uri;
+    this.EncodingType = EncodingType;
+  }
+  async writeAsStringAsync(fileUri, contents, options2) {
+    const file = new expoFileSystem.File(fileUri);
+    if (options2?.encoding === "base64" /* Base64 */) {
+      file.write(contents, { encoding: "base64" });
+      return;
+    }
+    file.write(contents, { encoding: "utf8" });
+  }
+  async readAsStringAsync(fileUri, options2) {
+    const file = new expoFileSystem.File(fileUri);
+    if (options2?.encoding === "base64" /* Base64 */) {
+      const bytes = await file.bytes();
+      return buffer.Buffer.from(bytes).toString("base64");
+    }
+    return file.textSync();
+  }
+  async readAsBase64Async(fileUri) {
+    return this.readAsStringAsync(fileUri, { encoding: "base64" /* Base64 */ });
+  }
+  async getInfoAsync(fileUri) {
+    const pathInfo = expoFileSystem.Paths.info(fileUri);
+    if (pathInfo.isDirectory) {
+      const directory = new expoFileSystem.Directory(fileUri);
+      const info2 = directory.info();
+      return {
+        exists: info2.exists,
+        isDirectory: true,
+        size: info2.size,
+        modificationTime: info2.modificationTime,
+        uri: fileUri
+      };
+    }
+    const file = new expoFileSystem.File(fileUri);
+    const info = file.info();
+    return {
+      exists: info.exists,
+      isDirectory: false,
+      size: info.size,
+      modificationTime: info.modificationTime,
+      uri: fileUri
+    };
+  }
+  async copyContentUriToLocal(contentUri, fileName) {
+    logger.info(`[copyContentUriToLocal] Copying content uri to local file: ${fileName}`);
+    try {
+      const localUri = `${expoFileSystem.Paths.document.uri}${fileName}`;
+      await FileSystemLegacy__namespace.copyAsync({ from: contentUri, to: localUri });
+      logger.info(`[copyContentUriToLocal] Copy successful: ${localUri}`);
+      return localUri;
+    } catch (e) {
+      logger.error(`[copyContentUriToLocal] Copy failed: ${tsCommon.getErrorMessage(e)}`, e);
+      throw e;
+    }
+  }
+  async readDirectoryAsync(fileUri) {
+    const directory = new expoFileSystem.Directory(fileUri);
+    const contents = directory.list();
+    return contents.map((item) => item.name);
+  }
+  async makeDirectoryAsync(fileUri, options2) {
+    const directory = new expoFileSystem.Directory(fileUri);
+    const intermediates = options2?.intermediates ?? false;
+    directory.create({ intermediates });
+  }
+  async deleteAsync(fileUri) {
+    const pathInfo = expoFileSystem.Paths.info(fileUri);
+    if (!pathInfo.exists) {
+      logger.warn(`[deleteAsync] Path does not exist: ${fileUri}`);
+      return;
+    }
+    if (pathInfo.isDirectory) {
+      const directory = new expoFileSystem.Directory(fileUri);
+      directory.delete();
+    } else {
+      const file = new expoFileSystem.File(fileUri);
+      file.delete();
+    }
+  }
+};
+var nativeFileSystem = new NativeFileSystem();
+
+// src/utils/file.utils.ts
+var DEFAULT_ENCODING = "utf8" /* UTF8 */;
+var DEFAULT_OPTIONS = { encoding: DEFAULT_ENCODING };
+var isFileExists = async (fileUri = "") => {
+  const { exists } = await nativeFileSystem.getInfoAsync(fileUri);
+  return exists;
+};
+var getDocumentFolderRelativePath = (fileUri = "/") => fileUri.substring(nativeFileSystem.documentDirectory?.length ?? 0);
+var getDocumentFullFilename = (filename = "") => nativeFileSystem.documentDirectory + filename;
+var createDirectoryStructure = async (folderUri = "") => {
+  const exists = await isFileExists(folderUri);
+  if (exists) {
+    return { exists: true };
+  }
+  try {
+    await nativeFileSystem.makeDirectoryAsync(folderUri, { intermediates: true });
+    return { exists: true };
+  } catch (error) {
+    logger.error("createDirectoryStructure", error);
+    return {
+      exists: false,
+      error
+    };
+  }
+};
+var saveTextContent = async ({ fileUri = "", text = "" }) => {
+  try {
+    await nativeFileSystem.writeAsStringAsync(fileUri, text, DEFAULT_OPTIONS);
+    const exists = await isFileExists(fileUri);
+    return { exists };
+  } catch (error) {
+    logger.error("saveTextContent", error);
+    return {
+      exists: false,
+      error
+    };
+  }
+};
+var loadTextContent = async (fileUri = "") => {
+  const exists = await isFileExists(fileUri);
+  if (!exists) {
+    return { exists };
+  }
+  try {
+    const content = await nativeFileSystem.readAsStringAsync(fileUri, DEFAULT_OPTIONS);
+    return {
+      exists,
+      content
+    };
+  } catch (error) {
+    logger.error("loadTextContent", error);
+    return { exists, error };
+  }
+};
+var deleteFile = async (fileUri = "") => {
+  const exists = await isFileExists(fileUri);
+  if (!exists) {
+    return { exists };
+  }
+  try {
+    await nativeFileSystem.deleteAsync(fileUri);
+    return { exists };
+  } catch (error) {
+    logger.error("deleteFile", error);
+    return { exists, error };
+  }
+};
+var nowAsIsoFilename = () => {
+  const isoString = (/* @__PURE__ */ new Date()).toISOString();
+  return isoString.replace(new RegExp(":", "g"), "_");
+};
+var isFileUri = (uri) => {
+  if (!tsCommon.hasScheme(uri)) {
+    return false;
+  }
+  try {
+    return new URL(uri).protocol === `${tsCommon.SCHEME_PREFIXES.file}:`;
+  } catch (e) {
+    logger.debug(`[isFileUri] Invalid URI: [${uri}]`, e);
+    return false;
+  }
+};
+var normalizeFileUri = (uri) => {
+  if (!uri) {
+    return "";
+  }
+  if (isFileUri(uri)) {
+    return uri;
+  }
+  if (tsCommon.hasScheme(uri)) {
+    logger.debug(`[normalizeFileUri] Non-file URI scheme provided: [${uri}]`);
+    return "";
+  }
+  return `${tsCommon.SCHEME_PREFIXES.file}://${uri}`;
+};
+
+// src/utils/sharing.utils.ts
+var buildShareOptionsFromMimeType = (mimeType) => {
+  if (!mimeType) {
+    return {};
+  }
+  const dialogTitle = i18next__default.default.t("common:share");
+  if (mimeType === "text/plain") {
+    return reactNative.Platform.select({
+      ios: { mimeType: "public.plain-text", UTI: "public.plain-text" },
+      default: { dialogTitle, mimeType }
+    });
+  }
+  if (["application/xml", "text/xml"].includes(mimeType)) {
+    return reactNative.Platform.select({
+      ios: { mimeType: "application/xml", UTI: "public.xml" },
+      default: { dialogTitle, mimeType }
+    });
+  }
+  return {};
+};
+var shareTextFile = async (fileUri) => {
+  return shareFile({ fileUri, mimeType: "text/plain" });
+};
+var shareXmlFile = async (fileUri) => {
+  return shareFile({ fileUri, mimeType: "application/xml" });
+};
+var shareFile = async ({ fileUri, mimeType }) => {
+  if (!fileUri) {
+    return;
+  }
+  const isAvailable = await Sharing__namespace.isAvailableAsync();
+  if (!isAvailable) {
+    logger.warn("Sharing is not available on this device");
+    return;
+  }
+  const options2 = buildShareOptionsFromMimeType(mimeType);
+  const normalizedFileUri = normalizeFileUri(fileUri);
+  if (!normalizedFileUri) {
+    logger.warn(`[shareFile] Invalid file URI: [${fileUri}]`);
+    return;
+  }
+  try {
+    logger.info(`Sharing file [${normalizedFileUri}] of type ${mimeType}.`);
+    await Sharing__namespace.shareAsync(normalizedFileUri, options2);
+  } catch (e) {
+    logger.error(`Error while sharing file [${normalizedFileUri}] of type ${mimeType}`, e);
+  }
+};
+var shareCurrentLogsFile = async () => {
+  const logsFileUri = await loadCurrentLogsFileUri();
+  return shareTextFile(logsFileUri);
+};
+var ErrorBoundaryScreen = () => {
+  const styles7 = useStyles9();
+  const { t } = reactI18next.useTranslation();
+  const { title, description, id } = expoRouter.useLocalSearchParams();
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.container, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Card, { style: styles7.card, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Card.Title, { title, titleStyle: styles7.errorText }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Card.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "titleMedium", style: styles7.label, children: "ID:" }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", children: id }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "titleMedium", style: styles7.label, children: "Description:" }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", children: description })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Card.Actions, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "outlined", onPress: shareCurrentLogsFile, children: t("common:errorBoundary.details") }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "contained", onPress: () => expoRouter.router.replace("/"), children: t("common:close") })
+    ] })
+  ] }) });
+};
+var useStyles9 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      flex: 1,
+      marginTop: theme.spacing(2),
+      padding: theme.spacing(2)
+    },
+    card: {
+      borderWidth: reactNative.StyleSheet.hairlineWidth,
+      borderColor: theme.colors.error
+    },
+    errorText: {
+      color: theme.colors.error
+    },
+    label: {
+      marginTop: theme.spacing(1),
+      color: theme.colors.onSurfaceVariant
+    }
+  });
+};
+var useErrorDetails = (error) => {
+  const { t } = reactI18next.useTranslation();
+  const id = uuid__default.default.v4();
+  const title = t("common:error");
+  const errorMsg = tsCommon.getErrorMessage(error) || "Unknown";
+  const description = t("common:errorBoundary.error", { id, errorMsg });
+  const stack = error instanceof Error ? error.stack : "";
+  return {
+    id,
+    title,
+    errorMsg,
+    description,
+    stack
+  };
+};
+
+// src/components/error/error-boundary.tsx
+var ErrorBoundary = ({ error }) => {
+  const router3 = expoRouter.useRouter();
+  const { title, description, errorMsg, id, stack } = useErrorDetails(error);
+  react.useEffect(() => {
+    logger.error(`ErrorBoundary Unexpected error: ${errorMsg} (ID: ${id}). Stack: ${stack}`, error);
+    Sentry__namespace.captureException(error, {
+      extra: {
+        title,
+        description,
+        errorMsg,
+        id,
+        stack
+      }
+    });
+    router3.replace({
+      pathname: "/error",
+      params: { title, description, errorMsg, id }
+    });
+  }, [router3, error]);
+  return null;
+};
+var ErrorDetails = ({ error, title = "Error" }) => {
+  const styles7 = useStyles10();
+  const errorToStringify = {
+    ...error,
+    stack: void 0
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNativeGestureHandler.ScrollView, { style: styles7.container, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", style: styles7.errorText, children: title }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { style: styles7.jsonText, children: JSON.stringify(errorToStringify, null, 2) })
+  ] });
+};
+var useStyles10 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      flex: 1,
+      padding: theme.spacing(2),
+      borderWidth: reactNative.StyleSheet.hairlineWidth,
+      borderColor: theme.colors.error
+    },
+    errorText: {
+      color: theme.colors.error
+    },
+    jsonText: {
+      fontSize: 12,
+      fontFamily: reactNative.Platform.select({
+        ios: "Menlo",
+        default: "monospace"
+      })
+    }
+  });
+};
+var EventLogsScreen = () => {
+  const styles7 = useStyles11();
+  const theme = useAppTheme();
+  const { t } = reactI18next.useTranslation();
+  const [files, setFiles] = react.useState([]);
+  react.useEffect(() => {
+    loadAllLogFilesInfo().then(setFiles);
+  }, []);
+  const [isDeleteDialogVisible, toggleDeleteConfirmVisibility] = usehooks.useToggle(false);
+  const onDeleteConfirmed = () => {
+    deleteAllLogFiles().then(() => setFiles([])).finally(() => toggleDeleteConfirmVisibility());
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.container, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "titleMedium", style: styles7.title, children: t("common:eventLogs") }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      list.LegendList,
+      {
+        data: files,
+        renderItem: ({ item }) => {
+          const title = item.uri.split("/").pop();
+          const updatedAt = "modificationTime" in item ? new Date(item.modificationTime ?? 0) : /* @__PURE__ */ new Date();
+          const formattedUpdatedAt = dateFns.format(updatedAt, "yyyy-MM-dd HH:mm:ss");
+          const size = "size" in item ? filesize.filesize(item.size ?? 0) : "";
+          const description = `${formattedUpdatedAt} [ ${size} ]`;
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            reactNativePaper.List.Item,
+            {
+              title,
+              description,
+              left: (props) => /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.List.Icon, { ...props, icon: (props2) => /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Icon, { source: "file-document", ...props2 }) }),
+              right: () => /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.IconButton, { iconColor: theme.colors.primary, icon: "share", onPress: () => shareTextFile(item.uri) })
+            }
+          );
+        },
+        estimatedItemSize: 30
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.actions, children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "outlined", icon: "delete", onPress: () => toggleDeleteConfirmVisibility(), children: t("common:delete") }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      DialogOkCancel,
+      {
+        icon: "alert",
+        title: t("common:confirm"),
+        description: t("common:deleteAllLogsFilesConfirmation"),
+        isVisible: isDeleteDialogVisible,
+        onOk: onDeleteConfirmed,
+        onCancel: toggleDeleteConfirmVisibility
+      }
+    )
+  ] });
+};
+var useStyles11 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      flex: 1,
+      padding: theme.spacing(2)
+    },
+    title: {
+      marginBottom: theme.spacing(2)
+    },
+    fileItem: {
+      padding: theme.spacing(2),
+      borderBottomWidth: 1,
+      borderBottomColor: theme.colors.outline
+    },
+    actions: {
+      flexDirection: "row",
+      justifyContent: "center",
+      gap: theme.spacing(2)
+    },
+    sharePressed: {
+      opacity: 0.5
+    }
+  });
+};
+var LogEntryItemSuffix = ({ filterText, onPress }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.TextInput.Icon, { icon: filterText ? "close" : "magnify", onPress });
+};
+
+// src/logger/use-log-entry-color.ts
+var LOG_COLORS_DARK_MODE = /* @__PURE__ */ new Map([
+  [LOG_LEVELS.debug, "#9e9e9e"],
+  [LOG_LEVELS.log, "#e0e0e0"],
+  [LOG_LEVELS.info, "#64b5f6"],
+  [LOG_LEVELS.warn, "#ffb74d"],
+  [LOG_LEVELS.error, "#ef5350"]
+]);
+var LOG_COLORS_LIGHT_MODE = /* @__PURE__ */ new Map([
+  [LOG_LEVELS.debug, "#757575"],
+  [LOG_LEVELS.log, "#424242"],
+  [LOG_LEVELS.info, "#1976d2"],
+  [LOG_LEVELS.warn, "#f57c00"],
+  [LOG_LEVELS.error, "#d32f2f"]
+]);
+var useLogEntryColor = (severity) => {
+  const isDarkMode = useIsDarkMode();
+  const colors = isDarkMode ? LOG_COLORS_DARK_MODE : LOG_COLORS_LIGHT_MODE;
+  return colors.get(severity) ?? "orange";
+};
+
+// src/components/event-logs/live-logs-viewer/logs-viewer.utils.ts
+var formatLogMessage = (msg) => {
+  return msg.substring(11);
+};
+var LogEntryItem = ({ logEntry }) => {
+  const styles7 = useStyles12();
+  const { showSnackbarMessage } = useSnackbar();
+  const { t } = reactI18next.useTranslation();
+  const color = useLogEntryColor(logEntry.level.severity);
+  const handleLongPress = async (text) => {
+    await setClipboardTextContent(text);
+    showSnackbarMessage(t("common:copiedToClipboard"));
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.ScrollView, { horizontal: true, showsHorizontalScrollIndicator: false, contentContainerStyle: styles7.logEntry, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onLongPress: () => handleLongPress(logEntry.msg), children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { style: [styles7.logText, { color }], children: formatLogMessage(logEntry.msg) }) }) });
+};
+var useStyles12 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    logEntry: {
+      paddingHorizontal: theme.spacing(0.5)
+    },
+    logText: {
+      fontFamily: reactNative.Platform.select({
+        ios: "Menlo",
+        default: "monospace"
+      })
+    }
+  });
+};
+var useAutoScroll = (shouldAutoScroll = false) => {
+  const listRef = react.useRef(null);
+  const [isAutoScrollEnabled, toggleAutoScroll] = usehooks.useToggle(shouldAutoScroll);
+  const scrollToBottom = (items) => {
+    if (!isAutoScrollEnabled || !listRef.current || !items.length) {
+      return;
+    }
+    const lastItemIndex = items.length - 1;
+    listRef.current.scrollToIndex({ index: lastItemIndex, animated: false, viewPosition: 1 });
+  };
+  return {
+    listRef,
+    scrollToBottom,
+    isAutoScrollEnabled,
+    toggleAutoScroll
+  };
+};
+var useLogsActions = () => {
+  const { showSnackbarMessage } = useSnackbar();
+  const { t } = reactI18next.useTranslation();
+  const [filterText, setFilterText] = react.useState("");
+  const debouncedFilterText = usehooks.useDebounce(filterText, 300);
+  const filteredLogs = commonLogsStore.filterLogs(debouncedFilterText);
+  const handleCopyAllLogs = async () => {
+    await setClipboardTextContent(commonLogsStore.allLogsAsText);
+    showSnackbarMessage(t("common:copiedToClipboard"));
+  };
+  return {
+    filterText,
+    setFilterText,
+    filteredLogs,
+    handleCopyAllLogs
+  };
+};
+var LogsViewer = mobxReactLite.observer(
+  ({ shouldDisplayToolbar = true, shouldAutoScroll = false }) => {
+    const styles7 = useStyles13();
+    const { t } = reactI18next.useTranslation();
+    const { filterText, setFilterText, filteredLogs, handleCopyAllLogs } = useLogsActions();
+    const { listRef, scrollToBottom, toggleAutoScroll, isAutoScrollEnabled } = useAutoScroll(shouldAutoScroll);
+    react.useEffect(() => scrollToBottom(filteredLogs), [filteredLogs, scrollToBottom]);
+    react.useEffect(() => reactNative.LogBox.ignoreAllLogs(), []);
+    return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.container, children: [
+      shouldDisplayToolbar && /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.actionsBar, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNativePaper.TextInput,
+          {
+            mode: reactNative.Platform.OS === "windows" ? "flat" : "outlined",
+            autoCapitalize: "none",
+            value: filterText,
+            onChangeText: setFilterText,
+            placeholder: t("common:logs.filter"),
+            style: styles7.filterInput,
+            right: reactNative.Platform.OS === "windows" ? void 0 : /* @__PURE__ */ jsxRuntime.jsx(LogEntryItemSuffix, { filterText, onPress: () => setFilterText("") })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNativePaper.IconButton,
+          {
+            icon: isAutoScrollEnabled ? "arrow-down-bold" : "arrow-down-bold-outline",
+            mode: "contained",
+            onPress: () => toggleAutoScroll(),
+            style: styles7.button,
+            accessibilityLabel: t("common:toggleAutoScroll")
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNativePaper.IconButton,
+          {
+            icon: "delete",
+            mode: "contained",
+            onPress: () => commonLogsStore.clearLogs(),
+            style: styles7.button,
+            accessibilityLabel: t("common:logs.clear")
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNativePaper.IconButton,
+          {
+            icon: "content-copy",
+            mode: "contained",
+            onPress: handleCopyAllLogs,
+            style: styles7.button,
+            accessibilityLabel: t("common:logs.copyAll")
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        list.LegendList,
+        {
+          ref: listRef,
+          data: filteredLogs,
+          renderItem: ({ item }) => /* @__PURE__ */ jsxRuntime.jsx(LogEntryItem, { logEntry: item }),
+          estimatedItemSize: 30,
+          keyExtractor: (logEntry, index) => `${logEntry.msg.substring(0, 20)}_${index}`
+        }
+      )
+    ] });
+  }
+);
+var useStyles13 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      flex: 1
+    },
+    actionsBar: {
+      flexDirection: "row",
+      padding: theme.spacing(0.5),
+      marginBottom: theme.spacing(0.5),
+      alignItems: "center"
+    },
+    filterInput: {
+      flex: 1,
+      height: 40
+    },
+    button: {
+      marginVertical: 0
+    }
+  });
+};
+var HeaderButton = ({ iconName, onPress }) => {
+  const styles7 = useStyles14();
+  const theme = useAppTheme();
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.IconButton, { icon: iconName, size: 25, iconColor: theme.colors.primary, style: styles7.iconStyle, onPress });
+};
+var useStyles14 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    iconStyle: {
+      marginHorizontal: theme.spacing(2)
+    }
+  });
+};
+var HeaderBackButton = () => /* @__PURE__ */ jsxRuntime.jsx(HeaderButton, { iconName: "arrow-left", onPress: () => expoRouter.router.back() });
+var LanguageSelectorMenu = ({
+  onLanguageChange,
+  label,
+  currentLanguage,
+  supportedLanguages
+}) => {
+  const [isMenuVisible, toggleMenu] = usehooks.useToggle(false);
+  const actionLabel = `${label} (${currentLanguage})`;
+  const onLanguageSelected = (newCode) => {
+    onLanguageChange(newCode);
+    toggleMenu(false);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNativePaper.Menu,
+    {
+      visible: isMenuVisible,
+      onDismiss: () => toggleMenu(false),
+      anchorPosition: "bottom",
+      anchor: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { mode: "outlined", onPress: () => toggleMenu(true), icon: "translate", children: actionLabel }),
+      children: supportedLanguages.map(({ code, selectionLabel }) => /* @__PURE__ */ jsxRuntime.jsx(
+        reactNativePaper.Menu.Item,
+        {
+          title: `${selectionLabel} (${code})`,
+          trailingIcon: code === currentLanguage ? "check" : void 0,
+          onPress: () => onLanguageSelected(code)
+        },
+        code
+      ))
+    },
+    String(isMenuVisible)
+  );
+};
+var LanguageSelectorSegmented = ({
+  onLanguageChange,
+  currentLanguage,
+  supportedLanguages
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNativePaper.SegmentedButtons,
+    {
+      value: currentLanguage,
+      onValueChange: onLanguageChange,
+      style: { minWidth: supportedLanguages.length * 100 },
+      buttons: supportedLanguages.map(({ code, selectionLabel }) => ({
+        value: code,
+        label: selectionLabel
+      }))
+    }
+  );
+};
+var LanguageSelector = ({
+  onLanguageChange,
+  label,
+  currentLanguage,
+  supportedLanguages,
+  placeholder,
+  searchPlaceholder
+}) => {
+  const options2 = supportedLanguages.map((lang) => ({
+    label: lang.selectionLabel,
+    value: lang.code
+  }));
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DropDownSelector,
+    {
+      label,
+      value: currentLanguage,
+      onChange: onLanguageChange,
+      options: options2,
+      placeholder,
+      searchPlaceholder
+    }
+  );
+};
+var FullCentered = ({ children, style }) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [style, { flex: 1, justifyContent: "center", alignItems: "center" }], children });
+var useWindowOrientation = () => {
+  const { width, height } = reactNative.useWindowDimensions();
+  return width > height ? "landscape" : "portrait";
+};
+var useIsLandscape = () => {
+  const orientation = useWindowOrientation();
+  return orientation === "landscape";
+};
+var TabBarIcon = ({ name, color, size = 28 }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Icon, { source: name, size, color });
+};
+var styles2 = reactNative.StyleSheet.create({
+  tabBarIcon: {
+    marginBottom: 0
+  }
+});
+var OrientationAwareTabButton = ({
+  icon,
+  title,
+  activeColor,
+  isFocused,
+  isLabelHidden = false,
+  ...props
+}) => {
+  const theme = useAppTheme();
+  const styles7 = useStyles15();
+  const isLabelVisible = !isLabelHidden;
+  const color = isFocused ? activeColor : theme.colors.onSurfaceDisabled;
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Pressable, { ...props, style: [styles7.tabButton], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(TabBarIcon, { name: icon, color }),
+    isLabelVisible && /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", style: { color }, children: title })
+  ] });
+};
+var useStyles15 = () => {
+  const theme = useAppTheme();
+  const isLandscape = useIsLandscape();
+  const padding = theme.spacing(0.5);
+  return reactNative.StyleSheet.create({
+    tabButton: {
+      flex: 1,
+      alignItems: "center",
+      justifyContent: "center",
+      paddingLeft: isLandscape ? padding : 0,
+      paddingTop: isLandscape ? 0 : padding
+    }
+  });
+};
+var OrientationAwareTabsLayout = ({
+  tabs,
+  activeColor,
+  containerStyle,
+  tabListStyle
+}) => {
+  const theme = useAppTheme();
+  const styles7 = useStyles16();
+  const isLandscape = useIsLandscape();
+  return /* @__PURE__ */ jsxRuntime.jsxs(ui.Tabs, { style: [styles7.tabsContainer, containerStyle], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ui.TabSlot, { style: styles7.tabSlot }),
+    /* @__PURE__ */ jsxRuntime.jsx(ui.TabList, { style: [styles7.tabList, tabListStyle], children: tabs.map((tab) => /* @__PURE__ */ jsxRuntime.jsx(ui.TabTrigger, { name: tab.name, href: tab.href, asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+      OrientationAwareTabButton,
+      {
+        isLabelHidden: isLandscape,
+        icon: tab.icon,
+        title: tab.title,
+        activeColor: activeColor ?? theme.colors.primary
+      }
+    ) }, tab.name)) })
+  ] });
+};
+var useStyles16 = () => {
+  const theme = useAppTheme();
+  const { bottom, right } = reactNativeSafeAreaContext.useSafeAreaInsets();
+  const minPadding = theme.spacing(0.5);
+  const isLandscape = useIsLandscape();
+  return reactNative.StyleSheet.create({
+    tabsContainer: {
+      flex: 1,
+      flexDirection: isLandscape ? "row" : "column"
+    },
+    tabSlot: {
+      flex: 1
+    },
+    tabList: {
+      backgroundColor: theme.colors.elevation.level1,
+      justifyContent: "space-around",
+      flexDirection: isLandscape ? "column" : "row",
+      paddingBottom: isLandscape ? minPadding : bottom,
+      paddingRight: isLandscape ? right : minPadding,
+      borderTopWidth: isLandscape ? void 0 : reactNative.StyleSheet.hairlineWidth,
+      borderTopColor: isLandscape ? void 0 : theme.colors.outline,
+      borderLeftWidth: isLandscape ? reactNative.StyleSheet.hairlineWidth : void 0,
+      borderLeftColor: isLandscape ? theme.colors.outline : void 0
+    }
+  });
+};
+var askConfirmation = async (question) => new Promise((resolve) => {
+  reactNative.Alert.alert("Confirmation", question, [
+    {
+      text: "Cancel",
+      onPress: () => resolve(false),
+      style: "cancel"
+    },
+    { text: "OK", onPress: () => resolve(true) }
+  ]);
+});
+
+// src/logger/logger.utils.ts
+var X_REQUEST_START_TIME = "x-request-start-time";
+var toLogLevel = (type) => {
+  const logLevelKey = type.toLowerCase();
+  return {
+    text: type.toUpperCase(),
+    severity: LOG_LEVELS[logLevelKey]
+  };
+};
+var logRequestStart = (request) => {
+  request.headers.set(X_REQUEST_START_TIME, Date.now().toString());
+  return request;
+};
+var sanitizeUrl = (url) => {
+  if (!url) return url;
+  const regExp = /http:\/\/(.*):(.*)@(.*)/;
+  const isMatching = url.match(regExp);
+  return isMatching ? `http://${isMatching[3]}` : url;
+};
+var logRequestEnd = (response) => {
+  const { status, config } = response;
+  const { method, baseURL, url } = config;
+  const startTime = Number(config.headers.get(X_REQUEST_START_TIME) ?? 0);
+  const duration = startTime ? `(${Date.now() - startTime}ms)` : "";
+  const { verb, fullUrl } = buildRequestLogInfos({ baseURL, url, method });
+  const sanitizedUrl = sanitizeUrl(fullUrl);
+  logger.info(`\u27A1\uFE0F Axios ${verb} ${sanitizedUrl} http ${status} ${duration}.`);
+  return response;
+};
+var buildRequestLogInfos = ({ baseURL, url, method }) => {
+  const fullUrl = `${baseURL ?? ""}${url ?? ""}`;
+  const verb = method?.toUpperCase() ?? "";
+  return { verb, fullUrl };
+};
+
+// src/utils/axios.config.ts
+var axiosInstance = axios__default.default.create({
+  timeout: 10 * tsCommon.PeriodsInMS.oneSecond,
+  headers: {
+    "Content-Type": "application/json",
+    "User-Agent": `native module ${getAppIdentifier()} - ${getDeviceType()}`
+  }
+});
+axiosInstance.interceptors.request.use(logRequestStart);
+axiosInstance.interceptors.response.use(logRequestEnd);
+var axios_config_default = axiosInstance;
+var base64Encode = (text) => {
+  return buffer.Buffer.from(text).toString("base64");
+};
+var base64Decode = (base64) => {
+  return buffer.Buffer.from(base64, "base64").toString("utf-8");
+};
+
+// src/utils/date.utils.ts
+var dateToISOLikeButLocal = (date) => {
+  const offsetMs = date.getTimezoneOffset() * 60 * 1e3;
+  const msLocal = date.getTime() - offsetMs;
+  const dateLocal = new Date(msLocal);
+  const iso = dateLocal.toISOString();
+  const isoLocal = iso.slice(0, 19);
+  return isoLocal;
+};
+var nowToISOLikeButLocal = () => dateToISOLikeButLocal(/* @__PURE__ */ new Date());
+var nowToISOLikeButLocalForFilename = () => {
+  const isoLocal = nowToISOLikeButLocal();
+  const isoLocalForFilename = isoLocal.replace(/:/g, "-");
+  return isoLocalForFilename;
+};
+var DigestAuth = class {
+  constructor({ username, password, shouldEmit2ndRequest = true }) {
+    this.nonce = null;
+    this.realm = null;
+    this.qop = null;
+    this.opaque = null;
+    this.algorithm = null;
+    this.nc = 0;
+    this.shouldEmit2ndRequest = true;
+    this.username = username;
+    this.password = password;
+    this.shouldEmit2ndRequest = shouldEmit2ndRequest;
+  }
+  md5(str) {
+    return utils_js.bytesToHex(legacy_js.md5(utils_js.utf8ToBytes(str)));
+  }
+  getRandomBytes(length) {
+    const isOK = validateGetRandomValues();
+    if (isOK) {
+      return crypto.getRandomValues(new Uint8Array(length));
+    } else {
+      throw new Error("[DigestAuth] crypto.getRandomValues is not available");
+    }
+  }
+  generateCNonce() {
+    const randomBytes = this.getRandomBytes(8);
+    return utils_js.bytesToHex(randomBytes);
+  }
+  parseAuthHeader(header) {
+    const parts = header.match(/(\w+)=("[^"]+"|[^,]+)/g);
+    if (!parts) return;
+    parts.forEach((part) => {
+      const [key, value] = part.split("=");
+      const cleanValue = value.replace(/^"|"$/g, "");
+      switch (key.trim()) {
+        case "nonce":
+          if (this.nonce !== cleanValue) {
+            this.nonce = cleanValue;
+            this.nc = 0;
+          }
+          break;
+        case "realm":
+          this.realm = cleanValue;
+          break;
+        case "qop":
+          this.qop = cleanValue;
+          break;
+        case "opaque":
+          this.opaque = cleanValue;
+          break;
+        case "algorithm":
+          this.algorithm = cleanValue;
+          break;
+        case "stale":
+          if (cleanValue === "true") {
+            this.nonce = null;
+            this.nc = 0;
+          }
+          break;
+      }
+    });
+    if (!this.nonce || !this.realm) {
+      throw new Error("Failed to parse authentication headers");
+    }
+  }
+  extractPathAndQuery(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.pathname + parsed.search;
+    } catch {
+      return url;
+    }
+  }
+  generateAuthHeader(config) {
+    if (!this.nonce || !this.realm) {
+      throw new Error("Missing nonce or realm");
+    }
+    const method = config.method?.toUpperCase() || "GET";
+    const uri = this.extractPathAndQuery(config.url || "");
+    const cnonce = this.generateCNonce();
+    const ncHex = (++this.nc).toString(16).padStart(8, "0");
+    const qop = this.qop || "auth";
+    const ha1 = this.md5(`${this.username}:${this.realm}:${this.password}`);
+    const ha2 = this.md5(`${method}:${uri}`);
+    const response = this.md5(`${ha1}:${this.nonce}:${ncHex}:${cnonce}:${qop}:${ha2}`);
+    return `Digest username="${this.username}", realm="${this.realm}", nonce="${this.nonce}", uri="${uri}", algorithm=${this.algorithm || "MD5"}, response="${response}", qop=${qop}, nc=${ncHex}, cnonce="${cnonce}"${this.opaque ? `, opaque="${this.opaque}"` : ""}`;
+  }
+  async request(config) {
+    try {
+      const method = config.method?.toUpperCase() ?? "GET";
+      logger.debug(`[DigestAuth] ${method}: ${sanitizeUrl(config.url)}`);
+      const response = await axios_config_default(config);
+      logger.debug(`[DigestAuth] response status: ${response.status}`);
+      return response;
+    } catch (e) {
+      this.handleNoResponseError(e);
+      const { authHeader, isDigestChallenge } = this.parseHttpErrorHeaders(e);
+      if (!isDigestChallenge) {
+        const err = e;
+        logger.info(`[DigestAuth] error received. Axios error code: "${err.code}" status: "${err.response?.status}"`);
+        throw e;
+      }
+      logger.debug("[DigestAuth] Received Unauthorized with Digest header challenge.");
+      this.parseAuthHeader(authHeader);
+      const authHeaderValue = this.generateAuthHeader(config);
+      if (this.shouldEmit2ndRequest) {
+        return this.replyToDigestChallenge({ config, authHeaderValue });
+      } else {
+        return authHeaderValue;
+      }
+    }
+  }
+  handleNoResponseError(e) {
+    if (typeof e !== "object" || e === null) return;
+    if (!("code" in e) || !("response" in e)) return;
+    const hasReceivedResponse = e.response !== void 0;
+    if (!hasReceivedResponse) {
+      logger.info(`[DigestAuth] no response. Axios error code: "${e.code}"`);
+      throw e;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- error object shape from axios is not typed
+  parseHttpErrorHeaders(e) {
+    const isUnauthorized = e.response?.status === 401;
+    const authHeader = e.response?.headers?.["www-authenticate"];
+    const hasDigestHeader = authHeader?.startsWith("Digest");
+    const isDigestChallenge = isUnauthorized && hasDigestHeader;
+    return { isUnauthorized, authHeader, hasDigestHeader, isDigestChallenge };
+  }
+  replyToDigestChallenge({ config, authHeaderValue }) {
+    const newConfig = immer.produce(config, (draft) => {
+      const originalHeaders = draft.headers ?? {};
+      draft.headers = {
+        ...originalHeaders,
+        Authorization: authHeaderValue
+      };
+    });
+    logger.debug(`[DigestAuth] emitting 2nd request with new config for url: ${sanitizeUrl(config.url)}`);
+    return axios_config_default(newConfig);
+  }
+};
+var loggedError = ({ context, e }) => {
+  const errorMessage = tsCommon.getErrorMessage(e);
+  const errorMessageDetails = `${context}: ${errorMessage}`;
+  logger.error(errorMessageDetails, e);
+  return new Error(errorMessageDetails);
+};
+var DEFAULT_FILE_PICKER_OPTIONS = { type: ["*/*"], copyToCacheDirectory: true };
+var pickSingleFile = async (options2 = DEFAULT_FILE_PICKER_OPTIONS) => {
+  try {
+    const result = await DocumentPicker__namespace.getDocumentAsync(options2);
+    if (result.canceled) {
+      return { exists: false, error: "canceled", name: "", uri: "", size: 0, mimeType: "", lastModified: 0 };
+    }
+    const singleAsset = result.assets[0];
+    return {
+      exists: singleAsset.uri && singleAsset.name,
+      ...singleAsset
+    };
+  } catch (error) {
+    logger.error("pickSingleFile", error);
+    return { error, exists: false };
+  }
+};
+var hasFileSeparator = (fileUri = "") => {
+  return fileUri?.includes("/") ?? false;
+};
+var getFilenameOnly = (fileUri = "/") => {
+  if (hasFileSeparator(fileUri)) {
+    return fileUri.split("/").pop() ?? "";
+  } else {
+    return fileUri;
+  }
+};
+var hasExtension = (fileUri = "/") => {
+  const filename = getFilenameOnly(fileUri);
+  return filename.includes(".");
+};
+var getFilenameWithoutExtension = (fileUri = "/") => {
+  const filename = getFilenameOnly(fileUri);
+  if (hasExtension(fileUri)) {
+    return filename.split(".").slice(0, -1).join(".");
+  } else {
+    return filename;
+  }
+};
+var getFileExtensionOnly = (fileUri = "/") => {
+  const filename = getFilenameOnly(fileUri);
+  if (hasExtension(fileUri)) {
+    return filename.split(".").pop()?.toLowerCase() ?? "";
+  } else {
+    return "";
+  }
+};
+var getDirectoryOnly = (fileUri = "/") => fileUri.substring(0, fileUri.lastIndexOf("/"));
+Handlebars__default.default.registerHelper("timestampFormat", (timestamp, dateTimeFormatInput) => {
+  const dateTimeFormat = Handlebars__default.default.escapeExpression(dateTimeFormatInput);
+  const formattedDateTime = dateFnsTz.formatInTimeZone(timestamp, "UTC", dateTimeFormat);
+  return new Handlebars__default.default.SafeString(formattedDateTime);
+});
+var toHandlebarsTemplate = (inputPattern) => {
+  const cleanedInput = Handlebars__default.default.escapeExpression(inputPattern);
+  const args = {};
+  let argCounter = 1;
+  const handlebarTemplate = cleanedInput.replace(/{{{(.*?)}}}/g, (_match, content) => {
+    const argName = `arg${argCounter}`;
+    args[argName] = content;
+    argCounter++;
+    return `{{timestampFormat timestamp ${argName}}}`;
+  });
+  return { handlebarTemplate, ...args };
+};
+var normalizeIsoInfo = (input) => {
+  return input.replace(/[:\.]/g, "_");
+};
+var buildAdditionalContextData = (timestamp = /* @__PURE__ */ new Date()) => {
+  const infos = {};
+  const isoString = timestamp.toISOString();
+  const isoDateStringParts = isoString.split("T");
+  infos.isoString = normalizeIsoInfo(isoString);
+  infos.isoDate = isoDateStringParts[0];
+  infos.isoTime = normalizeIsoInfo(isoDateStringParts[1].split(".")[0]);
+  infos.localDate = dateFns.format(timestamp, "yyyy-MM-dd");
+  infos.localTime = dateFns.format(timestamp, "HH_mm_ss");
+  infos.timezoneOffset = timestamp.getTimezoneOffset().toString();
+  infos.uuid = uuid__default.default.v4();
+  infos.unixTimestamp = timestamp.getTime().toString();
+  return infos;
+};
+var applyFilenameTemplate = ({ filename, pattern, timestamp = /* @__PURE__ */ new Date() }) => {
+  if (!pattern) {
+    return filename;
+  }
+  const { handlebarTemplate, ...args } = toHandlebarsTemplate(pattern);
+  const template = Handlebars__default.default.compile(handlebarTemplate);
+  return template({
+    ...args,
+    ...buildAdditionalContextData(timestamp),
+    timestamp,
+    filename
+  });
+};
+
+// src/utils/image.utils.ts
+var convertImageToBase64 = async (uri) => {
+  try {
+    const base64String = await nativeFileSystem.readAsStringAsync(uri, {
+      encoding: "base64" /* Base64 */
+    });
+    return base64String;
+  } catch (error) {
+    logger.error("Error converting image to base64:", error);
+    return null;
+  }
+};
+
+// src/utils/licences.utils.ts
+var numberRegex = /\d+(\.\d+)*/;
+var atRegex = /(?:@)/gi;
+var parseLicenceData = (entries) => {
+  const licences = [];
+  for (const [id, licence] of Object.entries(entries)) {
+    const version = id.match(numberRegex);
+    const nameWithoutVersion = id.replace(atRegex, "").replace(version ? version[0] : "", "");
+    licences.push({
+      title: nameWithoutVersion,
+      version: version ? version[0] : "",
+      licenceType: licence.licenses,
+      repository: licence.repository || "",
+      licenseUrl: licence.licenseFile || ""
+    });
+  }
+  return licences;
+};
+var openWifiSettings = async () => {
+  if (reactNative.Platform.OS === "ios") {
+    return openWifiSettingsIos();
+  }
+  if (reactNative.Platform.OS === "android") {
+    return openWifiSettingsAndroid();
+  }
+  logger.warn(`[openWifiSettings] is not supported on this platform: ${reactNative.Platform.OS}`);
+};
+var openWifiSettingsIos = async () => {
+  const url = "App-Prefs:root=WIFI";
+  try {
+    const canOpen = await reactNative.Linking.canOpenURL(url);
+    if (canOpen) {
+      return reactNative.Linking.openURL(url);
+    }
+  } catch (e) {
+    logger.error("[openWifiSettings] error opening iOS Wi-Fi settings", e);
+  }
+  return reactNative.Linking.openSettings();
+};
+var openWifiSettingsAndroid = async () => {
+  try {
+    await reactNative.Linking.openURL("android.settings.WIFI_SETTINGS");
+  } catch (e) {
+    logger.error("[openWifiSettings] Error opening Android Wi-Fi settings:", e);
+  }
+};
+var extractInfoFromNetInfoState = (netInfoState) => {
+  const { isConnected, type } = netInfoState;
+  const details = netInfoState.details ?? {};
+  const ipAddress = "ipAddress" in details ? details.ipAddress : "";
+  const ipLabel = ipAddress ? `ip: ${ipAddress}` : "";
+  return { isConnected, type, ipLabel };
+};
+var startNetworkStateLogging = () => {
+  return netinfo.addEventListener((netInfoState) => {
+    const { isConnected, type, ipLabel } = extractInfoFromNetInfoState(netInfoState);
+    if (isConnected) {
+      logger.info(`[startNetworkStateLogging] connected: ${type} ${ipLabel}`);
+    } else {
+      logger.warn(`[startNetworkStateLogging] disconnected`);
+    }
+  });
+};
+var isAxiosNetworkError = (error) => {
+  if (!axios.isAxiosError(error)) {
+    return false;
+  }
+  const code = error.code ?? "";
+  if (!code) {
+    return false;
+  }
+  return axios.AxiosError.ERR_NETWORK === code;
+};
+var isValidIpAddressV4 = (ip) => {
+  if (tsCommon.isBlank(ip)) {
+    return false;
+  }
+  return tsCommon.REGEX_IPV4.test(ip);
+};
+var notImplementedYet = (...args) => {
+  logger.debug(`Not implemented yet on "${reactNative.Platform.OS}" platform`, args);
+};
+var getSQLiteVersion = async () => {
+  try {
+    const db = await SQLite__namespace.openDatabaseAsync(":memory:");
+    const result = await db.getFirstAsync("SELECT sqlite_version() as version");
+    await db.closeAsync();
+    return result?.version ?? "Unknown";
+  } catch (e) {
+    const message = tsCommon.getErrorMessage(e);
+    logger.error(`[getSQLiteVersion] ${message}`, e);
+    throw new Error(`[getSQLiteVersion] ${message}`);
+  }
+};
+var createDbFolderUri = async () => {
+  const dbFolderUri = getDocumentFullFilename("SQLite");
+  const exists = await isFileExists(dbFolderUri);
+  if (!exists) {
+    await createDirectoryStructure(dbFolderUri);
+  }
+};
+var getUniqueDbFilename = (prefix = "") => {
+  const nowAsFilename = tsCommon.nowAsDateTimeForFilename();
+  return `${prefix}${nowAsFilename}.db`;
+};
+var createDbInstance = async (existingFilename) => {
+  await createDbFolderUri();
+  const dbFilename = existingFilename ?? getUniqueDbFilename();
+  const db = await SQLite__namespace.openDatabaseAsync(dbFilename);
+  return { db, dbFilename };
+};
+
+// src/utils/webview.utils.ts
+var htmlDocumentMessage = (message = {}) => {
+  const jsonMessage = JSON.stringify(message ?? {});
+  return `
+      window.onReactNativeMessage('${jsonMessage}');
+      true;
+    `;
+};
+var htmlDocumentRawMessage = (message = "") => {
+  return `
+      window.onReactNativeMessage("${message}");
+      true;
+    `;
+};
+var logIncomingHtmlDocMessage = ({ type = "log", log = "" }) => {
+  logger[type](`[incoming-html-doc-message] ${log}`);
+};
+var validateResizableSplitViewProps = (props) => {
+  const { initialLeftRatio, minLeftRatio, maxLeftRatio } = props;
+  if (!tsCommon.isNullish(initialLeftRatio)) {
+    if (initialLeftRatio < 0 || initialLeftRatio > 1)
+      throw new Error(`initialLeftRatio must be between 0 and 1. Provided: ${initialLeftRatio}`);
+  }
+  if (!tsCommon.isNullish(minLeftRatio)) {
+    if (minLeftRatio < 0 || minLeftRatio > 1)
+      throw new Error(`minLeftRatio must be between 0 and 1. Provided: ${minLeftRatio}`);
+  }
+  if (!tsCommon.isNullish(maxLeftRatio)) {
+    if (maxLeftRatio < 0 || maxLeftRatio > 1)
+      throw new Error(`maxLeftRatio must be between 0 and 1. Provided: ${maxLeftRatio}`);
+  }
+  if (!tsCommon.isNullish(minLeftRatio) && !tsCommon.isNullish(maxLeftRatio) && minLeftRatio >= maxLeftRatio)
+    throw new Error(
+      `minLeftRatio must be less than maxLeftRatio. Provided: ${JSON.stringify({ minLeftRatio, maxLeftRatio })}`
+    );
+  if (!tsCommon.isNullish(initialLeftRatio) && !tsCommon.isNullish(minLeftRatio) && initialLeftRatio < minLeftRatio)
+    throw new Error(
+      `initialLeftRatio must be >= minLeftRatio. Provided: ${JSON.stringify({ initialLeftRatio, minLeftRatio })}`
+    );
+  if (!tsCommon.isNullish(initialLeftRatio) && !tsCommon.isNullish(maxLeftRatio) && initialLeftRatio > maxLeftRatio)
+    throw new Error(
+      `initialLeftRatio must be <= maxLeftRatio. Provided: ${JSON.stringify({ initialLeftRatio, maxLeftRatio })}`
+    );
+};
+var DRAG_HANDLE_WIDTH = 20;
+var DEFAULT_ANIMATION_CONFIG = { damping: 25, stiffness: 300, mass: 0.8 };
+var HorizontalResizableSplitView = (props) => {
+  if (isDevelopment()) validateResizableSplitViewProps(props);
+  const {
+    leftContent,
+    rightContent,
+    initialLeftRatio = 0.5,
+    minLeftRatio = 0.15,
+    maxLeftRatio = 0.85,
+    handleContainerStyle,
+    handleStyle,
+    hideHandle = false
+  } = props;
+  const [isReady, setIsReady] = react.useState(false);
+  const leftSectionWidth = Animated.useSharedValue(0);
+  const minWidth = Animated.useSharedValue(0);
+  const maxWidth = Animated.useSharedValue(0);
+  const startX = Animated.useSharedValue(0);
+  const isDragging = Animated.useSharedValue(false);
+  const handleLayout = react.useCallback(
+    (event) => {
+      const { width } = event.nativeEvent.layout;
+      if (width > 0 && !isReady) {
+        minWidth.value = width * minLeftRatio;
+        maxWidth.value = width * maxLeftRatio;
+        leftSectionWidth.value = width * initialLeftRatio;
+        setIsReady(true);
+      }
+    },
+    [minLeftRatio, maxLeftRatio, initialLeftRatio, minWidth, maxWidth, leftSectionWidth, isReady]
+  );
+  const panGesture = reactNativeGestureHandler.Gesture.Pan().onStart(() => {
+    startX.value = leftSectionWidth.value;
+    isDragging.value = true;
+  }).onUpdate((event) => {
+    const newWidth = startX.value + event.translationX;
+    leftSectionWidth.value = Math.max(minWidth.value, Math.min(newWidth, maxWidth.value));
+  }).onEnd(() => {
+    isDragging.value = false;
+  });
+  const leftSectionAnimatedStyle = Animated.useAnimatedStyle(() => ({ width: leftSectionWidth.value }));
+  const dragHandleContainerAnimatedStyle = Animated.useAnimatedStyle(() => ({
+    left: leftSectionWidth.value - DRAG_HANDLE_WIDTH / 2
+  }));
+  const dragHandleAnimatedStyle = Animated.useAnimatedStyle(() => ({
+    transform: [{ scale: Animated.withSpring(isDragging.value ? 1.2 : 1, DEFAULT_ANIMATION_CONFIG) }]
+  }));
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles3.container], onLayout: handleLayout, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles3.leftSection, leftSectionAnimatedStyle], children: leftContent }),
+    !hideHandle && /* @__PURE__ */ jsxRuntime.jsx(reactNativeGestureHandler.GestureDetector, { gesture: panGesture, children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles3.handleContainer, handleContainerStyle, dragHandleContainerAnimatedStyle], children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles3.handle, handleStyle, dragHandleAnimatedStyle] }) }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles3.rightSection], children: rightContent })
+  ] });
+};
+var styles3 = reactNative.StyleSheet.create({
+  container: {
+    flex: 1,
+    flexDirection: "row"
+  },
+  leftSection: {
+    overflow: "hidden"
+  },
+  rightSection: {
+    flex: 1,
+    overflow: "hidden"
+  },
+  handleContainer: {
+    position: "absolute",
+    top: 0,
+    bottom: 0,
+    width: DRAG_HANDLE_WIDTH,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  handle: {
+    width: 4,
+    height: 40,
+    backgroundColor: "#888888",
+    borderRadius: 2
+  }
+});
+
+// src/components/layout/resizable/resizable-overlay-view.utils.ts
+var computeResizableOverlayLayoutValues = ({
+  event,
+  initialForegroundRatio,
+  minForegroundRatio,
+  maxForegroundRatio,
+  foregroundContentAspectRatio
+}) => {
+  const { height, width } = event.nativeEvent.layout;
+  if (height <= 0) return { containerHeight: 0, containerWidth: 0, minHeight: 0, maxHeight: 0, overlayHeight: 0 };
+  const computedMinHeight = height * minForegroundRatio;
+  const computedMaxHeightFromContainer = height * maxForegroundRatio;
+  const computedMaxHeightFromAspectRatio = foregroundContentAspectRatio !== void 0 ? width / foregroundContentAspectRatio : Number.POSITIVE_INFINITY;
+  const computedMaxHeight = Math.max(
+    computedMinHeight,
+    Math.min(computedMaxHeightFromContainer, computedMaxHeightFromAspectRatio)
+  );
+  const computedOverlayHeight = Math.max(
+    computedMinHeight,
+    Math.min(height * initialForegroundRatio, computedMaxHeight)
+  );
+  return {
+    containerHeight: height,
+    containerWidth: width,
+    minHeight: computedMinHeight,
+    maxHeight: computedMaxHeight,
+    overlayHeight: computedOverlayHeight
+  };
+};
+var validateResizableOverlayProps = (props) => {
+  const { foregroundContentAspectRatio, initialForegroundRatio, minForegroundRatio, maxForegroundRatio } = props;
+  if (!tsCommon.isNullish(foregroundContentAspectRatio)) {
+    if (foregroundContentAspectRatio <= 0)
+      throw new Error("foregroundContentAspectRatio must be greater than 0. Provided: " + foregroundContentAspectRatio);
+  }
+  if (!tsCommon.isNullish(initialForegroundRatio)) {
+    if (initialForegroundRatio < 0 || initialForegroundRatio > 1)
+      throw new Error(`initialForegroundRatio must be between 0 and 1. Provided: ${initialForegroundRatio}`);
+  }
+  if (!tsCommon.isNullish(minForegroundRatio)) {
+    if (minForegroundRatio < 0 || minForegroundRatio > 1)
+      throw new Error(`minForegroundRatio must be between 0 and 1. Provided: ${minForegroundRatio}`);
+  }
+  if (!tsCommon.isNullish(maxForegroundRatio)) {
+    if (maxForegroundRatio < 0 || maxForegroundRatio > 1)
+      throw new Error(`maxForegroundRatio must be between 0 and 1. Provided: ${maxForegroundRatio}`);
+  }
+  if (!tsCommon.isNullish(minForegroundRatio) && !tsCommon.isNullish(maxForegroundRatio) && minForegroundRatio >= maxForegroundRatio)
+    throw new Error(
+      `minForegroundRatio must be less than maxForegroundRatio. Provided: ${JSON.stringify({ minForegroundRatio, maxForegroundRatio })}`
+    );
+  if (!tsCommon.isNullish(initialForegroundRatio) && !tsCommon.isNullish(minForegroundRatio) && initialForegroundRatio < minForegroundRatio)
+    throw new Error(
+      `initialForegroundRatio must be >= minForegroundRatio. Provided: ${JSON.stringify({ initialForegroundRatio, minForegroundRatio })}`
+    );
+  if (!tsCommon.isNullish(initialForegroundRatio) && !tsCommon.isNullish(maxForegroundRatio) && initialForegroundRatio > maxForegroundRatio)
+    throw new Error(
+      `initialForegroundRatio must be <= maxForegroundRatio. Provided: ${JSON.stringify({ initialForegroundRatio, maxForegroundRatio })}`
+    );
+};
+var DRAG_HANDLE_HEIGHT = 20;
+var DEFAULT_ANIMATION_CONFIG2 = { damping: 25, stiffness: 300, mass: 0.8 };
+var OVERLAY_ANCHOR_STYLES = {
+  topLeft: { top: 0, left: 0 },
+  topRight: { top: 0, right: 0 },
+  bottomLeft: { bottom: 0, left: 0 },
+  bottomRight: { bottom: 0, right: 0 }
+};
+var ResizableOverlayView = (props) => {
+  if (isDevelopment()) validateResizableOverlayProps(props);
+  const {
+    foregroundContent,
+    backgroundContent,
+    initialForegroundRatio = 0.5,
+    minForegroundRatio = 0.15,
+    maxForegroundRatio = 0.85,
+    foregroundContentAspectRatio,
+    handleContainerStyle,
+    handleStyle,
+    hideHandle = false,
+    anchorType = "topRight"
+  } = props;
+  const overlayAnchorStyle = OVERLAY_ANCHOR_STYLES[anchorType];
+  const isBottomAnchored = ["bottomLeft", "bottomRight"].includes(anchorType);
+  const isLeftAnchored = ["topLeft", "bottomLeft"].includes(anchorType);
+  const overlayHeight = Animated.useSharedValue(0);
+  const containerHeight = Animated.useSharedValue(0);
+  const containerWidth = Animated.useSharedValue(0);
+  const minHeight = Animated.useSharedValue(0);
+  const maxHeight = Animated.useSharedValue(0);
+  const startY = Animated.useSharedValue(0);
+  const isDragging = Animated.useSharedValue(false);
+  const handleLayout = (event) => {
+    const computedValues = computeResizableOverlayLayoutValues({
+      event,
+      initialForegroundRatio,
+      minForegroundRatio,
+      maxForegroundRatio,
+      foregroundContentAspectRatio
+    });
+    containerHeight.value = computedValues.containerHeight;
+    containerWidth.value = computedValues.containerWidth;
+    minHeight.value = computedValues.minHeight;
+    maxHeight.value = computedValues.maxHeight;
+    overlayHeight.value = computedValues.overlayHeight;
+  };
+  const panGesture = reactNativeGestureHandler.Gesture.Pan().onStart(() => {
+    startY.value = overlayHeight.value;
+    isDragging.value = true;
+  }).onUpdate((event) => {
+    const direction = isBottomAnchored ? -1 : 1;
+    const newHeight = startY.value + direction * event.translationY;
+    overlayHeight.value = Math.max(minHeight.value, Math.min(newHeight, maxHeight.value));
+  }).onEnd(() => {
+    isDragging.value = false;
+  });
+  const overlayAnimatedStyle = Animated.useAnimatedStyle(() => {
+    let height = overlayHeight.value;
+    let width;
+    if (foregroundContentAspectRatio !== void 0) {
+      const calculatedWidth = height * foregroundContentAspectRatio;
+      if (calculatedWidth > containerWidth.value) {
+        width = containerWidth.value;
+        height = Math.max(containerWidth.value / foregroundContentAspectRatio, minHeight.value);
+      } else {
+        width = calculatedWidth;
+      }
+    }
+    return width !== void 0 ? { height, width } : { height };
+  });
+  const dragHandleContainerAnimatedStyle = Animated.useAnimatedStyle(() => {
+    let effectiveHeight = overlayHeight.value;
+    let effectiveWidth = containerWidth.value;
+    if (foregroundContentAspectRatio !== void 0) {
+      const calculatedWidth = effectiveHeight * foregroundContentAspectRatio;
+      if (calculatedWidth > containerWidth.value) {
+        effectiveHeight = Math.max(containerWidth.value / foregroundContentAspectRatio, minHeight.value);
+        effectiveWidth = containerWidth.value;
+      } else {
+        effectiveWidth = calculatedWidth;
+      }
+    }
+    const left = isLeftAnchored ? 0 : Math.max(0, containerWidth.value - effectiveWidth);
+    const top = isBottomAnchored ? containerHeight.value - effectiveHeight - DRAG_HANDLE_HEIGHT / 2 : effectiveHeight - DRAG_HANDLE_HEIGHT / 2;
+    return {
+      top,
+      width: effectiveWidth,
+      left
+    };
+  }, [foregroundContentAspectRatio, isBottomAnchored, isLeftAnchored]);
+  const dragHandleAnimatedStyle = Animated.useAnimatedStyle(() => ({
+    transform: [{ scale: Animated.withSpring(isDragging.value ? 1.2 : 1, DEFAULT_ANIMATION_CONFIG2) }]
+  }));
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles4.container], onLayout: handleLayout, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles4.backgroundSection, children: backgroundContent }),
+    /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles4.overlaySection, overlayAnchorStyle, overlayAnimatedStyle], children: foregroundContent }),
+    !hideHandle && /* @__PURE__ */ jsxRuntime.jsx(reactNativeGestureHandler.GestureDetector, { gesture: panGesture, children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles4.handleContainer, handleContainerStyle, dragHandleContainerAnimatedStyle], children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles4.handle, handleStyle, dragHandleAnimatedStyle] }) }) })
+  ] });
+};
+var styles4 = reactNative.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  backgroundSection: {
+    flex: 1
+  },
+  overlaySection: {
+    position: "absolute",
+    overflow: "hidden"
+  },
+  handleContainer: {
+    position: "absolute",
+    height: DRAG_HANDLE_HEIGHT,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  handle: {
+    width: 40,
+    height: 4,
+    backgroundColor: "#888888",
+    borderRadius: 4
+  }
+});
+var validateResizableSplitViewProps2 = (props) => {
+  const { initialTopRatio, minTopRatio, maxTopRatio } = props;
+  if (!tsCommon.isNullish(initialTopRatio)) {
+    if (initialTopRatio < 0 || initialTopRatio > 1)
+      throw new Error(`initialTopRatio must be between 0 and 1. Provided: ${initialTopRatio}`);
+  }
+  if (!tsCommon.isNullish(minTopRatio)) {
+    if (minTopRatio < 0 || minTopRatio > 1)
+      throw new Error(`minTopRatio must be between 0 and 1. Provided: ${minTopRatio}`);
+  }
+  if (!tsCommon.isNullish(maxTopRatio)) {
+    if (maxTopRatio < 0 || maxTopRatio > 1)
+      throw new Error(`maxTopRatio must be between 0 and 1. Provided: ${maxTopRatio}`);
+  }
+  if (!tsCommon.isNullish(minTopRatio) && !tsCommon.isNullish(maxTopRatio) && minTopRatio >= maxTopRatio)
+    throw new Error(
+      `minTopRatio must be less than maxTopRatio. Provided: ${JSON.stringify({ minTopRatio, maxTopRatio })}`
+    );
+  if (!tsCommon.isNullish(initialTopRatio) && !tsCommon.isNullish(minTopRatio) && initialTopRatio < minTopRatio)
+    throw new Error(
+      `initialTopRatio must be >= minTopRatio. Provided: ${JSON.stringify({ initialTopRatio, minTopRatio })}`
+    );
+  if (!tsCommon.isNullish(initialTopRatio) && !tsCommon.isNullish(maxTopRatio) && initialTopRatio > maxTopRatio)
+    throw new Error(
+      `initialTopRatio must be <= maxTopRatio. Provided: ${JSON.stringify({ initialTopRatio, maxTopRatio })}`
+    );
+};
+var DRAG_HANDLE_HEIGHT2 = 20;
+var DEFAULT_ANIMATION_CONFIG3 = { damping: 25, stiffness: 300, mass: 0.8 };
+var VerticalResizableSplitView = (props) => {
+  if (isDevelopment()) validateResizableSplitViewProps2(props);
+  const {
+    topContent,
+    bottomContent,
+    initialTopRatio = 0.5,
+    minTopRatio = 0.15,
+    maxTopRatio = 0.85,
+    handleContainerStyle,
+    handleStyle,
+    hideHandle = false
+  } = props;
+  const [isReady, setIsReady] = react.useState(false);
+  const topSectionHeight = Animated.useSharedValue(0);
+  const minHeight = Animated.useSharedValue(0);
+  const maxHeight = Animated.useSharedValue(0);
+  const startY = Animated.useSharedValue(0);
+  const isDragging = Animated.useSharedValue(false);
+  const handleLayout = react.useCallback(
+    (event) => {
+      const { height } = event.nativeEvent.layout;
+      if (height > 0 && !isReady) {
+        minHeight.value = height * minTopRatio;
+        maxHeight.value = height * maxTopRatio;
+        topSectionHeight.value = height * initialTopRatio;
+        setIsReady(true);
+      }
+    },
+    [minTopRatio, maxTopRatio, initialTopRatio, minHeight, maxHeight, topSectionHeight, isReady]
+  );
+  const panGesture = reactNativeGestureHandler.Gesture.Pan().onStart(() => {
+    startY.value = topSectionHeight.value;
+    isDragging.value = true;
+  }).onUpdate((event) => {
+    const newHeight = startY.value + event.translationY;
+    topSectionHeight.value = Math.max(minHeight.value, Math.min(newHeight, maxHeight.value));
+  }).onEnd(() => {
+    isDragging.value = false;
+  });
+  const topSectionAnimatedStyle = Animated.useAnimatedStyle(() => ({ height: topSectionHeight.value }));
+  const dragHandleContainerAnimatedStyle = Animated.useAnimatedStyle(() => ({
+    top: topSectionHeight.value - DRAG_HANDLE_HEIGHT2 / 2
+  }));
+  const dragHandleAnimatedStyle = Animated.useAnimatedStyle(() => ({
+    transform: [{ scale: Animated.withSpring(isDragging.value ? 1.2 : 1, DEFAULT_ANIMATION_CONFIG3) }]
+  }));
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles5.container], onLayout: handleLayout, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles5.topSection, topSectionAnimatedStyle], children: topContent }),
+    !hideHandle && /* @__PURE__ */ jsxRuntime.jsx(reactNativeGestureHandler.GestureDetector, { gesture: panGesture, children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles5.handleContainer, handleContainerStyle, dragHandleContainerAnimatedStyle], children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: [styles5.handle, handleStyle, dragHandleAnimatedStyle] }) }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles5.bottomSection], children: bottomContent })
+  ] });
+};
+var styles5 = reactNative.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  topSection: {
+    overflow: "hidden"
+  },
+  bottomSection: {
+    flex: 1,
+    overflow: "hidden"
+  },
+  handleContainer: {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    height: DRAG_HANDLE_HEIGHT2,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  handle: {
+    width: 40,
+    height: 4,
+    backgroundColor: "#888888",
+    borderRadius: 2
+  }
+});
+var SafeContainer = ({ children, style, shouldAnimate = false }) => {
+  const isScreenFocused = native.useIsFocused();
+  if (!isScreenFocused) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativeSafeAreaContext.SafeAreaView, { style: [styles6.container, style], children: /* @__PURE__ */ jsxRuntime.jsx(Animated__default.default.View, { style: styles6.container, entering: shouldAnimate ? Animated.FadeInUp.duration(500) : void 0, children }) });
+};
+var styles6 = reactNative.StyleSheet.create({
+  container: {
+    flex: 1
+  }
+});
+var ListHeader = ({ title }) => {
+  const styles7 = useStyles17();
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.container, children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "titleMedium", children: title }) });
+};
+var useStyles17 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      paddingHorizontal: theme.spacing(1)
+    }
+  });
+};
+var ListItemsSeparator = () => {
+  const styles7 = useStyles18();
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.separator });
+};
+var useStyles18 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    separator: {
+      height: reactNative.StyleSheet.hairlineWidth,
+      backgroundColor: theme.colors.outline
+    }
+  });
+};
+var OnOffState = {
+  on: "on",
+  off: "off"
+};
+var OnOffToggle = ({ isOn, onValueChange, style }) => {
+  const theme = useAppTheme();
+  const checkedColor = theme.colors.primary;
+  const uncheckedColor = theme.colors.tertiary;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNativePaper.SegmentedButtons,
+    {
+      value: isOn ? OnOffState.on : OnOffState.off,
+      onValueChange: (value) => onValueChange(value === OnOffState.on),
+      buttons: [
+        {
+          value: OnOffState.on,
+          icon: "play",
+          checkedColor,
+          uncheckedColor
+        },
+        {
+          value: OnOffState.off,
+          icon: "stop",
+          checkedColor,
+          uncheckedColor
+        }
+      ],
+      style
+    }
+  );
+};
+var PasswordInput = ({ label, ...rest }) => {
+  const { t } = reactI18next.useTranslation();
+  const [isPasswordVisible, toggleShowPassword] = usehooks.useToggle();
+  const displayLabel = label ?? t("common:password");
+  const icon = isPasswordVisible ? "eye-off" : "eye";
+  const showA11yLabel = isPasswordVisible ? t("common:passwordInput.hidePassword") : t("common:passwordInput.showPassword");
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNativePaper.TextInput,
+    {
+      label: displayLabel,
+      secureTextEntry: !isPasswordVisible,
+      right: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.TextInput.Icon, { icon, onPress: () => toggleShowPassword(), accessibilityLabel: showA11yLabel }),
+      ...rest
+    }
+  );
+};
+
+// src/components/spinner/activity-progress.utils.ts
+var import_pretty_bytes = __toESM(require_pretty_bytes());
+var computeActivityProgress = (progress) => {
+  if (!progress) {
+    return { percentage: 0, stats: "" };
+  }
+  const { loaded, total, isBytes = true, decimals = 2 } = progress;
+  const hasTotal = !!total;
+  if (isBytes) {
+    const loadedLabel = (0, import_pretty_bytes.default)(loaded);
+    const totalLabel = hasTotal ? (0, import_pretty_bytes.default)(total) : "";
+    const stats2 = `${loadedLabel} / ${totalLabel}`;
+    const percentage2 = hasTotal ? tsCommon.toFixed(loaded / total * 100, decimals) : 0;
+    return { percentage: percentage2, stats: stats2 };
+  }
+  const stats = hasTotal ? `${loaded} / ${total}` : `${loaded}`;
+  const percentage = hasTotal ? tsCommon.toFixed(loaded / total * 100, decimals) : 0;
+  return { percentage, stats };
+};
+var ActivityProgressBarStats = ({
+  progress,
+  shouldShowSpinner = false
+}) => {
+  const styles7 = useStyles19();
+  const { percentage, stats } = computeActivityProgress(progress);
+  if (shouldShowSpinner) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.ActivityIndicator, {});
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.ProgressBar, { progress: percentage / 100, style: styles7.progressBar }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.statsContainer, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", children: stats }),
+      /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Text, { variant: "bodySmall", children: [
+        percentage.toFixed(0),
+        "%"
+      ] })
+    ] })
+  ] });
+};
+var useStyles19 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    progressBar: {
+      height: 8,
+      borderRadius: theme.roundness
+    },
+    statsContainer: {
+      flexDirection: "row",
+      justifyContent: "space-between"
+    }
+  });
+};
+var ActivityProgressBar = ({
+  title,
+  progress,
+  description = "",
+  shouldShowSpinner
+}) => {
+  const styles7 = useStyles20();
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.container, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", style: styles7.label, children: title }),
+    /* @__PURE__ */ jsxRuntime.jsx(ActivityProgressBarStats, { progress, shouldShowSpinner }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { variant: "bodySmall", style: styles7.label, children: description })
+  ] });
+};
+var useStyles20 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      gap: theme.spacing(1)
+    },
+    label: {
+      alignSelf: "center"
+    }
+  });
+};
+var FullCenteredSpinner = () => /* @__PURE__ */ jsxRuntime.jsx(FullCentered, { children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.ActivityIndicator, {}) });
+var ModalSpinner = ({
+  isVisible,
+  title = "Loading",
+  description = "Please wait...",
+  modelLoadingLogs,
+  onDismiss
+}) => {
+  const styles7 = useStyles21();
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog, { visible: isVisible, onDismiss, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Title, { style: styles7.title, children: title }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNativePaper.Dialog.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.ActivityIndicator, { style: styles7.spinner }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { children: description }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.progressLogs, children: modelLoadingLogs.map((log) => /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Text, { numberOfLines: 1, ellipsizeMode: "tail", style: styles7.progressLog, children: log }, log)) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Dialog.Actions, { children: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.Button, { onPress: onDismiss, children: "Cancel" }) })
+  ] }) });
+};
+var useStyles21 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    title: {
+      textAlign: "center"
+    },
+    spinner: {
+      marginVertical: theme.spacing(3)
+    },
+    progressLogs: {
+      height: 80,
+      maxHeight: 80,
+      overflow: "scroll",
+      marginVertical: 10,
+      width: "100%"
+    },
+    progressLog: {
+      color: theme.colors.secondary,
+      width: "100%"
+    }
+  });
+};
+var buildFinalValue = ({ query, recordingValue }) => {
+  return [query, recordingValue].filter(tsCommon.isNotBlank).join(" ");
+};
+var ensureVoiceRecognitionPermissions = async () => {
+  try {
+    const permissions = await expoSpeechRecognition.ExpoSpeechRecognitionModule.getPermissionsAsync();
+    if (!permissions.granted) {
+      const result = await expoSpeechRecognition.ExpoSpeechRecognitionModule.requestPermissionsAsync();
+      if (!result.granted) {
+        logger.info("[ensureVoiceRecognitionPermissions] Permissions not granted", result);
+        return false;
+      }
+    }
+    return true;
+  } catch (e) {
+    logger.error("[ensureVoiceRecognitionPermissions] Error getting permissions", e);
+    return false;
+  }
+};
+var VoiceRecognitionTextInput = ({
+  label,
+  value,
+  onValueChange,
+  onValueSubmit,
+  ...rest
+}) => {
+  const styles7 = useStyles22();
+  const [isRecording, setIsRecording] = react.useState(false);
+  const [recordingValue, setRecordingValue] = react.useState("");
+  const { t } = reactI18next.useTranslation();
+  const speechToTextLanguageCode = t("common:speechToTextLanguageCode");
+  const finalValue = buildFinalValue({ query: value, recordingValue });
+  const triggerOnSearch = () => {
+    reactNative.Keyboard.dismiss();
+    onValueSubmit(finalValue.trim());
+    setIsRecording(false);
+    setRecordingValue("");
+  };
+  expoSpeechRecognition.useSpeechRecognitionEvent("result", (event) => {
+    if (!isRecording) return;
+    const transcript = event.results[0].transcript;
+    if (tsCommon.isNotBlank(transcript)) {
+      setRecordingValue(transcript);
+    }
+  });
+  expoSpeechRecognition.useSpeechRecognitionEvent("error", (event) => {
+    const { error, message } = event;
+    logger.error(`[useSpeechRecognitionEvent] error: ${error} - ${message}`);
+    setIsRecording(false);
+    setRecordingValue("");
+  });
+  const handleStartRecording = async () => {
+    const hasPermissions = await ensureVoiceRecognitionPermissions();
+    if (!hasPermissions) return;
+    setIsRecording(true);
+    setRecordingValue("");
+    reactNative.Keyboard.dismiss();
+    expoSpeechRecognition.ExpoSpeechRecognitionModule.start({
+      lang: speechToTextLanguageCode,
+      interimResults: true,
+      continuous: true
+    });
+  };
+  const handleStopRecording = async () => {
+    if (!isRecording) return;
+    setIsRecording(false);
+    expoSpeechRecognition.ExpoSpeechRecognitionModule.stop();
+    if (tsCommon.isNotBlank(recordingValue)) {
+      onValueChange(buildFinalValue({ query: value, recordingValue }));
+    }
+    setRecordingValue("");
+  };
+  const toggleRecording = () => {
+    if (isRecording) {
+      handleStopRecording();
+    } else {
+      handleStartRecording();
+    }
+  };
+  const clearValue = () => {
+    onValueChange("");
+    setRecordingValue("");
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles7.container, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNativePaper.TextInput,
+      {
+        ...rest,
+        style: styles7.textInput,
+        label,
+        value: finalValue,
+        readOnly: isRecording,
+        onChangeText: onValueChange,
+        multiline: true,
+        numberOfLines: 4,
+        left: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.TextInput.Icon, { icon: isRecording ? "stop" : "microphone-outline", onPress: toggleRecording }),
+        right: /* @__PURE__ */ jsxRuntime.jsx(reactNativePaper.TextInput.Icon, { icon: "close", onPress: clearValue, disabled: tsCommon.isBlank(finalValue) })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles7.actionsContainer, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNativePaper.IconButton,
+      {
+        icon: "send",
+        onPress: triggerOnSearch,
+        disabled: tsCommon.isBlank(finalValue),
+        iconColor: styles7.sendIcon.color
+      }
+    ) })
+  ] });
+};
+var useStyles22 = () => {
+  const theme = useAppTheme();
+  return reactNative.StyleSheet.create({
+    container: {
+      flexDirection: "row"
+    },
+    textInput: {
+      flex: 1
+    },
+    actionsContainer: {
+      flexDirection: "row"
+    },
+    sendIcon: {
+      color: theme.colors.primary
+    }
+  });
+};
+var toSinglePictureUri = (result) => {
+  if (!result.canceled && result.assets.length > 0) {
+    return result.assets[0].uri;
+  }
+  return null;
+};
+var requestTakePhotoPermissions = async () => {
+  const { status } = await ImagePicker__namespace.requestCameraPermissionsAsync();
+  return status === "granted";
+};
+var requestMediaLibPermissions = async () => {
+  const { status } = await ImagePicker__namespace.requestMediaLibraryPermissionsAsync();
+  return status === "granted";
+};
+var DEFAULT_OPTIONS2 = {
+  allowsEditing: true,
+  aspect: [4, 3],
+  quality: 0.7
+};
+var useCameraImagePicker = (options2 = DEFAULT_OPTIONS2) => {
+  const { t } = reactI18next.useTranslation();
+  const { showSnackbarMessage } = useSnackbar();
+  const handlePermissionDenied = () => {
+    showSnackbarMessage(t("common:imagePicker.permissionDenied"));
+    return null;
+  };
+  const handleError = (e) => {
+    logger.error("[useCameraImagePicker] Error picking image", e);
+    showSnackbarMessage(t("common:imagePicker.error"));
+  };
+  const pickImage = async () => {
+    const hasPermission = await requestMediaLibPermissions();
+    if (!hasPermission) return handlePermissionDenied();
+    try {
+      const result = await ImagePicker__namespace.launchImageLibraryAsync(options2);
+      return toSinglePictureUri(result);
+    } catch (e) {
+      handleError(e);
+    }
+    return null;
+  };
+  const takePhoto = async () => {
+    const hasPermission = await requestTakePhotoPermissions();
+    if (!hasPermission) return handlePermissionDenied();
+    try {
+      const result = await ImagePicker__namespace.launchCameraAsync(options2);
+      return toSinglePictureUri(result);
+    } catch (e) {
+      handleError(e);
+    }
+    return null;
+  };
+  return {
+    pickImage,
+    takePhoto
+  };
+};
+var options = {
+  mediaTypes: ["images", "livePhotos"],
+  allowsEditing: true,
+  quality: 1
+};
+var DEFAULT_DIMENSIONS = {
+  width: 0,
+  height: 0,
+  aspectRatio: 1
+};
+var useImagePicker = () => {
+  const [selectedImage, setSelectedImage] = react.useState();
+  const [dimensions, setDimensions] = react.useState(DEFAULT_DIMENSIONS);
+  const hasSelectedImage = !!selectedImage;
+  const pickImage = async () => {
+    const result = await ImagePicker__namespace.launchImageLibraryAsync(options);
+    if (result.canceled) {
+      return;
+    }
+    const { uri } = result.assets[0];
+    setSelectedImage(uri);
+    reactNative.Image.getSize(uri, (width, height) => setDimensions({ width, height, aspectRatio: width / height }), logger.error);
+  };
+  return {
+    pickImage,
+    hasSelectedImage,
+    selectedImage,
+    dimensions
+  };
+};
+var useInvalidateQueriesOnFocus = (queryKeys) => {
+  const queryClient2 = reactQuery.useQueryClient();
+  native.useFocusEffect(
+    react.useCallback(() => {
+      const invalidationPromises = queryKeys.map((queryKey) => queryClient2.invalidateQueries({ queryKey }));
+      Promise.all(invalidationPromises);
+    }, [queryClient2])
+  );
+};
+var useOnHtmlDocMessage = () => {
+  const [isDocumentReady, setIsDocumentReady] = react.useState(false);
+  const onMessage = (payload) => {
+    const payloadData = payload?.nativeEvent?.data ?? "";
+    try {
+      const { type, data } = JSON.parse(payloadData);
+      if (type === "documentReady") {
+        setIsDocumentReady(true);
+      } else if (type === "console") {
+        logIncomingHtmlDocMessage(data);
+      } else {
+        logger.warn(`useWebviewDocument onMessage: <${type}> not handled`);
+      }
+    } catch (e) {
+      logger.error("Error in useWebviewDocument onMessage", e, payloadData);
+    }
+  };
+  return {
+    isDocumentReady,
+    onMessage
+  };
+};
+var useSingleFileSelector = ({ mimeTypes, copyToCacheDirectory = false }) => {
+  const { t } = reactI18next.useTranslation();
+  const { showSnackbarMessage } = useSnackbar();
+  const [selectedFile, setSelectedFile] = react.useState();
+  const handleFileSelection = async () => {
+    try {
+      const type = mimeTypes ?? ["*/*"];
+      const result = await pickSingleFile({ type, copyToCacheDirectory });
+      if (!result.exists) return;
+      const { name, size, uri, mimeType, lastModified } = result;
+      if (uri && name) {
+        setSelectedFile({ name, size, uri, lastModified, mimeType });
+      }
+    } catch (e) {
+      logger.error("[handleFileSelection] error selecting file", e);
+      showSnackbarMessage(t("common:errorUnexpected"));
+    }
+  };
+  return {
+    selectedFile,
+    handleFileSelection,
+    hasSelectedFile: !!selectedFile
+  };
+};
+var useTimeoutState = (timeoutMs) => {
+  const [isLoading, toggleLoading] = usehooks.useToggle(true);
+  react.useEffect(() => {
+    const timer = setTimeout(toggleLoading, timeoutMs);
+    return () => clearTimeout(timer);
+  }, []);
+  return isLoading;
+};
+var useTimeoutToggle = (timeoutMs) => {
+  const [isLoading, toggleLoading] = usehooks.useToggle(false);
+  const timeoutRef = react.useRef(null);
+  const onStartLoading = react.useCallback(() => {
+    clearTimeout(timeoutRef.current ?? void 0);
+    toggleLoading();
+    timeoutRef.current = setTimeout(() => {
+      toggleLoading();
+      timeoutRef.current = null;
+    }, timeoutMs);
+  }, [timeoutMs, toggleLoading]);
+  react.useEffect(() => {
+    return () => clearTimeout(timeoutRef.current ?? void 0);
+  }, []);
+  return [isLoading, onStartLoading];
+};
+
+// src/utils/env.utils.windows.ts
+var isProduction2 = () => {
+  if (__DEV__) {
+    return false;
+  }
+  return true;
+};
+
+// src/hooks/use-updates.ts
+var checkForUpdateAsync2 = async () => {
+  const deviceType = getDeviceType();
+  if (isRealDevice() && isProduction2()) {
+    logger.info(`[checkForUpdateAsync] Checking for update on ${deviceType}`);
+    await Updates2__namespace.checkForUpdateAsync();
+    return;
+  }
+  logger.info(`[checkForUpdateAsync] Faking update check on ${deviceType}`);
+  await tsCommon.sleep(1e3);
+};
+var useUpdates2 = () => {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const { currentlyRunning, isUpdateAvailable, isUpdatePending } = Updates2__namespace.useUpdates();
+  const fetchAndApplyUpdate = async () => {
+    setIsLoading(true);
+    try {
+      logger.info("[useUpdates.fetchAndApplyUpdate] Fetching update...");
+      await Updates2__namespace.fetchUpdateAsync();
+      logger.info("[useUpdates.fetchAndApplyUpdate] Update fetched successfully");
+    } catch (error) {
+      logger.error("[useUpdates.fetchAndApplyUpdate] Failed to fetch update:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const checkForUpdates = async () => {
+    setIsLoading(true);
+    try {
+      logger.info("[useUpdates.checkForUpdates] Checking for updates...");
+      await checkForUpdateAsync2();
+      logger.info("[useUpdates.checkForUpdates] Updates checked successfully");
+    } catch (error) {
+      logger.error("[useUpdates.checkForUpdates] Failed to check for updates:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  react.useEffect(() => {
+    if (isUpdatePending) {
+      logger.info("[useUpdates.useEffect] Reloading app...");
+      Updates2__namespace.reloadAsync();
+    }
+  }, [isUpdatePending]);
+  const storeVersion = `Store version: ${expoApplication.nativeApplicationVersion} (${expoApplication.nativeBuildVersion})`;
+  const runTypeMessage = currentlyRunning.isEmbeddedLaunch ? `${storeVersion}: from built-in code (no OTA update yet).` : `${storeVersion}: including OTA update.`;
+  return {
+    runTypeMessage,
+    isUpdateAvailable,
+    isUpdatePending,
+    checkForUpdates,
+    isLoading,
+    fetchAndApplyUpdate
+  };
+};
+
+// src/i18n/en/common.json
+var common_default = {
+  common: {
+    about: "About",
+    accept: "Accept",
+    account: "Account",
+    actions: "Actions",
+    add: "Add",
+    addLink: "Add a link",
+    addMember: "Add a member",
+    advanced: "Advanced",
+    all: "All",
+    apiCallResult: "API Call Result",
+    appLoading: "Loading Application\u2026",
+    appLoadingVersion: "Loading version {{version}}\u2026",
+    apply: "Apply",
+    archive: "Archive",
+    associate: "Associate",
+    asyncStatus: {
+      converting: "Converting\u2026",
+      deleteFileError: "Could not delete file",
+      deletingFile: "Deleting file...",
+      downloadError: "Error while downloading",
+      downloading: "Downloading\u2026",
+      loading: "Loading\u2026",
+      waiting: "Waiting\u2026"
+    },
+    back: "Back",
+    backup: "Backup",
+    barcodeScanner: {
+      scanBarcodeInstruction: "Position the barcode or QR code within the frame",
+      requestingCameraPermission: "Requesting camera permission...",
+      noCameraAccess: "No access to camera"
+    },
+    battery: {
+      level: "Battery level: {{batteryLevel}}%"
+    },
+    browse: "Browse",
+    cancel: "Cancel",
+    check: "Check",
+    clear: "Clear",
+    close: "Close",
+    complete: "Complete",
+    configure: "Configure",
+    confirm: "Confirm",
+    connect: "Connect",
+    continue: "Continue",
+    copiedToClipboard: "Text copied to clipboard",
+    copy: "Copy",
+    copyToClipboard: "Copy to clipboard",
+    create: "Create",
+    customize: "Customize",
+    data: "Data",
+    date: "Date",
+    default: "Default",
+    delete: "Delete",
+    deleteAllLogsFilesConfirmation: "Are you sure you want to delete all logs files?",
+    description: "Description",
+    details: "Details",
+    disable: "Disable",
+    done: "Done",
+    download: "Download",
+    edit: "Edit",
+    editItem: "Edit {{name}}",
+    enable: "Enable",
+    endDate: "End Date",
+    error: "Error",
+    errorBoundary: {
+      error: "An unexpected error occurred: {{errorMsg}} (ID: {{id}})",
+      details: "Details"
+    },
+    errorUnexpected: "An unexpected error occurred. Consult the logs for more details.",
+    errorLoadingFiles: "Error loading file tree",
+    eventLogs: "Event Logs",
+    export: "Export",
+    externalLinks: "External Links",
+    failed: "Failed",
+    file: "File",
+    filter: "Filter",
+    finish: "Finish",
+    folder: "Folder",
+    formValidations: {
+      filePathMustNotContainsRelativePath: "The file path must not contain a relative path",
+      filePathShouldNotContainsSpecialChars: "Invalid characters detected in the file path",
+      invalidPattern: "Verifiy that the opening '{' and closing '}' curly braces are correctly placed. Also ensure that the internal curly braces content is not blank.",
+      required: "This field is required",
+      email: "This field must be a valid email address",
+      minLength: "This field must be at least {{minLength}} characters long"
+    },
+    fullscreen: "Fullscreen",
+    help: "Help",
+    hide: "Hide",
+    i18nInitialized: "i18n 'en' \u2705",
+    imagePicker: {
+      takePhoto: "Take a photo",
+      chooseFromGallery: "Choose from gallery",
+      permissionDenied: "Permission denied to access gallery",
+      cameraPermissionDenied: "Permission denied to access camera",
+      error: "Error accessing image picker"
+    },
+    import: "Import",
+    information: "Information",
+    install: "Install",
+    item: "Item",
+    language: "Language",
+    link: "Link",
+    list: "List",
+    lock: "Lock",
+    logout: "Logout",
+    logs: {
+      filter: "Filter logs",
+      clear: "Clear logs",
+      copyAll: "Copy all logs"
+    },
+    manage: "Manage",
+    menu: "Menu",
+    more: "More",
+    move: "Move",
+    name: "Name",
+    na: "N/A",
+    new: "New",
+    next: "Next",
+    no: "No",
+    noCameraAvailable: "No camera available",
+    noDataFound: "No data available",
+    notification: "Notification",
+    nowDateTime: "Today's date and time",
+    off: "Off",
+    ok: "Ok",
+    on: "On",
+    open: "Open",
+    options: "Options",
+    password: "Password",
+    passwordInput: {
+      showPassword: "Show password",
+      hidePassword: "Hide password"
+    },
+    paste: "Paste",
+    preview: "Preview",
+    previous: "Previous",
+    print: "Print",
+    profile: "Profile",
+    public: "Public",
+    recent: "Recent",
+    refresh: "Refresh",
+    remove: "Remove",
+    rename: "Rename",
+    replace: "Replace",
+    reset: "Reset",
+    restore: "Restore",
+    retry: "Retry",
+    save: "Save",
+    saved: "Data has been saved.",
+    savedChanges: "Changes saved successfully",
+    saving: "Data is being modified.",
+    scan: "Scan",
+    search: "Search",
+    select: "Select",
+    selectItem: "Select item",
+    send: "Send",
+    set: "Set",
+    settings: "Settings",
+    share: "Share",
+    showMore: "Show more",
+    sort: "Sort",
+    speechToTextLanguageCode: "en-CA",
+    start: "Start",
+    startDate: "Start Date",
+    status: "Status",
+    stop: "Stop",
+    submit: "Submit",
+    success: "Success",
+    time: "Time",
+    title: "Title",
+    unlock: "Unlock",
+    update: "Update",
+    upload: "Upload",
+    user: "User",
+    view: "View",
+    warning: "Warning",
+    wifi: {
+      connectError: "Error connecting to WiFi: {{error}}",
+      currentNetworkRetrievalError: "Error retrieving current WiFi network information",
+      availableNetworksRetrievalError: "Error retrieving available WiFi networks"
+    },
+    yes: "Yes",
+    zoom: "Zoom"
+  }
+};
+
+// src/i18n/fr/common.json
+var common_default2 = {
+  common: {
+    about: "\xC0 propos",
+    accept: "Accepter",
+    account: "Compte",
+    actions: "Actions",
+    add: "Ajouter",
+    addLink: "Ajouter un lien",
+    addMember: "Ajouter un utilisateur",
+    advanced: "Avanc\xE9",
+    all: "Tous",
+    apiCallResult: "R\xE9sultat de l'appel API",
+    appLoading: "Chargement de l'application\u2026",
+    appLoadingVersion: "Chargement de la version de l'application {{version}}\u2026",
+    apply: "Appliquer",
+    archive: "Archiver",
+    associate: "Associer",
+    asyncStatus: {
+      converting: "Conversion\u2026",
+      deleteFileError: "Impossible de supprimer le fichier",
+      deletingFile: "Suppression du fichier\u2026",
+      downloadError: "Erreur lors du t\xE9l\xE9chargement",
+      downloading: "T\xE9l\xE9chargement\u2026",
+      loading: "Chargement\u2026",
+      waiting: "En attente\u2026"
+    },
+    back: "Retour",
+    backup: "Sauvegarde",
+    barcodeScanner: {
+      scanBarcodeInstruction: "Positionnez le code barre ou le code QR dans le cadre",
+      requestingCameraPermission: "Demande de permission de la cam\xE9ra\u2026",
+      noCameraAccess: "Aucun acc\xE8s \xE0 la cam\xE9ra"
+    },
+    battery: {
+      level: "Niveau de la pile: {{batteryLevel}}%"
+    },
+    browse: "Parcourir",
+    cancel: "Annuler",
+    check: "V\xE9rifier",
+    clear: "Effacer",
+    close: "Fermer",
+    complete: "Terminer",
+    configure: "Configurer",
+    confirm: "Confirmer",
+    connect: "Connecter",
+    continue: "Continuer",
+    copiedToClipboard: "Texte copi\xE9 dans le presse-papiers",
+    copy: "Copier",
+    copyToClipboard: "Copier dans le presse-papiers",
+    create: "Cr\xE9er",
+    customize: "Personnaliser",
+    data: "Donn\xE9es",
+    date: "Date",
+    default: "Par d\xE9faut",
+    delete: "Supprimer",
+    deleteAllLogsFilesConfirmation: "Voulez-vous vraiment supprimer tous les fichiers de logs ?",
+    description: "Description",
+    details: "D\xE9tails",
+    disable: "D\xE9sactiver",
+    done: "Termin\xE9",
+    download: "T\xE9l\xE9charger",
+    edit: "Modifier",
+    editItem: "Modifier {{name}}",
+    enable: "Activer",
+    endDate: "Date de fin",
+    error: "Erreur",
+    errorBoundary: {
+      error: "Une erreur inattendue est survenue: {{errorMsg}} (ID: {{id}})",
+      details: "D\xE9tails"
+    },
+    errorUnexpected: "Une erreur inattendue est survenue. Consultez les logs pour plus de d\xE9tails.",
+    errorLoadingFiles: "Erreur lors du chargement de l'arborescence des fichiers",
+    eventLogs: "Logs d'\xE9v\xE9nements",
+    export: "Exporter",
+    externalLinks: "Liens externes",
+    failed: "\xC9chec",
+    file: "Fichier",
+    filter: "Filtrer",
+    finish: "Terminer",
+    folder: "Dossier",
+    formValidations: {
+      filePathMustNotContainsRelativePath: "Le chemin du fichier ne doit pas contenir de chemin relatif",
+      filePathShouldNotContainsSpecialChars: "Caract\xE8res invalides d\xE9tect\xE9s dans le chemin du fichier",
+      invalidPattern: "V\xE9rifiez que les accolades ouvrantes '{' et fermantes '}' sont correctement plac\xE9es. Assurez-vous \xE9galement que le contenu entre les accolades n'est pas vide.",
+      required: "Ce champ est obligatoire",
+      email: "Veuillez saisir une adresse de courriel valide",
+      minLength: "Ce champ doit contenir au moins {{minLength}} caract\xE8res"
+    },
+    fullscreen: "Plein \xE9cran",
+    help: "Aide",
+    hide: "Masquer",
+    i18nInitialized: "i18n 'fr' \u2705",
+    imagePicker: {
+      takePhoto: "Prenndre une photo",
+      chooseFromGallery: "Choisir depuis la galerie",
+      permissionDenied: "Permission refus\xE9e pour acc\xE9der \xE0 la galerie",
+      cameraPermissionDenied: "Permission refus\xE9e pour acc\xE9der \xE0 la cam\xE9ra",
+      error: "Erreur lors de l'acc\xE8s \xE0 la s\xE9lection d'image"
+    },
+    import: "Importer",
+    information: "Informations",
+    install: "Installer",
+    item: "\xC9l\xE9ment",
+    language: "Langue",
+    link: "Lien",
+    list: "Liste",
+    lock: "Verrouiller",
+    logout: "D\xE9connexion",
+    logs: {
+      filter: "Filtrer les logs",
+      clear: "Effacer les logs",
+      copyAll: "Copier tous les logs"
+    },
+    manage: "Gestion",
+    menu: "Menu",
+    more: "Plus",
+    move: "D\xE9placer",
+    name: "Nom",
+    na: "N.D.",
+    new: "Nouveau",
+    next: "Suivant",
+    no: "Non",
+    noCameraAvailable: "Aucune cam\xE9ra disponible",
+    noDataFound: "Aucune donn\xE9e disponible",
+    notification: "Notification",
+    nowDateTime: "Date et heure d'aujourd'hui",
+    off: "D\xE9sactiv\xE9",
+    ok: "Ok",
+    on: "Activ\xE9",
+    open: "Ouvrir",
+    options: "Options",
+    password: "Mot de passe",
+    passwordInput: {
+      showPassword: "Afficher le mot de passe",
+      hidePassword: "Masquer le mot de passe"
+    },
+    paste: "Coller",
+    preview: "Aper\xE7u",
+    previous: "Pr\xE9c\xE9dent",
+    print: "Imprimer",
+    profile: "Profil",
+    public: "Public",
+    recent: "R\xE9cent",
+    refresh: "Actualiser",
+    remove: "Retirer",
+    rename: "Renommer",
+    replace: "Remplacer",
+    reset: "R\xE9initialiser",
+    restore: "Restaurer",
+    retry: "R\xE9essayer",
+    save: "Sauvegarder",
+    saved: "Les donn\xE9es ont \xE9t\xE9 sauvegard\xE9es.",
+    savedChanges: "Modifications sauvegard\xE9es avec succ\xE8s",
+    saving: "Les donn\xE9es sont en cours de modifications.",
+    scan: "Scanner",
+    search: "Rechercher",
+    select: "S\xE9lectionner",
+    selectItem: "S\xE9lectionner un \xE9l\xE9ment",
+    send: "Envoyer",
+    set: "D\xE9finir",
+    settings: "Param\xE8tres",
+    share: "Partager",
+    showMore: "Afficher plus",
+    sort: "Trier",
+    speechToTextLanguageCode: "fr-CA",
+    start: "D\xE9marrer",
+    startDate: "Date de d\xE9but",
+    status: "Statut",
+    stop: "Arr\xEAter",
+    submit: "Soumettre",
+    success: "Succ\xE8s",
+    time: "Heure",
+    title: "Titre",
+    unlock: "D\xE9verrouiller",
+    update: "Mettre \xE0 jour",
+    upload: "T\xE9l\xE9verser",
+    user: "Utilisateur",
+    view: "Voir",
+    warning: "Avertissement",
+    wifi: {
+      connectError: "Erreur de connexion au WiFi : {{error}}",
+      currentNetworkRetrievalError: "Erreur lors de la r\xE9cup\xE9ration des informations du r\xE9seau WiFi actuel",
+      availableNetworksRetrievalError: "Erreur lors de la r\xE9cup\xE9ration des r\xE9seaux WiFi disponibles"
+    },
+    yes: "Oui",
+    zoom: "Zoom"
+  }
+};
+var detectLanguage = () => {
+  const deviceLanguage = Localization__namespace.getLocales()[0]?.languageTag;
+  return deviceLanguage ? deviceLanguage : "en";
+};
+
+// src/i18n/i18n.ts
+var STORAGE_KEY_LANGUAGE = "appLanguage";
+var SUPPORTED_LANGUAGES = [
+  { code: "fr", selectionLabel: "Fran\xE7ais" },
+  { code: "en", selectionLabel: "English" }
+];
+var DEFAULT_LANGUAGE = "fr";
+var storeSelectedLanguage = (newCode) => {
+  storage.setItem(STORAGE_KEY_LANGUAGE, newCode);
+};
+var loadSelectedLanguage = () => {
+  return storage.getItem(STORAGE_KEY_LANGUAGE, DEFAULT_LANGUAGE);
+};
+var languageDetector = {
+  type: "languageDetector",
+  async: false,
+  detect: detectLanguage,
+  init: () => {
+  },
+  cacheUserLanguage: () => {
+  }
+};
+var initCommonI18N = (instance) => {
+  const i18next3 = instance ?? i18next__default.default;
+  const savedLanguage = loadSelectedLanguage();
+  if (!savedLanguage) {
+    storeSelectedLanguage(DEFAULT_LANGUAGE);
+  }
+  i18next3.use(languageDetector).use(reactI18next.initReactI18next).init({
+    resources: { fr: common_default2, en: common_default },
+    defaultNS: "common",
+    fallbackLng: DEFAULT_LANGUAGE,
+    lng: savedLanguage || DEFAULT_LANGUAGE,
+    debug: false,
+    interpolation: {
+      escapeValue: false
+      // not needed for react as it escapes by default
+    }
+  });
+};
+var DeviceFinder = class {
+  constructor() {
+    this.type = "";
+    this.protocol = "";
+    this.domain = void 0;
+    this.zeroConf = null;
+    this.isScanning = false;
+    this.timerID = void 0;
+    this.discoveredDevices = [];
+    this.onErrorCallback = () => {
+    };
+    this.onSuccessCallback = () => {
+    };
+  }
+  scan(args) {
+    const { type, protocol, domain, onError, onSuccess, timeoutMs } = args;
+    this.type = type;
+    this.protocol = protocol;
+    this.domain = domain;
+    this.onErrorCallback = onError;
+    this.onSuccessCallback = onSuccess;
+    this.start(timeoutMs);
+  }
+  setupListeners() {
+    this.zeroConf = new Zeroconf__default.default();
+    this.zeroConf.on("start", () => {
+      logger.info("[DeviceFinder] Scan started");
+      this.isScanning = true;
+    });
+    this.zeroConf.on("stop", () => {
+      logger.info("[DeviceFinder] Scan stopped");
+      this.isScanning = false;
+    });
+    this.zeroConf.on("resolved", (bonjourDevice) => this.onScanSuccess(bonjourDevice));
+    this.zeroConf.on("error", (err) => this.onScanFailure(err));
+  }
+  onScanSuccess(bonjourDevice) {
+    this.stop();
+    logger.info("[DeviceFinder] Resolved bonjour device:", JSON.stringify(bonjourDevice, null, 2));
+    if (this.discoveredDevices.some(({ name }) => name === bonjourDevice.name)) {
+      logger.debug("[DeviceFinder] Resolved bonjour device already in list, skipping");
+      return;
+    }
+    this.discoveredDevices.push(bonjourDevice);
+    this.onSuccessCallback();
+  }
+  onScanFailure(e) {
+    this.stop();
+    logger.info("[DeviceFinder] Failed to scan for cameras:", e);
+    this.onErrorCallback(tsCommon.toError(e));
+  }
+  start(timeoutMs) {
+    this.stop();
+    try {
+      this.setupListeners();
+      logger.info("[DeviceFinder] Starting scan for ionodes-media");
+      this.zeroConf?.scan(this.type, this.protocol, this.domain);
+      this.timerID = setTimeout(
+        () => this.onScanFailure(new Error(`[DeviceFinder] timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+    } catch (e) {
+      this.onScanFailure(e);
+    }
+  }
+  stop() {
+    try {
+      this.zeroConf?.stop();
+    } catch (e) {
+      logger.error("[DeviceFinder] Error stopping scan:", e);
+    } finally {
+      this.reset();
+    }
+  }
+  reset() {
+    this.resetZeroConf();
+    this.resetTimer();
+    this.resetState();
+  }
+  resetZeroConf() {
+    try {
+      this.zeroConf?.removeDeviceListeners();
+    } catch {
+    } finally {
+      this.zeroConf = null;
+    }
+  }
+  resetTimer() {
+    clearTimeout(this.timerID);
+    this.timerID = void 0;
+  }
+  resetState() {
+    this.discoveredDevices = [];
+    this.isScanning = false;
+  }
+};
+
+// src/services/wifi/query-keys.ts
+var WifiDiagnoseQueryKey = {
+  all: ["wifi-diagnose"],
+  list: () => [...WifiDiagnoseQueryKey.all, "list"],
+  details: () => [...WifiDiagnoseQueryKey.all, "details"]
+};
+var DEFAULT_CONNECT_WIFI_TIMEOUT = 10 * tsCommon.PeriodsInMS.oneSecond;
+var toWifiInfoArray = (networks) => {
+  if (!Array.isArray(networks)) {
+    return [];
+  }
+  return [...networks].map(toWifiInfo);
+};
+var toWifiInfo = (network) => {
+  const { SSID, BSSID, level, capabilities, frequency, timestamp } = network;
+  return {
+    ssid: SSID,
+    bssid: BSSID,
+    signalStrength: Math.abs(level),
+    capabilities,
+    frequency,
+    timestamp,
+    isHidden: SSID === "(hidden SSID)"
+  };
+};
+var randomIpSegment = () => Math.floor(Math.random() * 255);
+var randomLanIp = () => `192.168.${randomIpSegment()}.${randomIpSegment()}`;
+var fetchWifiInfosSimulator = async () => {
+  await tsCommon.sleep(Math.random() * 100);
+  const randomNumber = Math.floor(Math.random() * 100);
+  return {
+    signalStrength: randomNumber,
+    ssid: `Simulated WiFi ${randomNumber}`,
+    ip: randomLanIp()
+  };
+};
+var fetchAvailableWifiListSimulator = async () => {
+  await tsCommon.sleep(Math.random() * 100);
+  const numberOfNetworks = Math.floor(Math.random() * 30) + 2;
+  const networks = Array.from({ length: numberOfNetworks }, (_, index) => ({
+    ssid: `Simulated WiFi ${index + 1}`,
+    signalStrength: Math.floor(Math.random() * 100),
+    ip: randomLanIp()
+  }));
+  return networks;
+};
+
+// src/services/wifi/wifi-info.utils.ts
+var fetchWifiInfo = async () => {
+  if (!isRealDevice()) {
+    return fetchWifiInfosSimulator();
+  }
+  try {
+    await requestLocationPermission();
+    logger.info("[fetchWifiInfo] calling WifiManager.getCurrentWifiSSID");
+    const [ssid, signalStrength, ip] = await Promise.all([
+      WifiManager__default.default.getCurrentWifiSSID(),
+      // the following methods are not implemented on all platforms:
+      WifiManager__default.default.getCurrentSignalStrength?.(),
+      WifiManager__default.default.getIP?.()
+    ]);
+    return {
+      ssid,
+      signalStrength: Math.abs(signalStrength ?? 0),
+      ip: ip ?? ""
+    };
+  } catch (e) {
+    if (isDisconnectedOrConnecting(e)) {
+      logger.info("[fetchWifiInfo] Cannot fetch WiFi info since state is either disconnected or connecting");
+    } else {
+      logger.error("[fetchWifiInfo] Error fetching WiFi info", e);
+    }
+    throw e;
+  }
+};
+var isDisconnectedOrConnecting = (e) => {
+  return e instanceof Error && e.message.toLowerCase().includes("not connected or connecting");
+};
+var isUnexpectedWifiConnectionError = (e) => {
+  return !!e && !isDisconnectedOrConnecting(e);
+};
+var connectToWiFi = async ({
+  ssid,
+  password,
+  isWEP = false,
+  isHidden = false,
+  timeout = DEFAULT_CONNECT_WIFI_TIMEOUT
+}) => {
+  try {
+    logger.info(`[connectToWiFi] attempting to connect to WiFi ${ssid}`);
+    await WifiManager__default.default.connectToProtectedWifiSSID({ ssid, password, isWEP, isHidden, timeout });
+    logger.info(`[connectToWiFi] Connected to WiFi ${ssid}`);
+  } catch (e) {
+    logger.info(`[connectToWiFi] Unable to connect to WiFi ${ssid}`, e);
+    throw e;
+  }
+};
+var disconnectFromWiFi = async () => {
+  logger.info("[disconnectFromWiFi]: disconnecting from WiFi");
+  try {
+    const ssid = await WifiManager__default.default.getCurrentWifiSSID();
+    logger.info(`[disconnectFromWiFi]: Current WiFi SSID: ${ssid}`);
+    if (reactNative.Platform.OS === "ios") {
+      await WifiManager__default.default.disconnectFromSSID(ssid);
+    } else if (reactNative.Platform.OS === "android") {
+      const result = await WifiManager__default.default.disconnect();
+      logger.info(`[disconnectFromWiFi]: Disconnected from WiFi result: ${result}`);
+    } else {
+      logger.info(`[disconnectFromWiFi]: Unsupported platform: ${reactNative.Platform.OS}`);
+    }
+    logger.info("[disconnectFromWiFi]: Disconnected from WiFi ended.");
+  } catch (e) {
+    logger.error("[disconnectFromWiFi]: Error disconnecting from WiFi", e);
+    throw e;
+  }
+};
+var fetchAvailableWifiList = async () => {
+  if (!isRealDevice()) {
+    return fetchAvailableWifiListSimulator();
+  }
+  if (reactNative.Platform.OS === "ios") {
+    logger.info("[fetchAvailableWifiList] returning empty array for iOS");
+    return [];
+  }
+  try {
+    await requestLocationPermission();
+    logger.info("[fetchAvailableWifiList] calling WifiManager.loadWifiList");
+    const networks = await WifiManager__default.default.loadWifiList();
+    if (Array.isArray(networks)) {
+      return toWifiInfoArray(networks);
+    }
+    logger.info("[fetchAvailableWifiList] 2nd try: calling WifiManager.reScanAndLoadWifiList");
+    const networks2ndTry = await WifiManager__default.default.reScanAndLoadWifiList();
+    return toWifiInfoArray(networks2ndTry);
+  } catch (e) {
+    logger.error("[fetchAvailableWifiList] Error fetching available WiFi list", e);
+    throw e;
+  }
+};
+var requestLocationPermission = async () => {
+  const currentStatus = await Location__namespace.getForegroundPermissionsAsync();
+  if (currentStatus.status === "granted") {
+    return;
+  }
+  logger.info("[requestLocationPermission] requesting location permission");
+  const { status } = await Location__namespace.requestForegroundPermissionsAsync();
+  logger.info(`[requestLocationPermission] location permission requested, result: ${status}`);
+  if (status !== "granted") {
+    throw new Error(`Location permission not granted: ${status}`);
+  }
+};
+
+// src/services/wifi/use-wifi-info.ts
+var REFRESH_INTERVAL = 30 * 1e3;
+var wifiInfoRetryStrategy = (failureCount, error) => {
+  if (isDisconnectedOrConnecting(error) && failureCount < 3) {
+    logger.info(`[useWifiInfo]: retrying, failureCount: ${failureCount}`);
+    return true;
+  }
+  logger.info(`[useWifiInfo]: not retrying, failureCount: ${failureCount}`);
+  return false;
+};
+var useWifiInfo = () => {
+  const { data, isLoading, isFetching, isError, error, ...rest } = reactQuery.useQuery({
+    queryKey: WifiDiagnoseQueryKey.details(),
+    queryFn: fetchWifiInfo,
+    refetchInterval: REFRESH_INTERVAL,
+    retry: wifiInfoRetryStrategy,
+    retryDelay: (failureCount) => failureCount * 1e3
+  });
+  return {
+    wifiInfo: data,
+    isLoadingWiFiInfos: isLoading,
+    isFetchingWiFiInfos: isFetching,
+    isErrorWiFiInfos: isError,
+    errorWiFiInfos: error,
+    ...rest
+  };
+};
+var useLoadAvailableWifiList = () => {
+  const { data, isLoading, isFetching, isError, error, ...rest } = reactQuery.useQuery({
+    queryKey: WifiDiagnoseQueryKey.list(),
+    queryFn: fetchAvailableWifiList,
+    refetchInterval: REFRESH_INTERVAL,
+    retry: false
+  });
+  return {
+    availableNetworks: data ?? [],
+    hasAvailableNetworks: !!data?.length,
+    isLoadingNetworks: isLoading,
+    isFetchingNetworks: isFetching,
+    isErrorNetworks: isError,
+    errorNetworks: error,
+    ...rest
+  };
+};
+var useConnectToWifiMutation = () => {
+  const queryClient2 = reactQuery.useQueryClient();
+  const { t } = reactI18next.useTranslation();
+  const { mutateAsync, isPending, isError, error, isSuccess, ...rest } = reactQuery.useMutation({
+    mutationFn: connectToWiFi,
+    onSuccess: () => queryClient2.clear(),
+    onError: (e) => {
+      const title = t("common:error");
+      const message = t("common:wifi.connectError", { error: e?.message });
+      reactNative.Alert.alert(title, message);
+    }
+  });
+  return {
+    connectToWiFi: mutateAsync,
+    isConnectingToWiFi: isPending,
+    isErrorConnectingToWiFi: isError,
+    errorConnectingToWiFi: error,
+    isSuccessConnectingToWiFi: isSuccess,
+    ...rest
+  };
+};
+var useDisconnectFromWifiMutation = () => {
+  const queryClient2 = reactQuery.useQueryClient();
+  const { mutateAsync, isPending, isError, error, isSuccess, ...rest } = reactQuery.useMutation({
+    mutationFn: disconnectFromWiFi,
+    onSuccess: () => queryClient2.clear()
+  });
+  return {
+    disconnectFromWiFi: mutateAsync,
+    isDisconnectingFromWiFi: isPending,
+    isErrorDisconnectingFromWiFi: isError,
+    errorDisconnectingFromWiFi: error,
+    isSuccessDisconnectingFromWiFi: isSuccess,
+    ...rest
+  };
+};
+var useWifiInfosErrorSnackbar = () => {
+  const { t } = reactI18next.useTranslation();
+  const { showSnackbarMessage } = useSnackbar();
+  const { errorWiFiInfos } = useWifiInfo();
+  react.useEffect(() => {
+    if (isUnexpectedWifiConnectionError(errorWiFiInfos)) {
+      const message = t("common:wifi.currentNetworkRetrievalError", { error: tsCommon.getErrorMessage(errorWiFiInfos) });
+      showSnackbarMessage(message);
+    }
+  }, [errorWiFiInfos, t, showSnackbarMessage]);
+};
+var useLoadAvailableWifiListErrorSnackbar = () => {
+  const { t } = reactI18next.useTranslation();
+  const { showSnackbarMessage } = useSnackbar();
+  const { isErrorNetworks, errorNetworks } = useLoadAvailableWifiList();
+  react.useEffect(() => {
+    if (isErrorNetworks) {
+      const message = t("common:wifi.availableNetworksRetrievalError", { error: errorNetworks?.message });
+      showSnackbarMessage(message);
+    }
+  }, [isErrorNetworks, errorNetworks, t, showSnackbarMessage]);
+};
+var queryClient = new reactQuery.QueryClient();
+var TanstackQueryProvider = ({ children }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient, children });
+};
+var WifiInfosContext = react.createContext(void 0);
+var WifiInfosProvider = mobxReactLite.observer(({ children }) => {
+  const queryClient2 = reactQuery.useQueryClient();
+  const value = useWifiInfo();
+  useWifiInfosErrorSnackbar();
+  const prevAppStatusRef = react.useRef(commonStore.appStatus);
+  react.useEffect(() => {
+    const newAppStatus = commonStore.appStatus;
+    const prevAppStatus = prevAppStatusRef.current;
+    const hasChangedToActive = newAppStatus === "active" && prevAppStatus !== "active";
+    if (hasChangedToActive) {
+      logger.info("[WifiInfosProvider] App status changed to active, invalidating wifi infos queries");
+      queryClient2.invalidateQueries({ queryKey: WifiDiagnoseQueryKey.details() });
+    }
+    prevAppStatusRef.current = newAppStatus;
+  }, [queryClient2, commonStore.appStatus]);
+  return /* @__PURE__ */ jsxRuntime.jsx(WifiInfosContext.Provider, { value, children });
+});
+var useWifiInfosContext = () => {
+  const context = react.useContext(WifiInfosContext);
+  if (context === void 0) {
+    throw new Error("useWifiInfosContext must be used within a WifiInfosProvider");
+  }
+  return context;
+};
+
+exports.ActivityProgressBar = ActivityProgressBar;
+exports.ActivityProgressBarStats = ActivityProgressBarStats;
+exports.BARCODE_TYPES = BARCODE_TYPES;
+exports.BarcodeScanner = BarcodeScanner;
+exports.BarcodeScannerDialog = BarcodeScannerDialog;
+exports.BatteryLevel = BatteryLevel;
+exports.CodeTag = CodeTag;
+exports.DARK_COLORS_SCHEME = DARK_COLORS_SCHEME;
+exports.DARK_THEME = DARK_THEME;
+exports.DEFAULT_CONNECT_WIFI_TIMEOUT = DEFAULT_CONNECT_WIFI_TIMEOUT;
+exports.DEFAULT_LANGUAGE = DEFAULT_LANGUAGE;
+exports.DEFAULT_SHEET_SNAP_POINTS = DEFAULT_SHEET_SNAP_POINTS;
+exports.DefaultBackdrop = DefaultBackdrop;
+exports.DefaultSheetBackground = DefaultSheetBackground;
+exports.DeviceFinder = DeviceFinder;
+exports.DialogCloseOnly = DialogCloseOnly;
+exports.DialogOkCancel = DialogOkCancel;
+exports.DialogSingleTextInput = DialogSingleTextInput;
+exports.DialogSyntaxColorResult = DialogSyntaxColorResult;
+exports.DigestAuth = DigestAuth;
+exports.DropDownSelector = DropDownSelector;
+exports.EncodingType = EncodingType;
+exports.ErrorBoundary = ErrorBoundary;
+exports.ErrorBoundaryScreen = ErrorBoundaryScreen;
+exports.ErrorDetails = ErrorDetails;
+exports.EventLogsScreen = EventLogsScreen;
+exports.FullCentered = FullCentered;
+exports.FullCenteredSpinner = FullCenteredSpinner;
+exports.HeaderBackButton = HeaderBackButton;
+exports.HeaderButton = HeaderButton;
+exports.HorizontalResizableSplitView = HorizontalResizableSplitView;
+exports.LIGHT_COLORS_SCHEME = LIGHT_COLORS_SCHEME;
+exports.LIGHT_THEME = LIGHT_THEME;
+exports.LOG_LEVELS = LOG_LEVELS;
+exports.LanguageSelector = LanguageSelector;
+exports.LanguageSelectorMenu = LanguageSelectorMenu;
+exports.LanguageSelectorSegmented = LanguageSelectorSegmented;
+exports.ListHeader = ListHeader;
+exports.ListItemsSeparator = ListItemsSeparator;
+exports.LogEntryItem = LogEntryItem;
+exports.LogEntryItemSuffix = LogEntryItemSuffix;
+exports.LogsViewer = LogsViewer;
+exports.ModalSpinner = ModalSpinner;
+exports.NAVIGATION_DARK = NAVIGATION_DARK;
+exports.NAVIGATION_LIGHT = NAVIGATION_LIGHT;
+exports.NativeFileSystem = NativeFileSystem;
+exports.OnOffToggle = OnOffToggle;
+exports.OrientationAwareTabButton = OrientationAwareTabButton;
+exports.OrientationAwareTabsLayout = OrientationAwareTabsLayout;
+exports.PasswordInput = PasswordInput;
+exports.PreTag = PreTag;
+exports.ResizableOverlayView = ResizableOverlayView;
+exports.SUPPORTED_LANGUAGES = SUPPORTED_LANGUAGES;
+exports.SafeContainer = SafeContainer;
+exports.SnackbarContext = SnackbarContext;
+exports.SnackbarDurationsMs = SnackbarDurationsMs;
+exports.SnackbarProvider = SnackbarProvider;
+exports.SyntaxColoring = SyntaxColoring;
+exports.TabBarIcon = TabBarIcon;
+exports.TanstackQueryProvider = TanstackQueryProvider;
+exports.VerticalResizableSplitView = VerticalResizableSplitView;
+exports.VoiceRecognitionTextInput = VoiceRecognitionTextInput;
+exports.WifiDiagnoseQueryKey = WifiDiagnoseQueryKey;
+exports.WifiInfosContext = WifiInfosContext;
+exports.WifiInfosProvider = WifiInfosProvider;
+exports.applyFilenameTemplate = applyFilenameTemplate;
+exports.askConfirmation = askConfirmation;
+exports.axiosInstance = axiosInstance;
+exports.base64Decode = base64Decode;
+exports.base64Encode = base64Encode;
+exports.buildAdditionalContextData = buildAdditionalContextData;
+exports.buildFinalValue = buildFinalValue;
+exports.commonLogsStore = commonLogsStore;
+exports.commonLogsStoreTransport = commonLogsStoreTransport;
+exports.commonStore = commonStore;
+exports.computeActivityProgress = computeActivityProgress;
+exports.connectToWiFi = connectToWiFi;
+exports.convertImageToBase64 = convertImageToBase64;
+exports.createDbFolderUri = createDbFolderUri;
+exports.createDbInstance = createDbInstance;
+exports.createDirectoryStructure = createDirectoryStructure;
+exports.dateToISOLikeButLocal = dateToISOLikeButLocal;
+exports.deleteAllLogFiles = deleteAllLogFiles;
+exports.deleteFile = deleteFile;
+exports.detectLanguage = detectLanguage;
+exports.disconnectFromWiFi = disconnectFromWiFi;
+exports.ensureVoiceRecognitionPermissions = ensureVoiceRecognitionPermissions;
+exports.fetchAvailableWifiList = fetchAvailableWifiList;
+exports.fetchAvailableWifiListSimulator = fetchAvailableWifiListSimulator;
+exports.fetchWifiInfo = fetchWifiInfo;
+exports.fetchWifiInfosSimulator = fetchWifiInfosSimulator;
+exports.formatLogMessage = formatLogMessage;
+exports.getAppIdentifier = getAppIdentifier;
+exports.getBatteryColor = getBatteryColor;
+exports.getBatteryIcon = getBatteryIcon;
+exports.getDeviceType = getDeviceType;
+exports.getDirectoryOnly = getDirectoryOnly;
+exports.getDocumentFolderRelativePath = getDocumentFolderRelativePath;
+exports.getDocumentFullFilename = getDocumentFullFilename;
+exports.getEnvVarsSource = getEnvVarsSource;
+exports.getFileExtensionOnly = getFileExtensionOnly;
+exports.getFilenameOnly = getFilenameOnly;
+exports.getFilenameWithoutExtension = getFilenameWithoutExtension;
+exports.getMonospaceFontName = getMonospaceFontName;
+exports.getPermissionMessage = getPermissionMessage;
+exports.getSQLiteVersion = getSQLiteVersion;
+exports.getSentryDns = getSentryDns;
+exports.getUniqueDbFilename = getUniqueDbFilename;
+exports.hasExtension = hasExtension;
+exports.hasFileSeparator = hasFileSeparator;
+exports.htmlDocumentMessage = htmlDocumentMessage;
+exports.htmlDocumentRawMessage = htmlDocumentRawMessage;
+exports.initCommonI18N = initCommonI18N;
+exports.isAxiosNetworkError = isAxiosNetworkError;
+exports.isDevelopment = isDevelopment;
+exports.isDisconnectedOrConnecting = isDisconnectedOrConnecting;
+exports.isEmulator = isEmulator;
+exports.isFileExists = isFileExists;
+exports.isFileUri = isFileUri;
+exports.isPreview = isPreview;
+exports.isProduction = isProduction;
+exports.isRealDevice = isRealDevice;
+exports.isSentryActivated = isSentryActivated;
+exports.isUnexpectedWifiConnectionError = isUnexpectedWifiConnectionError;
+exports.isValidIpAddressV4 = isValidIpAddressV4;
+exports.languageDetector = languageDetector;
+exports.loadAllLogFilesInfo = loadAllLogFilesInfo;
+exports.loadCurrentLogsFileUri = loadCurrentLogsFileUri;
+exports.loadSelectedLanguage = loadSelectedLanguage;
+exports.loadTextContent = loadTextContent;
+exports.logIncomingHtmlDocMessage = logIncomingHtmlDocMessage;
+exports.logRequestEnd = logRequestEnd;
+exports.logRequestStart = logRequestStart;
+exports.loggedError = loggedError;
+exports.logger = logger;
+exports.mmkvStorageForMobxPersist = mmkvStorageForMobxPersist;
+exports.nativeFileSystem = nativeFileSystem;
+exports.normalizeFileUri = normalizeFileUri;
+exports.notImplementedYet = notImplementedYet;
+exports.nowAsIsoFilename = nowAsIsoFilename;
+exports.nowToISOLikeButLocal = nowToISOLikeButLocal;
+exports.nowToISOLikeButLocalForFilename = nowToISOLikeButLocalForFilename;
+exports.openWifiSettings = openWifiSettings;
+exports.openWifiSettingsAndroid = openWifiSettingsAndroid;
+exports.openWifiSettingsIos = openWifiSettingsIos;
+exports.parseLicenceData = parseLicenceData;
+exports.pickSingleFile = pickSingleFile;
+exports.queryClient = queryClient;
+exports.requestCameraPermissions = requestCameraPermissions;
+exports.requestLocationPermission = requestLocationPermission;
+exports.requestMediaLibPermissions = requestMediaLibPermissions;
+exports.requestTakePhotoPermissions = requestTakePhotoPermissions;
+exports.sanitizeUrl = sanitizeUrl;
+exports.saveTextContent = saveTextContent;
+exports.setClipboardTextContent = setClipboardTextContent;
+exports.shareCurrentLogsFile = shareCurrentLogsFile;
+exports.shareFile = shareFile;
+exports.shareTextFile = shareTextFile;
+exports.shareXmlFile = shareXmlFile;
+exports.startNetworkStateLogging = startNetworkStateLogging;
+exports.storage = storage;
+exports.storeSelectedLanguage = storeSelectedLanguage;
+exports.styles = styles2;
+exports.toLogLevel = toLogLevel;
+exports.toSinglePictureUri = toSinglePictureUri;
+exports.toWifiInfo = toWifiInfo;
+exports.toWifiInfoArray = toWifiInfoArray;
+exports.useAppTheme = useAppTheme;
+exports.useAutoScroll = useAutoScroll;
+exports.useBottomSheetToggler = useBottomSheetToggler;
+exports.useCameraImagePicker = useCameraImagePicker;
+exports.useConnectToWifiMutation = useConnectToWifiMutation;
+exports.useDialogStyles = useDialogStyles;
+exports.useDisconnectFromWifiMutation = useDisconnectFromWifiMutation;
+exports.useErrorDetails = useErrorDetails;
+exports.useImagePicker = useImagePicker;
+exports.useInvalidateQueriesOnFocus = useInvalidateQueriesOnFocus;
+exports.useIsDarkMode = useIsDarkMode;
+exports.useIsLandscape = useIsLandscape;
+exports.useLoadAvailableWifiList = useLoadAvailableWifiList;
+exports.useLoadAvailableWifiListErrorSnackbar = useLoadAvailableWifiListErrorSnackbar;
+exports.useLogEntryColor = useLogEntryColor;
+exports.useLogsActions = useLogsActions;
+exports.useOnHtmlDocMessage = useOnHtmlDocMessage;
+exports.useSingleFileSelector = useSingleFileSelector;
+exports.useSnackbar = useSnackbar;
+exports.useTimeoutState = useTimeoutState;
+exports.useTimeoutToggle = useTimeoutToggle;
+exports.useUpdates = useUpdates2;
+exports.useWifiInfo = useWifiInfo;
+exports.useWifiInfosContext = useWifiInfosContext;
+exports.useWifiInfosErrorSnackbar = useWifiInfosErrorSnackbar;
+exports.useWindowOrientation = useWindowOrientation;
+exports.validateGetRandomValues = validateGetRandomValues;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map