@webority-technologies/mobile-core 0.0.1

package/lib/module/formatters/currency.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const hasIntlNumber = () => typeof Intl !== 'undefined' && typeof Intl.NumberFormat === 'function';
+const indianGroupingFallback = (n, fractionDigits) => {
+  // Indian numbering: 1,23,45,678.90 (last 3 digits, then groups of 2).
+  const sign = n < 0 ? '-' : '';
+  const abs = Math.abs(n);
+  const fixed = abs.toFixed(fractionDigits);
+  const [intPart, decPart] = fixed.split('.');
+  const last3 = intPart.length > 3 ? intPart.slice(-3) : intPart;
+  const rest = intPart.length > 3 ? intPart.slice(0, -3) : '';
+  const grouped = rest ? rest.replace(/\B(?=(\d{2})+(?!\d))/g, ',') + ',' + last3 : last3;
+  return sign + grouped + (decPart ? `.${decPart}` : '');
+};
+
+/**
+ * Format an amount as currency. Defaults to **INR** with Indian numbering (`en-IN`),
+ * which matches the standard convention across Webority projects.
+ *
+ * @example
+ * formatCurrency(150000)            // ₹1,50,000
+ * formatCurrency(1234.5)            // ₹1,234.50
+ * formatCurrency(99, { currency: 'USD', locale: 'en-US' }) // $99.00
+ * formatCurrency(150000, { stripSymbol: true })            // 1,50,000
+ */
+export const formatCurrency = (amount, options = {}) => {
+  if (amount == null || Number.isNaN(amount)) {
+    return '';
+  }
+  const {
+    currency = 'INR',
+    locale = 'en-IN',
+    minimumFractionDigits,
+    maximumFractionDigits = 2,
+    stripSymbol = false
+  } = options;
+  const minFrac = minimumFractionDigits ?? (Number.isInteger(amount) ? 0 : 2);
+  if (hasIntlNumber()) {
+    try {
+      const formatted = new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency,
+        minimumFractionDigits: minFrac,
+        maximumFractionDigits
+      }).format(amount);
+      if (!stripSymbol) {
+        return formatted;
+      }
+      // Strip currency code/symbol while keeping digits, separators and sign.
+      return formatted.replace(/[^\d,.\s\-+]/g, '').trim();
+    } catch {
+      /* fall through to fallback */
+    }
+  }
+  const numeric = indianGroupingFallback(amount, minFrac);
+  if (stripSymbol) {
+    return numeric;
+  }
+  if (currency === 'INR') {
+    return `₹${numeric}`;
+  }
+  return `${currency} ${numeric}`;
+};
+//# sourceMappingURL=currency.js.map

package/lib/module/formatters/date.js

