@webority-technologies/mobile-core 0.0.1 → 0.0.3

package/lib/module/geolocation/index.js

@@ -0,0 +1,332 @@
+"use strict";
+
+import * as ExpoLocation from 'expo-location';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Logger } from "../logger/index.js";
+import { Permissions } from "../permissions/index.js";
+import { adaptExpoLocation } from "./adapters/expoLocation.js";
+const PREFIX = '[@webority-technologies/mobile-core]';
+export class GeolocationError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'GeolocationError';
+    this.code = code;
+    // Babel downlevels `class extends Error`, which breaks `instanceof` for
+    // subclasses unless the prototype is restored explicitly.
+    Object.setPrototypeOf(this, GeolocationError.prototype);
+  }
+}
+
+/** Minimal shape of the native geolocation module we depend on. */
+
+const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_RETRIES = 1;
+const DEFAULT_RETRY_DELAY_MS = 800;
+const isGeolocationLike = value => {
+  const candidate = value;
+  return typeof candidate?.getCurrentPosition === 'function' && typeof candidate?.watchPosition === 'function' && typeof candidate?.clearWatch === 'function';
+};
+
+/** Only what a test or the showcase injected; null means use expo-location. */
+let backend = null;
+let expoBackend;
+const resolveBackend = () => {
+  if (backend) {
+    return backend;
+  }
+  if (!expoBackend) {
+    expoBackend = adaptExpoLocation(ExpoLocation);
+  }
+  return expoBackend;
+};
+
+/**
+ * Replace the geolocation provider. Intended for TESTS and for the showcase,
+ * which injects a denying provider to demo the permission and services-off
+ * errors; an app gets expo-location without wiring anything. Pass `null` to
+ * restore it.
+ */
+export const setGeolocationImplementation = impl => {
+  backend = impl;
+};
+const requireBackend = op => {
+  const b = resolveBackend();
+  if (!b) {
+    throw new GeolocationError('unsupported', `${PREFIX} No geolocation provider is available; cannot ${op}. ` + 'expo-location did not load, which on a real build means the native ' + 'module was not linked.');
+  }
+  return b;
+};
+
+/**
+ * Android reports "location services are switched off" through the same code 2
+ * that also covers a genuine failure to fix a position, and the two need
+ * different handling: one is fixed by the user in system settings, the other is
+ * worth retrying. The message is the only signal that separates them.
+ */
+const SERVICES_OFF_PATTERN = /(location|gps)[^.]{0,40}(disabled|switched off|turned off|not enabled)|no location provider|settings_not_satisfied|location services (are |is )?off/i;
+const toGeoError = raw => {
+  if (raw instanceof GeolocationError) {
+    return raw;
+  }
+  const native = raw ?? {};
+  const detail = typeof native.message === 'string' && native.message.length > 0 ? native.message : 'the provider gave no reason';
+  switch (native.code) {
+    case 1:
+      return new GeolocationError('permission-denied', `${PREFIX} Location permission was denied (${detail}). Request the ` + 'location permission before calling, or send the user to settings.');
+    case 2:
+      return SERVICES_OFF_PATTERN.test(detail) ? new GeolocationError('services-disabled', `${PREFIX} Location services are switched off (${detail}). Ask the user ` + 'to enable location in system settings; retrying will not help.') : new GeolocationError('position-unavailable', `${PREFIX} No position fix (${detail}).`);
+    case 3:
+      return new GeolocationError('timeout', `${PREFIX} Location request timed out (${detail}).`);
+    case 4:
+    case 5:
+      return new GeolocationError('services-disabled', `${PREFIX} Location services are unavailable on this device (${detail}). ` + 'Ask the user to enable location, or install Google Play services.');
+    default:
+      return new GeolocationError('position-unavailable', `${PREFIX} Location request failed (${detail}).`);
+  }
+};
+const RETRYABLE = ['timeout', 'position-unavailable'];
+const normalizeCoords = raw => {
+  const coords = raw?.coords;
+  if (!coords || !Number.isFinite(coords.latitude) || !Number.isFinite(coords.longitude)) {
+    return null;
+  }
+  return {
+    latitude: coords.latitude,
+    longitude: coords.longitude,
+    // An absent radius is treated as infinitely bad rather than perfect, so a
+    // provider that omits it can never satisfy `minimumAccuracyM` by accident.
+    accuracy: Number.isFinite(coords.accuracy) ? coords.accuracy : Number.POSITIVE_INFINITY,
+    altitude: Number.isFinite(coords.altitude) ? coords.altitude : null,
+    heading: Number.isFinite(coords.heading) ? coords.heading : null,
+    speed: Number.isFinite(coords.speed) ? coords.speed : null
+  };
+};
+const normalizePosition = raw => {
+  const coords = normalizeCoords(raw);
+  if (!coords) {
+    return null;
+  }
+  return {
+    coords,
+    timestamp: Number.isFinite(raw?.timestamp) ? raw?.timestamp : Date.now()
+  };
+};
+const toNativeOptions = options => {
+  const native = {
+    enableHighAccuracy: (options.accuracy ?? 'fine') === 'fine',
+    timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maximumAge: options.maximumAgeMs ?? 0
+  };
+  if (options.distanceFilterM !== undefined) {
+    native.distanceFilter = options.distanceFilterM;
+  }
+  return native;
+};
+const sleep = ms => new Promise(resolve => {
+  setTimeout(resolve, ms);
+});
+const ensureLocationPermission = async () => {
+  const status = await Permissions.ensure('location');
+  if (status === 'granted' || status === 'limited') {
+    return;
+  }
+  if (status === 'unavailable') {
+    Logger.warn(`${PREFIX} Location permission status is unavailable (react-native-permissions is not ` + 'installed, or this platform has no mapping); attempting the location request anyway.');
+    return;
+  }
+  throw new GeolocationError('permission-denied', `${PREFIX} Location permission is "${status}". Grant it before requesting a position` + (status === 'blocked' ? ', or call Permissions.openSettings() to let the user fix it.' : '.'));
+};
+const positionOnce = (b, options) => {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    // The native timeout is passed through as well, but a provider that never
+    // calls back at all would otherwise hang the caller forever.
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(new GeolocationError('timeout', `${PREFIX} Location request timed out after ${timeoutMs}ms. Raise timeoutMs, or use ` + "accuracy: 'coarse' where a network fix is good enough."));
+    }, timeoutMs);
+    const settle = run => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      run();
+    };
+    const onSuccess = raw => settle(() => {
+      const position = normalizePosition(raw);
+      if (!position) {
+        reject(new GeolocationError('position-unavailable', `${PREFIX} The provider returned a fix without usable coordinates.`));
+        return;
+      }
+      const floor = options.minimumAccuracyM;
+      if (floor !== undefined && position.coords.accuracy > floor) {
+        reject(new GeolocationError('position-unavailable', `${PREFIX} Fix accuracy ${position.coords.accuracy}m is worse than the required ` + `${floor}m.`));
+        return;
+      }
+      resolve(position);
+    });
+    const onError = error => settle(() => reject(toGeoError(error)));
+    try {
+      b.getCurrentPosition(onSuccess, onError, toNativeOptions(options));
+    } catch (error) {
+      settle(() => reject(toGeoError(error)));
+    }
+  });
+};
+const getCurrentPosition = async (options = {}) => {
+  const b = requireBackend('get the current position');
+  await ensureLocationPermission();
+  const attempts = Math.max(0, Math.trunc(options.retries ?? DEFAULT_RETRIES)) + 1;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  let lastError = null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      return await positionOnce(b, options);
+    } catch (error) {
+      const geoError = toGeoError(error);
+      if (!RETRYABLE.includes(geoError.code)) {
+        throw geoError;
+      }
+      lastError = geoError;
+      if (attempt < attempts - 1 && retryDelayMs > 0) {
+        await sleep(retryDelayMs);
+      }
+    }
+  }
+  throw lastError ?? new GeolocationError('position-unavailable', `${PREFIX} Location request failed.`);
+};
+const watchPosition = (listener, options = {}) => {
+  const b = requireBackend('watch the position');
+  let cancelled = false;
+  let watchId = null;
+  const stop = () => {
+    if (cancelled) {
+      return;
+    }
+    cancelled = true;
+    if (watchId !== null) {
+      b.clearWatch(watchId);
+      watchId = null;
+    }
+  };
+  const fail = error => {
+    const geoError = toGeoError(error);
+    Logger.error(geoError.message);
+    options.onError?.(geoError);
+  };
+  void ensureLocationPermission().then(() => {
+    // The caller can unsubscribe while the permission gate is still pending;
+    // registering afterwards would leak a watch nothing can clear.
+    if (cancelled) {
+      return;
+    }
+    watchId = b.watchPosition(raw => {
+      if (cancelled) {
+        return;
+      }
+      const position = normalizePosition(raw);
+      if (!position) {
+        return;
+      }
+      const floor = options.minimumAccuracyM;
+      if (floor !== undefined && position.coords.accuracy > floor) {
+        return;
+      }
+      listener(position);
+    }, error => {
+      if (!cancelled) {
+        fail(error);
+      }
+    }, toNativeOptions(options));
+  }).catch(fail);
+  return stop;
+};
+const isAvailable = () => resolveBackend() !== null;
+export const Geolocation = {
+  getCurrentPosition,
+  watchPosition,
+  isAvailable
+};
+export const useCurrentPosition = (options = {}) => {
+  const {
+    enabled = true,
+    accuracy,
+    timeoutMs,
+    maximumAgeMs,
+    retries,
+    minimumAccuracyM,
+    retryDelayMs
+  } = options;
+  const [state, setState] = useState({
+    position: null,
+    error: null,
+    loading: enabled
+  });
+  const mountedRef = useRef(true);
+  // Identifies the in-flight request so a slow earlier fix cannot overwrite the
+  // result of a later refresh().
+  const requestRef = useRef(0);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+
+  // Every dependency is a primitive read off `options`, so an inline options
+  // object (the normal call shape) does not re-create this on every render.
+  const run = useCallback(() => {
+    requestRef.current += 1;
+    const token = requestRef.current;
+    setState(prev => prev.loading ? prev : {
+      ...prev,
+      loading: true
+    });
+    const accept = next => {
+      if (mountedRef.current && requestRef.current === token) {
+        setState(next);
+      }
+    };
+    getCurrentPosition({
+      accuracy,
+      timeoutMs,
+      maximumAgeMs,
+      retries,
+      minimumAccuracyM,
+      retryDelayMs
+    }).then(position => accept({
+      position,
+      error: null,
+      loading: false
+    }), error => accept({
+      position: null,
+      error: toGeoError(error),
+      loading: false
+    }));
+  }, [accuracy, timeoutMs, maximumAgeMs, retries, minimumAccuracyM, retryDelayMs]);
+  useEffect(() => {
+    if (!enabled) {
+      // Discard any in-flight request so its result cannot land after opting out.
+      requestRef.current += 1;
+      setState(prev => prev.loading || prev.position !== null || prev.error !== null ? {
+        position: null,
+        error: null,
+        loading: false
+      } : prev);
+      return;
+    }
+    run();
+  }, [enabled, run]);
+  return {
+    position: state.position,
+    error: state.error,
+    loading: state.loading,
+    refresh: run
+  };
+};
+//# sourceMappingURL=index.js.map

