@jmruthers/pace-core 0.5.135 → 0.5.137

package/dist/utils.d.ts

@@ -1,11 +1,14 @@
-export { A as AppConfig, S as SecureDataAccess, a as cn, j as formatCompactNumber, e as formatCurrency, f as formatDate, k as formatFileSize, h as formatNumber, i as formatPercent, g as getAppConfig, d as getCurrentAppId, b as getCurrentAppName, s as setAppConfig, u as useSessionTracking } from './formatting-DFcCxUEk.js';
+export { S as SecureDataAccess, a as cn, j as formatCompactNumber, e as formatCurrency, f as formatDate, k as formatFileSize, h as formatNumber, i as formatPercent, g as getAppConfig, d as getCurrentAppId, s as setAppConfig, u as useSessionTracking } from './formatting-CvUXy2mF.js';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { D as Database } from './database-C6jy7EOu.js';
+export { deepMerge, isEmpty, isObject, isStrongPassword, isValidDate, isValidEmail, isValidUrl, isWithinRange, matchesPattern } from './validation.js';
 import { z } from 'zod';
+export { c as combineSchemas, p as pickSchema } from './schema-DTDZQe2u.js';
 export { u as useComponentPerformance } from './useComponentPerformance-DE9l5RkL.js';
 import * as date_fns from 'date-fns';
-import { D as DataTable } from './DataTable-C7GaRZye.js';
-import './types-D5rqZQXk.js';
+import { D as DataTable } from './DataTable-CWAZZcXC.js';
+import './types-Dfz9dmVH.js';
 import React__default, { ComponentType } from 'react';
-import { SupabaseClient } from '@supabase/supabase-js';
 import 'clsx';
 import 'react/jsx-runtime';
 import '@tanstack/react-table';
@@ -43,6 +46,109 @@ declare class DebugLogger {
     static info(component: string, message: string, ...args: any[]): void;
 }
 
