@oxyhq/services 5.10.16 → 5.11.2

package/src/ui/stores/followStore.ts

@@ -1,5 +1,5 @@
 import { create } from 'zustand';
-import { OxyServices } from '../../core';
+import type { OxyServices } from '../../core';
 
 interface FollowState {
   followingUsers: Record<string, boolean>;
@@ -163,16 +163,16 @@ export const useFollowStore = create<FollowState>((set: any, get: any) => ({
         set((state: FollowState) => ({
           followerCounts: { 
             ...state.followerCounts, 
-            [userId]: user._count.followers || 0 
+            [userId]: user._count?.followers || 0 
           },
           followingCounts: { 
             ...state.followingCounts, 
-            [userId]: user._count.following || 0 
+            [userId]: user._count?.following || 0 
           },
           loadingCounts: { ...state.loadingCounts, [userId]: false },
         }));
       }
-    } catch (error: any) {
+    } catch (error: unknown) {
       set((state: FollowState) => ({
         loadingCounts: { ...state.loadingCounts, [userId]: false },
       }));

package/src/ui/styles/fonts.ts

@@ -1,4 +1,4 @@
-import { Platform, TextStyle } from 'react-native';
+import { Platform, type TextStyle } from 'react-native';
 
 /**
  * Font family names for use across the app

package/src/ui/styles/theme.ts

@@ -1,4 +1,4 @@
-import { Platform, StyleSheet, TextStyle } from 'react-native';
+import { Platform, StyleSheet, type TextStyle } from 'react-native';
 import { fontFamilies } from './fonts';
 
 export interface ThemeColors {

package/src/utils/__tests__/validationUtils.test.ts

@@ -0,0 +1,236 @@
+import {
+  isRequiredString,
+  isRequiredNumber,
+  isRequiredBoolean,
+  isValidArray,
+  isValidObject,
+  isValidEmail,
+  isValidUsername,
+  isValidPassword,
+  isValidUUID,
+  isValidDate,
+  isValidFileSize,
+  isValidFileType,
+  sanitizeString,
+  sanitizeHTML,
+  validateAndSanitizeUserInput
+} from '../validationUtils';
+
+describe('Validation Utils', () => {
+  describe('isRequiredString', () => {
+    it('should return true for valid non-empty strings', () => {
+      expect(isRequiredString('hello')).toBe(true);
+      expect(isRequiredString('  hello  ')).toBe(true); // trims whitespace
+    });
+
+    it('should return false for invalid or empty strings', () => {
+      expect(isRequiredString('')).toBe(false);
+      expect(isRequiredString('   ')).toBe(false); // only whitespace
+      expect(isRequiredString(null)).toBe(false);
+      expect(isRequiredString(undefined)).toBe(false);
+      expect(isRequiredString(123)).toBe(false);
+    });
+  });
+
+  describe('isRequiredNumber', () => {
+    it('should return true for valid numbers', () => {
+      expect(isRequiredNumber(123)).toBe(true);
+      expect(isRequiredNumber(0)).toBe(true);
+      expect(isRequiredNumber(-456)).toBe(true);
+      expect(isRequiredNumber(3.14)).toBe(true);
+    });
+
+    it('should return false for invalid numbers', () => {
+      expect(isRequiredNumber(Number.NaN)).toBe(false);
+      expect(isRequiredNumber('123')).toBe(false);
+      expect(isRequiredNumber(null)).toBe(false);
+      expect(isRequiredNumber(undefined)).toBe(false);
+    });
+  });
+
+  describe('isRequiredBoolean', () => {
+    it('should return true for boolean values', () => {
+      expect(isRequiredBoolean(true)).toBe(true);
+      expect(isRequiredBoolean(false)).toBe(true);
+    });
+
+    it('should return false for non-boolean values', () => {
+      expect(isRequiredBoolean('true')).toBe(false);
+      expect(isRequiredBoolean(1)).toBe(false);
+      expect(isRequiredBoolean(0)).toBe(false);
+      expect(isRequiredBoolean(null)).toBe(false);
+      expect(isRequiredBoolean(undefined)).toBe(false);
+    });
+  });
+
+  describe('isValidArray', () => {
+    it('should return true for arrays', () => {
+      expect(isValidArray([])).toBe(true);
+      expect(isValidArray([1, 2, 3])).toBe(true);
+      expect(isValidArray(['a', 'b'])).toBe(true);
+    });
+
+    it('should return false for non-arrays', () => {
+      expect(isValidArray({})).toBe(false);
+      expect(isValidArray('[]')).toBe(false);
+      expect(isValidArray(null)).toBe(false);
+      expect(isValidArray(undefined)).toBe(false);
+    });
+  });
+
+  describe('isValidObject', () => {
+    it('should return true for plain objects', () => {
+      expect(isValidObject({})).toBe(true);
+      expect(isValidObject({ key: 'value' })).toBe(true);
+    });
+
+    it('should return false for non-objects', () => {
+      expect(isValidObject([])).toBe(false);
+      expect(isValidObject(null)).toBe(false);
+      expect(isValidObject(undefined)).toBe(false);
+      expect(isValidObject('object')).toBe(false);
+      expect(isValidObject(123)).toBe(false);
+    });
+  });
+
+  describe('isValidEmail', () => {
+    it('should return true for valid email addresses', () => {
+      expect(isValidEmail('test@example.com')).toBe(true);
+      expect(isValidEmail('user.name+tag@domain.co.uk')).toBe(true);
+      expect(isValidEmail('simple@test.io')).toBe(true);
+    });
+
+    it('should return false for invalid email addresses', () => {
+      expect(isValidEmail('invalid-email')).toBe(false);
+      expect(isValidEmail('test@')).toBe(false);
+      expect(isValidEmail('@domain.com')).toBe(false);
+      expect(isValidEmail('test.domain.com')).toBe(false);
+      expect(isValidEmail('')).toBe(false);
+    });
+  });
+
+  describe('isValidUsername', () => {
+    it('should return true for valid usernames', () => {
+      expect(isValidUsername('user123')).toBe(true);
+      expect(isValidUsername('test_user')).toBe(true);
+      expect(isValidUsername('john-doe')).toBe(true);
+    });
+
+    it('should return false for invalid usernames', () => {
+      expect(isValidUsername('')).toBe(false);
+      expect(isValidUsername('a')).toBe(false); // too short
+      expect(isValidUsername('ab')).toBe(false); // too short
+      expect(isValidUsername('user@domain')).toBe(false); // invalid characters
+      expect(isValidUsername('user with spaces')).toBe(false); // spaces
+    });
+  });
+
+  describe('isValidPassword', () => {
+    it('should return true for valid passwords', () => {
+      expect(isValidPassword('password123')).toBe(true);
+      expect(isValidPassword('mySecurePass')).toBe(true);
+      expect(isValidPassword('12345678')).toBe(true);
+    });
+
+    it('should return false for invalid passwords', () => {
+      expect(isValidPassword('')).toBe(false);
+      expect(isValidPassword('short')).toBe(false); // too short
+      expect(isValidPassword('1234567')).toBe(false); // too short
+    });
+  });
+
+  describe('isValidUUID', () => {
+    it('should return true for valid UUIDs', () => {
+      expect(isValidUUID('123e4567-e89b-12d3-a456-426614174000')).toBe(true);
+      expect(isValidUUID('550e8400-e29b-41d4-a716-446655440000')).toBe(true);
+    });
+
+    it('should return false for invalid UUIDs', () => {
+      expect(isValidUUID('invalid-uuid')).toBe(false);
+      expect(isValidUUID('123-456-789')).toBe(false);
+      expect(isValidUUID('')).toBe(false);
+    });
+  });
+
+  describe('isValidDate', () => {
+    it('should return true for valid date strings', () => {
+      expect(isValidDate('2024-01-01')).toBe(true);
+      expect(isValidDate('2024-12-31T23:59:59.999Z')).toBe(true);
+      expect(isValidDate('January 1, 2024')).toBe(true);
+    });
+
+    it('should return false for invalid date strings', () => {
+      expect(isValidDate('invalid-date')).toBe(false);
+      expect(isValidDate('2024-13-01')).toBe(false); // invalid month
+      expect(isValidDate('')).toBe(false);
+    });
+  });
+
+  describe('isValidFileSize', () => {
+    const maxSize = 1024 * 1024; // 1MB
+
+    it('should return true for valid file sizes', () => {
+      expect(isValidFileSize(1024, maxSize)).toBe(true);
+      expect(isValidFileSize(maxSize, maxSize)).toBe(true);
+      expect(isValidFileSize(1, maxSize)).toBe(true);
+    });
+
+    it('should return false for invalid file sizes', () => {
+      expect(isValidFileSize(0, maxSize)).toBe(false);
+      expect(isValidFileSize(-1, maxSize)).toBe(false);
+      expect(isValidFileSize(maxSize + 1, maxSize)).toBe(false);
+    });
+  });
+
+  describe('isValidFileType', () => {
+    const allowedTypes = ['jpg', 'png', 'gif', 'pdf'];
+
+    it('should return true for allowed file types', () => {
+      expect(isValidFileType('image.jpg', allowedTypes)).toBe(true);
+      expect(isValidFileType('document.PDF', allowedTypes)).toBe(true); // case insensitive
+      expect(isValidFileType('photo.png', allowedTypes)).toBe(true);
+    });
+
+    it('should return false for disallowed file types', () => {
+      expect(isValidFileType('script.js', allowedTypes)).toBe(false);
+      expect(isValidFileType('data.txt', allowedTypes)).toBe(false);
+      expect(isValidFileType('noextension', allowedTypes)).toBe(false);
+    });
+  });
+
+  describe('sanitizeString', () => {
+    it('should trim whitespace and remove dangerous characters', () => {
+      expect(sanitizeString('  hello  ')).toBe('hello');
+      expect(sanitizeString('hello<script>alert("xss")</script>world')).toBe('helloalert("xss")world');
+      expect(sanitizeString('normal text')).toBe('normal text');
+    });
+  });
+
+  describe('sanitizeHTML', () => {
+    it('should escape HTML characters', () => {
+      expect(sanitizeHTML('<script>alert("xss")</script>')).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
+      expect(sanitizeHTML('Hello & Goodbye')).toBe('Hello &amp; Goodbye');
+      expect(sanitizeHTML("It's a test")).toBe('It&#x27;s a test');
+    });
+  });
+
+  describe('validateAndSanitizeUserInput', () => {
+    it('should validate and sanitize email input', () => {
+      expect(validateAndSanitizeUserInput('  test@example.com  ', 'email')).toBe('test@example.com');
+      expect(validateAndSanitizeUserInput('invalid-email', 'email')).toBeNull();
+      expect(validateAndSanitizeUserInput(123, 'email')).toBeNull();
+    });
+
+    it('should validate and sanitize username input', () => {
+      expect(validateAndSanitizeUserInput('  testuser  ', 'username')).toBe('testuser');
+      expect(validateAndSanitizeUserInput('ab', 'username')).toBeNull(); // too short
+      expect(validateAndSanitizeUserInput(123, 'username')).toBeNull();
+    });
+
+    it('should validate and sanitize string input', () => {
+      expect(validateAndSanitizeUserInput('  hello world  ', 'string')).toBe('hello world');
+      expect(validateAndSanitizeUserInput('', 'string')).toBeNull();
+      expect(validateAndSanitizeUserInput(123, 'string')).toBeNull();
+    });
+  });
+});

package/src/utils/asyncUtils.ts

@@ -45,8 +45,8 @@ export async function parallelWithErrorHandling<T>(
  */
 export async function retryAsync<T>(
   operation: () => Promise<T>,
-  maxRetries: number = 3,
-  baseDelay: number = 1000,
+  maxRetries = 3,
+  baseDelay = 1000,
   shouldRetry?: (error: any) => boolean
 ): Promise<T> {
   let lastError: any;
@@ -81,7 +81,7 @@ export function debounceAsync<T extends (...args: any[]) => Promise<any>>(
   delay: number
 ): (...args: Parameters<T>) => Promise<ReturnType<T>> {
   let timeoutId: NodeJS.Timeout;
-  let lastPromise: Promise<ReturnType<T>> | null = null;
+  const lastPromise: Promise<ReturnType<T>> | null = null;
   
   return (...args: Parameters<T>): Promise<ReturnType<T>> => {
     return new Promise((resolve, reject) => {
@@ -256,7 +256,7 @@ export const delay = (ms: number): Promise<void> =>
 export async function retryOnError<T>(
   operation: () => Promise<T>,
   retryableErrors: (string | number)[],
-  maxRetries: number = 3
+  maxRetries = 3
 ): Promise<T> {
   return retryAsync(operation, maxRetries, 1000, (error) => {
     const errorCode = error?.code || error?.status || error?.message;

package/src/utils/errorUtils.ts

@@ -1,4 +1,4 @@
-import { ApiError } from '../models/interfaces';
+import type { ApiError } from '../models/interfaces';
 
 /**
  * Error handling utilities for consistent error processing
@@ -40,8 +40,8 @@ export const ErrorCodes = {
 export function createApiError(
   message: string,
   code: string = ErrorCodes.INTERNAL_ERROR,
-  status: number = 500,
-  details?: any
+  status = 500,
+  details?: Record<string, unknown>
 ): ApiError {
   return {
     message,
@@ -54,26 +54,29 @@ export function createApiError(
 /**
  * Handle common HTTP errors and convert to ApiError
  */
-export function handleHttpError(error: any): ApiError {
+export function handleHttpError(error: unknown): ApiError {
   // If it's already an ApiError, return it
   if (error && typeof error === 'object' && 'code' in error && 'status' in error) {
     return error as ApiError;
   }
 
-  // Handle axios errors
-  if (error?.response) {
-    const { status, data } = error.response;
-    
-    return createApiError(
-      data?.message || `HTTP ${status} error`,
-      data?.code || getErrorCodeFromStatus(status),
-      status,
-      data
-    );
+  // Handle axios errors - check if it looks like an axios error
+  if (error && typeof error === 'object' && 'response' in error) {
+    const axiosError = error as { response?: { status: number; data?: { message?: string; code?: string } } };
+    if (axiosError.response) {
+      const { status, data } = axiosError.response;
+      
+      return createApiError(
+        data?.message || `HTTP ${status} error`,
+        data?.code || getErrorCodeFromStatus(status),
+        status,
+        data
+      );
+    }
   }
 
-  // Handle network errors
-  if (error?.request) {
+  // Handle network errors - check if it looks like a network error
+  if (error && typeof error === 'object' && 'request' in error) {
     return createApiError(
       'Network error - no response received',
       ErrorCodes.NETWORK_ERROR,
@@ -81,9 +84,18 @@ export function handleHttpError(error: any): ApiError {
     );
   }
 
+  // Handle standard errors
+  if (error instanceof Error) {
+    return createApiError(
+      error.message || 'Unknown error occurred',
+      ErrorCodes.INTERNAL_ERROR,
+      500
+    );
+  }
+
   // Handle other errors
   return createApiError(
-    error?.message || 'Unknown error occurred',
+    String(error) || 'Unknown error occurred',
     ErrorCodes.INTERNAL_ERROR,
     500
   );
@@ -118,7 +130,7 @@ function getErrorCodeFromStatus(status: number): string {
 /**
  * Validate required fields and throw error if missing
  */
-export function validateRequiredFields(data: Record<string, any>, fields: string[]): void {
+export function validateRequiredFields(data: Record<string, unknown>, fields: string[]): void {
   const missing = fields.filter(field => !data[field]);
   
   if (missing.length > 0) {
@@ -133,7 +145,7 @@ export function validateRequiredFields(data: Record<string, any>, fields: string
 /**
  * Safe error logging with context
  */
-export function logError(error: any, context?: string): void {
+export function logError(error: unknown, context?: string): void {
   const prefix = context ? `[${context}]` : '[Error]';
   
   if (error instanceof Error) {
@@ -148,10 +160,10 @@ export function logError(error: any, context?: string): void {
  */
 export async function retryWithBackoff<T>(
   fn: () => Promise<T>,
-  maxRetries: number = 3,
-  baseDelay: number = 1000
+  maxRetries = 3,
+  baseDelay = 1000
 ): Promise<T> {
-  let lastError: any;
+  let lastError: unknown;
   
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
@@ -163,7 +175,7 @@ export async function retryWithBackoff<T>(
         break;
       }
       
-      const delay = baseDelay * Math.pow(2, attempt);
+      const delay = baseDelay * 2 ** attempt;
       await new Promise(resolve => setTimeout(resolve, delay));
     }
   }

package/src/utils/hookUtils.ts

@@ -9,7 +9,7 @@ import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
  */
 export function useAsync<T>(
   asyncFn: () => Promise<T>,
-  deps: any[] = []
+  deps: React.DependencyList = []
 ) {
   const [data, setData] = useState<T | null>(null);
   const [loading, setLoading] = useState(false);
@@ -40,7 +40,7 @@ export function useAsync<T>(
  */
 export function useAsyncEffect<T>(
   asyncFn: () => Promise<T>,
-  deps: any[] = []
+  deps: React.DependencyList = []
 ) {
   const [data, setData] = useState<T | null>(null);
   const [loading, setLoading] = useState(true);
@@ -121,7 +121,7 @@ export function useThrottle<T>(value: T, delay: number): T {
  * Hook for previous value
  */
 export function usePrevious<T>(value: T): T | undefined {
-  const ref = useRef<T>();
+  const ref = useRef<T | undefined>(undefined);
   
   useEffect(() => {
     ref.current = value;
@@ -133,7 +133,7 @@ export function usePrevious<T>(value: T): T | undefined {
 /**
  * Hook for boolean state with toggle
  */
-export function useToggle(initialValue: boolean = false) {
+export function useToggle(initialValue = false) {
   const [value, setValue] = useState(initialValue);
   
   const toggle = useCallback(() => setValue(v => !v), []);
@@ -146,7 +146,7 @@ export function useToggle(initialValue: boolean = false) {
 /**
  * Hook for counter state
  */
-export function useCounter(initialValue: number = 0) {
+export function useCounter(initialValue = 0) {
   const [count, setCount] = useState(initialValue);
   
   const increment = useCallback(() => setCount(c => c + 1), []);
@@ -352,7 +352,7 @@ export function useClickOutside(ref: React.RefObject<HTMLElement>, handler: () =
 /**
  * Hook for form validation
  */
-export function useFormValidation<T extends Record<string, any>>(
+export function useFormValidation<T extends Record<string, unknown>>(
   initialValues: T,
   validationSchema: (values: T) => Partial<Record<keyof T, string>>
 ) {
@@ -364,7 +364,7 @@ export function useFormValidation<T extends Record<string, any>>(
     return validationSchema(valuesToValidate);
   }, [validationSchema]);
 
-  const setValue = useCallback((field: keyof T, value: any) => {
+  const setValue = useCallback((field: keyof T, value: T[keyof T]) => {
     setValues(prev => ({ ...prev, [field]: value }));
     if (touched[field]) {
       const newErrors = validate({ ...values, [field]: value });

package/src/utils/loggerUtils.ts

@@ -16,7 +16,7 @@ export interface LogContext {
   userId?: string;
   sessionId?: string;
   requestId?: string;
-  [key: string]: any;
+  [key: string]: unknown;
 }
 
 class Logger {
@@ -37,7 +37,7 @@ class Logger {
     return `[${timestamp}] ${level}${contextStr}: ${message}`;
   }
 
-  debug(message: string, context?: LogContext, ...args: any[]): void {
+  debug(message: string, context?: LogContext, ...args: unknown[]): void {
     if (this.shouldLog(LogLevel.DEBUG)) {
       const formattedMessage = this.formatMessage('DEBUG', message, context);
       if (this.isDevelopment) {
@@ -46,21 +46,21 @@ class Logger {
     }
   }
 
-  info(message: string, context?: LogContext, ...args: any[]): void {
+  info(message: string, context?: LogContext, ...args: unknown[]): void {
     if (this.shouldLog(LogLevel.INFO)) {
       const formattedMessage = this.formatMessage('INFO', message, context);
       console.log(formattedMessage, ...args);
     }
   }
 
-  warn(message: string, context?: LogContext, ...args: any[]): void {
+  warn(message: string, context?: LogContext, ...args: unknown[]): void {
     if (this.shouldLog(LogLevel.WARN)) {
       const formattedMessage = this.formatMessage('WARN', message, context);
       console.warn(formattedMessage, ...args);
     }
   }
 
-  error(message: string, error?: any, context?: LogContext, ...args: any[]): void {
+  error(message: string, error?: Error | unknown, context?: LogContext, ...args: unknown[]): void {
     if (this.shouldLog(LogLevel.ERROR)) {
       const formattedMessage = this.formatMessage('ERROR', message, context);
       if (error) {
@@ -72,27 +72,27 @@ class Logger {
   }
 
   // Specialized logging methods for common patterns
-  auth(message: string, context?: LogContext, ...args: any[]): void {
+  auth(message: string, context?: LogContext, ...args: unknown[]): void {
     this.info(`🔐 ${message}`, { ...context, category: 'auth' }, ...args);
   }
 
-  api(message: string, context?: LogContext, ...args: any[]): void {
+  api(message: string, context?: LogContext, ...args: unknown[]): void {
     this.info(`🌐 ${message}`, { ...context, category: 'api' }, ...args);
   }
 
-  session(message: string, context?: LogContext, ...args: any[]): void {
+  session(message: string, context?: LogContext, ...args: unknown[]): void {
     this.info(`📱 ${message}`, { ...context, category: 'session' }, ...args);
   }
 
-  user(message: string, context?: LogContext, ...args: any[]): void {
+  user(message: string, context?: LogContext, ...args: unknown[]): void {
     this.info(`👤 ${message}`, { ...context, category: 'user' }, ...args);
   }
 
-  device(message: string, context?: LogContext, ...args: any[]): void {
+  device(message: string, context?: LogContext, ...args: unknown[]): void {
     this.info(`📱 ${message}`, { ...context, category: 'device' }, ...args);
   }
 
-  payment(message: string, context?: LogContext, ...args: any[]): void {
+  payment(message: string, context?: LogContext, ...args: unknown[]): void {
     this.info(`💳 ${message}`, { ...context, category: 'payment' }, ...args);
   }
 
@@ -128,25 +128,25 @@ class Logger {
 export const logger = new Logger();
 
 // Convenience functions for common logging patterns
-export const logAuth = (message: string, context?: LogContext, ...args: any[]) => 
+export const logAuth = (message: string, context?: LogContext, ...args: unknown[]) => 
   logger.auth(message, context, ...args);
 
-export const logApi = (message: string, context?: LogContext, ...args: any[]) => 
+export const logApi = (message: string, context?: LogContext, ...args: unknown[]) => 
   logger.api(message, context, ...args);
 
-export const logSession = (message: string, context?: LogContext, ...args: any[]) => 
+export const logSession = (message: string, context?: LogContext, ...args: unknown[]) => 
   logger.session(message, context, ...args);
 
-export const logUser = (message: string, context?: LogContext, ...args: any[]) => 
+export const logUser = (message: string, context?: LogContext, ...args: unknown[]) => 
   logger.user(message, context, ...args);
 
-export const logDevice = (message: string, context?: LogContext, ...args: any[]) => 
+export const logDevice = (message: string, context?: LogContext, ...args: unknown[]) => 
   logger.device(message, context, ...args);
 
-export const logPayment = (message: string, context?: LogContext, ...args: any[]) => 
+export const logPayment = (message: string, context?: LogContext, ...args: unknown[]) => 
   logger.payment(message, context, ...args);
 
-export const logError = (message: string, error?: any, context?: LogContext, ...args: any[]) => 
+export const logError = (message: string, error?: Error | unknown, context?: LogContext, ...args: unknown[]) => 
   logger.error(message, error, context, ...args);
 
 export const logPerformance = (operation: string, duration: number, context?: LogContext) => 

package/src/utils/validationUtils.ts

@@ -41,35 +41,35 @@ export function isValidPassword(password: string): boolean {
 /**
  * Validate required string
  */
-export function isRequiredString(value: any): boolean {
+export function isRequiredString(value: unknown): boolean {
   return typeof value === 'string' && value.trim().length > 0;
 }
 
 /**
  * Validate required number
  */
-export function isRequiredNumber(value: any): boolean {
-  return typeof value === 'number' && !isNaN(value);
+export function isRequiredNumber(value: unknown): boolean {
+  return typeof value === 'number' && !Number.isNaN(value);
 }
 
 /**
  * Validate required boolean
  */
-export function isRequiredBoolean(value: any): boolean {
+export function isRequiredBoolean(value: unknown): boolean {
   return typeof value === 'boolean';
 }
 
 /**
  * Validate array
  */
-export function isValidArray(value: any): boolean {
+export function isValidArray(value: unknown): boolean {
   return Array.isArray(value);
 }
 
 /**
  * Validate object
  */
-export function isValidObject(value: any): boolean {
+export function isValidObject(value: unknown): boolean {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
@@ -98,7 +98,7 @@ export function isValidURL(url: string): boolean {
  */
 export function isValidDate(dateString: string): boolean {
   const date = new Date(dateString);
-  return !isNaN(date.getTime());
+  return !Number.isNaN(date.getTime());
 }
 
 /**
@@ -138,7 +138,7 @@ export function sanitizeHTML(input: string): string {
 /**
  * Validate and sanitize user input
  */
-export function validateAndSanitizeUserInput(input: any, type: 'string' | 'email' | 'username'): string | null {
+export function validateAndSanitizeUserInput(input: unknown, type: 'string' | 'email' | 'username'): string | null {
   if (typeof input !== 'string') {
     return null;
   }