@webority-technologies/mobile-core 0.0.1

package/lib/module/network/networkStatus.js

@@ -0,0 +1,91 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { Logger } from "../logger/index.js";
+const DEFAULT_STATUS = {
+  isConnected: true,
+  isInternetReachable: null,
+  type: 'unknown'
+};
+let netInfo = null;
+let resolved = false;
+const resolveNetInfo = () => {
+  if (resolved) {
+    return netInfo;
+  }
+  resolved = true;
+  try {
+    const mod = require('@react-native-community/netinfo');
+    netInfo = mod.default ?? mod;
+  } catch {
+    Logger.warn('[network] @react-native-community/netinfo is not installed; ' + 'useNetworkStatus() will report a default "online" status.');
+    netInfo = null;
+  }
+  return netInfo;
+};
+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/index.js

@@ -0,0 +1,197 @@
+"use strict";
+
+import { Linking, Platform } from 'react-native';
+import { Logger } from "../logger/index.js";
+
+// Android only — legacy WRITE_EXTERNAL_STORAGE
+
+let permsModule = null;
+let resolved = false;
+const resolveModule = () => {
+  if (resolved) {
+    return permsModule;
+  }
+  resolved = true;
+  try {
+    const mod = require('react-native-permissions');
+    permsModule = mod.default ?? mod;
+  } catch {
+    Logger.warn('[permissions] react-native-permissions is not installed; ' + 'permission checks will report "unavailable".');
+    permsModule = null;
+  }
+  return permsModule;
+};
+const mapToNative = kind => {
+  const m = resolveModule();
+  if (!m) {
+    return null;
+  }
+  const {
+    IOS,
+    ANDROID
+  } = m.PERMISSIONS;
+  if (Platform.OS === 'ios') {
+    switch (kind) {
+      case 'camera':
+        return IOS.CAMERA ?? null;
+      case 'microphone':
+        return IOS.MICROPHONE ?? null;
+      case 'photos':
+        return IOS.PHOTO_LIBRARY ?? null;
+      case 'photosAdd':
+        return IOS.PHOTO_LIBRARY_ADD_ONLY ?? null;
+      case 'mediaLibrary':
+        return IOS.MEDIA_LIBRARY ?? null;
+      case 'location':
+        return IOS.LOCATION_WHEN_IN_USE ?? null;
+      case 'locationAlways':
+        return IOS.LOCATION_ALWAYS ?? null;
+      case 'contacts':
+        return IOS.CONTACTS ?? null;
+      case 'calendar':
+        return IOS.CALENDARS ?? null;
+      case 'reminders':
+        return IOS.REMINDERS ?? null;
+      case 'notifications':
+        return null;
+      // handled separately on iOS
+      case 'bluetooth':
+        return IOS.BLUETOOTH ?? null;
+      case 'storage':
+        return null;
+      default:
+        return null;
+    }
+  }
+  switch (kind) {
+    case 'camera':
+      return ANDROID.CAMERA ?? null;
+    case 'microphone':
+      return ANDROID.RECORD_AUDIO ?? null;
+    case 'photos':
+    case 'mediaLibrary':
+      return ANDROID.READ_MEDIA_IMAGES ?? ANDROID.READ_EXTERNAL_STORAGE ?? null;
+    case 'photosAdd':
+      return ANDROID.READ_MEDIA_IMAGES ?? null;
+    case 'location':
+    case 'locationAlways':
+      return ANDROID.ACCESS_FINE_LOCATION ?? null;
+    case 'contacts':
+      return ANDROID.READ_CONTACTS ?? null;
+    case 'calendar':
+      return ANDROID.READ_CALENDAR ?? null;
+    case 'reminders':
+      return null;
+    case 'notifications':
+      return ANDROID.POST_NOTIFICATIONS ?? null;
+    case 'bluetooth':
+      return ANDROID.BLUETOOTH_CONNECT ?? null;
+    case 'storage':
+      return ANDROID.WRITE_EXTERNAL_STORAGE ?? null;
+    default:
+      return null;
+  }
+};
+const mapResult = raw => {
+  const m = resolveModule();
+  if (!m || !raw) {
+    return 'unavailable';
+  }
+  const {
+    RESULTS
+  } = m;
+  if (raw === RESULTS.GRANTED) {
+    return 'granted';
+  }
+  if (raw === RESULTS.DENIED) {
+    return 'denied';
+  }
+  if (raw === RESULTS.LIMITED) {
+    return 'limited';
+  }
+  if (raw === RESULTS.BLOCKED) {
+    return 'blocked';
+  }
+  return 'unavailable';
+};
+const checkPermission = async kind => {
+  const m = resolveModule();
+  if (!m) {
+    return 'unavailable';
+  }
+  const native = mapToNative(kind);
+  if (!native) {
+    return 'unavailable';
+  }
+  try {
+    const raw = await m.check(native);
+    return mapResult(raw);
+  } catch (error) {
+    Logger.error(`[permissions] check(${kind}) failed`, error);
+    return 'unavailable';
+  }
+};
+const requestPermission = async kind => {
+  const m = resolveModule();
+  if (!m) {
+    return 'unavailable';
+  }
+  const native = mapToNative(kind);
+  if (!native) {
+    return 'unavailable';
+  }
+  try {
+    const raw = await m.request(native);
+    return mapResult(raw);
+  } catch (error) {
+    Logger.error(`[permissions] request(${kind}) failed`, error);
+    return 'unavailable';
+  }
+};
+const openAppSettings = async () => {
+  const m = resolveModule();
+  if (!m) {
+    try {
+      await Linking.openSettings();
+      return true;
+    } catch (error) {
+      Logger.error('[permissions] openAppSettings fallback failed', error);
+      return false;
+    }
+  }
+  try {
+    await m.openSettings();
+    return true;
+  } catch (error) {
+    Logger.error('[permissions] openSettings failed', error);
+    return false;
+  }
+};
+
+/**
+ * Cross-platform permissions wrapper. Maps an abstract `PermissionKind`
+ * (camera, photos, location, notifications, …) to the right
+ * iOS / Android permission string under the hood.
+ *
+ * Requires `react-native-permissions` as an optional peer dependency;
+ * when missing, every check/request resolves to `'unavailable'`.
+ */
+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/storage/index.js