+/**
+ * @file Production-Safe Logger Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/Logger
+ * @since 0.4.76
+ */
+/**
+ * Logger levels for different types of messages
+ */
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Logger configuration interface
+ */
+interface LoggerConfig {
+    /** Minimum log level to output */
+    level: LogLevel;
+    /** Whether to include timestamps */
+    includeTimestamp: boolean;
+    /** Whether to include component names */
+    includeComponent: boolean;
+    /** Custom prefix for all log messages */
+    prefix?: string;
+}
+/**
+ * Production-safe logger that no-ops in production builds
+ * Only outputs logs in development mode to prevent production console spam
+ */
+declare class Logger {
+    private static config;
+    /**
+     * Check if we're in development or test mode
+     * Allows logging in both development and test environments
+     */
+    private static get isDevelopment();
+    /**
+     * Configure the logger
+     */
+    static configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Format a log message with optional timestamp and component
+     */
+    private static formatMessage;
+    /**
+     * Check if a log level should be output
+     */
+    private static shouldLog;
+    /**
+     * Log debug information (development only)
+     */
+    static debug(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log info information (development only)
+     */
+    static info(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log warning information (development only)
+     */
+    static warn(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log error information (development only)
+     */
+    static error(component: string, message: string, ...args: any[]): void;
+    /**
+     * Create a scoped logger for a specific component
+     */
+    static createScopedLogger(component: string): {
+        debug: (message: string, ...args: any[]) => void;
+        info: (message: string, ...args: any[]) => void;
+        warn: (message: string, ...args: any[]) => void;
+        error: (message: string, ...args: any[]) => void;
+    };
+}
+/**
+ * Default logger instance for convenience
+ */
+declare const logger: {
+    debug: (component: string, message: string, ...args: any[]) => void;
+    info: (component: string, message: string, ...args: any[]) => void;
+    warn: (component: string, message: string, ...args: any[]) => void;
+    error: (component: string, message: string, ...args: any[]) => void;
+    createScopedLogger: (component: string) => {
+        debug: (message: string, ...args: any[]) => void;
+        info: (message: string, ...args: any[]) => void;
+        warn: (message: string, ...args: any[]) => void;
+        error: (message: string, ...args: any[]) => void;
+    };
+    configure: (config: Partial<LoggerConfig>) => void;
+};
+/**
+ * Convenience function to create a scoped logger
+ */
+declare function createLogger(component: string): {
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+};
+
 /**
  * Utility to resolve the current app name from various sources
  * Priority: package.json > environment variables > fallback
@@ -67,6 +173,11 @@ declare function getAppNameFromGlobal(): string | null;
  * Fallback method for when package.json is not available
  */
 declare function getAppNameFromEnvironment(): string | null;
+/**
+ * Get the current app name from the most reliable source
+ * Priority: global variable > build-time injection > package.json > environment variables > null
+ */
+declare function getCurrentAppName(): string | null;
 /**
  * Set the app name globally for RBAC resolution
  * Call this in your app's main entry point (e.g., main.tsx, index.tsx)
@@ -92,55 +203,46 @@ declare function setRBACAppName(appName: string): void;
 declare function getCurrentAppNameWithFallback(fallback?: string): string;
 
 /**
- * @file Internal utilities for validation module
- * @internal This file contains implementation details that should not be used directly
- */
-/**
- * Utility functions for validating data in the application
- */
-/**
- * Check if a string is a valid email
- */
-declare function isValidEmail(email: string): boolean;
-/**
- * Check if a string is empty (either null, undefined, or just whitespace)
- */
-declare function isEmpty(value: string | null | undefined): boolean;
-/**
- * Check if a password meets minimum requirements
- */
-declare function isStrongPassword(password: string): boolean;
-/**
- * Check if a URL is valid
- */
-declare function isValidUrl(url: string): boolean;
-/**
- * Check if a date string is valid
- */
-declare function isValidDate(dateStr: string): boolean;
-/**
- * Check if a value is within a range
+ * App ID Resolution Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/AppIdResolver
+ * @since 1.0.0
+ *
+ * This module provides utilities to resolve app names to app IDs for database operations.
  */
-declare function isWithinRange(value: number, min: number, max: number): boolean;
+
 /**
- * Check if a value matches a specific pattern
+ * Resolves an app name to its corresponding app ID
+ *
+ * @param supabase - Supabase client instance
+ * @param appName - The app name to resolve
+ * @returns Promise resolving to the app ID or null if not found
  */
-declare function matchesPattern(value: string, pattern: RegExp): boolean;
+declare function getAppId(supabase: SupabaseClient<Database>, appName: string): Promise<string | null>;
 /**
- * Utility function to deep merge objects for schema combination
- * @internal
+ * Resolves multiple app names to their corresponding app IDs
+ *
+ * @param supabase - Supabase client instance
+ * @param appNames - Array of app names to resolve
+ * @returns Promise resolving to a map of app names to app IDs
  */
-declare function deepMerge<T extends Record<string, unknown>>(target: T, source: Record<string, unknown>): T;
+declare function getAppIds(supabase: SupabaseClient<Database>, appNames: string[]): Promise<Record<string, string | null>>;
 /**
- * Type guard to check if a value is a plain object
- * @internal
+ * Cached app ID resolver with TTL
  */
-declare function isObject(item: unknown): item is Record<string, unknown>;
+declare class CachedAppIdResolver {
+    private cache;
+    private ttl;
+    getAppId(supabase: SupabaseClient<Database>, appName: string): Promise<string | null>;
+    clearCache(): void;
+    clearCacheForApp(appName: string): void;
+}
+declare const cachedAppIdResolver: CachedAppIdResolver;
 
 /**
  * @file Input Sanitization Layer
  * @package @jmruthers/pace-core
- * @module Security
+ * @module Utils/Validation/Sanitization
  * @since 0.1.0
  *
  * Comprehensive input sanitization utilities to prevent XSS, injection attacks,
@@ -162,26 +264,6 @@ interface SanitizationOptions {
  * Sanitizes user input by removing potentially dangerous characters and patterns
  */
 declare function sanitizeUserInput(input: string, options?: SanitizationOptions): string;
-/**
- * Sanitizes email addresses
- */
-declare function sanitizeEmail(email: string): string;
-/**
- * Sanitizes phone numbers
- */
-declare function sanitizePhoneNumber(phone: string): string;
-/**
- * Sanitizes URLs
- */
-declare function sanitizeUrl(url: string): string;
-/**
- * Sanitizes file names
- */
-declare function sanitizeFileName(fileName: string): string;
-/**
- * Sanitizes SQL input to prevent injection
- */
-declare function sanitizeSqlInput(input: string): string;
 /**
  * Validates and sanitizes form data using Zod schemas
  */
@@ -190,31 +272,6 @@ declare function sanitizeFormData<T>(data: unknown, schema: z.ZodSchema<T>, sani
     data?: T;
     error?: string;
 };
-/**
- * Content Security Policy (CSP) utilities
- */
-declare const CSP_DIRECTIVES: {
-    default: string;
-    script: string;
-    style: string;
-    img: string;
-    font: string;
-    connect: string;
-    frame: string;
-};
-declare function generateCSPHeader(customDirectives?: Partial<typeof CSP_DIRECTIVES>): string;
-/**
- * Rate limiting utilities
- */
-declare class RateLimiter {
-    private maxAttempts;
-    private windowMs;
-    private attempts;
-    constructor(maxAttempts?: number, windowMs?: number);
-    isAllowed(identifier: string): boolean;
-    getRemainingAttempts(identifier: string): number;
-    reset(identifier: string): void;
-}
 
 /**
  * @file Validation utilities
@@ -231,34 +288,41 @@ declare function validateUserInput<T>(schema: z.ZodSchema<T>, data: unknown, san
     error?: string;
 };
 /**
- * Sanitizes user input by removing potentially dangerous characters
- * @deprecated Use sanitizeUserInput from lib/sanitization instead
+ * Username validation with sanitization
  */
-declare function sanitizeUserInput_deprecated(input: string): string;
+declare const usernameSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, string, string>, z.ZodString>;
+
 /**
- * Enhanced email validation with sanitization
+ * @file Common validation schemas
+ * @description Reusable validation schemas for common data types
  */
-declare const emailSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, string, string>, z.ZodString>;
+
 /**
- * Enhanced password validation
+ * Email validation schema
  */
-declare const passwordSchema: z.ZodString;
+declare const emailSchema: z.ZodString;
 /**
- * Username validation with sanitization
+ * Name validation schema
  */
-declare const usernameSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, string, string>, z.ZodString>;
+declare const nameSchema: z.ZodString;
 /**
- * Name validation with sanitization
+ * Phone number validation schema
  */
-declare const nameSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+declare const phoneSchema: z.ZodString;
+/**
+ * URL validation schema
+ */
+declare const urlSchema: z.ZodString;
+
 /**
- * Phone number validation with sanitization
+ * @file Enhanced Password Schema with Security Validations
+ * @description Comprehensive password validation with security checks
  */
-declare const phoneSchema: z.ZodEffects<z.ZodString, string, string>;
+
 /**
- * URL validation with sanitization
+ * Basic password schema for less strict requirements
  */
-declare const urlSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+declare const passwordSchema: z.ZodString;
 
 interface SecurityEvent$1 {
     type: string;
@@ -269,6 +333,27 @@ interface SecurityEvent$1 {
 declare function getSecurityHeaders(): Record<string, string>;
 declare function validateSecurityHeaders(headers: Record<string, string>): boolean;
 
+interface SecurityEvent {
+    id?: string;
+    action: string;
+    details: Record<string, any>;
+    timestamp?: number;
+}
+interface SecurityAlert {
+    id: string;
+    type: string;
+    message: string;
+    timestamp: Date;
+}
+declare class SecurityMonitor {
+    private events;
+    logEvent(event: SecurityEvent): void;
+    getEvents(): SecurityEvent[];
+    clearEvents(): void;
+    createAlert(alert: Omit<SecurityAlert, 'id' | 'timestamp'>): SecurityAlert;
+}
+declare const securityMonitor: SecurityMonitor;
+
 /**
  * Performance thresholds and constants
  */
@@ -318,6 +403,39 @@ declare const bundleAnalyzer: BundleAnalyzer;
 declare function validateImportPattern(moduleId: string, importedItems: string[]): void;
 declare function trackDynamicImport(moduleName: string): void;
 
+interface PerformanceBudget {
+    metric: string;
+    budget: number;
+    actual: number;
+    threshold: 'error' | 'warning' | 'info';
+}
+interface PerformanceMetrics {
+    bundleSize: number;
+    chunkCount: number;
+    treeshakingEffectiveness: number;
+    dynamicImportUsage: number;
+}
+interface MeasurementResult {
+    passed: boolean;
+    value: number;
+    threshold: number;
+}
+declare const PERFORMANCE_BUDGETS: {
+    [key: string]: {
+        threshold: number;
+    };
+};
+declare class PerformanceBudgetMonitor {
+    private metrics;
+    private budgets;
+    measure(metric: string, value: number, metadata?: Record<string, unknown>): MeasurementResult;
+    setBudget(metric: string, budget: number, threshold?: 'error' | 'warning' | 'info'): void;
+    checkBudgets(): PerformanceBudget[];
+    getMetrics(): PerformanceMetrics;
+    reset(): void;
+}
+declare const performanceBudgetMonitor: PerformanceBudgetMonitor;
+
 /**
  * Dynamic utility loader to reduce initial bundle size
  * Heavy utilities are loaded on-demand
@@ -366,39 +484,6 @@ declare const lazyChartUtils: ReturnType<typeof createLazyUtility<unknown>>;
 declare const lazyFormUtils: ReturnType<typeof createLazyUtility<Awaited<ReturnType<typeof loadFormUtils>>>>;
 declare const lazyCSVUtils: ReturnType<typeof createLazyUtility<unknown>>;
 
-interface PerformanceBudget {
-    metric: string;
-    budget: number;
-    actual: number;
-    threshold: 'error' | 'warning' | 'info';
-}
-interface PerformanceMetrics {
-    bundleSize: number;
-    chunkCount: number;
-    treeshakingEffectiveness: number;
-    dynamicImportUsage: number;
-}
-interface MeasurementResult {
-    passed: boolean;
-    value: number;
-    threshold: number;
-}
-declare const PERFORMANCE_BUDGETS: {
-    [key: string]: {
-        threshold: number;
-    };
-};
-declare class PerformanceBudgetMonitor {
-    private metrics;
-    private budgets;
-    measure(metric: string, value: number, metadata?: Record<string, unknown>): MeasurementResult;
-    setBudget(metric: string, budget: number, threshold?: 'error' | 'warning' | 'info'): void;
-    checkBudgets(): PerformanceBudget[];
-    getMetrics(): PerformanceMetrics;
-    reset(): void;
-}
-declare const performanceBudgetMonitor: PerformanceBudgetMonitor;
-
 interface LazyLoadOptions {
     fallback?: React__default.ReactNode;
     errorBoundary?: ComponentType<{
@@ -441,43 +526,6 @@ declare function parsePermission(permission: string): {
     action: string;
 } | null;
 
-/**
- * Creates a subset schema from a larger schema
- *
- * @param schema - Original Zod schema
- * @param keys - Array of keys to pick from the schema
- * @returns New schema with only the selected fields
- */
-declare function pickSchema<T extends z.ZodObject<any, any, any>, K extends keyof z.infer<T>>(schema: T, keys: K[]): z.ZodObject<any>;
-/**
- * Combines multiple Zod schemas into one
- *
- * @param schemas - Array of Zod schemas to combine
- * @returns Combined schema
- */
-declare function combineSchemas<T extends z.ZodObject<any, any, any>[]>(schemas: T): z.ZodObject<any>;
-
-interface SecurityEvent {
-    id?: string;
-    action: string;
-    details: Record<string, any>;
-    timestamp?: number;
-}
-interface SecurityAlert {
-    id: string;
-    type: string;
-    message: string;
-    timestamp: Date;
-}
-declare class SecurityMonitor {
-    private events;
-    logEvent(event: SecurityEvent): void;
-    getEvents(): SecurityEvent[];
-    clearEvents(): void;
-    createAlert(alert: Omit<SecurityAlert, 'id' | 'timestamp'>): SecurityAlert;
-}
-declare const securityMonitor: SecurityMonitor;
-
 /**
  * @file Audit Logger - General Utility
  *
@@ -597,4 +645,4 @@ declare function getOrganisationContext(supabase: SupabaseClient): Promise<strin
  */
 declare function isOrganisationContextAvailable(supabase: SupabaseClient): Promise<boolean>;
 
-export { CSP_DIRECTIVES, DebugLogger, LazyDataTable, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, RateLimiter, type SanitizationOptions, type SecurityEvent$1 as SecurityEvent, auditLog, auditLogger, bundleAnalyzer, clearOrganisationContext, combineSchemas, createLazyComponent, createLazyUtility, createPerformanceBenchmark, deepMerge, emailSchema, generateCSPHeader, generateDeviceFingerprint, getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCurrentAppNameWithFallback, getOrganisationContext, getSecurityHeaders, hasAllPermissions, hasAnyPermission, hasPermission, isEmpty, isObject, isOrganisationContextAvailable, isStrongPassword, isValidDate, isValidEmail, isValidUrl, isWithinRange, lazyCSVUtils, lazyChartUtils, lazyDateUtils, lazyFormUtils, lazyLodash, loadCSVUtils, loadChartUtils, loadDateUtils, loadFormUtils, loadLodash, logAuditEvent, logAuthEvent, logPermissionEvent, logSecurityEvent, matchesPattern, measureRenderPerformance, nameSchema, parsePermission, passwordSchema, performanceBudgetMonitor, phoneSchema, pickSchema, sanitizeEmail, sanitizeFileName, sanitizeFormData, sanitizePhoneNumber, sanitizeSqlInput, sanitizeUrl, sanitizeUserInput, sanitizeUserInput_deprecated, securityMonitor, setOrganisationContext, setRBACAppName, trackDynamicImport, transformPermissionMapToBoolean, urlSchema, usernameSchema, validateDeviceFingerprint, validateImportPattern, validateSecurityHeaders, validateUserInput };
+export { CachedAppIdResolver, DebugLogger, LazyDataTable, LogLevel, Logger, type LoggerConfig, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, type SecurityEvent$1 as SecurityEvent, auditLog, auditLogger, bundleAnalyzer, cachedAppIdResolver, clearOrganisationContext, createLazyComponent, createLazyUtility, createLogger, createPerformanceBenchmark, emailSchema, generateDeviceFingerprint, getAppId, getAppIds, getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCurrentAppName, getCurrentAppNameWithFallback, getOrganisationContext, getSecurityHeaders, hasAllPermissions, hasAnyPermission, hasPermission, isOrganisationContextAvailable, lazyCSVUtils, lazyChartUtils, lazyDateUtils, lazyFormUtils, lazyLodash, loadCSVUtils, loadChartUtils, loadDateUtils, loadFormUtils, loadLodash, logAuditEvent, logAuthEvent, logPermissionEvent, logSecurityEvent, logger, measureRenderPerformance, nameSchema, parsePermission, passwordSchema, performanceBudgetMonitor, phoneSchema, sanitizeFormData, sanitizeUserInput, securityMonitor, setOrganisationContext, setRBACAppName, trackDynamicImport, transformPermissionMapToBoolean, urlSchema, usernameSchema, validateDeviceFingerprint, validateImportPattern, validateSecurityHeaders, validateUserInput };