@webority-technologies/mobile 0.0.1

package/lib/module/formatters/initials.js

@@ -0,0 +1,23 @@
+"use strict";
+
+/**
+ * Returns up to `maxChars` uppercase initials from a name.
+ *
+ * @example
+ * getInitials('Navneet Singh')       // 'NS'
+ * getInitials('mary anne lee', 3)    // 'MAL'
+ * getInitials('navneet')             // 'NA'
+ * getInitials('  ')                  // ''
+ */
+export const getInitials = (name, maxChars = 2) => {
+  if (!name) return '';
+  const trimmed = name.trim();
+  if (!trimmed) return '';
+  const parts = trimmed.split(/\s+/);
+  if (parts.length === 1) {
+    const single = parts[0] ?? '';
+    return single.slice(0, maxChars).toUpperCase();
+  }
+  return parts.slice(0, maxChars).map(p => (p[0] ?? '').toUpperCase()).join('');
+};
+//# sourceMappingURL=initials.js.map

package/lib/module/formatters/number.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const hasIntlNumber = () => typeof Intl !== 'undefined' && typeof Intl.NumberFormat === 'function';
+
+/**
+ * Locale-aware number formatter. Defaults to `'en-IN'` (Indian grouping).
+ */
+export const formatNumber = (value, fractionDigits, locale = 'en-IN') => {
+  if (value == null || Number.isNaN(value)) return '';
+  if (hasIntlNumber()) {
+    try {
+      const opts = {};
+      if (fractionDigits != null) {
+        opts.minimumFractionDigits = fractionDigits;
+        opts.maximumFractionDigits = fractionDigits;
+      }
+      return new Intl.NumberFormat(locale, opts).format(value);
+    } catch {
+      /* fall through */
+    }
+  }
+  return fractionDigits != null ? value.toFixed(fractionDigits) : String(value);
+};
+
+/**
+ * Format a 0–1 ratio (or 0–100 percent) as a percent string.
+ * Pass `asRatio: false` if your input is already on the 0–100 scale.
+ */
+export const formatPercent = (value, fractionDigits = 0, asRatio = true, locale = 'en-IN') => {
+  if (value == null || Number.isNaN(value)) return '';
+  const ratio = asRatio ? value : value / 100;
+  if (hasIntlNumber()) {
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: 'percent',
+        minimumFractionDigits: fractionDigits,
+        maximumFractionDigits: fractionDigits
+      }).format(ratio);
+    } catch {
+      /* fall through */
+    }
+  }
+  return `${(ratio * 100).toFixed(fractionDigits)}%`;
+};
+
+/**
+ * Format a number compactly (1.2K, 3.4M, 1.5L, 2.3Cr).
+ * Defaults to Indian compact notation via `'en-IN'` locale (lakh / crore).
+ */
+export const formatCompactNumber = (value, locale = 'en-IN') => {
+  if (value == null || Number.isNaN(value)) return '';
+  if (hasIntlNumber()) {
+    try {
+      return new Intl.NumberFormat(locale, {
+        notation: 'compact',
+        maximumFractionDigits: 1
+      }).format(value);
+    } catch {
+      /* fall through */
+    }
+  }
+  const abs = Math.abs(value);
+  const sign = value < 0 ? '-' : '';
+  if (abs >= 1e7) return `${sign}${(abs / 1e7).toFixed(1)}Cr`;
+  if (abs >= 1e5) return `${sign}${(abs / 1e5).toFixed(1)}L`;
+  if (abs >= 1e3) return `${sign}${(abs / 1e3).toFixed(1)}K`;
+  return `${value}`;
+};
+//# sourceMappingURL=number.js.map

package/lib/module/formatters/phone.js

