@webority/mobile-core 0.0.23

package/lib/commonjs/initUserAuth.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initUserAuth = void 0;
+var _userClient = require("./api/userClient.js");
+var _index = require("./logger/index.js");
+/** The tokens a refresh response carries, with their expiry timestamps. */
+
+/**
+ * How the library calls the app's refresh endpoint. The call goes through
+ * `publicClient`, and the new tokens are stored under the library's own keys.
+ */
+
+/**
+ * Wire the user client to the app: the Redux store it dispatches `logout` to,
+ * and the refresh endpoint it calls when an access token expires or a request
+ * answers 401. Only a 400 or 401 from that endpoint, or a missing or expired
+ * refresh token, logs out; a network error, timeout or 5xx keeps the session.
+ *
+ * @example
+ * initUserAuth(store, { logout, refresh: { path: '/Account/RefreshToken' } });
+ */
+const initUserAuth = (store, options) => {
+  if (!store) {
+    throw new Error('Redux store is required for user package initialization');
+  }
+  if (!options.logout || !options.refresh?.path) {
+    throw new Error('initUserAuth needs a logout action and refresh.path');
+  }
+  (0, _userClient.injectStore)(store);
+  (0, _userClient.injectUserAuth)(options);
+  _index.Logger.info('[@webority/mobile-core] user auth wired to the store');
+};
+exports.initUserAuth = initUserAuth;
+//# sourceMappingURL=initUserAuth.js.map

package/lib/commonjs/logger/index.js

@@ -0,0 +1,291 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setRemoteLogger = exports.setDeviceContext = exports.getDeviceContext = exports.configureLogger = exports.Logger = void 0;
+var _index = require("../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 = (0, _index.getConfigValue)('logLevel', 'info');
+  return levels.indexOf(level) >= levels.indexOf(current);
+};
+const isEnabled = () => (0, _index.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`.
+ */
+const setRemoteLogger = impl => {
+  remote = impl;
+};
+exports.setRemoteLogger = setRemoteLogger;
+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.
+ */
+const setDeviceContext = context => {
+  deviceContext = context;
+  if (context) {
+    for (const [key, value] of Object.entries(context)) {
+      safe(() => remote?.setAttribute?.(key, normalizeAttributeValue(value)));
+    }
+  }
+};
+exports.setDeviceContext = setDeviceContext;
+const getDeviceContext = () => deviceContext;
+
+/** Tuning knobs for screen history and duplicate-error suppression. */
+exports.getDeviceContext = getDeviceContext;
+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. */
+const configureLogger = options => {
+  loggerOptions = {
+    ...loggerOptions,
+    ...options
+  };
+  if (screenHistory.length > loggerOptions.screenHistoryLimit) {
+    screenHistory = screenHistory.slice(screenHistory.length - loggerOptions.screenHistoryLimit);
+  }
+};
+exports.configureLogger = configureLogger;
+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];
+const Logger = exports.Logger = {
+  info: logInfo,
+  warn: logWarning,
+  error: logError,
+  breadcrumb,
+  recordError,
+  setUser,
+  setAttribute,
+  trackScreen,
+  getCurrentScreen,
+  getScreenHistory
+};
+//# sourceMappingURL=index.js.map

package/lib/commonjs/network/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "addNetworkStatusListener", {
+  enumerable: true,
+  get: function () {
+    return _networkStatus.addNetworkStatusListener;
+  }
+});
+Object.defineProperty(exports, "getNetworkStatus", {
+  enumerable: true,
+  get: function () {
+    return _networkStatus.getNetworkStatus;
+  }
+});
+Object.defineProperty(exports, "setNetworkStatusImplementation", {
+  enumerable: true,
+  get: function () {
+    return _networkStatus.setNetworkStatusImplementation;
+  }
+});
+Object.defineProperty(exports, "useNetworkStatus", {
+  enumerable: true,
+  get: function () {
+    return _networkStatus.useNetworkStatus;
+  }
+});
+var _networkStatus = require("./networkStatus.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/network/networkStatus.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNetworkStatus = exports.setNetworkStatusImplementation = exports.getNetworkStatus = exports.addNetworkStatusListener = void 0;
+var ExpoNetwork = _interopRequireWildcard(require("expo-network"));
+var _react = require("react");
+var _index = require("../logger/index.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+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.
+ */
+const setNetworkStatusImplementation = impl => {
+  override = impl;
+};
+exports.setNetworkStatusImplementation = setNetworkStatusImplementation;
+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.
+ */
+const getNetworkStatus = async () => {
+  const ni = resolveNetInfo();
+  if (!ni) {
+    return DEFAULT_STATUS;
+  }
+  try {
+    const state = await ni.fetch();
+    return normalize(state);
+  } catch (error) {
+    _index.Logger.error('[network] getNetworkStatus failed', error);
+    return DEFAULT_STATUS;
+  }
+};
+
+/**
+ * Subscribe to network status changes. Returns an unsubscribe function.
+ */
+exports.getNetworkStatus = getNetworkStatus;
+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.
+ */
+exports.addNetworkStatusListener = addNetworkStatusListener;
+const useNetworkStatus = () => {
+  const [status, setStatus] = (0, _react.useState)(DEFAULT_STATUS);
+  (0, _react.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;
+};
+exports.useNetworkStatus = useNetworkStatus;
+//# sourceMappingURL=networkStatus.js.map

package/lib/commonjs/package.json

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

package/lib/commonjs/permissions/calendar.js

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

package/lib/commonjs/permissions/camera.js

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

package/lib/commonjs/permissions/contacts.js

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

package/lib/commonjs/permissions/index.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setPermissionsImplementation = exports.registerPermissionAdapter = exports.Permissions = void 0;
+var _reactNative = require("react-native");
+var _index = require("../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.
+ */
+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.
+ */
+exports.setPermissionsImplementation = setPermissionsImplementation;
+const registry = new Map();
+
+/** Called by the per-package entry points to register their kind(s). Not for app code. */
+const registerPermissionAdapter = (kind, fns) => {
+  registry.set(kind, fns);
+};
+exports.registerPermissionAdapter = registerPermissionAdapter;
+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) {
+    _index.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) {
+    _index.Logger.error(`[permissions] request(${kind}) failed`, error);
+    return 'unavailable';
+  }
+};
+const openAppSettings = async () => {
+  try {
+    await _reactNative.Linking.openSettings();
+    return true;
+  } catch (error) {
+    _index.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.
+ */
+const Permissions = exports.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/commonjs/permissions/location.js

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

package/lib/commonjs/permissions/mediaLibrary.js

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