@umituz/react-native-design-system 4.28.21 → 4.28.23

package/dist/utils/async/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Async Utilities
+ * Retry and timeout utilities for async operations
+ */
+export { retryWithBackoff, retryWithTimeout, isNetworkError, isRetryableHttpStatus, type RetryOptions, } from './retryWithBackoff';

package/dist/utils/async/retryWithBackoff.d.ts

@@ -0,0 +1,74 @@
+/**
+ * retryWithBackoff
+ *
+ * Retry utility with exponential backoff for async operations.
+ * Useful for network requests, file operations, etc.
+ */
+export interface RetryOptions {
+    /**
+     * Maximum number of retry attempts
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Initial delay in milliseconds before first retry
+     * @default 1000
+     */
+    baseDelay?: number;
+    /**
+     * Maximum delay in milliseconds (caps exponential growth)
+     * @default 10000
+     */
+    maxDelay?: number;
+    /**
+     * Multiplier for exponential backoff
+     * @default 2
+     */
+    backoffMultiplier?: number;
+    /**
+     * Function to determine if error is retryable
+     * @default () => true (retry all errors)
+     */
+    shouldRetry?: (error: Error, attempt: number) => boolean;
+    /**
+     * Callback on each retry attempt
+     */
+    onRetry?: (error: Error, attempt: number, delay: number) => void;
+}
+/**
+ * Retry an async function with exponential backoff
+ *
+ * @example
+ * ```ts
+ * const result = await retryWithBackoff(
+ *   () => fetch('https://api.example.com'),
+ *   { maxRetries: 3, baseDelay: 1000 }
+ * );
+ * ```
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Retry with timeout
+ * Combines retry logic with a timeout
+ *
+ * @example
+ * ```ts
+ * const result = await retryWithTimeout(
+ *   () => fetch('https://api.example.com'),
+ *   { timeout: 5000, maxRetries: 3 }
+ * );
+ * ```
+ */
+export declare function retryWithTimeout<T>(fn: () => Promise<T>, options?: RetryOptions & {
+    timeout?: number;
+}): Promise<T>;
+/**
+ * Check if error is a network error
+ * Useful for shouldRetry callback
+ */
+export declare function isNetworkError(error: Error): boolean;
+/**
+ * Check if error is retryable HTTP status
+ * Useful for shouldRetry callback
+ */
+export declare function isRetryableHttpStatus(status: number): boolean;

package/dist/utils/constants/TimeConstants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Time Constants
+ *
+ * Centralized time-related constants to replace magic numbers
+ */
+export declare const MILLISECONDS_PER_SECOND = 1000;
+export declare const MILLISECONDS_PER_MINUTE: number;
+export declare const MILLISECONDS_PER_HOUR: number;
+export declare const MILLISECONDS_PER_DAY: number;
+export declare const SECONDS_PER_MINUTE = 60;
+export declare const SECONDS_PER_HOUR: number;
+export declare const SECONDS_PER_DAY: number;
+export declare const MINUTES_PER_HOUR = 60;
+export declare const MINUTES_PER_DAY: number;
+export declare const ONE_SECOND_MS = 1000;
+export declare const FIVE_SECONDS_MS: number;
+export declare const TEN_SECONDS_MS: number;
+export declare const THIRTY_SECONDS_MS: number;
+export declare const ONE_MINUTE_MS: number;
+export declare const FIVE_MINUTES_MS: number;
+export declare const TEN_MINUTES_MS: number;
+export declare const THIRTY_MINUTES_MS: number;
+export declare const ONE_HOUR_MS: number;
+export declare const ONE_DAY_MS: number;
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare const DEFAULT_LONG_TIMEOUT_MS: number;
+export declare const DEFAULT_CACHE_TTL_MS: number;

package/dist/utils/errors/DesignSystemError.d.ts