@@ -0,0 +1,160 @@
+"use strict";
+
+const toDate = value => {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+};
+const hasIntl = () => typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat === 'function';
+const PAD = n => n < 10 ? `0${n}` : `${n}`;
+const fallbackDate = (d, style) => {
+  const day = PAD(d.getDate());
+  const monthShort = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()];
+  const monthLong = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][d.getMonth()];
+  const year = d.getFullYear();
+  const weekdayLong = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d.getDay()];
+  switch (style) {
+    case 'short':
+      return `${day}/${PAD(d.getMonth() + 1)}/${year}`;
+    case 'long':
+      return `${day} ${monthLong} ${year}`;
+    case 'full':
+      return `${weekdayLong}, ${day} ${monthLong} ${year}`;
+    case 'medium':
+    default:
+      return `${day} ${monthShort} ${year}`;
+  }
+};
+const fallbackTime = (d, style) => {
+  const hh = PAD(d.getHours());
+  const mm = PAD(d.getMinutes());
+  if (style === 'short') {
+    return `${hh}:${mm}`;
+  }
+  const ss = PAD(d.getSeconds());
+  return `${hh}:${mm}:${ss}`;
+};
+
+/**
+ * Locale-aware date formatter. Defaults to `'medium'` style and `'en-IN'` locale,
+ * matching the Indian-locale convention used across Webority apps.
+ */
+export const formatDate = (value, style = 'medium', locale = 'en-IN') => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (hasIntl()) {
+    try {
+      return new Intl.DateTimeFormat(locale, {
+        dateStyle: style
+      }).format(d);
+    } catch {
+      /* fall through to fallback */
+    }
+  }
+  return fallbackDate(d, style);
+};
+
+/**
+ * Locale-aware time formatter (24-hour fallback when Intl is unavailable).
+ */
+export const formatTime = (value, style = 'short', locale = 'en-IN') => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (hasIntl()) {
+    try {
+      return new Intl.DateTimeFormat(locale, {
+        timeStyle: style
+      }).format(d);
+    } catch {
+      /* fall through */
+    }
+  }
+  return fallbackTime(d, style);
+};
+
+/**
+ * Combined date + time formatter.
+ */
+export const formatDateTime = (value, dateStyle = 'medium', timeStyle = 'short', locale = 'en-IN') => {
+  const d = toDate(value);
+  if (!d) {
+    return '';
+  }
+  if (hasIntl()) {
+    try {
+      return new Intl.DateTimeFormat(locale, {
+        dateStyle,
+        timeStyle
+      }).format(d);
+    } catch {
+      /* fall through */
+    }
+  }
+  return `${fallbackDate(d, dateStyle)}, ${fallbackTime(d, timeStyle)}`;
+};
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const WEEK = 7 * DAY;
+const MONTH = 30 * DAY;
+const YEAR = 365 * DAY;
+
+/**
+ * Returns a humanized relative-time string (e.g. "5 minutes ago", "in 3 days").
+ * Uses `Intl.RelativeTimeFormat` when available; otherwise a sensible English fallback.
+ */
+export const formatRelativeTime = (value, base = new Date(), locale = 'en-IN') => {
+  const target = toDate(value);
+  const now = toDate(base);
+  if (!target || !now) {
+    return '';
+  }
+  const diffMs = target.getTime() - now.getTime();
+  const abs = Math.abs(diffMs);
+  let unit;
+  let amount;
+  if (abs < MINUTE) {
+    unit = 'second';
+    amount = Math.round(diffMs / SECOND);
+  } else if (abs < HOUR) {
+    unit = 'minute';
+    amount = Math.round(diffMs / MINUTE);
+  } else if (abs < DAY) {
+    unit = 'hour';
+    amount = Math.round(diffMs / HOUR);
+  } else if (abs < WEEK) {
+    unit = 'day';
+    amount = Math.round(diffMs / DAY);
+  } else if (abs < MONTH) {
+    unit = 'week';
+    amount = Math.round(diffMs / WEEK);
+  } else if (abs < YEAR) {
+    unit = 'month';
+    amount = Math.round(diffMs / MONTH);
+  } else {
+    unit = 'year';
+    amount = Math.round(diffMs / YEAR);
+  }
+  const Rtf = Intl.RelativeTimeFormat;
+  if (typeof Rtf === 'function') {
+    try {
+      return new Rtf(locale, {
+        numeric: 'auto'
+      }).format(amount, unit);
+    } catch {
+      /* fall through */
+    }
+  }
+  const past = amount < 0;
+  const n = Math.abs(amount);
+  const u = n === 1 ? unit : `${unit}s`;
+  return past ? `${n} ${u} ago` : `in ${n} ${u}`;
+};
+//# sourceMappingURL=date.js.map

package/lib/module/formatters/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export { formatCurrency } from "./currency.js";
+export { formatDate, formatDateTime, formatRelativeTime, formatTime } from "./date.js";
+export { getInitials } from "./initials.js";
+export { formatCompactNumber, formatNumber, formatPercent } from "./number.js";
+export { formatPhone, normalizePhone } from "./phone.js";
+//# sourceMappingURL=index.js.map

package/lib/module/formatters/initials.js

@@ -0,0 +1,27 @@
+"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,81 @@
+"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,61 @@
+"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/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+// API clients
+export { default as publicClient } from "./api/publicClient.js";
+export { default as userClient, injectAuthActions, injectStore, RequestOfflineError, SESSION_TERMINATION_CODES } from "./api/userClient.js";
+// Auth / token storage
+export { getToken, removeToken, setKeychainImplementation, storeToken } from "./auth/authStore.js";
+export { decodeJWT, getJWTExpiry, isJWTExpired } from "./auth/jwt.js";
+// Configuration
+export { getConfig, getConfigValue, resetConfig, setConfig } from "./config/index.js";
+// Formatters
+export { formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from "./formatters/index.js";
+// Initialization
+export { initWebority } from "./initSDK.js";
+export { initUserAuth } from "./initUserAuth.js";
+// Logger
+export { Logger, setRemoteLogger } from "./logger/index.js";
+// Network status (the NetworkStatusBanner UI lives in @webority-technologies/mobile-ui)
+export { addNetworkStatusListener, getNetworkStatus, useNetworkStatus } from "./network/index.js";
+// Permissions
+export { Permissions } from "./permissions/index.js";
+// Storage
+export { Storage, setStorageImplementation } from "./storage/index.js";
+// Media utils
+export { compressImage } from "./utils/index.js";
+// Validators
+export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from "./validators/index.js";
+// Version check (the ForceUpdateDialog UI lives in @webority-technologies/mobile-ui)
+export { setDeviceInfoImplementation, useVersionCheck, VersionCheck } from "./versionCheck/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/initSDK.js

@@ -0,0 +1,40 @@
+"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()
+  });
+  console.log('✅ Webority packages initialized successfully');
+};
+//# sourceMappingURL=initSDK.js.map

package/lib/module/initUserAuth.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * Simple initialization API for Webority User package
+ * Easy setup for Redux integration
+ */
+
+import { injectAuthActions, injectStore } 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);
+  console.log('✅ Webority User package initialized with Redux');
+};
+//# sourceMappingURL=initUserAuth.js.map

package/lib/module/logger/index.js

@@ -0,0 +1,133 @@
+"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/index.js

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