@webority-technologies/mobile 0.0.1

package/lib/module/components/Tooltip/Tooltip.js

@@ -0,0 +1,358 @@
+"use strict";
+
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Animated, Dimensions, Modal, Pressable, StyleSheet, Text, View } from 'react-native';
+import { useTheme } from "../../theme/index.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const TOOLTIP_GAP = 8;
+const SCREEN_PADDING = 8;
+const PRESS_AUTO_HIDE_MS = 4000;
+const ARROW_HALF_WIDTH = 4; // half of 8px arrow base
+const ARROW_HEIGHT = 6;
+const ARROW_CORNER_PADDING = 12;
+const Tooltip = props => {
+  const {
+    content,
+    children,
+    placement = 'auto',
+    trigger = 'longPress',
+    visible: controlledVisible,
+    onVisibleChange,
+    hideOnContentPress = true,
+    maxWidth = 240,
+    showArrow = true,
+    accessibilityLabel,
+    style,
+    testID
+  } = props;
+  const theme = useTheme();
+  const styles = useMemo(() => buildStyles(theme), [theme]);
+  const isControlled = trigger === 'manual' || typeof controlledVisible === 'boolean';
+  const [internalVisible, setInternalVisible] = useState(false);
+  const visible = isControlled ? Boolean(controlledVisible) : internalVisible;
+  const [anchor, setAnchor] = useState(null);
+  const [size, setSize] = useState({
+    width: 0,
+    height: 0
+  });
+  const wrapperRef = useRef(null);
+  const scale = useRef(new Animated.Value(visible ? 1 : 0.85)).current;
+  const opacity = useRef(new Animated.Value(visible ? 1 : 0)).current;
+  const autoHideTimer = useRef(null);
+  const didMount = useRef(false);
+  const setVisible = useCallback(next => {
+    if (!isControlled) setInternalVisible(next);
+    onVisibleChange?.(next);
+  }, [isControlled, onVisibleChange]);
+  const measureAnchor = useCallback(() => {
+    if (!wrapperRef.current) return;
+    wrapperRef.current.measureInWindow((x, y, width, height) => {
+      setAnchor({
+        x,
+        y,
+        width,
+        height
+      });
+    });
+  }, []);
+  const handleTrigger = useCallback(_event => {
+    if (trigger === 'manual') return;
+    measureAnchor();
+    setVisible(true);
+  }, [trigger, measureAnchor, setVisible]);
+  const handleHide = useCallback(() => {
+    setVisible(false);
+  }, [setVisible]);
+
+  // Animations + auto-hide
+  useEffect(() => {
+    // On first mount, skip the entry animation if we're already visible
+    // (avoids native-driver bootstrap issues during render).
+    if (!didMount.current) {
+      didMount.current = true;
+      if (visible) {
+        measureAnchor();
+        if (trigger === 'press') {
+          if (autoHideTimer.current) clearTimeout(autoHideTimer.current);
+          autoHideTimer.current = setTimeout(() => {
+            handleHide();
+          }, PRESS_AUTO_HIDE_MS);
+        }
+      }
+      return () => {
+        if (autoHideTimer.current) {
+          clearTimeout(autoHideTimer.current);
+          autoHideTimer.current = null;
+        }
+      };
+    }
+    if (visible) {
+      measureAnchor();
+      Animated.parallel([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
+      }), Animated.timing(opacity, {
+        toValue: 1,
+        duration: theme.motion.duration.fast,
+        useNativeDriver: true
+      })]).start();
+      if (trigger === 'press') {
+        if (autoHideTimer.current) clearTimeout(autoHideTimer.current);
+        autoHideTimer.current = setTimeout(() => {
+          handleHide();
+        }, PRESS_AUTO_HIDE_MS);
+      }
+    } else {
+      Animated.parallel([Animated.timing(scale, {
+        toValue: 0.85,
+        duration: 150,
+        useNativeDriver: true
+      }), Animated.timing(opacity, {
+        toValue: 0,
+        duration: 150,
+        useNativeDriver: true
+      })]).start();
+      if (autoHideTimer.current) {
+        clearTimeout(autoHideTimer.current);
+        autoHideTimer.current = null;
+      }
+    }
+    return () => {
+      if (autoHideTimer.current) {
+        clearTimeout(autoHideTimer.current);
+        autoHideTimer.current = null;
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [visible]);
+  const handleContentLayout = e => {
+    const {
+      width,
+      height
+    } = e.nativeEvent.layout;
+    if (width !== size.width || height !== size.height) {
+      setSize({
+        width,
+        height
+      });
+    }
+  };
+  const position = useMemo(() => {
+    const screen = Dimensions.get('window');
+    if (!anchor) {
+      // Fallback before measurement: render off-screen-ish at top-left, will reposition on layout.
+      return {
+        top: SCREEN_PADDING,
+        left: SCREEN_PADDING,
+        placement: 'bottom',
+        arrowOffset: 0
+      };
+    }
+    const tooltipWidth = size.width || Math.min(maxWidth, screen.width - SCREEN_PADDING * 2);
+    const tooltipHeight = size.height || 0;
+
+    // Choose placement.
+    let resolved;
+    if (placement === 'auto') {
+      const space = {
+        top: anchor.y,
+        bottom: screen.height - (anchor.y + anchor.height),
+        left: anchor.x,
+        right: screen.width - (anchor.x + anchor.width)
+      };
+      const max = Math.max(space.top, space.bottom, space.left, space.right);
+      if (max === space.bottom) resolved = 'bottom';else if (max === space.top) resolved = 'top';else if (max === space.right) resolved = 'right';else resolved = 'left';
+    } else {
+      resolved = placement;
+    }
+    let top = 0;
+    let left = 0;
+    if (resolved === 'top') {
+      top = anchor.y - tooltipHeight - TOOLTIP_GAP;
+      left = anchor.x + anchor.width / 2 - tooltipWidth / 2;
+    } else if (resolved === 'bottom') {
+      top = anchor.y + anchor.height + TOOLTIP_GAP;
+      left = anchor.x + anchor.width / 2 - tooltipWidth / 2;
+    } else if (resolved === 'left') {
+      top = anchor.y + anchor.height / 2 - tooltipHeight / 2;
+      left = anchor.x - tooltipWidth - TOOLTIP_GAP;
+    } else {
+      top = anchor.y + anchor.height / 2 - tooltipHeight / 2;
+      left = anchor.x + anchor.width + TOOLTIP_GAP;
+    }
+
+    // Clamp to screen.
+    left = Math.max(SCREEN_PADDING, Math.min(left, screen.width - tooltipWidth - SCREEN_PADDING));
+    top = Math.max(SCREEN_PADDING, Math.min(top, screen.height - tooltipHeight - SCREEN_PADDING));
+
+    // Compute arrow offset along the card's trigger-facing edge so the caret stays
+    // pointing at the trigger even after the card is clamped to the viewport.
+    let arrowOffset = 0;
+    if (resolved === 'top' || resolved === 'bottom') {
+      const triggerCenterX = anchor.x + anchor.width / 2;
+      const desired = triggerCenterX - left; // x-offset from card's left edge
+      const min = ARROW_CORNER_PADDING;
+      const max = Math.max(min, tooltipWidth - ARROW_CORNER_PADDING);
+      arrowOffset = Math.max(min, Math.min(desired, max));
+    } else {
+      const triggerCenterY = anchor.y + anchor.height / 2;
+      const desired = triggerCenterY - top;
+      const min = ARROW_CORNER_PADDING;
+      const max = Math.max(min, tooltipHeight - ARROW_CORNER_PADDING);
+      arrowOffset = Math.max(min, Math.min(desired, max));
+    }
+    return {
+      top,
+      left,
+      placement: resolved,
+      arrowOffset
+    };
+  }, [anchor, size, placement, maxWidth]);
+
+  // Build the cloned trigger.
+  const triggerProps = {};
+  if (trigger === 'longPress') {
+    triggerProps.onLongPress = handleTrigger;
+    triggerProps.accessibilityHint = 'Long press for more info';
+  } else if (trigger === 'press') {
+    const childOnPress = children.props.onPress;
+    triggerProps.onPress = e => {
+      childOnPress?.(e);
+      handleTrigger(e);
+    };
+  }
+  const clonedChild = /*#__PURE__*/React.cloneElement(children, triggerProps);
+  const a11yLabel = accessibilityLabel ?? (typeof content === 'string' ? content : 'Tooltip');
+
+  // Arrow style: a CSS-triangle implemented via 0-width view with transparent
+  // borders. We rotate the base (placement='top' = arrow on bottom-edge pointing
+  // down) into the four cardinal orientations.
+  const arrowStyle = useMemo(() => {
+    if (!showArrow) return null;
+    const arrowColor = theme.colors.background.inverse;
+    const base = {
+      position: 'absolute',
+      width: 0,
+      height: 0,
+      backgroundColor: 'transparent',
+      borderStyle: 'solid',
+      borderLeftWidth: ARROW_HALF_WIDTH,
+      borderRightWidth: ARROW_HALF_WIDTH,
+      borderBottomWidth: ARROW_HEIGHT,
+      borderTopWidth: 0,
+      borderLeftColor: 'transparent',
+      borderRightColor: 'transparent',
+      borderTopColor: 'transparent',
+      borderBottomColor: arrowColor
+    };
+    if (position.placement === 'top') {
+      // Card is above trigger; arrow on bottom edge, pointing down.
+      return {
+        ...base,
+        bottom: -ARROW_HEIGHT,
+        left: position.arrowOffset - ARROW_HALF_WIDTH,
+        transform: [{
+          rotate: '180deg'
+        }]
+      };
+    }
+    if (position.placement === 'bottom') {
+      // Card below trigger; arrow on top edge, pointing up.
+      return {
+        ...base,
+        top: -ARROW_HEIGHT,
+        left: position.arrowOffset - ARROW_HALF_WIDTH
+      };
+    }
+    if (position.placement === 'left') {
+      // Card left of trigger; arrow on right edge, pointing right.
+      return {
+        ...base,
+        right: -ARROW_HEIGHT,
+        top: position.arrowOffset - ARROW_HALF_WIDTH,
+        transform: [{
+          rotate: '90deg'
+        }]
+      };
+    }
+    // 'right': card right of trigger; arrow on left edge, pointing left.
+    return {
+      ...base,
+      left: -ARROW_HEIGHT,
+      top: position.arrowOffset - ARROW_HALF_WIDTH,
+      transform: [{
+        rotate: '-90deg'
+      }]
+    };
+  }, [showArrow, position, theme]);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(View, {
+      ref: wrapperRef,
+      collapsable: false,
+      onLayout: measureAnchor,
+      testID: testID,
+      children: clonedChild
+    }), /*#__PURE__*/_jsx(Modal, {
+      visible: visible,
+      transparent: true,
+      statusBarTranslucent: true,
+      presentationStyle: "overFullScreen",
+      animationType: "none",
+      onRequestClose: handleHide,
+      children: /*#__PURE__*/_jsx(Pressable, {
+        style: StyleSheet.absoluteFill,
+        onPress: hideOnContentPress ? handleHide : undefined,
+        accessibilityLabel: "Close tooltip",
+        accessibilityRole: "button",
+        children: visible ? /*#__PURE__*/_jsxs(Animated.View, {
+          accessibilityRole: 'tooltip',
+          accessibilityLiveRegion: "polite",
+          accessibilityLabel: a11yLabel,
+          onLayout: handleContentLayout,
+          style: [{
+            position: 'absolute',
+            top: position.top,
+            left: position.left,
+            maxWidth,
+            opacity,
+            transform: [{
+              scale
+            }]
+          }, style],
+          children: [/*#__PURE__*/_jsx(View, {
+            style: [styles.tooltip, {
+              backgroundColor: theme.colors.background.inverse,
+              borderRadius: theme.radius.md,
+              paddingHorizontal: theme.spacing.md,
+              paddingVertical: theme.spacing.sm,
+              ...theme.shadows.lg,
+              shadowColor: theme.shadows.lg.shadowColor
+            }],
+            children: typeof content === 'string' ? /*#__PURE__*/_jsx(Text, {
+              style: {
+                color: theme.colors.text.inverse,
+                fontSize: theme.typography.fontSize.sm,
+                lineHeight: 18
+              },
+              children: content
+            }) : content
+          }), arrowStyle ? /*#__PURE__*/_jsx(View, {
+            style: arrowStyle,
+            pointerEvents: "none"
+          }) : null]
+        }) : null
+      })
+    })]
+  });
+};
+const buildStyles = _theme => StyleSheet.create({
+  tooltip: {
+    overflow: 'hidden'
+  }
+});
+export { Tooltip };
+export default Tooltip;
+//# sourceMappingURL=Tooltip.js.map

