@webority-technologies/mobile 0.0.1

package/lib/module/theme/tokens.js

@@ -0,0 +1,315 @@
+"use strict";
+
+const typography = {
+  fontSize: {
+    xs: 11,
+    sm: 13,
+    base: 15,
+    lg: 17,
+    xl: 20,
+    '2xl': 24,
+    '3xl': 30,
+    '4xl': 36
+  },
+  fontWeight: {
+    normal: '400',
+    medium: '500',
+    semibold: '600',
+    bold: '700'
+  },
+  lineHeight: {
+    tight: 1.2,
+    normal: 1.4,
+    relaxed: 1.6
+  },
+  letterSpacing: {
+    tight: -0.2,
+    normal: 0,
+    wide: 0.4
+  }
+};
+const spacing = {
+  none: 0,
+  xxs: 2,
+  xs: 4,
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 24,
+  '2xl': 32,
+  '3xl': 48,
+  '4xl': 64
+};
+const radius = {
+  none: 0,
+  xs: 4,
+  sm: 6,
+  md: 10,
+  lg: 14,
+  xl: 20,
+  '2xl': 28,
+  full: 9999
+};
+const motion = {
+  duration: {
+    instant: 80,
+    fast: 160,
+    normal: 240,
+    slow: 360,
+    slower: 500
+  },
+  easing: {
+    standard: [0.4, 0.0, 0.2, 1],
+    accelerate: [0.4, 0.0, 1, 1],
+    decelerate: [0.0, 0.0, 0.2, 1],
+    sharp: [0.4, 0.0, 0.6, 1]
+  },
+  spring: {
+    gentle: {
+      damping: 18,
+      stiffness: 140,
+      mass: 1
+    },
+    bouncy: {
+      damping: 12,
+      stiffness: 200,
+      mass: 1
+    },
+    snappy: {
+      damping: 22,
+      stiffness: 260,
+      mass: 1
+    }
+  }
+};
+const lightShadows = {
+  none: {},
+  xs: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 1
+    },
+    shadowOpacity: 0.04,
+    shadowRadius: 2,
+    elevation: 1
+  },
+  sm: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.06,
+    shadowRadius: 4,
+    elevation: 2
+  },
+  md: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 4
+    },
+    shadowOpacity: 0.08,
+    shadowRadius: 8,
+    elevation: 4
+  },
+  lg: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 8
+    },
+    shadowOpacity: 0.1,
+    shadowRadius: 16,
+    elevation: 8
+  },
+  xl: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 12
+    },
+    shadowOpacity: 0.14,
+    shadowRadius: 24,
+    elevation: 12
+  },
+  '2xl': {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 20
+    },
+    shadowOpacity: 0.18,
+    shadowRadius: 32,
+    elevation: 20
+  }
+};
+const darkShadows = {
+  none: {},
+  xs: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 1
+    },
+    shadowOpacity: 0.3,
+    shadowRadius: 2,
+    elevation: 1
+  },
+  sm: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.4,
+    shadowRadius: 4,
+    elevation: 2
+  },
+  md: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 4
+    },
+    shadowOpacity: 0.5,
+    shadowRadius: 8,
+    elevation: 4
+  },
+  lg: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 8
+    },
+    shadowOpacity: 0.55,
+    shadowRadius: 16,
+    elevation: 8
+  },
+  xl: {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 12
+    },
+    shadowOpacity: 0.6,
+    shadowRadius: 24,
+    elevation: 12
+  },
+  '2xl': {
+    shadowColor: '#000',
+    shadowOffset: {
+      width: 0,
+      height: 20
+    },
+    shadowOpacity: 0.7,
+    shadowRadius: 32,
+    elevation: 20
+  }
+};
+export const lightTheme = {
+  mode: 'light',
+  colors: {
+    primary: '#5B5BD6',
+    primaryHover: '#4F4FBF',
+    primaryPressed: '#4040A8',
+    primaryMuted: '#EEEEFC',
+    secondary: '#F4F4F8',
+    secondaryHover: '#E9E9F0',
+    success: '#1FAD66',
+    warning: '#F59E0B',
+    error: '#E5484D',
+    info: '#3B82F6',
+    text: {
+      primary: '#0F0F1A',
+      secondary: '#52525B',
+      tertiary: '#8B8B95',
+      inverse: '#FFFFFF',
+      disabled: '#B4B4BB',
+      link: '#5B5BD6'
+    },
+    background: {
+      primary: '#FFFFFF',
+      secondary: '#F8F8FB',
+      tertiary: '#F1F1F5',
+      elevated: '#FFFFFF',
+      overlay: 'rgba(15, 15, 26, 0.5)',
+      inverse: '#0F0F1A'
+    },
+    border: {
+      primary: '#E5E5EC',
+      secondary: '#EFEFF3',
+      focus: '#5B5BD6',
+      error: '#E5484D'
+    },
+    surface: {
+      pressed: 'rgba(15, 15, 26, 0.06)',
+      hovered: 'rgba(15, 15, 26, 0.04)',
+      selected: 'rgba(91, 91, 214, 0.1)',
+      disabled: '#F1F1F5'
+    },
+    skeleton: {
+      background: '#EBEDF3',
+      highlight: '#F5F6FA'
+    }
+  },
+  typography,
+  spacing,
+  radius,
+  shadows: lightShadows,
+  motion
+};
+export const darkTheme = {
+  mode: 'dark',
+  colors: {
+    primary: '#7C7CE8',
+    primaryHover: '#9292EE',
+    primaryPressed: '#A8A8F2',
+    primaryMuted: '#1F1F3D',
+    secondary: '#1F1F26',
+    secondaryHover: '#2A2A33',
+    success: '#30C780',
+    warning: '#FBBF24',
+    error: '#F87171',
+    info: '#60A5FA',
+    text: {
+      primary: '#FAFAFA',
+      secondary: '#B4B4BB',
+      tertiary: '#71717A',
+      inverse: '#0F0F1A',
+      disabled: '#52525B',
+      link: '#9292EE'
+    },
+    background: {
+      primary: '#0B0B12',
+      secondary: '#13131C',
+      tertiary: '#1C1C26',
+      elevated: '#1C1C26',
+      overlay: 'rgba(0, 0, 0, 0.65)',
+      inverse: '#FAFAFA'
+    },
+    border: {
+      primary: '#27272F',
+      secondary: '#1C1C26',
+      focus: '#7C7CE8',
+      error: '#F87171'
+    },
+    surface: {
+      pressed: 'rgba(255, 255, 255, 0.08)',
+      hovered: 'rgba(255, 255, 255, 0.05)',
+      selected: 'rgba(124, 124, 232, 0.18)',
+      disabled: '#1C1C26'
+    },
+    skeleton: {
+      background: '#1C1C26',
+      highlight: '#27272F'
+    }
+  },
+  typography,
+  spacing,
+  radius,
+  shadows: darkShadows,
+  motion
+};
+//# sourceMappingURL=tokens.js.map

