ts-packages 1.0.0 → 3.0.0

package/packages/errors-utils/src/middleware/express/errorConverter.middleware.ts

@@ -0,0 +1,52 @@
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
+import type { NextFunction, Request, Response } from 'express'
+import { ERROR_CODES, type ErrorCode } from '../../constants'
+import { AppError } from '../../error/AppError'
+
+export function errorConverter(
+	err: unknown,
+	_req: Request,
+	_res: Response,
+	next: NextFunction,
+) {
+	// 1. Already a known AppError → pass through
+	if (err instanceof AppError) {
+		return next(err)
+	}
+
+	let code: ErrorCode = ERROR_CODES.INTERNAL_SERVER_ERROR
+	let statusCode: number = HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR
+	let details: unknown = undefined
+	let cause: Error | undefined = undefined
+
+	// 2. Handle unknown objects safely
+	if (typeof err === 'object' && err !== null) {
+		const e = err as Record<string, unknown>
+
+		if (typeof e.code === 'string' && e.code in ERROR_CODES) {
+			code = e.code as ErrorCode
+		}
+
+		if (typeof e.statusCode === 'number') {
+			statusCode = e.statusCode
+		}
+
+		if ('details' in e) {
+			details = e.details
+		}
+
+		if (err instanceof Error) {
+			cause = err
+		}
+	}
+
+	// 3. Handle string errors
+	if (typeof err === 'string') {
+		details = err
+	}
+
+	// 4. Convert to AppError
+	const convertedError = new AppError(code, statusCode, details, cause)
+
+	next(convertedError)
+}

package/packages/errors-utils/src/middleware/express/errorHandler.middleware.ts

@@ -0,0 +1,32 @@
+import { ExpressResponder, HTTP_STATUS } from '@naman_deep_singh/response-utils'
+import type { NextFunction, Request, Response } from 'express'
+import { errorMessageRegistry } from 'src/errorRegistry'
+import { ERROR_CODES } from '../../constants'
+import { AppError } from '../../error/AppError'
+
+export function expressErrorHandler(
+	err: unknown,
+	_req: Request,
+	res: Response,
+	_next: NextFunction,
+) {
+	const responder = new ExpressResponder({}, res)
+
+	// 1. Known operational error
+	if (err instanceof AppError) {
+		return errorMessageRegistry.mapAppErrorToResponder(responder, err)
+	}
+
+	// 2. Log unexpected errors (never expose internals in prod)
+	console.error('UNEXPECTED ERROR:', err)
+
+	// 3. Normalize unknown error → AppError
+	const internalError = new AppError(
+		ERROR_CODES.INTERNAL_SERVER_ERROR,
+		HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR,
+		process.env.NODE_ENV === 'production' ? undefined : err,
+		err instanceof Error ? err : undefined,
+	)
+
+	return errorMessageRegistry.mapAppErrorToResponder(responder, internalError)
+}

package/packages/errors-utils/src/middleware/express/index.ts

@@ -0,0 +1,2 @@
+export * from './errorHandler.middleware'
+export * from './errorConverter.middleware'

package/packages/errors-utils/tsconfig.base.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    }
+  },
+  "include": ["src/**/*"]
+}

package/packages/errors-utils/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "rootDir": "./src",
+    "outDir": "./dist/cjs"
+  }
+}

package/packages/errors-utils/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "rootDir": "./src",
+    "outDir": "./dist/esm"
+  }
+}

package/packages/errors-utils/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/js-extensions/README.md

