@webority-technologies/mobile-core 0.0.1

package/lib/commonjs/auth/jwt.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isJWTExpired = exports.getJWTExpiry = exports.decodeJWT = void 0;
+var _index = require("../logger/index.js");
+/**
+ * Standard claims plus arbitrary keys.
+ * `sub`, `exp`, `iat`, `nbf` follow RFC 7519 conventions.
+ */
+
+const base64UrlToBase64 = input => {
+  const padded = input + '='.repeat((4 - input.length % 4) % 4);
+  return padded.replace(/-/g, '+').replace(/_/g, '/');
+};
+const decodeBase64 = input => {
+  // RN runtimes expose `atob` (Hermes 0.71+); fall back to a Buffer-based decode otherwise.
+  if (typeof atob === 'function') {
+    return atob(input);
+  }
+  const {
+    Buffer
+  } = require('buffer');
+  return Buffer.from(input, 'base64').toString('utf-8');
+};
+const utf8FromBinary = binary => {
+  // Convert percent-encoded UTF-8 sequence so multi-byte chars survive.
+  try {
+    return decodeURIComponent(binary.split('').map(c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0')).join(''));
+  } catch {
+    return binary;
+  }
+};
+
+/**
+ * Decode a JWT's payload claims. Does **not** verify the signature.
+ *
+ * @returns claims object on success, `null` if the token is malformed.
+ */
+const decodeJWT = token => {
+  if (!token || typeof token !== 'string') {
+    return null;
+  }
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    _index.Logger.warn('[jwt] decodeJWT: token is not a valid JWT (expected 3 segments)');
+    return null;
+  }
+  try {
+    const payload = parts[1];
+    const json = utf8FromBinary(decodeBase64(base64UrlToBase64(payload)));
+    return JSON.parse(json);
+  } catch (error) {
+    _index.Logger.warn('[jwt] decodeJWT failed to parse payload', error);
+    return null;
+  }
+};
+
+/**
+ * Returns true when the token is expired (or unparseable / missing `exp`).
+ *
+ * @param token JWT string
+ * @param leewaySeconds amount of clock-skew tolerance to apply (default 30s)
+ */
+exports.decodeJWT = decodeJWT;
+const isJWTExpired = (token, leewaySeconds = 30) => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') {
+    return true;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  return claims.exp <= nowSeconds + leewaySeconds;
+};
+
+/**
+ * Returns the token's expiry as a Date, or `null` when no `exp` claim exists.
+ */
+exports.isJWTExpired = isJWTExpired;
+const getJWTExpiry = token => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') {
+    return null;
+  }
+  return new Date(claims.exp * 1000);
+};
+exports.getJWTExpiry = getJWTExpiry;
+//# sourceMappingURL=jwt.js.map

