numora 3.0.2 → 3.2.0

package/dist/types.d.ts

@@ -6,7 +6,8 @@ export declare enum ThousandStyle {
     None = "none",
     Thousand = "thousand",
     Lakh = "lakh",
-    Wan = "wan"
+    Wan = "wan",
+    Locale = "locale"
 }
 export interface FormattingOptions {
     formatOn?: FormatOn;

package/dist/utils/locale.d.ts

@@ -0,0 +1,14 @@
+import { ThousandStyle } from '../types';
+export declare function getSeparatorsFromLocale(locale?: string): {
+    thousandSeparator: string;
+    decimalSeparator: string;
+};
+export declare function resolveLocaleOptions(options: {
+    thousandSeparator?: string;
+    thousandStyle?: ThousandStyle;
+    decimalSeparator?: string;
+}): {
+    thousandSeparator: string;
+    thousandStyle: ThousandStyle;
+    decimalSeparator: string;
+};

package/dist/utils/regex-cache.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Regex caching utility for performance optimization.
+ * Caches compiled RegExp objects to avoid recompilation on every function call.
+ */
+/**
+ * Gets a cached RegExp or creates and caches a new one.
+ * Use this for dynamic patterns that depend on user input (e.g., separators).
+ *
+ * @param pattern - The regex pattern string
+ * @param flags - Optional regex flags (default: 'g')
+ * @returns A cached RegExp object
+ *
+ * @example
+ * // Instead of: new RegExp(escapeRegExp(separator), 'g')
+ * getCachedRegex(escapeRegExp(separator), 'g')
+ */
+export declare function getCachedRegex(pattern: string, flags?: string): RegExp;
+/**
+ * Gets a cached RegExp for a separator character.
+ * Handles escaping of special regex characters automatically.
+ *
+ * @param separator - The separator character to match
+ * @param flags - Optional regex flags (default: 'g')
+ * @returns A cached RegExp object that matches the separator
+ *
+ * @example
+ * getCachedSeparatorRegex(',') // Returns cached /,/g
+ * getCachedSeparatorRegex('.') // Returns cached /\./g (escaped)
+ */
+export declare function getCachedSeparatorRegex(separator: string, flags?: string): RegExp;
+/**
+ * Clears the regex cache.
+ * Useful for testing or when separator configuration changes significantly.
+ */
+export declare function clearRegexCache(): void;
+/**
+ * Gets the current size of the regex cache.
+ * Useful for debugging and monitoring.
+ */
+export declare function getRegexCacheSize(): number;

package/dist/validation.d.ts

@@ -1,5 +1,4 @@
-import { FormatOn } from './types';
-import { ThousandStyle } from './types';
+import { FormatOn, ThousandStyle } from './types';
 export interface NumoraInputValidationOptions {
     decimalMaxLength?: number;
     decimalMinLength?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "numora",
-  "version": "3.0.2",
-  "description": "Precision-first numeric input library for DeFi and financial applications",
+  "version": "3.2.0",
+  "description": "Framework-agnostic numeric input library for DeFi and financial apps",
   "homepage": "https://numora.xyz/",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,16 +52,18 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^22.13.11",
+    "fast-check": "^3.15.0",
     "jsdom": "^26.0.0",
     "typescript": "^5.8.2",
     "vite": "^6.2.2",
     "vitest": "^3.0.9"
   },
+  "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "vite build & tsc --emitDeclarationOnly",
+    "build": "vite build && tsc --emitDeclarationOnly",
     "test": "vitest run",
     "dev": "vite build --watch"
   }

package/dist/features/formatting/character-equivalence.d.ts

@@ -1,9 +0,0 @@
-/**
- * Character equivalence utilities for cursor position calculation.
- */
-import type { IsCharacterEquivalent } from './cursor-position';
-/**
- * Default character equivalence function.
- * Only considers identical characters as equivalent.
- */
-export declare const defaultIsCharacterEquivalent: IsCharacterEquivalent;

package/dist/features/formatting/large-number.d.ts

@@ -1,39 +0,0 @@
-/**
- * Large number formatting utilities for displaying numbers with scale notation (k, M, T, etc.).
- * These are display-only utilities, not for input formatting.
- */
-import { ThousandStyle } from '@/types';
-export interface FormatLargeNumberOptions {
-    /** Minimum scale threshold - only apply scale notation above this (default: 0, meaning always apply if applicable) */
-    minScale?: number;
-    /** Under what value should decimals be shown (default: 1000) */
-    decimalsUnder?: number;
-    /** Maximum decimal places to show (default: 2) */
-    decimals?: number;
-    /** Minimum decimal places to show (default: 0) */
-    decimalsMin?: number;
-    /** Show minimum decimals even when value is 0 (default: false) */
-    decimalsMinAppliesToZero?: boolean;
-    /** Placeholder for very large numbers that exceed our scale notation (default: '🔥') */
-    veryLargePlaceholder?: string;
-    /** Decimal separator (default: '.') */
-    decimalSeparator?: string;
-    /** Thousand separator for formatting (optional) */
-    thousandSeparator?: string;
-    /** Thousand grouping style (default: None) */
-    thousandStyle?: ThousandStyle;
-}
-/**
- * Formats a large number with scale notation (k, M, T, etc.) for display.
- *
- * @param value - The numeric string value to format
- * @param options - Optional formatting options
- * @returns The formatted string with scale suffix if applicable
- *
- * @example
- * formatLargeNumber("123")        // "123"
- * formatLargeNumber("1234")        // "1.23k"
- * formatLargeNumber("1234567")    // "1.23M"
- * formatLargeNumber("0")          // "0"
- */
-export declare function formatLargeNumber(value: string, options?: FormatLargeNumberOptions): string;

