@webority-technologies/mobile 0.0.1

package/lib/commonjs/initUserAuth.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initUserAuth = void 0;
+var _userClient = require("./api/userClient.js");
+/**
+ * Simple initialization API for Webority User package
+ * Easy setup for Redux integration
+ */
+
+/**
+ * Auth action creators required by the user package.
+ */
+
+/**
+ * Initialize user package with Redux store and auth actions.
+ *
+ * @example
+ * import store from './store';
+ * import { logout, refreshToken } from './actions/authActions';
+ *
+ * initUserAuth(store, { logout, refreshToken });
+ */
+const initUserAuth = (store, authActions) => {
+  if (!store) {
+    throw new Error('Redux store is required for user package initialization');
+  }
+  if (!authActions.logout || !authActions.refreshToken) {
+    throw new Error('Both logout and refreshToken actions are required');
+  }
+  (0, _userClient.injectStore)(store);
+  (0, _userClient.injectAuthActions)(authActions);
+
+  // eslint-disable-next-line no-console
+  console.log('✅ Webority User package initialized with Redux');
+};
+exports.initUserAuth = initUserAuth;
+//# sourceMappingURL=initUserAuth.js.map

package/lib/commonjs/logger/index.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setRemoteLogger = 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));
+  }
+};
+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) {
+    safe(() => remote?.recordError?.(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 ?? '');
+  }
+  safe(() => remote?.recordError?.(err, context));
+};
+const setUser = (id, attrs) => {
+  safe(() => remote?.setUser?.(id, attrs));
+};
+const setAttribute = (key, value) => {
+  safe(() => remote?.setAttribute?.(key, value));
+};
+const Logger = exports.Logger = {
+  info: logInfo,
+  warn: logWarning,
+  error: logError,
+  breadcrumb,
+  recordError,
+  setUser,
+  setAttribute
+};
+//# sourceMappingURL=index.js.map

package/lib/commonjs/network/NetworkStatusBanner.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.NetworkStatusBanner = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+var _index = require("../theme/index.js");
+var _networkStatus = require("./networkStatus.js");
+var _jsxRuntime = require("react/jsx-runtime");
+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); }
+/**
+ * A subtle animated banner that slides in when the device goes offline.
+ * Mount once near the app root (above your navigation tree).
+ */
+const NetworkStatusBanner = ({
+  message = 'You are offline. Some features may be unavailable.',
+  position = 'top',
+  style,
+  disabled = false
+}) => {
+  const theme = (0, _index.useTheme)();
+  const {
+    isConnected,
+    isInternetReachable
+  } = (0, _networkStatus.useNetworkStatus)();
+  const offline = !disabled && (!isConnected || isInternetReachable === false);
+  const slide = (0, _react.useRef)(new _reactNative.Animated.Value(0)).current;
+  const opacity = (0, _react.useRef)(new _reactNative.Animated.Value(0)).current;
+  (0, _react.useEffect)(() => {
+    _reactNative.Animated.parallel([_reactNative.Animated.timing(slide, {
+      toValue: offline ? 1 : 0,
+      duration: theme.motion.duration.normal,
+      useNativeDriver: true
+    }), _reactNative.Animated.timing(opacity, {
+      toValue: offline ? 1 : 0,
+      duration: theme.motion.duration.normal,
+      useNativeDriver: true
+    })]).start();
+  }, [offline, slide, opacity, theme.motion.duration.normal]);
+  const styles = (0, _react.useMemo)(() => buildStyles(), []);
+  const translateY = slide.interpolate({
+    inputRange: [0, 1],
+    outputRange: [position === 'top' ? -56 : 56, 0]
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Animated.View, {
+    pointerEvents: offline ? 'auto' : 'none',
+    accessibilityRole: "alert",
+    accessibilityLiveRegion: offline ? 'polite' : 'none',
+    style: [styles.container, position === 'top' ? styles.top : styles.bottom, {
+      backgroundColor: theme.colors.error,
+      opacity,
+      transform: [{
+        translateY
+      }]
+    }, style],
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+      style: {
+        color: theme.colors.text.inverse,
+        fontSize: theme.typography.fontSize.sm,
+        fontWeight: theme.typography.fontWeight.semibold,
+        textAlign: 'center'
+      },
+      numberOfLines: 2,
+      children: message
+    })
+  });
+};
+exports.NetworkStatusBanner = NetworkStatusBanner;
+const buildStyles = () => _reactNative.StyleSheet.create({
+  container: {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    paddingVertical: 10,
+    paddingHorizontal: 16,
+    zIndex: 1000,
+    elevation: 8
+  },
+  top: {
+    top: 0
+  },
+  bottom: {
+    bottom: 0
+  }
+});
+var _default = exports.default = NetworkStatusBanner;
+//# sourceMappingURL=NetworkStatusBanner.js.map

package/lib/commonjs/network/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "NetworkStatusBanner", {
+  enumerable: true,
+  get: function () {
+    return _NetworkStatusBanner.NetworkStatusBanner;
+  }
+});
+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, "useNetworkStatus", {
+  enumerable: true,
+  get: function () {
+    return _networkStatus.useNetworkStatus;
+  }
+});
+var _networkStatus = require("./networkStatus.js");
+var _NetworkStatusBanner = require("./NetworkStatusBanner.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/network/networkStatus.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNetworkStatus = exports.getNetworkStatus = exports.addNetworkStatusListener = void 0;
+var _react = require("react");
+var _index = require("../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 {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const mod = require('@react-native-community/netinfo');
+    /* eslint-enable */
+    netInfo = mod.default ?? mod;
+  } catch {
+    _index.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.
+ */
+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/index.js

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Permissions = void 0;
+var _reactNative = require("react-native");
+var _index = require("../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 {
+    _index.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 (_reactNative.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) {
+    _index.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) {
+    _index.Logger.error(`[permissions] request(${kind}) failed`, error);
+    return 'unavailable';
+  }
+};
+const openAppSettings = async () => {
+  const m = resolveModule();
+  if (!m) {
+    try {
+      await _reactNative.Linking.openSettings();
+      return true;
+    } catch (error) {
+      _index.Logger.error('[permissions] openAppSettings fallback failed', error);
+      return false;
+    }
+  }
+  try {
+    await m.openSettings();
+    return true;
+  } catch (error) {
+    _index.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'`.
+ */
+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