@@ -0,0 +1,189 @@
+"use strict";
+
+import { Logger } from "../logger/index.js";
+
+/**
+ * Minimal AsyncStorage shape we depend on.
+ * Lets us avoid a hard import on `@react-native-async-storage/async-storage`.
+ */
+
+let backend = null;
+let resolved = false;
+const resolveBackend = () => {
+  if (resolved) {
+    return backend;
+  }
+  resolved = true;
+  try {
+    const mod = require('@react-native-async-storage/async-storage');
+    backend = mod.default ?? mod;
+  } catch {
+    backend = null;
+  }
+  return backend;
+};
+const requireBackend = op => {
+  const b = resolveBackend();
+  if (!b) {
+    const err = new Error(`[Storage] @react-native-async-storage/async-storage is not installed; cannot ${op}. ` + 'Install the peer dep or call setStorageImplementation() with a custom backend.');
+    Logger.error(err.message);
+    throw err;
+  }
+  return b;
+};
+
+/**
+ * Inject a custom storage backend (e.g. MMKV adapter) at runtime.
+ * Pass `null` to reset to the default AsyncStorage backend.
+ */
+export const setStorageImplementation = impl => {
+  backend = impl;
+  resolved = true;
+};
+const safeJsonParse = raw => {
+  if (raw == null) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    Logger.warn('[Storage] Failed to parse JSON value, returning null', error);
+    return null;
+  }
+};
+const getItem = async key => {
+  try {
+    return await requireBackend('getItem').getItem(key);
+  } catch (error) {
+    Logger.error(`[Storage] getItem failed for key "${key}"`, error);
+    return null;
+  }
+};
+const setItem = async (key, value) => {
+  try {
+    await requireBackend('setItem').setItem(key, value);
+    return true;
+  } catch (error) {
+    Logger.error(`[Storage] setItem failed for key "${key}"`, error);
+    return false;
+  }
+};
+const removeItem = async key => {
+  try {
+    await requireBackend('removeItem').removeItem(key);
+    return true;
+  } catch (error) {
+    Logger.error(`[Storage] removeItem failed for key "${key}"`, error);
+    return false;
+  }
+};
+const getJson = async key => {
+  const raw = await getItem(key);
+  return safeJsonParse(raw);
+};
+const setJson = async (key, value) => {
+  try {
+    return await setItem(key, JSON.stringify(value));
+  } catch (error) {
+    Logger.error(`[Storage] setJson failed for key "${key}"`, error);
+    return false;
+  }
+};
+const multiGet = async keys => {
+  try {
+    const b = requireBackend('multiGet');
+    if (!b.multiGet) {
+      const out = {};
+      await Promise.all(keys.map(async k => {
+        out[k] = await b.getItem(k);
+      }));
+      return out;
+    }
+    const pairs = await b.multiGet(keys);
+    const out = {};
+    for (const [k, v] of pairs) {
+      out[k] = v;
+    }
+    return out;
+  } catch (error) {
+    Logger.error('[Storage] multiGet failed', error);
+    return {};
+  }
+};
+const multiSet = async entries => {
+  try {
+    const b = requireBackend('multiSet');
+    const pairs = Object.entries(entries);
+    if (!b.multiSet) {
+      await Promise.all(pairs.map(([k, v]) => b.setItem(k, v)));
+      return true;
+    }
+    await b.multiSet(pairs);
+    return true;
+  } catch (error) {
+    Logger.error('[Storage] multiSet failed', error);
+    return false;
+  }
+};
+const multiRemove = async keys => {
+  try {
+    const b = requireBackend('multiRemove');
+    if (!b.multiRemove) {
+      await Promise.all(keys.map(k => b.removeItem(k)));
+      return true;
+    }
+    await b.multiRemove(keys);
+    return true;
+  } catch (error) {
+    Logger.error('[Storage] multiRemove failed', error);
+    return false;
+  }
+};
+const clear = async () => {
+  try {
+    const b = requireBackend('clear');
+    if (!b.clear) {
+      Logger.warn('[Storage] backend does not support clear()');
+      return false;
+    }
+    await b.clear();
+    return true;
+  } catch (error) {
+    Logger.error('[Storage] clear failed', error);
+    return false;
+  }
+};
+const getAllKeys = async () => {
+  try {
+    const b = requireBackend('getAllKeys');
+    if (!b.getAllKeys) {
+      return [];
+    }
+    const keys = await b.getAllKeys();
+    return [...keys];
+  } catch (error) {
+    Logger.error('[Storage] getAllKeys failed', error);
+    return [];
+  }
+};
+/**
+ * Typed AsyncStorage wrapper with safe JSON helpers.
+ * All operations swallow errors (logging them) and return a falsy result
+ * so that storage problems never crash the app.
+ *
+ * Backed by `@react-native-async-storage/async-storage` by default;
+ * override with `setStorageImplementation()` for MMKV or custom adapters.
+ */
+export const Storage = {
+  getItem,
+  setItem,
+  removeItem,
+  getJson,
+  setJson,
+  multiGet,
+  multiSet,
+  multiRemove,
+  clear,
+  getAllKeys
+};
+//# sourceMappingURL=index.js.map