package/lib/commonjs/config/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfig = void 0;
+exports.getConfigValue = getConfigValue;
+exports.setConfig = exports.resetConfig = void 0;
+/**
+ * Configuration management for Webority packages
+ * Provides a flexible way to inject configuration without hard dependencies
+ */
+
+const DEFAULT_CONFIG = {
+  baseUrl: null,
+  loggingEnabled: true,
+  logLevel: 'info',
+  environment: 'Development',
+  country: 'in',
+  appId: null,
+  appVersion: null
+};
+let globalConfig = {
+  ...DEFAULT_CONFIG
+};
+
+/**
+ * Set global configuration for all Webority packages
+ */
+const setConfig = config => {
+  globalConfig = {
+    ...globalConfig,
+    ...config
+  };
+};
+
+/**
+ * Get current configuration
+ */
+exports.setConfig = setConfig;
+const getConfig = () => globalConfig;
+
+/**
+ * Get a specific config value with optional fallback.
+ * If the stored value is `null`, the fallback is returned (when provided).
+ */
+exports.getConfig = getConfig;
+function getConfigValue(key, fallback) {
+  const value = globalConfig[key];
+  if (value !== null) {
+    return value;
+  }
+  return fallback;
+}
+
+/**
+ * Reset configuration to defaults
+ */
+const resetConfig = () => {
+  globalConfig = {
+    ...DEFAULT_CONFIG
+  };
+};
+exports.resetConfig = resetConfig;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/formatters/currency.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatCurrency = void 0;
+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
+ */
+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}`;
+};
+exports.formatCurrency = formatCurrency;
+//# sourceMappingURL=currency.js.map

package/lib/commonjs/formatters/date.js

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatTime = exports.formatRelativeTime = exports.formatDateTime = exports.formatDate = void 0;
+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.
+ */
+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).
+ */
+exports.formatDate = formatDate;
+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.
+ */
+exports.formatTime = formatTime;
+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)}`;
+};
+exports.formatDateTime = formatDateTime;
+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.
+ */
+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}`;
+};
+exports.formatRelativeTime = formatRelativeTime;
+//# sourceMappingURL=date.js.map

package/lib/commonjs/formatters/index.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "formatCompactNumber", {
+  enumerable: true,
+  get: function () {
+    return _number.formatCompactNumber;
+  }
+});
+Object.defineProperty(exports, "formatCurrency", {
+  enumerable: true,
+  get: function () {
+    return _currency.formatCurrency;
+  }
+});
+Object.defineProperty(exports, "formatDate", {
+  enumerable: true,
+  get: function () {
+    return _date.formatDate;
+  }
+});
+Object.defineProperty(exports, "formatDateTime", {
+  enumerable: true,
+  get: function () {
+    return _date.formatDateTime;
+  }
+});
+Object.defineProperty(exports, "formatNumber", {
+  enumerable: true,
+  get: function () {
+    return _number.formatNumber;
+  }
+});
+Object.defineProperty(exports, "formatPercent", {
+  enumerable: true,
+  get: function () {
+    return _number.formatPercent;
+  }
+});
+Object.defineProperty(exports, "formatPhone", {
+  enumerable: true,
+  get: function () {
+    return _phone.formatPhone;
+  }
+});
+Object.defineProperty(exports, "formatRelativeTime", {
+  enumerable: true,
+  get: function () {
+    return _date.formatRelativeTime;
+  }
+});
+Object.defineProperty(exports, "formatTime", {
+  enumerable: true,
+  get: function () {
+    return _date.formatTime;
+  }
+});
+Object.defineProperty(exports, "getInitials", {
+  enumerable: true,
+  get: function () {
+    return _initials.getInitials;
+  }
+});
+Object.defineProperty(exports, "normalizePhone", {
+  enumerable: true,
+  get: function () {
+    return _phone.normalizePhone;
+  }
+});
+var _currency = require("./currency.js");
+var _date = require("./date.js");
+var _initials = require("./initials.js");
+var _number = require("./number.js");
+var _phone = require("./phone.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/formatters/initials.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInitials = void 0;
+/**
+ * Returns up to `maxChars` uppercase initials from a name.
+ *
+ * @example
+ * getInitials('Navneet Singh')       // 'NS'
+ * getInitials('mary anne lee', 3)    // 'MAL'
+ * getInitials('navneet')             // 'NA'
+ * getInitials('  ')                  // ''
+ */
+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('');
+};
+exports.getInitials = getInitials;
+//# sourceMappingURL=initials.js.map

package/lib/commonjs/formatters/number.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatPercent = exports.formatNumber = exports.formatCompactNumber = void 0;
+const hasIntlNumber = () => typeof Intl !== 'undefined' && typeof Intl.NumberFormat === 'function';
+
+/**
+ * Locale-aware number formatter. Defaults to `'en-IN'` (Indian grouping).
+ */
+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.
+ */
+exports.formatNumber = formatNumber;
+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).
+ */
+exports.formatPercent = formatPercent;
+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}`;
+};
+exports.formatCompactNumber = formatCompactNumber;
+//# sourceMappingURL=number.js.map

package/lib/commonjs/formatters/phone.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizePhone = exports.formatPhone = void 0;
+/**
+ * Strip everything except digits and a leading `+` (preserved if present).
+ */
+const normalizePhone = input => {
+  if (!input) {
+    return '';
+  }
+  const trimmed = input.trim();
+  const hasPlus = trimmed.startsWith('+');
+  const digits = trimmed.replace(/\D/g, '');
+  return hasPlus ? `+${digits}` : digits;
+};
+exports.normalizePhone = normalizePhone;
+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.
+ */
+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();
+};
+exports.formatPhone = formatPhone;
+//# sourceMappingURL=phone.js.map