@webority/mobile-core 0.0.23

package/lib/module/logger/index.js

@@ -0,0 +1,285 @@
+"use strict";
+
+import { getConfigValue } from "../config/index.js";
+
+// ANSI color codes
+const Colors = {
+  RESET: '\x1b[0m',
+  BLUE: '\x1b[34m',
+  YELLOW: '\x1b[33m',
+  RED_BOLD: '\x1b[31;1m'
+};
+const LogLevels = {
+  INFO: {
+    level: 'info',
+    color: Colors.BLUE
+  },
+  WARN: {
+    level: 'warn',
+    color: Colors.YELLOW
+  },
+  ERROR: {
+    level: 'error',
+    color: Colors.RED_BOLD
+  }
+};
+
+// Check if a specific log level is allowed
+const isLogLevelAllowed = level => {
+  const levels = ['info', 'warn', 'error'];
+  const current = getConfigValue('logLevel', 'info');
+  return levels.indexOf(level) >= levels.indexOf(current);
+};
+const isEnabled = () => getConfigValue('loggingEnabled', true);
+
+/**
+ * Optional remote sink. Apps wire this via `setRemoteLogger()` to forward errors
+ * and breadcrumbs to Crashlytics, Sentry, Bugsnag, etc. — without making the
+ * library depend on any of them.
+ *
+ * Every method is optional; the library calls only what the adapter implements.
+ */
+
+let remote = null;
+
+/**
+ * Inject a remote logger adapter (e.g. Firebase Crashlytics, Sentry).
+ * Pass `null` to detach. Safe to call before or after `initWebority`.
+ */
+export const setRemoteLogger = impl => {
+  remote = impl;
+};
+const safe = fn => {
+  if (!fn) {
+    return;
+  }
+  try {
+    fn();
+  } catch {
+    /* never let the remote sink break the caller */
+  }
+};
+const toErrorObject = input => {
+  if (input instanceof Error) {
+    return input;
+  }
+  if (typeof input === 'string') {
+    return new Error(input);
+  }
+  try {
+    return new Error(JSON.stringify(input));
+  } catch {
+    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;
+  }
+  console.info(`${LogLevels.INFO.color}[INFO]: ${message}${Colors.RESET}`, ...optionalParams);
+  safe(() => remote?.log?.('info', message, optionalParams));
+};
+const logWarning = (message, ...optionalParams) => {
+  if (!isEnabled() || !isLogLevelAllowed(LogLevels.WARN.level)) {
+    return;
+  }
+  console.warn(`${LogLevels.WARN.color}[WARNING]: ${message}${Colors.RESET}`, ...optionalParams);
+  safe(() => remote?.log?.('warn', message, optionalParams));
+};
+const logError = (message, ...optionalParams) => {
+  if (isEnabled() && isLogLevelAllowed(LogLevels.ERROR.level)) {
+    console.error(`${LogLevels.ERROR.color}[ERROR]: ${message}${Colors.RESET}`, ...optionalParams);
+  }
+  // Always forward errors to the remote sink — even when console logging is muted —
+  // so production crash reporting still works with `loggingEnabled: false`.
+  safe(() => remote?.log?.('error', message, optionalParams));
+  // First optional param is treated as the underlying error if it looks like one.
+  const candidate = optionalParams[0];
+  if (candidate !== undefined) {
+    forwardErrorToRemote(toErrorObject(candidate), {
+      source: 'Logger.error',
+      message
+    });
+  }
+};
+const breadcrumb = (message, data) => {
+  if (isEnabled() && isLogLevelAllowed('info')) {
+    console.info(`${Colors.BLUE}[BREADCRUMB]: ${message}${Colors.RESET}`, data ?? '');
+  }
+  safe(() => remote?.breadcrumb?.(message, data));
+};
+const recordError = (error, context) => {
+  const err = toErrorObject(error);
+  if (isEnabled() && isLogLevelAllowed('error')) {
+    console.error(`${Colors.RED_BOLD}[RECORDED]: ${err.message}${Colors.RESET}`, context ?? '');
+  }
+  forwardErrorToRemote(err, context);
+};
+const setUser = (id, attrs) => {
+  safe(() => remote?.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,
+  error: logError,
+  breadcrumb,
+  recordError,
+  setUser,
+  setAttribute,
+  trackScreen,
+  getCurrentScreen,
+  getScreenHistory
+};
+//# sourceMappingURL=index.js.map

package/lib/module/network/index.js

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

package/lib/module/network/networkStatus.js

@@ -0,0 +1,124 @@
+"use strict";
+
+import * as ExpoNetwork from 'expo-network';
+import { useEffect, useState } from 'react';
+import { Logger } from "../logger/index.js";
+const DEFAULT_STATUS = {
+  isConnected: true,
+  isInternetReachable: null,
+  type: 'unknown'
+};
+/**
+ * expo-network is imported directly, not resolved through a seam.
+ *
+ * `expo` is a REQUIRED peer of this package, so every consumer has the Expo
+ * modules by construction and the static-require problem that forced the old
+ * injection design does not arise. An app wires nothing: connectivity works
+ * because the library uses Expo, which is the point of the Expo-first policy.
+ * One backend also means one behaviour, rather than each app choosing.
+ */
+let override = null;
+
+/**
+ * Replace the backend. Intended for TESTS and for the showcase, which uses it
+ * to reach error paths that a healthy device never takes; it is not the way an
+ * app is meant to configure the library. Pass `null` to restore expo-network.
+ */
+export const setNetworkStatusImplementation = impl => {
+  override = impl;
+};
+const resolveNetInfo = () => override ?? expoNetworkBackend;
+
+/**
+ * expo-network in the shape this module already speaks.
+ *
+ * The conversion is not cosmetic: expo reports its type as an UPPERCASE enum
+ * where this module's vocabulary is lowercase, marks every field optional, and
+ * returns an EventSubscription where an unsubscribe function is expected.
+ */
+const expoNetworkBackend = {
+  fetch: async () => {
+    const state = await ExpoNetwork.getNetworkStateAsync();
+    return {
+      isConnected: state?.isConnected !== false,
+      isInternetReachable: state?.isInternetReachable ?? null,
+      type: state?.type ? String(state.type).toLowerCase() : undefined
+    };
+  },
+  addEventListener: cb => {
+    const subscription = ExpoNetwork.addNetworkStateListener(state => {
+      cb({
+        isConnected: state?.isConnected !== false,
+        isInternetReachable: state?.isInternetReachable ?? null,
+        type: state?.type ? String(state.type).toLowerCase() : undefined
+      });
+    });
+    return () => subscription.remove();
+  }
+};
+const normalize = state => {
+  if (!state) {
+    return DEFAULT_STATUS;
+  }
+  return {
+    isConnected: state.isConnected !== false,
+    isInternetReachable: state.isInternetReachable,
+    type: state.type ?? 'unknown'
+  };
+};
+
+/**
+ * Imperative one-shot fetch of current network status. Resolves to the default
+ * online status when NetInfo is unavailable so callers never crash.
+ */
+export const getNetworkStatus = async () => {
+  const ni = resolveNetInfo();
+  if (!ni) {
+    return DEFAULT_STATUS;
+  }
+  try {
+    const state = await ni.fetch();
+    return normalize(state);
+  } catch (error) {
+    Logger.error('[network] getNetworkStatus failed', error);
+    return DEFAULT_STATUS;
+  }
+};
+
+/**
+ * Subscribe to network status changes. Returns an unsubscribe function.
+ */
+export const addNetworkStatusListener = listener => {
+  const ni = resolveNetInfo();
+  if (!ni) {
+    return () => undefined;
+  }
+  return ni.addEventListener(state => listener(normalize(state)));
+};
+
+/**
+ * React hook that returns the current network status and re-renders on change.
+ * Reports an optimistic online default when NetInfo is not installed.
+ */
+export const useNetworkStatus = () => {
+  const [status, setStatus] = useState(DEFAULT_STATUS);
+  useEffect(() => {
+    let mounted = true;
+    void getNetworkStatus().then(s => {
+      if (mounted) {
+        setStatus(s);
+      }
+    });
+    const unsubscribe = addNetworkStatusListener(s => {
+      if (mounted) {
+        setStatus(s);
+      }
+    });
+    return () => {
+      mounted = false;
+      unsubscribe();
+    };
+  }, []);
+  return status;
+};
+//# sourceMappingURL=networkStatus.js.map

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/permissions/calendar.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-calendar` is named. Import only if you use calendar/reminders. */
+const m = require('expo-calendar');
+registerPermissionAdapter('calendar', {
+  check: m.getCalendarPermissionsAsync,
+  request: m.requestCalendarPermissionsAsync
+});
+registerPermissionAdapter('reminders', {
+  check: m.getRemindersPermissionsAsync,
+  request: m.requestRemindersPermissionsAsync
+});
+//# sourceMappingURL=calendar.js.map

package/lib/module/permissions/camera.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-camera` is named. Import only if you use camera/microphone. */
+const m = require('expo-camera');
+registerPermissionAdapter('camera', {
+  check: m.getCameraPermissionsAsync,
+  request: m.requestCameraPermissionsAsync
+});
+registerPermissionAdapter('microphone', {
+  check: m.getMicrophonePermissionsAsync,
+  request: m.requestMicrophonePermissionsAsync
+});
+//# sourceMappingURL=camera.js.map

package/lib/module/permissions/contacts.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-contacts` is named. Import only if you use contacts. */
+const m = require('expo-contacts');
+registerPermissionAdapter('contacts', {
+  check: m.getPermissionsAsync,
+  request: m.requestPermissionsAsync
+});
+//# sourceMappingURL=contacts.js.map

package/lib/module/permissions/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+import { Linking } from 'react-native';
+import { Logger } from "../logger/index.js";
+
+// Android only — legacy WRITE_EXTERNAL_STORAGE
+
+/** The shared response shape every Expo permission function returns. */
+
+let backend = null;
+
+/**
+ * Inject a custom permissions backend at runtime. Pass `null` to reset to the
+ * default per-kind Expo resolution.
+ *
+ * Two legitimate reasons to call this: tests/the showcase reaching a denied,
+ * blocked or unavailable path a healthy device never takes; and an app that
+ * genuinely needs `bluetooth` or `storage`, which no Expo module covers.
+ */
+export const setPermissionsImplementation = impl => {
+  backend = impl;
+};
+
+/**
+ * Populated by the per-package entry points (`./camera`, `./photos`, …), never
+ * by this file. This module names NO Expo package — Metro resolves every
+ * literal require() reachable from the static import graph regardless of
+ * which switch branch would have run, so naming seven packages here would
+ * make each one a mandatory install for every consumer, whichever kinds they
+ * actually use. An app wires only the kinds it needs:
+ *
+ *   import '@webority/mobile-core/permissions/camera';
+ *   import '@webority/mobile-core/permissions/location';
+ *
+ * `bluetooth` and `storage` have no Expo module and are never registered here
+ * — they resolve through `setPermissionsImplementation` only.
+ */
+const registry = new Map();
+
+/** Called by the per-package entry points to register their kind(s). Not for app code. */
+export const registerPermissionAdapter = (kind, fns) => {
+  registry.set(kind, fns);
+};
+const resolveExpoModule = kind => registry.get(kind) ?? null;
+const toStatus = response => {
+  if (!response) {
+    return 'unavailable';
+  }
+  if (response.accessPrivileges === 'limited') {
+    return 'limited';
+  }
+  if (response.status === 'granted') {
+    return 'granted';
+  }
+  if (response.status === 'denied') {
+    return response.canAskAgain ? 'denied' : 'blocked';
+  }
+  // 'undetermined' — never asked yet. Treated as 'denied' so callers using
+  // Permissions.ensure() correctly trigger a request() rather than stalling.
+  return 'denied';
+};
+const checkPermission = async kind => {
+  if (backend) {
+    return backend.check(kind);
+  }
+  const fns = resolveExpoModule(kind);
+  if (!fns) {
+    return 'unavailable';
+  }
+  try {
+    return toStatus(await fns.check());
+  } catch (error) {
+    Logger.error(`[permissions] check(${kind}) failed`, error);
+    return 'unavailable';
+  }
+};
+const requestPermission = async kind => {
+  if (backend) {
+    return backend.request(kind);
+  }
+  const fns = resolveExpoModule(kind);
+  if (!fns) {
+    return 'unavailable';
+  }
+  try {
+    return toStatus(await fns.request());
+  } catch (error) {
+    Logger.error(`[permissions] request(${kind}) failed`, error);
+    return 'unavailable';
+  }
+};
+const openAppSettings = async () => {
+  try {
+    await Linking.openSettings();
+    return true;
+  } catch (error) {
+    Logger.error('[permissions] openAppSettings failed', error);
+    return false;
+  }
+};
+
+/**
+ * Cross-platform permissions wrapper. Maps an abstract `PermissionKind`
+ * (camera, photos, location, notifications, …) to whichever Expo adapter an
+ * app has registered by importing that kind's entry point — expo-camera,
+ * expo-image-picker, expo-location, expo-contacts, expo-calendar,
+ * expo-notifications, expo-media-library. An app imports only the entry
+ * points for the kinds it actually asks for.
+ */
+export const Permissions = {
+  check: checkPermission,
+  request: requestPermission,
+  /** Convenience: returns true when the permission is `granted` or `limited`. */
+  isAuthorized: async kind => {
+    const s = await checkPermission(kind);
+    return s === 'granted' || s === 'limited';
+  },
+  /** Convenience: check, and request only if not yet granted. */
+  ensure: async kind => {
+    const s = await checkPermission(kind);
+    if (s === 'granted' || s === 'limited' || s === 'blocked' || s === 'unavailable') {
+      return s;
+    }
+    return requestPermission(kind);
+  },
+  openSettings: openAppSettings
+};
+//# sourceMappingURL=index.js.map

package/lib/module/permissions/location.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-location` is named. Import only if you use location/locationAlways. */
+const m = require('expo-location');
+registerPermissionAdapter('location', {
+  check: m.getForegroundPermissionsAsync,
+  request: m.requestForegroundPermissionsAsync
+});
+registerPermissionAdapter('locationAlways', {
+  check: m.getBackgroundPermissionsAsync,
+  request: m.requestBackgroundPermissionsAsync
+});
+//# sourceMappingURL=location.js.map

package/lib/module/permissions/mediaLibrary.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-media-library` is named. Import only if you use mediaLibrary. */
+const m = require('expo-media-library');
+registerPermissionAdapter('mediaLibrary', {
+  check: m.getPermissionsAsync,
+  request: m.requestPermissionsAsync
+});
+//# sourceMappingURL=mediaLibrary.js.map

package/lib/module/permissions/notifications.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-notifications` is named. Import only if you use notifications. */
+const m = require('expo-notifications');
+registerPermissionAdapter('notifications', {
+  check: m.getPermissionsAsync,
+  request: m.requestPermissionsAsync
+});
+//# sourceMappingURL=notifications.js.map

package/lib/module/permissions/photos.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { registerPermissionAdapter } from "./index.js";
+
+/** The one place `expo-image-picker` is named. Import only if you use photos/photosAdd. */
+const m = require('expo-image-picker');
+registerPermissionAdapter('photos', {
+  check: () => m.getMediaLibraryPermissionsAsync(false),
+  request: () => m.requestMediaLibraryPermissionsAsync(false)
+});
+registerPermissionAdapter('photosAdd', {
+  check: () => m.getMediaLibraryPermissionsAsync(true),
+  request: () => m.requestMediaLibraryPermissionsAsync(true)
+});
+//# sourceMappingURL=photos.js.map