package/lib/module/theme/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/types/vector-icons.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=vector-icons.d.js.map

package/lib/module/utils/dimensions.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { ScreenDimensions, Breakpoints, isScreenSize, isTablet } from "./responsive.js";
+//# sourceMappingURL=dimensions.js.map

package/lib/module/utils/hapticUtils.js

@@ -0,0 +1,51 @@
+"use strict";
+
+import { Platform, Vibration } from 'react-native';
+let hapticImpl = null;
+const tryLoadOptional = () => {
+  if (hapticImpl) return;
+  try {
+    // Lazily try to load the user's optional haptic dep without making it a hard requirement.
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const haptic = require('react-native-haptic-feedback');
+    const trigger = haptic.default?.trigger ?? haptic.trigger;
+    if (typeof trigger === 'function') {
+      hapticImpl = type => trigger(type, {
+        enableVibrateFallback: true
+      });
+    }
+    /* eslint-enable */
+  } catch {
+    // Ignored: not installed; fall back to Vibration on Android, no-op on iOS.
+  }
+};
+const fallback = type => {
+  if (Platform.OS === 'android') {
+    const map = {
+      selection: 5,
+      impactLight: 10,
+      impactMedium: 20,
+      impactHeavy: 30,
+      notificationSuccess: 15,
+      notificationWarning: 25,
+      notificationError: 40
+    };
+    Vibration.vibrate(map[type] ?? 10);
+  }
+};
+export const triggerHaptic = (type = 'selection') => {
+  tryLoadOptional();
+  if (hapticImpl) {
+    try {
+      hapticImpl(type);
+      return;
+    } catch {
+      /* ignore */
+    }
+  }
+  fallback(type);
+};
+export const setHapticImplementation = impl => {
+  hapticImpl = impl;
+};
+//# sourceMappingURL=hapticUtils.js.map