package/dist/features/formatting/numeric-formatting-utils.d.ts

@@ -1,24 +0,0 @@
-/**
- * Common utilities for numeric formatting.
- */
-/**
- * Checks if a numeric string represents a very large number.
- */
-export declare function isVeryLarge(value: string): boolean;
-/**
- * Compares two numeric strings using string comparison.
- * Returns negative if a < b, positive if a > b, 0 if equal.
- * Uses string-based comparison to avoid precision issues.
- */
-export declare function compareStrings(a: string, b: string): number;
-/**
- * Applies scale notation to a numeric string.
- */
-export declare function applyScaleNotation(value: string, decimalSeparator: string, minScale?: number): {
-    scaledValue: string;
-    scaleSuffix: string;
-};
-/**
- * Helper for applying decimal precision and handling trailing zeros.
- */
-export declare function applyDecimalPrecision(value: string, decimals: number, decimalsMin: number, decimalSeparator: string, decimalsMinAppliesToZero?: boolean, isZeroValue?: boolean): string;

package/dist/features/formatting/percent.d.ts

@@ -1,45 +0,0 @@
-/**
- * Percent formatting utilities for displaying numeric values as percentages.
- * All functions use string arithmetic to avoid precision loss.
- */
-import { ThousandStyle } from '@/types';
-/**
- * Formats a decimal value as a percentage string.
- * Input is expected as a decimal (e.g., 0.01 represents 1%).
- *
- * @param value - The numeric string value (as decimal, e.g., "0.01" for 1%)
- * @param decimals - Number of decimal places to show (default: 2)
- * @param decimalSeparator - The decimal separator character (default: '.')
- * @param thousandSeparator - Optional thousand separator for large percentages
- * @param thousandStyle - Optional thousand grouping style
- * @returns The formatted percentage string (e.g., "1.00%")
- *
- * @example
- * formatPercent("0.01", 2)        // "1.00%"
- * formatPercent("0.1234", 2)      // "12.34%"
- * formatPercent("1", 0)           // "100%"
- * formatPercent("0", 2)            // "0%"
- */
-export declare function formatPercent(value: string, decimals?: number, decimalSeparator?: string, thousandSeparator?: string, thousandStyle?: ThousandStyle): string;
-/**
- * Formats a large percentage value with scale notation (k, M, T, etc.) for very large percentages.
- * Input is expected as a decimal (e.g., 0.01 represents 1%).
- *
- * @param value - The numeric string value (as decimal, e.g., "0.01" for 1%)
- * @param decimals - Number of decimal places to show for values under threshold (default: 2)
- * @param options - Optional formatting options
- * @returns The formatted percentage string with scale suffix if needed (e.g., "1.23M%")
- *
- * @example
- * formatLargePercent("0.01", 2)           // "1.00%"
- * formatLargePercent("1000", 2)           // "100000%"
- * formatLargePercent("1000000", 2)       // "100M%"
- */
-export declare function formatLargePercent(value: string | null | undefined, decimals?: number, options?: {
-    missingPlaceholder?: string;
-    veryLargePlaceholder?: string;
-    decimalsUnder?: number;
-    decimalSeparator?: string;
-    thousandSeparator?: string;
-    thousandStyle?: ThousandStyle;
-}): string;

package/dist/features/formatting/subscript-notation.d.ts

@@ -1,20 +0,0 @@
-/**
- * Subscript notation utilities for condensing leading decimal zeros.
- * Converts very small numbers like 0.000001 to 0₆1 for better readability.
- */
-/**
- * Condenses leading decimal zeros in a numeric string to subscript notation.
- * For example: 0.000001 → 0₆1 (meaning 6 leading zeros)
- *
- * @param value - The numeric string value to condense
- * @param maxDecimalDigits - Maximum number of decimal digits to show after condensation
- * @param decimalSeparator - The decimal separator character (default: '.')
- * @returns The condensed string with subscript notation for leading zeros
- *
- * @example
- * condenseDecimalZeros("0.000001", 8)     // "0₆1"
- * condenseDecimalZeros("0.000123", 8)     // "0₃123"
- * condenseDecimalZeros("1.000001", 8)     // "1.000001" (no leading zeros to condense)
- * condenseDecimalZeros("0.123", 8)        // "0.123" (not enough zeros to condense)
- */
-export declare function condenseDecimalZeros(value: string, maxDecimalDigits?: number, decimalSeparator?: string): string;