@webority-technologies/mobile 0.0.1

package/lib/module/permissions/index.js

@@ -0,0 +1,177 @@
+"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 {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const mod = require('react-native-permissions');
+    /* eslint-enable */
+    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,183 @@
+"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 {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const mod = require('@react-native-async-storage/async-storage');
+    /* eslint-enable */
+    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/theme/ThemeContext.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import React, { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { Appearance } from 'react-native';
+import { darkTheme, lightTheme } from "./tokens.js";
+import { mergeTheme } from "./merge.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const defaultValue = {
+  theme: lightTheme,
+  mode: 'light',
+  preference: 'system',
+  setPreference: () => undefined,
+  toggleColorMode: () => undefined
+};
+const ThemeContext = /*#__PURE__*/createContext(defaultValue);
+export const ThemeProvider = ({
+  children,
+  initialPreference = 'system',
+  lightOverrides,
+  darkOverrides
+}) => {
+  const [preference, setPreference] = useState(initialPreference);
+  const [systemMode, setSystemMode] = useState(() => Appearance.getColorScheme() ?? 'light');
+  useEffect(() => {
+    const sub = Appearance.addChangeListener(({
+      colorScheme
+    }) => {
+      setSystemMode(colorScheme ?? 'light');
+    });
+    return () => sub.remove();
+  }, []);
+  const mode = preference === 'system' ? systemMode : preference;
+  const theme = useMemo(() => {
+    const base = mode === 'dark' ? darkTheme : lightTheme;
+    const overrides = mode === 'dark' ? darkOverrides : lightOverrides;
+    return overrides ? mergeTheme(base, overrides) : base;
+  }, [mode, lightOverrides, darkOverrides]);
+  const value = useMemo(() => ({
+    theme,
+    mode,
+    preference,
+    setPreference,
+    toggleColorMode: () => setPreference(current => {
+      if (current === 'system') {
+        return systemMode === 'dark' ? 'light' : 'dark';
+      }
+      return current === 'dark' ? 'light' : 'dark';
+    })
+  }), [theme, mode, preference, systemMode]);
+  return /*#__PURE__*/_jsx(ThemeContext.Provider, {
+    value: value,
+    children: children
+  });
+};
+export const useTheme = () => useContext(ThemeContext).theme;
+export const useThemeMode = () => {
+  const ctx = useContext(ThemeContext);
+  return {
+    mode: ctx.mode,
+    preference: ctx.preference,
+    setPreference: ctx.setPreference,
+    toggleColorMode: ctx.toggleColorMode
+  };
+};
+//# sourceMappingURL=ThemeContext.js.map

package/lib/module/theme/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import { darkTheme, lightTheme } from "./tokens.js";
+import { mergeTheme } from "./merge.js";
+let currentMode = 'light';
+let currentTheme = lightTheme;
+let lightOverridesGlobal;
+let darkOverridesGlobal;
+const subscribers = new Set();
+const recompute = () => {
+  const base = currentMode === 'dark' ? darkTheme : lightTheme;
+  const overrides = currentMode === 'dark' ? darkOverridesGlobal : lightOverridesGlobal;
+  currentTheme = overrides ? mergeTheme(base, overrides) : base;
+  subscribers.forEach(cb => cb());
+};
+export const setTheme = (overrides, mode) => {
+  if (mode) {
+    currentMode = mode;
+  }
+  if (currentMode === 'dark') {
+    darkOverridesGlobal = overrides;
+  } else {
+    lightOverridesGlobal = overrides;
+  }
+  recompute();
+};
+export const setColorMode = mode => {
+  currentMode = mode;
+  recompute();
+};
+export const getColorMode = () => currentMode;
+export const getTheme = () => currentTheme;
+export const resetTheme = () => {
+  currentMode = 'light';
+  lightOverridesGlobal = undefined;
+  darkOverridesGlobal = undefined;
+  recompute();
+};
+export const subscribeTheme = callback => {
+  subscribers.add(callback);
+  return () => {
+    subscribers.delete(callback);
+  };
+};
+export { ThemeProvider, useTheme, useThemeMode } from "./ThemeContext.js";
+export { lightTheme, darkTheme } from "./tokens.js";
+export { mergeTheme } from "./merge.js";
+//# sourceMappingURL=index.js.map

package/lib/module/theme/merge.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const isPlainObject = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+const deepMerge = (target, source) => {
+  if (!isPlainObject(target) || !isPlainObject(source)) {
+    return source !== undefined ? source : target;
+  }
+  const result = {
+    ...target
+  };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== undefined) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+};
+export const mergeTheme = (base, overrides) => {
+  return deepMerge(base, overrides);
+};
+//# sourceMappingURL=merge.js.map