next-formatter 2.0.2 → 2.0.5

package/dist/esm/server.mjs

@@ -1,9 +1,234 @@
-import { FormattersProvider } from './client';
-import { createFormatters } from './core';
-import { resolveLocale, resolveCurrency } from './create';
+import { createContext, useMemo } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
-// src/server.tsx
+// src/client.tsx
+
+// src/core.ts
+var DEFAULT_RULES = {
+  compactThreshold: 1e4,
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2,
+  currencyDisplay: "narrowSymbol",
+  numberFormat: {},
+  dateFormat: { year: "numeric", month: "short", day: "2-digit" },
+  dateTimeFormat: {
+    year: "numeric",
+    month: "short",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true
+  }
+};
+function createFormatters(config = {}) {
+  const locale = config.locale ?? "en-US";
+  const defaultCurrency = config.currency ?? "USD";
+  const fallback = config.fallback ?? "\u2014";
+  const rules = {
+    ...DEFAULT_RULES,
+    ...config.rules
+  };
+  function toNumber(value) {
+    if (value == null || value === "") return null;
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isNaN(n) ? null : n;
+  }
+  function toValidDate(value) {
+    if (value == null || value === "") return null;
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  function isLarge(n) {
+    return Math.abs(n) >= rules.compactThreshold;
+  }
+  function normalizeICU(str) {
+    return str.replace(/\u202f/g, " ").replace(/\u00a0/g, " ").trim();
+  }
+  function alignFractionDigits(opts) {
+    const { minimumFractionDigits, maximumFractionDigits, maximumSignificantDigits, minimumSignificantDigits } = opts;
+    if (minimumFractionDigits !== void 0 && maximumFractionDigits !== void 0 && minimumFractionDigits !== maximumFractionDigits && maximumSignificantDigits === void 0 && minimumSignificantDigits === void 0) {
+      return { ...opts, minimumFractionDigits: maximumFractionDigits };
+    }
+    return opts;
+  }
+  const numberCache = /* @__PURE__ */ new Map();
+  function getNumberFormatter(options) {
+    const key = JSON.stringify({ locale, ...options });
+    if (!numberCache.has(key)) {
+      numberCache.set(key, new Intl.NumberFormat(locale, options));
+    }
+    return numberCache.get(key);
+  }
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto", style: "long" });
+  const formatters = {
+    /**
+     * Format a plain number.
+     * @example
+     * fmt.number(1234567)                              // "1.2M"
+     * fmt.number(1234, { notation: "standard" })       // "1,234"
+     * fmt.number(1.5678, { maximumFractionDigits: 1 }) // "1.6"
+     */
+    number(value, options = {}) {
+      const n = toNumber(value);
+      if (n == null) return fallback;
+      return normalizeICU(
+        getNumberFormatter(
+          alignFractionDigits({
+            style: "decimal",
+            notation: isLarge(n) ? "compact" : "standard",
+            minimumFractionDigits: rules.minimumFractionDigits,
+            maximumFractionDigits: rules.maximumFractionDigits,
+            ...rules.numberFormat,
+            ...options
+          })
+        ).format(n)
+      );
+    },
+    /**
+     * Format a currency value.
+     * @example
+     * fmt.currency(49900)                                // "$49.9K"
+     * fmt.currency(1234, { currency: "EUR" })            // "€1,234"
+     * fmt.currency(1234, { currencyDisplay: "code" })    // "USD 1,234"
+     * fmt.currency(1234, { minimumFractionDigits: 2 })   // "$1,234.00"
+     */
+    currency(value, options = {}) {
+      const n = toNumber(value);
+      if (n == null) return fallback;
+      const { currency: overrideCurrency, currencyDisplay, ...rest } = options;
+      return normalizeICU(
+        getNumberFormatter(
+          alignFractionDigits({
+            style: "currency",
+            currency: overrideCurrency ?? defaultCurrency,
+            notation: isLarge(n) ? "compact" : "standard",
+            minimumFractionDigits: rules.minimumFractionDigits,
+            maximumFractionDigits: rules.maximumFractionDigits,
+            currencyDisplay: currencyDisplay ?? rules.currencyDisplay,
+            ...rules.numberFormat,
+            ...rest
+          })
+        ).format(n)
+      );
+    },
+    /**
+     * Format a percentage. Input is treated as a raw percentage (50 → "50%").
+     * Uses minimumFractionDigits and maximumFractionDigits from rules.
+     * For values that would round to zero, maximumSignificantDigits is set to
+     * max(maximumFractionDigits, 4) to preserve meaningful precision.
+     * @example
+     * fmt.percentage(12.5)   // "12.50%" (with default rules min=0, max=2 → aligned to 2)
+     * fmt.percentage(0.001)  // "0.001%" (wouldBeZero → uses significantDigits)
+     * fmt.percentage(12.5, { maximumFractionDigits: 0 }) // "13%"
+     */
+    percentage(value, options = {}) {
+      const n = toNumber(value);
+      if (n == null) return fallback;
+      const normalized = n / 100;
+      const wouldBeZero = parseFloat(normalized.toFixed(3)) === 0;
+      const sigDigits = Math.max(rules.maximumFractionDigits, 4);
+      return getNumberFormatter({
+        style: "percent",
+        ...wouldBeZero ? { maximumSignificantDigits: sigDigits } : alignFractionDigits({
+          minimumFractionDigits: rules.minimumFractionDigits,
+          maximumFractionDigits: rules.maximumFractionDigits
+        }),
+        ...options
+      }).format(normalized);
+    },
+    /**
+     * Format a duration in seconds. Pure math — no Intl, no ICU risk.
+     * @example
+     * fmt.duration(150)  // "2m 30s"
+     * fmt.duration(45)   // "45s"
+     */
+    duration(value) {
+      const n = toNumber(value);
+      if (n == null) return fallback;
+      const mins = Math.floor(n / 60);
+      const secs = n % 60;
+      return mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+    },
+    /**
+     * Format a date.
+     * @example
+     * fmt.date("2024-01-15")                        // "Jan 15, 2024"
+     * fmt.date("2024-01-15", { dateStyle: "full" }) // "Monday, January 15, 2024"
+     */
+    date(value, options = {}) {
+      const date = toValidDate(value);
+      if (!date) return fallback;
+      const resolvedOptions = options.dateStyle ? options : { ...rules.dateFormat, ...options };
+      return normalizeICU(new Intl.DateTimeFormat(locale, resolvedOptions).format(date));
+    },
+    dateTime(value, options = {}) {
+      const date = toValidDate(value);
+      if (!date) return fallback;
+      const resolvedOptions = options.dateStyle || options.timeStyle ? options : { ...rules.dateTimeFormat, ...options };
+      return normalizeICU(new Intl.DateTimeFormat(locale, resolvedOptions).format(date));
+    },
+    /**
+     * Format a date as relative time.
+     * Always pass an explicit `now` timestamp — this ensures consistent
+     * output whether called from a server or client component.
+     * @example
+     * const now = Date.now();
+     * fmt.relativeTime("2024-01-15", now) // "3 months ago"
+     */
+    relativeTime(value, now = Date.now()) {
+      const date = toValidDate(value);
+      if (!date) return fallback;
+      const diffSec = Math.round((date.getTime() - now) / 1e3);
+      const abs = Math.abs(diffSec);
+      if (abs < 60) return rtf.format(diffSec, "second");
+      const min = Math.round(diffSec / 60);
+      if (Math.abs(min) < 60) return rtf.format(min, "minute");
+      const hr = Math.round(min / 60);
+      if (Math.abs(hr) < 24) return rtf.format(hr, "hour");
+      const day = Math.round(hr / 24);
+      if (Math.abs(day) < 7) return rtf.format(day, "day");
+      const week = Math.round(day / 7);
+      if (Math.abs(week) < 4) return rtf.format(week, "week");
+      const month = Math.round(day / 30);
+      if (Math.abs(month) < 12) return rtf.format(month, "month");
+      const year = Math.round(day / 365);
+      return rtf.format(year, "year");
+    }
+  };
+  return formatters;
+}
+var FormatterContext = createContext(null);
+function FormattersProvider({ config, children }) {
+  const formatters = useMemo(
+    () => createFormatters(config),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [config.locale, config.currency, config.fallback, JSON.stringify(config.rules)]
+  );
+  return /* @__PURE__ */ jsx(FormatterContext.Provider, { value: formatters, children });
+}
+
+// src/create.ts
+async function resolveLocale(resolver, defaultLocale) {
+  const resolved = await resolver?.();
+  if (resolved) return resolved;
+  if (defaultLocale) return defaultLocale;
+  try {
+    const { headers } = await import('next/headers');
+    const h = await headers();
+    const acceptLanguage = h.get("accept-language");
+    if (acceptLanguage) {
+      const locale = acceptLanguage.split(",")[0]?.trim().split(";")[0]?.trim();
+      if (locale) return locale;
+    }
+  } catch {
+  }
+  return "en-US";
+}
+async function resolveCurrency(resolver, defaultCurrency) {
+  const resolved = await resolver?.();
+  if (resolved) return resolved;
+  return defaultCurrency ?? "USD";
+}
 async function NextFormatterProvider({ config = {}, children }) {
   const locale = await resolveLocale(config.getLocale, config.locale);
   const currency = await resolveCurrency(config.getCurrency, config.currency);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-formatter",
-  "version": "2.0.2",
+  "version": "2.0.5",
   "description": "A universal formatter for numbers, currency, dates, and relative time — built for Next.js App Router, supporting server components, client components, and Node.js backends.",
   "author": "gauravgorade",
   "license": "MIT",
@@ -46,10 +46,7 @@
   "bugs": {
     "url": "https://github.com/gauravgorade/next-formatter/issues"
   },
-  "sideEffects": [
-    "./dist/esm/client.mjs",
-    "./dist/cjs/client.js"
-  ],
+  "sideEffects": false,
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
   "types": "./dist/types/index.d.ts",
@@ -68,16 +65,6 @@
       "types": "./dist/types/client.d.ts",
       "import": "./dist/esm/client.mjs",
       "require": "./dist/cjs/client.js"
-    },
-    "./core": {
-      "types": "./dist/types/core.d.ts",
-      "import": "./dist/esm/core.mjs",
-      "require": "./dist/cjs/core.js"
-    },
-    "./create": {
-      "types": "./dist/types/create.d.ts",
-      "import": "./dist/esm/create.mjs",
-      "require": "./dist/cjs/create.js"
     }
   },
   "files": [
@@ -102,15 +89,11 @@
   },
   "peerDependencies": {
     "next": ">=14.0.0",
-    "react": ">=18.3.0",
-    "@types/react": ">=18.3.0"
+    "react": ">=18.3.0"
   },
   "peerDependenciesMeta": {
     "next": {
       "optional": true
-    },
-    "@types/react": {
-      "optional": true
     }
   }
 }