package/lib/module/utils/imageCompression.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import { Logger } from "../logger/index.js";
+let compressor = null;
+let resolved = false;
+const resolveCompressor = () => {
+  if (resolved) return compressor;
+  resolved = true;
+  try {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    compressor = require('react-native-compressor');
+    /* eslint-enable */
+  } catch {
+    Logger.warn('[imageCompression] react-native-compressor is not installed; ' + 'compressImage() will return the original URI unchanged.');
+    compressor = null;
+  }
+  return compressor;
+};
+
+/**
+ * Compress an image referenced by a URI. Returns a new URI on success, or the
+ * original URI on failure / when the optional `react-native-compressor`
+ * dependency is missing — so callers can rely on always getting a usable URI.
+ */
+export const compressImage = async (uri, options = {}) => {
+  const lib = resolveCompressor();
+  if (!lib || !uri) return uri;
+  const {
+    maxSize = 1600,
+    quality = 0.7,
+    output = 'jpg'
+  } = options;
+  try {
+    return await lib.Image.compress(uri, {
+      maxWidth: maxSize,
+      maxHeight: maxSize,
+      quality,
+      compressionMethod: 'auto',
+      output
+    });
+  } catch (error) {
+    Logger.error('[imageCompression] compressImage failed; returning original URI', error);
+    return uri;
+  }
+};
+//# sourceMappingURL=imageCompression.js.map

package/lib/module/utils/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export { ScreenDimensions, Breakpoints, Responsive, isScreenSize, isTablet } from "./responsive.js";
+export { Spacing, Padding, Margin } from "./spacing.js";
+export { triggerHaptic, setHapticImplementation } from "./hapticUtils.js";
+export { shadowStyle } from "./shadows.js";
+export { compressImage } from "./imageCompression.js";
+//# sourceMappingURL=index.js.map

package/lib/module/utils/responsive.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { Dimensions, PixelRatio, Platform } from 'react-native';
+const BASE_WIDTH = 390;
+const BASE_HEIGHT = 844;
+const {
+  width: SCREEN_WIDTH,
+  height: SCREEN_HEIGHT
+} = Dimensions.get('window');
+export const ScreenDimensions = {
+  width: SCREEN_WIDTH,
+  height: SCREEN_HEIGHT,
+  pixelRatio: PixelRatio.get(),
+  fontScale: PixelRatio.getFontScale()
+};
+export const Breakpoints = {
+  xs: 0,
+  sm: 360,
+  md: 414,
+  lg: 768,
+  xl: 1024
+};
+export const isScreenSize = size => {
+  return SCREEN_WIDTH >= Breakpoints[size];
+};
+export const isTablet = () => SCREEN_WIDTH >= Breakpoints.lg;
+const widthScale = SCREEN_WIDTH / BASE_WIDTH;
+const heightScale = SCREEN_HEIGHT / BASE_HEIGHT;
+const minScale = Math.min(widthScale, heightScale);
+export const Responsive = {
+  width: size => Math.round(size * widthScale),
+  height: size => Math.round(size * heightScale),
+  size: size => Math.round(size * minScale),
+  font: size => {
+    const scaled = size * minScale;
+    if (Platform.OS === 'ios') {
+      return Math.round(PixelRatio.roundToNearestPixel(scaled));
+    }
+    return Math.round(PixelRatio.roundToNearestPixel(scaled)) - 1;
+  }
+};
+//# sourceMappingURL=responsive.js.map