package/lib/module/utils/imageCompression.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import { Logger } from "../logger/index.js";
+let compressor = null;
+let resolved = false;
+const resolveCompressor = () => {
+  if (resolved) {
+    return compressor;
+  }
+  resolved = true;
+  try {
+    compressor = require('react-native-compressor');
+  } catch {
+    Logger.warn('[imageCompression] react-native-compressor is not installed; ' + 'compressImage() will return the original URI unchanged.');
+    compressor = null;
+  }
+  return compressor;
+};
+const EIGHT_MB = 8 * 1024 * 1024;
+const THREE_MB = 3 * 1024 * 1024;
+
+/**
+ * Bigger source files get compressed harder — a fixed quality either over-compresses
+ * small photos or leaves large ones too heavy to upload quickly. Unknown size falls
+ * back to the middle rung rather than assuming either extreme.
+ */
+export const qualityForFileSize = fileSize => {
+  if (fileSize == null) {
+    return 0.7;
+  }
+  if (fileSize > EIGHT_MB) {
+    return 0.6;
+  }
+  if (fileSize > THREE_MB) {
+    return 0.7;
+  }
+  return 0.8;
+};
+
+/**
+ * Compress an image referenced by a URI. Returns a new URI on success, or the
+ * original URI on failure / when the optional `react-native-compressor`
+ * dependency is missing — so callers can rely on always getting a usable URI.
+ */
+export const compressImage = async (uri, options = {}) => {
+  const lib = resolveCompressor();
+  if (!lib || !uri) {
+    return uri;
+  }
+  const {
+    maxSize = 1500,
+    output = 'jpg',
+    fileSize
+  } = options;
+  const quality = options.quality ?? qualityForFileSize(fileSize);
+  try {
+    return await lib.Image.compress(uri, {
+      maxWidth: maxSize,
+      maxHeight: maxSize,
+      quality,
+      compressionMethod: 'manual',
+      output
+    });
+  } catch (error) {
+    Logger.error('[imageCompression] compressImage failed; returning original URI', error);
+    return uri;
+  }
+};
+//# sourceMappingURL=imageCompression.js.map

package/lib/module/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { compressImage } from "./imageCompression.js";
+//# sourceMappingURL=index.js.map