@@ -0,0 +1,53 @@
+"use strict";
+
+/**
+ * Strip everything except digits and a leading `+` (preserved if present).
+ */
+export const normalizePhone = input => {
+  if (!input) return '';
+  const trimmed = input.trim();
+  const hasPlus = trimmed.startsWith('+');
+  const digits = trimmed.replace(/\D/g, '');
+  return hasPlus ? `+${digits}` : digits;
+};
+const groupIndianMobile = digits => {
+  // Indian mobile is 10 digits: format as `XXXXX XXXXX`.
+  if (digits.length !== 10) return digits;
+  return `${digits.slice(0, 5)} ${digits.slice(5)}`;
+};
+
+/**
+ * Format a phone number for human display.
+ *
+ * - Indian mobile (10 digits) → `XXXXX XXXXX`
+ * - With `+91` country code → `+91 XXXXX XXXXX`
+ * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
+ */
+export const formatPhone = (input, defaultCountryCode = '+91') => {
+  if (!input) return '';
+  const normalized = normalizePhone(input);
+  if (!normalized) return '';
+
+  // Already starts with +
+  if (normalized.startsWith('+')) {
+    const rest = normalized.slice(1);
+    // Indian
+    if (rest.startsWith('91') && rest.length === 12) {
+      return `+91 ${groupIndianMobile(rest.slice(2))}`;
+    }
+    // Generic — split country code (first 1–3 digits) and group the rest in 4s.
+    const ccLen = rest.length > 11 ? 3 : rest.length > 10 ? 2 : 1;
+    const cc = rest.slice(0, ccLen);
+    const number = rest.slice(ccLen);
+    const grouped = number.replace(/(.{4})(?=.)/g, '$1 ').trim();
+    return `+${cc} ${grouped}`.trim();
+  }
+
+  // No country code; assume default if length matches Indian mobile.
+  if (normalized.length === 10) {
+    return `${defaultCountryCode} ${groupIndianMobile(normalized)}`;
+  }
+  // Otherwise just return groups of 4.
+  return normalized.replace(/(.{4})(?=.)/g, '$1 ').trim();
+};
+//# sourceMappingURL=phone.js.map

package/lib/module/hooks/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export { useToggle } from "./useToggle.js";
+export { useDebounce } from "./useDebounce.js";
+export { usePressAnimation } from "./usePressAnimation.js";
+//# sourceMappingURL=index.js.map

package/lib/module/hooks/useDebounce.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+export const useDebounce = (value, delay = 300) => {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const handle = setTimeout(() => setDebounced(value), delay);
+    return () => clearTimeout(handle);
+  }, [value, delay]);
+  return debounced;
+};
+//# sourceMappingURL=useDebounce.js.map

package/lib/module/hooks/usePressAnimation.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import { useCallback, useRef } from 'react';
+import { Animated, Easing } from 'react-native';
+import { useTheme } from "../theme/index.js";
+export const usePressAnimation = ({
+  scaleTo = 0.97,
+  pressDuration,
+  releaseDuration,
+  enabled = true
+} = {}) => {
+  const theme = useTheme();
+  const scale = useRef(new Animated.Value(1)).current;
+  const pressIn = useCallback(() => {
+    if (!enabled) return;
+    Animated.timing(scale, {
+      toValue: scaleTo,
+      duration: pressDuration ?? theme.motion.duration.fast,
+      easing: Easing.bezier(...theme.motion.easing.standard),
+      useNativeDriver: true
+    }).start();
+  }, [enabled, scale, scaleTo, pressDuration, theme]);
+  const pressOut = useCallback(() => {
+    if (!enabled) return;
+    Animated.spring(scale, {
+      toValue: 1,
+      damping: theme.motion.spring.snappy.damping,
+      stiffness: theme.motion.spring.snappy.stiffness,
+      mass: theme.motion.spring.snappy.mass,
+      useNativeDriver: true
+    }).start();
+  }, [enabled, scale, theme]);
+  return {
+    scale,
+    pressIn,
+    pressOut
+  };
+};
+//# sourceMappingURL=usePressAnimation.js.map

package/lib/module/hooks/useToggle.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { useCallback, useState } from 'react';
+export const useToggle = (initial = false) => {
+  const [value, setValue] = useState(initial);
+  const toggle = useCallback(() => setValue(v => !v), []);
+  const setOn = useCallback(() => setValue(true), []);
+  const setOff = useCallback(() => setValue(false), []);
+  return {
+    value,
+    toggle,
+    setOn,
+    setOff,
+    setValue
+  };
+};
+//# sourceMappingURL=useToggle.js.map