package/lib/module/index.js

@@ -1,28 +1,45 @@
 "use strict";
 
+/**
+ * The main barrel deliberately does NOT re-export the modules that need a native
+ * package. Metro resolves requires statically, so anything reachable from here
+ * is resolved for every consumer, which would make an optional peer mandatory
+ * for anyone importing anything at all. Those live behind their own import
+ * paths instead:
+ *
+ *   @webority-technologies/mobile-core/permissions  react-native-permissions
+ *   @webority-technologies/mobile-core/compressor   react-native-compressor
+ *   @webority-technologies/mobile-core/geolocation  a geolocation provider
+ *   @webority-technologies/mobile-core/sqlite       a SQLite driver
+ *   @webority-technologies/mobile-core/download     a filesystem module
+ *
+ * react-native-keychain is the exception and is a REQUIRED peer: the HTTP client
+ * reads the bearer token, so it is reachable from the main barrel by design.
+ */
 // API clients
+export { buildCurl, logCurl } from "./api/curl.js";
 export { default as publicClient } from "./api/publicClient.js";
-export { default as userClient, injectAuthActions, injectStore, RequestOfflineError, SESSION_TERMINATION_CODES } from "./api/userClient.js";
+export { attachRetry, isRetryableStatus } from "./api/retry.js";
+export { default as userClient, injectAuthActions, injectStore, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES } from "./api/userClient.js";
 // Auth / token storage