@@ -0,0 +1,218 @@
+@naman_deep_singh/js-extensions
+
+Version: 1.4.0
+
+Universal JavaScript prototype extensions for common development utilities. Works in both Node.js and browser environments with 70+ utility methods.
+
+⚠️ This library extends native prototypes (String, Array, Object, Number). Use consciously in shared or library code.
+
+---
+
+## Installation
+```bash
+npm install @naman_deep_singh/js-extensions
+# or
+pnpm add @naman_deep_singh/js-extensions
+Quick Start
+import { initializeExtensions } from '@naman_deep_singh/js-extensions';
+
+// Initialize all extensions
+initializeExtensions();
+
+// String utilities
+"hello world".toCapitalize();       // "Hello world"
+"hello world".capitalizeWords();    // "Hello World"
+"hello world".reverseWords();       // "world hello"
+"test@email.com".isEmail();         // true
+"hello world".words();              // ["hello", "world"]
+
+// Array utilities
+[1, 2, 2, 3].unique();              // [1, 2, 3]
+[1, 2, 3, 4, 5].chunk(2);           // [[1,2],[3,4],[5]]
+[1, 2, 3].sample();                 // random element
+[1,2,3,4].last();                   // 4
+[{id:1},{id:2},{id:1}].uniqueBy(x => x.id); // [{id:1},{id:2}]
+[3,1,2].sortBy(x => x);             // [1,2,3]
+
+// Number utilities
+(42).toOrdinal();                    // "42nd"
+(0.75).toPercent();                  // "75.00%"
+(3.14159).toFixedNumber(2);          // 3.14
+(5).randomUpTo();                    // 0..5 random number
+(5).times(i => console.log(i));      // 0..4
+
+// Object utilities
+({ a: 1, b: 2 }).pick(['a']);        // { a: 1 }
+({ a: 1, b: 2 }).mapValues(v => v * 2); // { a: 2, b: 4 }
+({ a: 1, b: 2 }).mapKeys(k => k + "_"); // { a_: 1, b_: 2 }
+({}).isEmpty();                       // true
+({ user: { name: "John" } }).getPath('user.name'); // "John"
+({ a: 1, b: 2 }).filterKeys(k => k === 'a'); // { a: 1 }
+({ a: 1, b: 2 }).filterValues(v => v === 1); // { a: 1 }
+Error Handling & Validation
+All methods include strict runtime validation and throw clear native errors.
+
+"hello".count(123);
+// TypeError: count: substring must be a string, got number
+
+"hello".count("");
+// TypeError: count: substring cannot be empty
+
+[].sum();
+// TypeError: sum: array must contain at least one number
+
+({ a: 1 }).pick(null as any);
+// TypeError: pick: keys must be an array, got object
+
+(3.14).round(-1);
+// TypeError: round: decimals must be a non-negative integer, got -1
+Error Types Used
+
+TypeError – invalid type or missing argument
+
+RangeError – out-of-range numeric values (e.g. toRoman)
+
+✅ No custom error classes are exposed — only standard JS errors.
+
+Configuration
+Selective Extension Loading
+import { initializeExtensions, extend } from '@naman_deep_singh/js-extensions';
+
+// Enable only specific prototypes
+initializeExtensions({
+  string: true,
+  array: true,
+  object: false,
+  number: false,
+});
+
+// Or initialize individually
+extend.string();
+extend.array();
+Performance Configuration
+Caching System
+import { setPerformanceConfig } from '@naman_deep_singh/js-extensions';
+
+setPerformanceConfig({
+  enableCaching: true,
+  maxCacheSize: 200,
+});
+Notes:
+
+Validation cannot be disabled
+
+Caching is optional
+
+Uses a simple LRU cache
+
+String Extensions (21 methods)
+Case Conversion
+
+"hello world".toCapitalize();    // "Hello world"
+"hello world".capitalizeWords(); // "Hello World"
+"hello-world".toCamelCase();     // "helloWorld"
+"HelloWorld".toKebabCase();      // "hello-world"
+"Hello World".toSnakeCase();     // "hello_world"
+"hello world".toTitleCase();     // "Hello World"
+Validation & Checks
+
+"test@example.com".isEmail();   // true
+"https://example.com".isUrl();  // true
+"racecar".isPalindrome();       // true
+Text Utilities
+
+"Long text here".truncate(8);        // "Long tex..."
+"hello world".truncateWords(1);      // "hello..."
+"hello world".removeWhitespace();    // "helloworld"
+"<p>Hello</p>".stripHtml();          // "Hello"
+"hello".reverse();                   // "olleh"
+"hello world".reverseWords();        // "world hello"
+"hello hello".count("hello");        // 2
+"Hello World".slugify();             // "hello-world"
+"hello world".words();               // ["hello", "world"]
+"hello\nworld".lines();              // ["hello","world"]
+Array Extensions (23 methods)
+Core Utilities
+
+[1, 2, 2, 3].unique();                  // [1,2,3]
+[{id:1},{id:2},{id:1}].uniqueBy(x => x.id); // [{id:1},{id:2}]
+[1,2,3,4,5].shuffle();                  // random order
+[1,2,3,4,5].chunk(2);                   // [[1,2],[3,4],[5]]
+[0,1,false,2,"",3].compact();           // [1,2,3] removes null, undefined, false, and empty strings
+[1,2,3,4].last();                        // 4
+[3,1,2].sortBy(x => x);                  // [1,2,3]
+Math
+
+[1,2,3].sum();       // 6
+[1,2,3].average();   // 2
+Advanced
+
+users.groupBy(u => u.age);
+users.pluck('name');
+[1,2,3,4].partition(n => n % 2 === 0);
+// [[2,4],[1,3]]
+Set Operations
+
+[1,2,3].difference([2]);     // [1,3]
+[1,2,3].intersection([2,3]); // [2,3]
+[1,2,3].union([3,4]);        // [1,2,3,4]
+Object Extensions (13 methods)
+({}).isEmpty(); // true
+({ a: 1, b: 2 }).pick(['a']);      // { a: 1 }
+({ a: 1, b: 2 }).omit(['b']);      // { a: 1 }
+({ a: 1, b: 2 }).mapValues(v => v*2); // { a: 2, b: 4 }
+({ a: 1, b: 2 }).mapKeys(k => k+"_");  // { a_:1, b_:2 }
+({ a: 1, b: 2 }).filterKeys(k => k==='a'); // { a:1 }
+({ a: 1, b: 2 }).filterValues(v => v===1); // { a:1 }
+({ a: { b: 2 } }).deepClone();
+({ a: { b: 2 } }).deepFreeze();
+data.hasPath('user.profile.name');
+data.getPath('user.profile.email', 'N/A');
+data.setPath('user.profile.email', 'john@example.com');
+Number Extensions (19 methods)
+(0.75).toPercent();                 // "75.00%"
+(3.14159).toFixedNumber(2);         // 3.14
+(1234.56).toCurrency();             // "$1,234.56"
+(1234.56).toCurrency('EUR','de-DE'); // "1.234,56 €"
+(5).clamp(1,10);                     // 5
+(5).inRange(1,10);                   // true
+(7).isPrime();                        // true
+(5).factorial();                      // 120
+(5).randomUpTo();                     // 0..5
+(3).times(i => console.log(i));      // 0,1,2
+(42).toOrdinal();                     // "42nd"
+(123).sign();                         // 1
+Caching Details
+Cached Methods (when enabled):
+
+Number.isPrime()
+
+Number.factorial()
+
+Number.toRoman()
+
+Custom Caching:
+
+import { withCache } from '@naman_deep_singh/js-extensions';
+const result = withCache('key', () => expensiveFn());
+TypeScript Support
+Full global augmentation
+
+Strict typing for all methods
+
+Zero any leakage in public APIs
+
+const x: number[] = [1,2,2].unique();
+const y: string = "hello".toCapitalize();
+Package Stats
+~70 utility methods
+
+Zero dependencies
+
+Node.js + Browser
+
+TypeScript-first
+
+Optional LRU caching
+
+Strict runtime validation

package/packages/js-extensions/dist/cjs/array/array-extensions.d.ts

@@ -0,0 +1 @@
+export declare function extendArray(): void;

package/packages/js-extensions/dist/cjs/array/array-extensions.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArray = extendArray;
+const utils_1 = require("src/utils");
+let arrayExtended = false;
+function extendArray() {
+    if (arrayExtended)
+        return;
+    arrayExtended = true;
+    (0, utils_1.defineExtension)(Array.prototype, 'unique', function () {
+        return [...new Set(this)];
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'shuffle', function () {
+        const arr = [...this];
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+        return arr;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'chunk', function (size) {
+        if (!Number.isInteger(size) || size <= 0) {
+            throw new TypeError(`chunk: size must be a positive integer, got ${size}`);
+        }
+        const chunks = [];
+        for (let i = 0; i < this.length; i += size) {
+            chunks.push(this.slice(i, i + size));
+        }
+        return chunks;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'groupBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`groupBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        return this.reduce((groups, item) => {
+            const key = keyFn(item);
+            if (!groups[key])
+                groups[key] = [];
+            groups[key].push(item);
+            return groups;
+        }, {});
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sum', function () {
+        if (this.length === 0) {
+            throw new TypeError('sum: array must contain at least one number');
+        }
+        return this.reduce((sum, num) => sum + num, 0);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'average', function () {
+        if (this.length === 0) {
+            throw new TypeError('average: array must contain at least one number');
+        }
+        return this.reduce((sum, num) => sum + num, 0) / this.length;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'compact', function () {
+        return this.filter((item) => item !== null && item !== undefined && item !== '');
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'compactTruthy', function () {
+        return this.filter(Boolean);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'pluck', function (key) {
+        return this
+            .map((item) => item[key])
+            .filter((val) => val !== undefined);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'findLast', function (predicate) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError(`findLast: predicate must be a function, got ${typeof predicate}`);
+        }
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (predicate(this[i]))
+                return this[i];
+        }
+        return undefined;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'partition', function (predicate) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError(`partition: predicate must be a function, got ${typeof predicate}`);
+        }
+        const truthy = [];
+        const falsy = [];
+        this.forEach((item) => predicate(item) ? truthy.push(item) : falsy.push(item));
+        return [truthy, falsy];
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'flatten', function (depth = 1) {
+        return depth > 0
+            ? this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.flatten(depth - 1) : val), [])
+            : this.slice();
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'deepFlatten', function () {
+        return this.reduce((acc, val) => acc.concat(Array.isArray(val) ? val.deepFlatten() : val), []);
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'difference', function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`difference: other must be an array, got ${typeof other}`);
+        }
+        return this.filter((item) => !other.includes(item));
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'intersection', function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`intersection: other must be an array, got ${typeof other}`);
+        }
+        return this.filter((item) => other.includes(item));
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'union', function (other) {
+        if (!Array.isArray(other)) {
+            throw new TypeError(`union: other must be an array, got ${typeof other}`);
+        }
+        return [...new Set([...this, ...other])];
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sample', function () {
+        return this.length > 0
+            ? this[Math.floor(Math.random() * this.length)]
+            : undefined;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'take', function (count) {
+        return this.slice(0, Math.max(0, count));
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'drop', function (count) {
+        return this.slice(Math.max(0, count));
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'uniqueBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`uniqueBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        const seen = new Set();
+        const result = [];
+        for (const item of this) {
+            const key = keyFn(item);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(item);
+            }
+        }
+        return result;
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'sortBy', function (keyFn) {
+        if (typeof keyFn !== 'function') {
+            throw new TypeError(`sortBy: keyFn must be a function, got ${typeof keyFn}`);
+        }
+        return [...this].sort((a, b) => {
+            const aVal = keyFn(a);
+            const bVal = keyFn(b);
+            if (aVal < bVal)
+                return -1;
+            if (aVal > bVal)
+                return 1;
+            return 0;
+        });
+    });
+    (0, utils_1.defineExtension)(Array.prototype, 'last', function () {
+        return this.length > 0 ? this[this.length - 1] : undefined;
+    });
+}