package/lib/module/utils/shadows.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export const shadowStyle = (shadows, level) => {
+  const def = shadows[level];
+  return def;
+};
+//# sourceMappingURL=shadows.js.map

package/lib/module/utils/spacing.js

@@ -0,0 +1,82 @@
+"use strict";
+
+import { getTheme } from "../theme/index.js";
+export const Spacing = {
+  get none() {
+    return getTheme().spacing.none;
+  },
+  get xxs() {
+    return getTheme().spacing.xxs;
+  },
+  get xs() {
+    return getTheme().spacing.xs;
+  },
+  get sm() {
+    return getTheme().spacing.sm;
+  },
+  get md() {
+    return getTheme().spacing.md;
+  },
+  get lg() {
+    return getTheme().spacing.lg;
+  },
+  get xl() {
+    return getTheme().spacing.xl;
+  },
+  get '2xl'() {
+    return getTheme().spacing['2xl'];
+  },
+  get '3xl'() {
+    return getTheme().spacing['3xl'];
+  },
+  get '4xl'() {
+    return getTheme().spacing['4xl'];
+  }
+};
+export const Padding = {
+  all: token => ({
+    padding: getTheme().spacing[token]
+  }),
+  horizontal: token => ({
+    paddingHorizontal: getTheme().spacing[token]
+  }),
+  vertical: token => ({
+    paddingVertical: getTheme().spacing[token]
+  }),
+  top: token => ({
+    paddingTop: getTheme().spacing[token]
+  }),
+  bottom: token => ({
+    paddingBottom: getTheme().spacing[token]
+  }),
+  left: token => ({
+    paddingLeft: getTheme().spacing[token]
+  }),
+  right: token => ({
+    paddingRight: getTheme().spacing[token]
+  })
+};
+export const Margin = {
+  all: token => ({
+    margin: getTheme().spacing[token]
+  }),
+  horizontal: token => ({
+    marginHorizontal: getTheme().spacing[token]
+  }),
+  vertical: token => ({
+    marginVertical: getTheme().spacing[token]
+  }),
+  top: token => ({
+    marginTop: getTheme().spacing[token]
+  }),
+  bottom: token => ({
+    marginBottom: getTheme().spacing[token]
+  }),
+  left: token => ({
+    marginLeft: getTheme().spacing[token]
+  }),
+  right: token => ({
+    marginRight: getTheme().spacing[token]
+  })
+};
+//# sourceMappingURL=spacing.js.map

package/lib/module/validators/index.js