package/lib/module/components/Tooltip/index.js

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

package/lib/module/components/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+export { Accordion, AccordionGroup } from "./Accordion/index.js";
+export { Avatar, AvatarGroup } from "./Avatar/index.js";
+export { Badge } from "./Badge/index.js";
+export { Banner } from "./Banner/index.js";
+export { BottomNavigation } from "./BottomNavigation/index.js";
+export { BottomSheet } from "./BottomSheet/index.js";
+export { Button } from "./Button/index.js";
+export { Card } from "./Card/index.js";
+export { Carousel } from "./Carousel/index.js";
+export { Checkbox } from "./Checkbox/index.js";
+export { Chip } from "./Chip/index.js";
+export { DatePicker } from "./DatePicker/index.js";
+export { DateRangePicker } from "./DateRangePicker/index.js";
+export { Dialog } from "./Dialog/index.js";
+export { Divider } from "./Divider/index.js";
+export { Drawer } from "./Drawer/index.js";
+export { EmptyState } from "./EmptyState/index.js";
+export { Field } from "./Field/index.js";
+export { FAB, FABGroup } from "./FAB/index.js";
+export { ForceUpdateDialog } from "./ForceUpdateDialog/index.js";
+export { Header } from "./Header/index.js";
+export { Icon } from "./Icon/index.js";
+export { ImageGallery } from "./ImageGallery/index.js";
+export { Input } from "./Input/index.js";
+export { ListItem } from "./ListItem/index.js";
+export { LoadingSpinner } from "./LoadingSpinner/index.js";
+export { Modal } from "./Modal/index.js";
+export { NumberInput } from "./NumberInput/index.js";
+export { OTPInput } from "./OTPInput/index.js";
+export { ProgressBar } from "./ProgressBar/index.js";
+export { Radio, RadioGroup } from "./Radio/index.js";
+export { Rating } from "./Rating/index.js";
+export { SearchBar } from "./SearchBar/index.js";
+export { SegmentedControl } from "./SegmentedControl/index.js";
+export { Select } from "./Select/index.js";
+export { Stepper } from "./Stepper/index.js";
+export { Skeleton, SkeletonAvatar, SkeletonCard, SkeletonCircle, SkeletonContent, SkeletonListItem, SkeletonText } from "./SkeletonLoader/index.js";
+export { Slider } from "./Slider/index.js";
+export { Swipeable } from "./Swipeable/index.js";
+export { Switch } from "./Switch/index.js";
+export { Tabs } from "./Tabs/index.js";
+export { TimePicker } from "./TimePicker/index.js";
+export { Toast, ToastProvider, useToast, toast } from "./Toast/index.js";
+export { Tooltip } from "./Tooltip/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/config/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+/**
+ * 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'
+};
+let globalConfig = {
+  ...DEFAULT_CONFIG
+};
+
+/**
+ * Set global configuration for all Webority packages
+ */
+export const setConfig = config => {
+  globalConfig = {
+    ...globalConfig,
+    ...config
+  };
+};
+
+/**
+ * Get current configuration
+ */
+export const getConfig = () => globalConfig;
+
+/**
+ * Get a specific config value with optional fallback.
+ * If the stored value is `null`, the fallback is returned (when provided).
+ */
+
+export function getConfigValue(key, fallback) {
+  const value = globalConfig[key];
+  if (value !== null) {
+    return value;
+  }
+  return fallback;
+}
+
+/**
+ * Reset configuration to defaults
+ */
+export const resetConfig = () => {
+  globalConfig = {
+    ...DEFAULT_CONFIG
+  };
+};
+//# sourceMappingURL=index.js.map

package/lib/module/formatters/currency.js

@@ -0,0 +1,56 @@
+"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,148 @@
+"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 { formatDate, formatTime, formatDateTime, formatRelativeTime } from "./date.js";
+export { formatPhone, normalizePhone } from "./phone.js";
+export { formatCurrency } from "./currency.js";
+export { formatNumber, formatPercent, formatCompactNumber } from "./number.js";
+export { getInitials } from "./initials.js";
+//# sourceMappingURL=index.js.map