package/lib/module/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+// Initialization
+export { initWebority } from "./initSDK.js";
+export { initUserAuth } from "./initUserAuth.js";
+export { initUI } from "./initUI.js";
+// Configuration
+export { setConfig, getConfig, getConfigValue, resetConfig } from "./config/index.js";
+// API clients
+export { default as publicClient } from "./api/publicClient.js";
+export { default as userClient, injectStore, injectAuthActions } from "./api/userClient.js";
+// Auth / token storage
+export { storeToken, getToken, removeToken } from "./auth/authStore.js";
+export { decodeJWT, isJWTExpired, getJWTExpiry } from "./auth/jwt.js";
+// Storage
+export { Storage, setStorageImplementation } from "./storage/index.js";
+// Logger
+export { Logger, setRemoteLogger } from "./logger/index.js";
+// Version check
+export { VersionCheck, useVersionCheck } from "./versionCheck/index.js";
+// Theme
+export { ThemeProvider, useTheme, useThemeMode, setTheme, setColorMode, getColorMode, getTheme, resetTheme, subscribeTheme, mergeTheme, lightTheme, darkTheme } from "./theme/index.js";
+// Hooks
+export { useToggle, useDebounce, usePressAnimation } from "./hooks/index.js";
+// Utils
+export { ScreenDimensions, Breakpoints, Responsive, isScreenSize, isTablet, Spacing, Padding, Margin, triggerHaptic, setHapticImplementation, shadowStyle, compressImage } from "./utils/index.js";
+// Formatters
+export { formatDate, formatTime, formatDateTime, formatRelativeTime, formatPhone, normalizePhone, formatCurrency, formatNumber, formatPercent, formatCompactNumber, getInitials } from "./formatters/index.js";
+// Validators
+export { isNonEmpty, isEmail, isIndianMobile, isPhone, isUrl, isNumeric, isInteger, isAlphanumeric, isStrongPassword, isIndianPincode, isPan, isGstin, isAadhaar, isIfsc, isHexColor, isBetween, minLength, maxLength } from "./validators/index.js";
+// Network
+export { useNetworkStatus, getNetworkStatus, addNetworkStatusListener, NetworkStatusBanner } from "./network/index.js";
+// Permissions
+export { Permissions } from "./permissions/index.js";
+// Components
+export * from "./components/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/initSDK.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/**
+ * Simple initialization API for Webority packages
+ * One function to configure everything needed
+ */
+
+import { setConfig } from "./config/index.js";
+/**
+ * Initialize Webority packages with your project configuration.
+ *
+ * @example
+ * // Basic setup
+ * initWebority({
+ *   baseUrl: 'https://api.myapp.com'
+ * });
+ *
+ * @example
+ * // Full configuration
+ * initWebority({
+ *   baseUrl: 'https://api.myapp.com',
+ *   loggingEnabled: __DEV__,
+ *   logLevel: 'warn',
+ *   environment: __DEV__ ? 'Development' : 'Production'
+ * });
+ */
+export const initWebority = config => {
+  if (!config.baseUrl) {
+    throw new Error('baseUrl is required for Webority packages initialization');
+  }
+  setConfig({
+    baseUrl: config.baseUrl,
+    loggingEnabled: config.loggingEnabled ?? true,
+    logLevel: config.logLevel || 'info',
+    environment: config.environment || 'Development',
+    country: (config.country || 'in').toLowerCase()
+  });
+
+  // eslint-disable-next-line no-console
+  console.log('✅ Webority packages initialized successfully');
+};
+//# sourceMappingURL=initSDK.js.map

package/lib/module/initUI.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { setColorMode, setTheme } from "./theme/index.js";
+/**
+ * Configure the global functional theme API used outside of React tree
+ * (use ThemeProvider for React-tree consumers; both can coexist).
+ */
+export const initUI = (options = {}) => {
+  if (options.defaultMode) {
+    setColorMode(options.defaultMode);
+  }
+  if (options.light) {
+    setTheme(options.light, 'light');
+  }
+  if (options.dark) {
+    setTheme(options.dark, 'dark');
+  }
+};
+//# sourceMappingURL=initUI.js.map

package/lib/module/initUserAuth.js

@@ -0,0 +1,36 @@
+"use strict";
+
+/**
+ * Simple initialization API for Webority User package
+ * Easy setup for Redux integration
+ */
+
+import { injectStore, injectAuthActions } from "./api/userClient.js";
+
+/**
+ * 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 });
+ */
+export 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');
+  }
+  injectStore(store);
+  injectAuthActions(authActions);
+
+  // eslint-disable-next-line no-console
+  console.log('✅ Webority User package initialized with Redux');
+};
+//# sourceMappingURL=initUserAuth.js.map

package/lib/module/logger/index.js

@@ -0,0 +1,123 @@
+"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));
+  }
+};
+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));
+};
+export const Logger = {
+  info: logInfo,
+  warn: logWarning,
+  error: logError,
+  breadcrumb,
+  recordError,
+  setUser,
+  setAttribute
+};
+//# sourceMappingURL=index.js.map

package/lib/module/network/NetworkStatusBanner.js

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

package/lib/module/network/index.js

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

package/lib/module/network/networkStatus.js

@@ -0,0 +1,81 @@
+"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 {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const mod = require('@react-native-community/netinfo');
+    /* eslint-enable */
+    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"}