@@ -0,0 +1,143 @@
+"use strict";
+
+/**
+ * Generic validators returning `boolean`. All accept `null`/`undefined` safely.
+ *
+ * Tradeoff: regexes are pragmatic, not RFC-strict. They reject the things real users
+ * typo and accept the long tail of legitimate inputs. For RFC-grade validation use
+ * a dedicated library at the boundary.
+ */
+
+const RE_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const RE_INDIAN_MOBILE = /^[6-9]\d{9}$/;
+const RE_NUMERIC = /^-?\d+(?:\.\d+)?$/;
+const RE_INTEGER = /^-?\d+$/;
+const RE_ALPHANUMERIC = /^[a-zA-Z0-9]+$/;
+const RE_PINCODE_IN = /^[1-9]\d{5}$/;
+const RE_PAN = /^[A-Z]{5}\d{4}[A-Z]$/;
+const RE_GSTIN = /^\d{2}[A-Z]{5}\d{4}[A-Z][1-9A-Z]Z[0-9A-Z]$/;
+const RE_AADHAAR = /^\d{12}$/;
+const RE_IFSC = /^[A-Z]{4}0[A-Z0-9]{6}$/;
+const RE_HEX_COLOR = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const asString = v => {
+  if (typeof v === 'string') return v.trim();
+  return null;
+};
+export const isNonEmpty = value => {
+  const s = asString(value);
+  return !!s && s.length > 0;
+};
+export const isEmail = value => {
+  const s = asString(value);
+  return !!s && RE_EMAIL.test(s);
+};
+
+/**
+ * Validate an Indian mobile number. Accepts:
+ * - 10-digit number starting with 6-9
+ * - Optional `+91` or `91` country code prefix
+ */
+export const isIndianMobile = value => {
+  const s = asString(value);
+  if (!s) return false;
+  const digits = s.replace(/\D/g, '');
+  const tail = digits.startsWith('91') && digits.length === 12 ? digits.slice(2) : digits;
+  return RE_INDIAN_MOBILE.test(tail);
+};
+
+/**
+ * Generic phone validator: 7–15 digits, optional `+` prefix.
+ * Use `isIndianMobile` when you specifically need an Indian mobile number.
+ */
+export const isPhone = value => {
+  const s = asString(value);
+  if (!s) return false;
+  const digits = s.replace(/[^\d+]/g, '').replace(/^\+/, '');
+  return digits.length >= 7 && digits.length <= 15 && /^\d+$/.test(digits);
+};
+export const isUrl = value => {
+  const s = asString(value);
+  if (!s) return false;
+  try {
+    // URL constructor is available on Hermes & JSC.
+
+    new URL(s);
+    return /^https?:\/\//i.test(s) || /^[a-z][a-z0-9+\-.]*:\/\//i.test(s);
+  } catch {
+    return false;
+  }
+};
+export const isNumeric = value => {
+  if (typeof value === 'number') return Number.isFinite(value);
+  const s = asString(value);
+  return !!s && RE_NUMERIC.test(s);
+};
+export const isInteger = value => {
+  if (typeof value === 'number') return Number.isInteger(value);
+  const s = asString(value);
+  return !!s && RE_INTEGER.test(s);
+};
+export const isAlphanumeric = value => {
+  const s = asString(value);
+  return !!s && RE_ALPHANUMERIC.test(s);
+};
+/**
+ * Common password complexity check. Defaults to 8+ chars,
+ * one uppercase, one lowercase, one digit.
+ */
+export const isStrongPassword = (value, rules = {}) => {
+  if (typeof value !== 'string') return false;
+  const {
+    minLength = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumber = true,
+    requireSymbol = false
+  } = rules;
+  if (value.length < minLength) return false;
+  if (requireUppercase && !/[A-Z]/.test(value)) return false;
+  if (requireLowercase && !/[a-z]/.test(value)) return false;
+  if (requireNumber && !/\d/.test(value)) return false;
+  if (requireSymbol && !/[^A-Za-z0-9]/.test(value)) return false;
+  return true;
+};
+export const isIndianPincode = value => {
+  const s = asString(value);
+  return !!s && RE_PINCODE_IN.test(s);
+};
+export const isPan = value => {
+  const s = asString(value);
+  return !!s && RE_PAN.test(s.toUpperCase());
+};
+export const isGstin = value => {
+  const s = asString(value);
+  return !!s && RE_GSTIN.test(s.toUpperCase());
+};
+export const isAadhaar = value => {
+  const s = asString(value);
+  if (!s) return false;
+  const digits = s.replace(/\s/g, '');
+  return RE_AADHAAR.test(digits);
+};
+export const isIfsc = value => {
+  const s = asString(value);
+  return !!s && RE_IFSC.test(s.toUpperCase());
+};
+export const isHexColor = value => {
+  const s = asString(value);
+  return !!s && RE_HEX_COLOR.test(s);
+};
+export const isBetween = (value, min, max, inclusive = true) => {
+  const n = typeof value === 'number' ? value : Number(asString(value));
+  if (!Number.isFinite(n)) return false;
+  return inclusive ? n >= min && n <= max : n > min && n < max;
+};
+export const minLength = (value, length) => {
+  const s = asString(value);
+  return !!s && s.length >= length;
+};
+export const maxLength = (value, length) => {
+  const s = asString(value);
+  return s == null ? true : s.length <= length;
+};
+//# sourceMappingURL=index.js.map