package/dist/cjs/core.js

@@ -1,198 +0,0 @@
-'use strict';
-
-// src/core.ts
-var DEFAULT_RULES = {
-  compactThreshold: 1e4,
-  minimumFractionDigits: 0,
-  maximumFractionDigits: 2,
-  currencyDisplay: "narrowSymbol",
-  numberFormat: {},
-  dateFormat: { year: "numeric", month: "short", day: "2-digit" },
-  dateTimeFormat: {
-    year: "numeric",
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: true
-  }
-};
-function createFormatters(config = {}) {
-  const locale = config.locale ?? "en-US";
-  const defaultCurrency = config.currency ?? "USD";
-  const fallback = config.fallback ?? "\u2014";
-  const rules = {
-    ...DEFAULT_RULES,
-    ...config.rules
-  };
-  function toNumber(value) {
-    if (value == null || value === "") return null;
-    const n = typeof value === "number" ? value : Number(value);
-    return Number.isNaN(n) ? null : n;
-  }
-  function toValidDate(value) {
-    if (value == null || value === "") return null;
-    const date = value instanceof Date ? value : new Date(value);
-    return Number.isNaN(date.getTime()) ? null : date;
-  }
-  function isLarge(n) {
-    return Math.abs(n) >= rules.compactThreshold;
-  }
-  function normalizeICU(str) {
-    return str.replace(/\u202f/g, " ").replace(/\u00a0/g, " ").trim();
-  }
-  function alignFractionDigits(opts) {
-    const { minimumFractionDigits, maximumFractionDigits, maximumSignificantDigits, minimumSignificantDigits } = opts;
-    if (minimumFractionDigits !== void 0 && maximumFractionDigits !== void 0 && minimumFractionDigits !== maximumFractionDigits && maximumSignificantDigits === void 0 && minimumSignificantDigits === void 0) {
-      return { ...opts, minimumFractionDigits: maximumFractionDigits };
-    }
-    return opts;
-  }
-  const numberCache = /* @__PURE__ */ new Map();
-  function getNumberFormatter(options) {
-    const key = JSON.stringify({ locale, ...options });
-    if (!numberCache.has(key)) {
-      numberCache.set(key, new Intl.NumberFormat(locale, options));
-    }
-    return numberCache.get(key);
-  }
-  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto", style: "long" });
-  const formatters = {
-    /**
-     * Format a plain number.
-     * @example
-     * fmt.number(1234567)                              // "1.2M"
-     * fmt.number(1234, { notation: "standard" })       // "1,234"
-     * fmt.number(1.5678, { maximumFractionDigits: 1 }) // "1.6"
-     */
-    number(value, options = {}) {
-      const n = toNumber(value);
-      if (n == null) return fallback;
-      return normalizeICU(
-        getNumberFormatter(
-          alignFractionDigits({
-            style: "decimal",
-            notation: isLarge(n) ? "compact" : "standard",
-            minimumFractionDigits: rules.minimumFractionDigits,
-            maximumFractionDigits: rules.maximumFractionDigits,
-            ...rules.numberFormat,
-            ...options
-          })
-        ).format(n)
-      );
-    },
-    /**
-     * Format a currency value.
-     * @example
-     * fmt.currency(49900)                                // "$49.9K"
-     * fmt.currency(1234, { currency: "EUR" })            // "€1,234"
-     * fmt.currency(1234, { currencyDisplay: "code" })    // "USD 1,234"
-     * fmt.currency(1234, { minimumFractionDigits: 2 })   // "$1,234.00"
-     */
-    currency(value, options = {}) {
-      const n = toNumber(value);
-      if (n == null) return fallback;
-      const { currency: overrideCurrency, currencyDisplay, ...rest } = options;
-      return normalizeICU(
-        getNumberFormatter(
-          alignFractionDigits({
-            style: "currency",
-            currency: overrideCurrency ?? defaultCurrency,
-            notation: isLarge(n) ? "compact" : "standard",
-            minimumFractionDigits: rules.minimumFractionDigits,
-            maximumFractionDigits: rules.maximumFractionDigits,
-            currencyDisplay: currencyDisplay ?? rules.currencyDisplay,
-            ...rules.numberFormat,
-            ...rest
-          })
-        ).format(n)
-      );
-    },
-    /**
-     * Format a percentage. Input is treated as a raw percentage (50 → "50%").
-     * Uses minimumFractionDigits and maximumFractionDigits from rules.
-     * For values that would round to zero, maximumSignificantDigits is set to
-     * max(maximumFractionDigits, 4) to preserve meaningful precision.
-     * @example
-     * fmt.percentage(12.5)   // "12.50%" (with default rules min=0, max=2 → aligned to 2)
-     * fmt.percentage(0.001)  // "0.001%" (wouldBeZero → uses significantDigits)
-     * fmt.percentage(12.5, { maximumFractionDigits: 0 }) // "13%"
-     */
-    percentage(value, options = {}) {
-      const n = toNumber(value);
-      if (n == null) return fallback;
-      const normalized = n / 100;
-      const wouldBeZero = parseFloat(normalized.toFixed(3)) === 0;
-      const sigDigits = Math.max(rules.maximumFractionDigits, 4);
-      return getNumberFormatter({
-        style: "percent",
-        ...wouldBeZero ? { maximumSignificantDigits: sigDigits } : alignFractionDigits({
-          minimumFractionDigits: rules.minimumFractionDigits,
-          maximumFractionDigits: rules.maximumFractionDigits
-        }),
-        ...options
-      }).format(normalized);
-    },
-    /**
-     * Format a duration in seconds. Pure math — no Intl, no ICU risk.
-     * @example
-     * fmt.duration(150)  // "2m 30s"
-     * fmt.duration(45)   // "45s"
-     */
-    duration(value) {
-      const n = toNumber(value);
-      if (n == null) return fallback;
-      const mins = Math.floor(n / 60);
-      const secs = n % 60;
-      return mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
-    },
-    /**
-     * Format a date.
-     * @example
-     * fmt.date("2024-01-15")                        // "Jan 15, 2024"
-     * fmt.date("2024-01-15", { dateStyle: "full" }) // "Monday, January 15, 2024"
-     */
-    date(value, options = {}) {
-      const date = toValidDate(value);
-      if (!date) return fallback;
-      const resolvedOptions = options.dateStyle ? options : { ...rules.dateFormat, ...options };
-      return normalizeICU(new Intl.DateTimeFormat(locale, resolvedOptions).format(date));
-    },
-    dateTime(value, options = {}) {
-      const date = toValidDate(value);
-      if (!date) return fallback;
-      const resolvedOptions = options.dateStyle || options.timeStyle ? options : { ...rules.dateTimeFormat, ...options };
-      return normalizeICU(new Intl.DateTimeFormat(locale, resolvedOptions).format(date));
-    },
-    /**
-     * Format a date as relative time.
-     * Always pass an explicit `now` timestamp — this ensures consistent
-     * output whether called from a server or client component.
-     * @example
-     * const now = Date.now();
-     * fmt.relativeTime("2024-01-15", now) // "3 months ago"
-     */
-    relativeTime(value, now = Date.now()) {
-      const date = toValidDate(value);
-      if (!date) return fallback;
-      const diffSec = Math.round((date.getTime() - now) / 1e3);
-      const abs = Math.abs(diffSec);
-      if (abs < 60) return rtf.format(diffSec, "second");
-      const min = Math.round(diffSec / 60);
-      if (Math.abs(min) < 60) return rtf.format(min, "minute");
-      const hr = Math.round(min / 60);
-      if (Math.abs(hr) < 24) return rtf.format(hr, "hour");
-      const day = Math.round(hr / 24);
-      if (Math.abs(day) < 7) return rtf.format(day, "day");
-      const week = Math.round(day / 7);
-      if (Math.abs(week) < 4) return rtf.format(week, "week");
-      const month = Math.round(day / 30);
-      if (Math.abs(month) < 12) return rtf.format(month, "month");
-      const year = Math.round(day / 365);
-      return rtf.format(year, "year");
-    }
-  };
-  return formatters;
-}
-
-exports.createFormatters = createFormatters;

package/dist/cjs/create.js

@@ -1,27 +0,0 @@
-'use strict';
-
-// src/create.ts
-async function resolveLocale(resolver, defaultLocale) {
-  const resolved = await resolver?.();
-  if (resolved) return resolved;
-  if (defaultLocale) return defaultLocale;
-  try {
-    const { headers } = await import('next/headers');
-    const h = await headers();
-    const acceptLanguage = h.get("accept-language");
-    if (acceptLanguage) {
-      const locale = acceptLanguage.split(",")[0]?.trim().split(";")[0]?.trim();
-      if (locale) return locale;
-    }
-  } catch {
-  }
-  return "en-US";
-}
-async function resolveCurrency(resolver, defaultCurrency) {
-  const resolved = await resolver?.();
-  if (resolved) return resolved;
-  return defaultCurrency ?? "USD";
-}
-
-exports.resolveCurrency = resolveCurrency;
-exports.resolveLocale = resolveLocale;