-export { getToken, removeToken, setKeychainImplementation, storeToken } from "./auth/authStore.js";
+export { ACCESS_TOKEN_KEY, getToken, REFRESH_TOKEN_KEY, removeToken, setKeychainImplementation, storeToken } from "./auth/authStore.js";
 export { decodeJWT, getJWTExpiry, isJWTExpired } from "./auth/jwt.js";
 // Configuration
 export { getConfig, getConfigValue, resetConfig, setConfig } from "./config/index.js";
+// Deep links
+export { DeepLink, parseDeepLink, useDeepLink } from "./deepLink/index.js";
 // Formatters
-export { formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from "./formatters/index.js";
+export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from "./formatters/index.js";
 // Initialization
 export { initWebority } from "./initSDK.js";
 export { initUserAuth } from "./initUserAuth.js";
 // Logger
-export { Logger, setRemoteLogger } from "./logger/index.js";
+export { configureLogger, getDeviceContext, Logger, setDeviceContext, setRemoteLogger } from "./logger/index.js";
 // Network status (the NetworkStatusBanner UI lives in @webority-technologies/mobile-ui)
-export { addNetworkStatusListener, getNetworkStatus, useNetworkStatus } from "./network/index.js";
-// Permissions
-export { Permissions } from "./permissions/index.js";
-// Storage
-export { Storage, setStorageImplementation } from "./storage/index.js";
-// Media utils
-export { compressImage } from "./utils/index.js";
+export { addNetworkStatusListener, getNetworkStatus, setNetworkStatusImplementation, useNetworkStatus } from "./network/index.js";
+// Storage: the API and the seam. No native package is required; wire one with
+// setStorageImplementation to get persistence.
+export { isStorageAvailable, Storage, setStorageImplementation } from "./storage/index.js";
 // Validators
 export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from "./validators/index.js";
 // Version check (the ForceUpdateDialog UI lives in @webority-technologies/mobile-ui)

package/lib/module/initSDK.js

@@ -5,7 +5,11 @@
  * One function to configure everything needed
  */
 
+import { setKeychainImplementation } from "./auth/authStore.js";
 import { setConfig } from "./config/index.js";
+import { Logger } from "./logger/index.js";
+import { setNetworkStatusImplementation } from "./network/networkStatus.js";
+import { setStorageImplementation } from "./storage/index.js";
 /**
  * Initialize Webority packages with your project configuration.
  *
@@ -33,8 +37,25 @@ export const initWebority = config => {
     loggingEnabled: config.loggingEnabled ?? true,
     logLevel: config.logLevel || 'info',
     environment: config.environment || 'Development',
-    country: (config.country || 'in').toLowerCase()
+    country: (config.country || 'in').toLowerCase(),
+    appId: config.appId ?? null,
+    appVersion: config.appVersion ?? null,
+    logCurl: config.logCurl ?? false
   });
-  console.log('✅ Webority packages initialized successfully');
+
+  // Only what the caller actually passed is wired. Calling a setter with
+  // `undefined` would reset a backend an app had already injected by hand,
+  // which is why each is guarded rather than passed straight through.
+  const backends = config.backends;
+  if (backends?.storage) {
+    setStorageImplementation(backends.storage);
+  }
+  if (backends?.keychain) {
+    setKeychainImplementation(backends.keychain);
+  }
+  if (backends?.network) {
+    setNetworkStatusImplementation(backends.network);
+  }
+  Logger.info('[@webority-technologies/mobile-core] initialized');
 };
 //# sourceMappingURL=initSDK.js.map

package/lib/module/initUserAuth.js

@@ -6,6 +6,7 @@
  */
 
 import { injectAuthActions, injectStore } from "./api/userClient.js";
+import { Logger } from "./logger/index.js";
 
 /**
  * Auth action creators required by the user package.
@@ -29,6 +30,6 @@ export const initUserAuth = (store, authActions) => {
   }
   injectStore(store);
   injectAuthActions(authActions);
-  console.log('✅ Webority User package initialized with Redux');
+  Logger.info('[@webority-technologies/mobile-core] user auth wired to the store');
 };
 //# sourceMappingURL=initUserAuth.js.map

package/lib/module/logger/index.js

@@ -72,6 +72,137 @@ const toErrorObject = input => {
     return new Error(String(input));
   }
 };
+
+/**
+ * Device / app context attached once at boot (platform, OS version, app version,
+ * build number, device model, etc). Merged into every `recordError` context so
+ * every crash carries it without every call site repeating it.
+ */
+
+let deviceContext = null;
+const normalizeAttributeValue = value => {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  return String(value);
+};
+
+/**
+ * Set (or clear, with `null`) the device/app context merged into every
+ * `recordError` call. Each key is also forwarded to `remote.setAttribute`
+ * once, at the moment it is set.
+ */
+export const setDeviceContext = context => {
+  deviceContext = context;
+  if (context) {
+    for (const [key, value] of Object.entries(context)) {
+      safe(() => remote?.setAttribute?.(key, normalizeAttributeValue(value)));
+    }
+  }
+};
+export const getDeviceContext = () => deviceContext;
+
+/** Tuning knobs for screen history and duplicate-error suppression. */
+
+const DEFAULT_LOGGER_OPTIONS = {
+  dedupeWindowMs: 5000,
+  dedupeMaxPerWindow: 1,
+  screenHistoryLimit: 20
+};
+let loggerOptions = {
+  ...DEFAULT_LOGGER_OPTIONS
+};
+
+/** Configure dedupe window/threshold and screen history size. Merges with current options. */
+export const configureLogger = options => {
+  loggerOptions = {
+    ...loggerOptions,
+    ...options
+  };
+  if (screenHistory.length > loggerOptions.screenHistoryLimit) {
+    screenHistory = screenHistory.slice(screenHistory.length - loggerOptions.screenHistoryLimit);
+  }
+};
+let currentScreen = null;
+let screenHistory = [];
+const dedupeMap = new Map();
+const MAX_DEDUPE_ENTRIES = 200;
+const dedupeKeyFor = err => {
+  const firstFrame = err.stack?.split('\n')[1]?.trim();
+  return firstFrame ? `${err.message}::${firstFrame}` : err.message;
+};
+const capDedupeMap = () => {
+  while (dedupeMap.size > MAX_DEDUPE_ENTRIES) {
+    const oldestKey = dedupeMap.keys().next().value;
+    if (oldestKey === undefined) {
+      return;
+    }
+    dedupeMap.delete(oldestKey);
+  }
+};
+const shouldForward = key => {
+  if (loggerOptions.dedupeWindowMs <= 0) {
+    return {
+      forward: true
+    };
+  }
+  const now = Date.now();
+  const entry = dedupeMap.get(key);
+  if (!entry || now - entry.windowStart >= loggerOptions.dedupeWindowMs) {
+    const suppressedCount = entry?.suppressedCount ?? 0;
+    dedupeMap.set(key, {
+      windowStart: now,
+      count: 1,
+      suppressedCount: 0
+    });
+    capDedupeMap();
+    return suppressedCount > 0 ? {
+      forward: true,
+      suppressedCount
+    } : {
+      forward: true
+    };
+  }
+  entry.count += 1;
+  if (entry.count > loggerOptions.dedupeMaxPerWindow) {
+    entry.suppressedCount += 1;
+    return {
+      forward: false
+    };
+  }
+  return {
+    forward: true
+  };
+};
+const buildErrorContext = (context, suppressedCount) => {
+  const merged = {
+    ...deviceContext
+  };
+  if (currentScreen !== null) {
+    merged.screen = currentScreen;
+  }
+  if (suppressedCount) {
+    merged.suppressedCount = suppressedCount;
+  }
+  return {
+    ...merged,
+    ...context
+  };
+};
+const forwardErrorToRemote = (err, context) => {
+  const key = dedupeKeyFor(err);
+  const {
+    forward,
+    suppressedCount
+  } = shouldForward(key);
+  if (!forward) {
+    return;
+  }
+  safe(() => remote?.recordError?.(err, buildErrorContext(context, suppressedCount)));
+};
 const logInfo = (message, ...optionalParams) => {
   if (!isEnabled() || !isLogLevelAllowed(LogLevels.INFO.level)) {
     return;
@@ -96,10 +227,10 @@ const logError = (message, ...optionalParams) => {
   // First optional param is treated as the underlying error if it looks like one.
   const candidate = optionalParams[0];
   if (candidate !== undefined) {
-    safe(() => remote?.recordError?.(toErrorObject(candidate), {
+    forwardErrorToRemote(toErrorObject(candidate), {
       source: 'Logger.error',
       message
-    }));
+    });
   }
 };
 const breadcrumb = (message, data) => {
@@ -113,7 +244,7 @@ const recordError = (error, context) => {
   if (isEnabled() && isLogLevelAllowed('error')) {
     console.error(`${Colors.RED_BOLD}[RECORDED]: ${err.message}${Colors.RESET}`, context ?? '');
   }
-  safe(() => remote?.recordError?.(err, context));
+  forwardErrorToRemote(err, context);
 };
 const setUser = (id, attrs) => {
   safe(() => remote?.setUser?.(id, attrs));
@@ -121,6 +252,24 @@ const setUser = (id, attrs) => {
 const setAttribute = (key, value) => {
   safe(() => remote?.setAttribute?.(key, value));
 };
+
+/**
+ * Record the active screen as a breadcrumb and remember it for subsequent
+ * `recordError` context. Re-tracking the same screen name is a no-op.
+ */
+const trackScreen = (name, params) => {
+  if (name === currentScreen) {
+    return;
+  }
+  currentScreen = name;
+  screenHistory.push(name);
+  if (screenHistory.length > loggerOptions.screenHistoryLimit) {
+    screenHistory = screenHistory.slice(screenHistory.length - loggerOptions.screenHistoryLimit);
+  }
+  breadcrumb(`Screen: ${name}`, params);
+};
+const getCurrentScreen = () => currentScreen;
+const getScreenHistory = () => [...screenHistory];
 export const Logger = {
   info: logInfo,
   warn: logWarning,
@@ -128,6 +277,9 @@ export const Logger = {
   breadcrumb,
   recordError,
   setUser,
-  setAttribute
+  setAttribute,
+  trackScreen,
+  getCurrentScreen,
+  getScreenHistory
 };
 //# sourceMappingURL=index.js.map

package/lib/module/network/index.js

@@ -1,4 +1,4 @@
 "use strict";
 
-export { addNetworkStatusListener, getNetworkStatus, useNetworkStatus } from "./networkStatus.js";
+export { addNetworkStatusListener, getNetworkStatus, setNetworkStatusImplementation, useNetworkStatus } from "./networkStatus.js";
 //# sourceMappingURL=index.js.map