@@ -0,0 +1,99 @@
+/**
+ * DesignSystemError
+ *
+ * Unified error class for the design system package.
+ * Provides consistent error handling with error codes and context.
+ */
+export declare class DesignSystemError extends Error {
+    /**
+     * Error code for categorization
+     */
+    readonly code: string;
+    /**
+     * Additional context about the error
+     */
+    readonly context?: Record<string, any>;
+    /**
+     * Timestamp when error was created
+     */
+    readonly timestamp: Date;
+    /**
+     * Error category for grouping
+     */
+    readonly category: ErrorCategory;
+    /**
+     * Operation that failed
+     */
+    readonly operation?: string;
+    /**
+     * Original error cause
+     */
+    readonly cause?: unknown;
+    /**
+     * Whether operation can be retried
+     */
+    readonly retryable: boolean;
+    constructor(message: string, code: string, context?: Record<string, any>, metadata?: ErrorMetadata);
+    /**
+     * Convert error to JSON for logging/debugging
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Get user-friendly error message
+     */
+    getUserMessage(): string;
+}
+/**
+ * Common error codes used across the design system
+ */
+export declare const ErrorCodes: {
+    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
+    readonly FILE_READ_ERROR: "FILE_READ_ERROR";
+    readonly FILE_WRITE_ERROR: "FILE_WRITE_ERROR";
+    readonly FILE_DELETE_ERROR: "FILE_DELETE_ERROR";
+    readonly DIRECTORY_CREATE_ERROR: "DIRECTORY_CREATE_ERROR";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly STORAGE_FULL: "STORAGE_FULL";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    readonly API_ERROR: "API_ERROR";
+    readonly MEDIA_PICKER_ERROR: "MEDIA_PICKER_ERROR";
+    readonly MEDIA_SAVE_ERROR: "MEDIA_SAVE_ERROR";
+    readonly IMAGE_LOAD_ERROR: "IMAGE_LOAD_ERROR";
+    readonly CACHE_ERROR: "CACHE_ERROR";
+    readonly STORAGE_ERROR: "STORAGE_ERROR";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly THEME_LOAD_ERROR: "THEME_LOAD_ERROR";
+    readonly THEME_SAVE_ERROR: "THEME_SAVE_ERROR";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly INITIALIZATION_ERROR: "INITIALIZATION_ERROR";
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+/**
+ * Error Categories for grouping related errors
+ */
+export declare enum ErrorCategory {
+    FILESYSTEM = "FILESYSTEM",
+    NETWORK = "NETWORK",
+    MEDIA = "MEDIA",
+    STORAGE = "STORAGE",
+    CACHE = "CACHE",
+    IMAGE = "IMAGE",
+    VALIDATION = "VALIDATION",
+    THEME = "THEME",
+    PERMISSION = "PERMISSION",
+    INITIALIZATION = "INITIALIZATION",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Error metadata for rich context
+ */
+export interface ErrorMetadata {
+    category?: ErrorCategory;
+    operation?: string;
+    key?: string;
+    cause?: unknown;
+    retryable?: boolean;
+    userMessage?: string;
+}

package/dist/utils/errors/ErrorHandler.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ErrorHandler
+ *
+ * Centralized error handling utility for the design system.
+ * Provides consistent error handling, logging, and reporting.
+ */
+import { DesignSystemError, type ErrorMetadata } from './DesignSystemError';
+import type { Result } from './types/Result';
+export declare class ErrorHandler {
+    /**
+     * Handle and normalize errors
+     * Converts any error type to DesignSystemError
+     */
+    static handle(error: unknown, context?: string, additionalContext?: Record<string, any>): DesignSystemError;
+    /**
+     * Log error to console (only in development)
+     */
+    static log(error: DesignSystemError | Error | unknown): void;
+    /**
+     * Handle error with logging
+     * Combines handle() and log() for convenience
+     */
+    static handleAndLog(error: unknown, context?: string, additionalContext?: Record<string, any>): DesignSystemError;
+    /**
+     * Create a new DesignSystemError with specific code
+     */
+    static create(message: string, code: string, context?: Record<string, any>): DesignSystemError;
+    /**
+     * Wrap async function with error handling
+     * Returns [error, result] tuple (similar to Go pattern)
+     */
+    static tryAsync<T>(fn: () => Promise<T>, context?: string): Promise<[DesignSystemError | null, T | null]>;
+    /**
+     * Wrap sync function with error handling
+     * Returns [error, result] tuple
+     */
+    static try<T>(fn: () => T, context?: string): [DesignSystemError | null, T | null];
+    /**
+     * Normalize any error to DesignSystemError with metadata
+     */
+    static normalize(error: unknown, code: string, metadata?: ErrorMetadata): DesignSystemError;
+    /**
+     * Wrap async function with timeout
+     */
+    static withTimeout<T>(promise: Promise<T>, timeoutMs: number, context?: string): Promise<T>;
+    /**
+     * Wrap async function returning Result type
+     */
+    static tryAsyncResult<T>(fn: () => Promise<T>, code: string, metadata?: ErrorMetadata): Promise<Result<T, DesignSystemError>>;
+    /**
+     * Wrap sync function returning Result type
+     */
+    static tryResult<T>(fn: () => T, code: string, metadata?: ErrorMetadata): Result<T, DesignSystemError>;
+}

package/dist/utils/errors/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Error Utilities
+ * Unified error handling for the design system
+ */
+export { DesignSystemError, ErrorCodes, ErrorCategory, type ErrorCode, type ErrorMetadata } from './DesignSystemError';
+export { ErrorHandler } from './ErrorHandler';
+export type { Result } from './types/Result';
+export { ok, err, unwrap, unwrapOr, map, mapError } from './types/Result';

package/dist/utils/errors/types/Result.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Result Type
+ *
+ * Rust/Go-inspired Result type for explicit error handling.
+ * Alternative to throwing errors or returning tuples.
+ */
+export type Result<T, E = Error> = {
+    success: true;
+    value: T;
+    error: null;
+} | {
+    success: false;
+    value: null;
+    error: E;
+};
+/**
+ * Create a successful result
+ */
+export declare function ok<T, E = Error>(value: T): Result<T, E>;
+/**
+ * Create an error result
+ */
+export declare function err<T, E = Error>(error: E): Result<T, E>;
+/**
+ * Unwrap result value or throw error
+ */
+export declare function unwrap<T, E = Error>(result: Result<T, E>): T;
+/**
+ * Unwrap result value or return default
+ */
+export declare function unwrapOr<T, E = Error>(result: Result<T, E>, defaultValue: T): T;
+/**
+ * Map result value if successful
+ */
+export declare function map<T, U, E = Error>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Map result error if failed
+ */
+export declare function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;

package/dist/utils/formatters/stringFormatter.d.ts

@@ -0,0 +1,78 @@
+/**
+ * String Formatter Utility
+ * String, phone, file size, and duration formatting functions
+ */
+/**
+ * File size formatting options
+ */
+export interface FileSizeFormatOptions {
+    decimals?: number;
+    locale?: string;
+}
+/**
+ * Formats a file size in bytes to human-readable format
+ *
+ * @param bytes - File size in bytes
+ * @param options - Formatting options
+ * @returns Formatted file size string
+ */
+export declare function formatFileSize(bytes: number, options?: FileSizeFormatOptions): string;
+/**
+ * Duration formatting options
+ */
+export interface DurationFormatOptions {
+    format?: 'short' | 'long' | 'digital';
+}
+/**
+ * Formats a duration in seconds to human-readable format
+ *
+ * @param seconds - Duration in seconds
+ * @param options - Formatting options
+ * @returns Formatted duration string
+ */
+export declare function formatDuration(seconds: number, options?: DurationFormatOptions): string;
+/**
+ * Phone number formatting options
+ */
+export interface PhoneFormatOptions {
+    format?: 'national' | 'international' | 'e164';
+    countryCode?: string;
+}
+/**
+ * Formats a phone number
+ *
+ * @param phone - Phone number string (digits only)
+ * @param options - Formatting options
+ * @returns Formatted phone number string
+ */
+export declare function formatPhone(phone: string, options?: PhoneFormatOptions): string;
+/**
+ * Truncates text to a maximum length with ellipsis
+ *
+ * @param text - Text to truncate
+ * @param maxLength - Maximum length
+ * @param suffix - Suffix to add (default: '...')
+ * @returns Truncated text
+ */
+export declare function truncateText(text: string, maxLength: number, suffix?: string): string;
+/**
+ * Capitalizes the first letter of a string
+ *
+ * @param text - Text to capitalize
+ * @returns Capitalized text
+ */
+export declare function capitalize(text: string): string;
+/**
+ * Converts a string to title case
+ *
+ * @param text - Text to convert
+ * @returns Title case text
+ */
+export declare function toTitleCase(text: string): string;
+/**
+ * Converts a string to slug format
+ *
+ * @param text - Text to convert
+ * @returns Slug string
+ */
+export declare function toSlug(text: string): string;

package/dist/utils/hooks/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared Hooks Barrel Export
+ */
+export { useAsyncOperation } from './useAsyncOperation';
+export type { AsyncOperationOptions, AsyncOperationState, AsyncOperationActions, AsyncOperationReturn, ErrorHandler, } from './types/AsyncOperationTypes';

package/dist/utils/hooks/types/AsyncOperationTypes.d.ts

@@ -0,0 +1,52 @@
+/**
+ * AsyncOperation Types
+ * Type definitions for useAsyncOperation hook
+ */
+export type ErrorHandler<E = Error> = (error: unknown) => E;
+export interface AsyncOperationOptions<T, E = Error> {
+    /** Skip execution (useful for conditional operations) */
+    skip?: boolean;
+    /** Execute immediately on mount */
+    immediate?: boolean;
+    /** Initial data value */
+    initialData?: T | null;
+    /** Convert error to custom type */
+    errorHandler?: ErrorHandler<E>;
+    /** Callback on success */
+    onSuccess?: (data: T) => void;
+    /** Callback on error */
+    onError?: (error: E) => void;
+    /** Callback on finally (success or error) */
+    onFinally?: () => void;
+    /** Enable retry functionality */
+    enableRetry?: boolean;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+}
+export interface AsyncOperationState<T, E = Error> {
+    /** Current data value */
+    data: T | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: E | null;
+    /** Is operation idle (not executed yet) */
+    isIdle: boolean;
+    /** Is operation successful */
+    isSuccess: boolean;
+    /** Is operation in error state */
+    isError: boolean;
+}
+export interface AsyncOperationActions<T, E = Error> {
+    /** Execute the async operation */
+    execute: (...args: any[]) => Promise<T | null>;
+    /** Retry the last operation */
+    retry: () => Promise<T | null>;
+    /** Reset to initial state */
+    reset: () => void;
+    /** Set data manually */
+    setData: (data: T | null) => void;
+    /** Set error manually */
+    setError: (error: E | null) => void;
+}
+export type AsyncOperationReturn<T, E = Error> = AsyncOperationState<T, E> & AsyncOperationActions<T, E>;

package/dist/utils/hooks/useAsyncOperation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * useAsyncOperation Hook
+ *
+ * Eliminates duplicate async error handling patterns across hooks.
+ * Handles isMountedRef + try-catch-finally + loading/error state management.
+ *
+ * Based on the useAsyncData pattern from useDeviceInfo.ts but generalized
+ * for broader use cases.
+ *
+ * @example
+ * ```typescript
+ * // Simple usage (like useAsyncData)
+ * const { data, isLoading, error, execute } = useAsyncOperation(
+ *   async () => await fetchData(),
+ *   { immediate: true }
+ * );
+ *
+ * // Manual execution (like useMedia)
+ * const { execute, isLoading, error } = useAsyncOperation(
+ *   async (uri: string) => await pickImage(uri),
+ *   { immediate: false }
+ * );
+ * const result = await execute('file://...');
+ *
+ * // With custom error handling
+ * const { data, error } = useAsyncOperation(
+ *   async () => await riskyOperation(),
+ *   {
+ *     errorHandler: (err) => err instanceof Error ? err.message : 'Failed',
+ *     onError: (err) => console.error('Operation failed:', err),
+ *   }
+ * );
+ * ```
+ */
+import type { AsyncOperationOptions, AsyncOperationReturn } from './types/AsyncOperationTypes';
+export declare function useAsyncOperation<T, E = Error>(operation: (...args: any[]) => Promise<T>, options?: AsyncOperationOptions<T, E>): AsyncOperationReturn<T, E>;

package/dist/utils/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utils Module
+ *
+ * Centralized utility functions for the design system.
+ *
+ * Usage:
+ *   import { createMappedArray, retryWithBackoff, formatFileSize, clamp, Logger, DesignSystemError } from '@umituz/react-native-design-system/utils';
+ */
+export { createMappedArray, safeSlice, filterById, findById, } from './arrayUtils';
+export { MILLISECONDS_PER_SECOND, MILLISECONDS_PER_MINUTE, MILLISECONDS_PER_HOUR, MILLISECONDS_PER_DAY, SECONDS_PER_MINUTE, SECONDS_PER_HOUR, SECONDS_PER_DAY, MINUTES_PER_HOUR, MINUTES_PER_DAY, ONE_SECOND_MS, FIVE_SECONDS_MS, TEN_SECONDS_MS, THIRTY_SECONDS_MS, ONE_MINUTE_MS, FIVE_MINUTES_MS, TEN_MINUTES_MS, THIRTY_MINUTES_MS, ONE_HOUR_MS, ONE_DAY_MS, DEFAULT_TIMEOUT_MS, DEFAULT_LONG_TIMEOUT_MS, DEFAULT_CACHE_TTL_MS, } from './constants/TimeConstants';
+export { retryWithBackoff, retryWithTimeout, isNetworkError, isRetryableHttpStatus, type RetryOptions, } from './async';
+export { formatFileSize, formatDuration, formatPhone, truncateText, capitalize, toTitleCase, toSlug, type FileSizeFormatOptions, type DurationFormatOptions, type PhoneFormatOptions, } from './formatters/stringFormatter';
+export { clamp, calculatePercentage, roundTo, calculateGridItemWidth, isInRange, lerp, mapRange, normalizeProgress, formatPercentage, calculateStepProgress, isComplete, hasStarted, intensityToOpacity, createRgbaColor, ratioToOpacity, } from './math';
+export { Logger, logger, type LoggerConfig, } from './logger';
+export { useAsyncOperation, type AsyncOperationOptions, type AsyncOperationState, type AsyncOperationActions, type AsyncOperationReturn, type ErrorHandler as AsyncErrorHandler, } from './hooks';
+export { DesignSystemError, ErrorCodes, ErrorCategory, } from './errors';
+export type { ErrorCode, ErrorMetadata, } from './errors';
+export { ErrorHandler } from './errors/ErrorHandler';
+export type { Result, } from './errors/types/Result';
+export { ok, err, unwrap, unwrapOr, map, mapError, } from './errors';

package/dist/utils/logger.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Logger Utility
+ * Production-safe logging that respects __DEV__ flag
+ * Logs are suppressed in production builds to reduce bundle size and improve performance
+ */
+interface LoggerConfig {
+    enableInProduction?: boolean;
+    errorTrackingService?: (error: unknown, context?: Record<string, unknown>) => void;
+}
+declare class Logger {
+    private isDev;
+    private config;
+    constructor(config?: LoggerConfig);
+    /**
+     * Debug logging - only in development
+     * Use for detailed debugging information
+     */
+    debug(...args: unknown[]): void;
+    /**
+     * Info logging - only in development
+     * Use for general information
+     */
+    info(...args: unknown[]): void;
+    /**
+     * Warning logging - always shown
+     * Use for recoverable issues
+     */
+    warn(...args: unknown[]): void;
+    /**
+     * Error logging - always shown
+     * Use for errors and exceptions
+     * In production, sends to error tracking service if configured
+     */
+    error(...args: unknown[]): void;
+    /**
+     * Group logging - only in development
+     * Use for grouping related logs
+     */
+    group(label: string): void;
+    /**
+     * End group logging - only in development
+     */
+    groupEnd(): void;
+    /**
+     * Table logging - only in development
+     * Use for displaying tabular data
+     */
+    table(data: unknown): void;
+    /**
+     * Time measurement - only in development
+     * Use for performance measurements
+     */
+    time(label: string): void;
+    /**
+     * End time measurement - only in development
+     */
+    timeEnd(label: string): void;
+    /**
+     * Assert logging - only in development
+     * Use for assertions
+     */
+    assert(condition: boolean, ...args: unknown[]): void;
+    /**
+     * Configure logger
+     */
+    configure(config: LoggerConfig): void;
+}
+export declare const logger: Logger;
+export { Logger };
+export type { LoggerConfig };

package/dist/utils/math/CalculationUtils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Calculation Utilities
+ *
+ * Common mathematical calculations used throughout the app
+ */
+/**
+ * Clamps a number between a minimum and maximum value
+ * @param value - The value to clamp
+ * @param min - Minimum allowed value (default: 0)
+ * @param max - Maximum allowed value (default: 100)
+ * @returns Clamped value
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+/**
+ * Calculates progress percentage
+ * @param current - Current value
+ * @param total - Total value
+ * @returns Percentage (0-100)
+ */
+export declare function calculatePercentage(current: number, total: number): number;
+/**
+ * Rounds a number to specified decimal places
+ * @param value - The value to round
+ * @param decimals - Number of decimal places (default: 0)
+ * @returns Rounded value
+ */
+export declare function roundTo(value: number, decimals?: number): number;
+/**
+ * Converts intensity (0-100) to opacity (0-1)
+ * @param intensity - Intensity value (0-100)
+ * @param minOpacity - Minimum opacity (default: 0.05)
+ * @param maxOpacity - Maximum opacity (default: 0.95)
+ * @returns Opacity value (0-1)
+ */
+export declare function intensityToOpacity(intensity: number, minOpacity?: number, maxOpacity?: number): number;
+/**
+ * Calculates grid item width based on container width and columns
+ * @param containerWidth - Total container width
+ * @param columns - Number of columns
+ * @param gap - Gap between items in pixels
+ * @returns Item width in pixels
+ */
+export declare function calculateGridItemWidth(containerWidth: number, columns: number, gap: number): number;
+/**
+ * Checks if a value is within a range (inclusive)
+ * @param value - Value to check
+ * @param min - Range minimum
+ * @param max - Range maximum
+ * @returns True if value is in range
+ */
+export declare function isInRange(value: number, min: number, max: number): boolean;
+/**
+ * Linear interpolation between two values
+ * @param start - Start value
+ * @param end - End value
+ * @param progress - Progress (0-1)
+ * @returns Interpolated value
+ */
+export declare function lerp(start: number, end: number, progress: number): number;
+/**
+ * Maps a value from one range to another
+ * @param value - Value to map
+ * @param inMin - Input range minimum
+ * @param inMax - Input range maximum
+ * @param outMin - Output range minimum
+ * @param outMax - Output range maximum
+ * @returns Mapped value
+ */
+export declare function mapRange(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;

package/dist/utils/math/OpacityUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Opacity Utilities
+ *
+ * Helper functions for opacity-related calculations
+ */
+/**
+ * Converts intensity value to opacity for glassmorphism effects
+ * @param intensity - Intensity value (0-100)
+ * @param options - Configuration options
+ * @returns Opacity value (0-1)
+ */
+export declare function intensityToOpacity(intensity: number, options?: {
+    minOpacity?: number;
+    maxOpacity?: number;
+    invert?: boolean;
+}): number;
+/**
+ * Creates an RGBA color string with specified opacity
+ * @param rgb - RGB color as array [r, g, b]
+ * @param opacity - Opacity value (0-1)
+ * @returns RGBA color string
+ */
+export declare function createRgbaColor(rgb: [number, number, number], opacity: number): string;
+/**
+ * Calculates opacity based on a ratio (0-1)
+ * @param ratio - Ratio value (0-1)
+ * @param minOpacity - Minimum opacity (default: 0.1)
+ * @param maxOpacity - Maximum opacity (default: 1)
+ * @returns Opacity value (0-1)
+ */
+export declare function ratioToOpacity(ratio: number, minOpacity?: number, maxOpacity?: number): number;