package/packages/js-extensions/dist/cjs/array/index.d.ts

@@ -0,0 +1 @@
+export { extendArray } from './array-extensions';

package/packages/js-extensions/dist/cjs/array/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArray = void 0;
+var array_extensions_1 = require("./array-extensions");
+Object.defineProperty(exports, "extendArray", { enumerable: true, get: function () { return array_extensions_1.extendArray; } });

package/packages/js-extensions/dist/cjs/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './validation';
+export * from './performance';

package/packages/js-extensions/dist/cjs/core/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export core utilities
+__exportStar(require("./validation"), exports);
+__exportStar(require("./performance"), exports);

package/packages/js-extensions/dist/cjs/core/performance.d.ts

@@ -0,0 +1,17 @@
+export interface PerformanceConfig {
+    enableCaching?: boolean;
+    maxCacheSize?: number;
+    enableValidation?: boolean;
+}
+export declare function setPerformanceConfig(newConfig: Partial<PerformanceConfig>): void;
+export declare function getPerformanceConfig(): PerformanceConfig;
+export declare class LRUCache<K, V> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    clear(): void;
+}
+export declare function makeInternalCacheKey(domain: string, key: string | number): string;
+export declare function withCache<T>(key: string, fn: () => T): T;

package/packages/js-extensions/dist/cjs/core/performance.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+exports.setPerformanceConfig = setPerformanceConfig;
+exports.getPerformanceConfig = getPerformanceConfig;
+exports.makeInternalCacheKey = makeInternalCacheKey;
+exports.withCache = withCache;
+const version_1 = require("./version");
+const defaultConfig = {
+    enableCaching: false,
+    maxCacheSize: 100,
+    enableValidation: true,
+};
+let config = { ...defaultConfig };
+function setPerformanceConfig(newConfig) {
+    const oldMaxSize = config.maxCacheSize;
+    config = { ...config, ...newConfig };
+    // Recreate cache if maxCacheSize changed
+    if (cache && oldMaxSize !== config.maxCacheSize) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+}
+function getPerformanceConfig() {
+    return { ...config };
+}
+// Simple LRU cache for expensive operations
+class LRUCache {
+    constructor(maxSize = 100) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Remove least recently used (first item)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.LRUCache = LRUCache;
+let cache = null;
+function getOrCreateCache() {
+    if (!cache) {
+        cache = new LRUCache(config.maxCacheSize);
+    }
+    return cache;
+}
+function makeInternalCacheKey(domain, key) {
+    const INTERNAL_CACHE_PREFIX = '@js-ext' + (0, version_1.getPackageVersion)();
+    return `${INTERNAL_CACHE_PREFIX}:${domain}:${key}`;
+}
+function withCache(key, fn) {
+    if (!config.enableCaching) {
+        return fn();
+    }
+    const currentCache = getOrCreateCache();
+    const cached = currentCache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    currentCache.set(key, result);
+    return result;
+}

package/packages/js-extensions/dist/cjs/core/validation.d.ts

@@ -0,0 +1,4 @@
+export declare function validateExtensionInput(value: any, type: string, methodName: string): void;
+export declare function validateArrayInput<T>(arr: T[], methodName: string): void;
+export declare function validateNumberRange(num: number, min: number, max: number, methodName: string): void;
+export declare function validatePositiveInteger(num: number, methodName: string): void;