@jmruthers/pace-core 0.2.4

package/dist/utils.js

@@ -0,0 +1,1103 @@
+import {
+  getAppNameFromBuildTime,
+  getAppNameFromEnvironment,
+  getAppNameFromGlobal,
+  getAppNameFromPackageJson,
+  getCurrentAppNameWithFallback,
+  init_appNameResolver,
+  setRBACAppName
+} from "./chunk-MZBUOP4P.js";
+import {
+  getAppConfig,
+  getCurrentAppId,
+  getCurrentAppName,
+  setAppConfig
+} from "./chunk-22KLBHPS.js";
+import {
+  LoadingSpinner
+} from "./chunk-CDQ3PX7L.js";
+import {
+  secureStorage
+} from "./chunk-5CDJCTOO.js";
+import {
+  useComponentPerformance
+} from "./chunk-I5Z3QH5X.js";
+import {
+  PERFORMANCE_BUDGETS,
+  performanceBudgetMonitor
+} from "./chunk-74C6SNEC.js";
+import {
+  DebugLogger,
+  clearOrganisationContext,
+  getOrganisationContext,
+  init_debugLogger,
+  init_organisationContext,
+  isOrganisationContextAvailable,
+  setOrganisationContext
+} from "./chunk-2V3Y6YBC.js";
+import {
+  cn,
+  init_cn
+} from "./chunk-OHXGNT3K.js";
+import "./chunk-PLDDJCW6.js";
+
+// src/utils/index.ts
+init_cn();
+init_debugLogger();
+init_appNameResolver();
+
+// src/utils/validation.ts
+function isValidEmail(email) {
+  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailPattern.test(email);
+}
+function isEmpty(value) {
+  return value === null || value === void 0 || value.trim() === "";
+}
+function isStrongPassword(password) {
+  const passwordPattern = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/;
+  return passwordPattern.test(password);
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidDate(dateStr) {
+  const date = new Date(dateStr);
+  return !isNaN(date.getTime());
+}
+function isWithinRange(value, min, max) {
+  return value >= min && value <= max;
+}
+function matchesPattern(value, pattern) {
+  return pattern.test(value);
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          const targetKey = key;
+          const targetValue = target[targetKey];
+          if (isObject(targetValue)) {
+            output[targetKey] = deepMerge(
+              targetValue,
+              source[key]
+            );
+          }
+        }
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+  return output;
+}
+function isObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+
+// src/utils/validationUtils.ts
+import { z as z2 } from "zod";
+
+// src/utils/sanitization.ts
+import { z } from "zod";
+var DEFAULT_OPTIONS = {
+  allowHtml: false,
+  allowedTags: [],
+  maxLength: 1e3,
+  trim: true,
+  removeScripts: true,
+  removeEvents: true
+};
+function sanitizeUserInput(input, options = {}) {
+  if (typeof input !== "string") {
+    return "";
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let sanitized = input;
+  if (opts.trim) {
+    sanitized = sanitized.trim();
+  }
+  if (opts.maxLength && sanitized.length > opts.maxLength) {
+    sanitized = sanitized.substring(0, opts.maxLength);
+  }
+  if (!opts.allowHtml) {
+    sanitized = sanitized.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/\//g, "&#x2F;");
+  } else if (opts.allowedTags && opts.allowedTags.length > 0) {
+    const allowedTagsRegex = new RegExp(`<(?!/?(?:${opts.allowedTags.join("|")})s*/?>)[^>]+>`, "gi");
+    sanitized = sanitized.replace(allowedTagsRegex, "");
+  }
+  if (opts.removeScripts) {
+    sanitized = sanitized.replace(/<script[^>]*>.*?<\/script>/gi, "").replace(/javascript:/gi, "").replace(/vbscript:/gi, "").replace(/data:/gi, "");
+  }
+  if (opts.removeEvents) {
+    sanitized = sanitized.replace(/on\w+\s*=/gi, "");
+  }
+  return sanitized;
+}
+function sanitizeEmail(email) {
+  if (typeof email !== "string") {
+    return "";
+  }
+  return email.trim().toLowerCase().replace(/[^\w@.-]/g, "");
+}
+function sanitizePhoneNumber(phone) {
+  if (typeof phone !== "string") {
+    return "";
+  }
+  return phone.replace(/[^\d+\-\s()]/g, "").trim();
+}
+function sanitizeUrl(url) {
+  if (typeof url !== "string") {
+    return "";
+  }
+  const sanitized = url.trim();
+  if (!/^https?:\/\/|^ftp:\/\//i.test(sanitized)) {
+    return "";
+  }
+  if (/javascript:|data:|vbscript:/i.test(sanitized)) {
+    return "";
+  }
+  return sanitized;
+}
+function sanitizeFileName(fileName) {
+  if (typeof fileName !== "string") {
+    return "";
+  }
+  return fileName.trim().replace(/[<>:"/\\|?*]/g, "").replace(/\.\./g, "").substring(0, 255);
+}
+function sanitizeSqlInput(input) {
+  if (typeof input !== "string") {
+    return "";
+  }
+  return input.replace(/['";\\]/g, "").replace(/--.*$/gm, "").replace(/\/\*.*?\*\//g, "").trim();
+}
+function sanitizeFormData(data, schema, sanitizationRules) {
+  try {
+    if (sanitizationRules && typeof data === "object" && data !== null) {
+      const sanitizedData = { ...data };
+      Object.entries(sanitizationRules).forEach(([field, options]) => {
+        if (typeof sanitizedData[field] === "string") {
+          sanitizedData[field] = sanitizeUserInput(sanitizedData[field], options);
+        }
+      });
+      data = sanitizedData;
+    }
+    const result = schema.parse(data);
+    return { success: true, data: result };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: error.errors.map((e) => e.message).join(", ")
+      };
+    }
+    return {
+      success: false,
+      error: "Validation failed"
+    };
+  }
+}
+var CSP_DIRECTIVES = {
+  default: "default-src 'self'",
+  script: "script-src 'self' 'unsafe-inline'",
+  style: "style-src 'self' 'unsafe-inline'",
+  img: "img-src 'self' data: https:",
+  font: "font-src 'self'",
+  connect: "connect-src 'self'",
+  frame: "frame-src 'none'"
+};
+function generateCSPHeader(customDirectives) {
+  const directives = { ...CSP_DIRECTIVES, ...customDirectives };
+  return Object.values(directives).join("; ");
+}
+var RateLimiter = class {
+  constructor(maxAttempts = 5, windowMs = 15 * 60 * 1e3) {
+    this.maxAttempts = maxAttempts;
+    this.windowMs = windowMs;
+    this.attempts = /* @__PURE__ */ new Map();
+  }
+  isAllowed(identifier) {
+    const now = Date.now();
+    const record = this.attempts.get(identifier);
+    if (!record || now > record.resetTime) {
+      this.attempts.set(identifier, { count: 1, resetTime: now + this.windowMs });
+      return true;
+    }
+    if (record.count >= this.maxAttempts) {
+      return false;
+    }
+    record.count++;
+    return true;
+  }
+  getRemainingAttempts(identifier) {
+    const record = this.attempts.get(identifier);
+    if (!record || Date.now() > record.resetTime) {
+      return this.maxAttempts;
+    }
+    return Math.max(0, this.maxAttempts - record.count);
+  }
+  reset(identifier) {
+    this.attempts.delete(identifier);
+  }
+};
+
+// src/utils/validationUtils.ts
+function validateUserInput(schema, data, sanitizationRules) {
+  return sanitizeFormData(data, schema, sanitizationRules);
+}
+function sanitizeUserInput_deprecated(input) {
+  console.warn("sanitizeUserInput is deprecated. Use sanitizeUserInput from lib/sanitization instead.");
+  return sanitizeUserInput(input);
+}
+var emailSchema = z2.string().transform((email) => email.toLowerCase().trim()).pipe(z2.string().min(1, "Email is required").email("Invalid email format").max(254, "Email too long"));
+var passwordSchema = z2.string().min(8, "Password must be at least 8 characters").max(128, "Password too long").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number").regex(/[^A-Za-z0-9]/, "Password must contain at least one special character");
+var usernameSchema = z2.string().transform((username) => username.toLowerCase().trim()).pipe(z2.string().min(3, "Username must be at least 3 characters").max(30, "Username too long").regex(/^[a-zA-Z0-9_-]+$/, "Username can only contain letters, numbers, hyphens, and underscores"));
+var nameSchema = z2.string().min(1, "Name is required").max(100, "Name too long").refine((name) => {
+  const dangerousPatterns = [
+    /<script/i,
+    /<img/i,
+    /on\w+\s*=/i,
+    /javascript:/i,
+    /data:/i,
+    /vbscript:/i
+  ];
+  return !dangerousPatterns.some((pattern) => pattern.test(name));
+}, "Name contains invalid characters").transform((name) => sanitizeUserInput(name, {
+  allowHtml: false,
+  maxLength: 100,
+  trim: true
+}));
+var phoneSchema = z2.string().min(10, "Phone number must be at least 10 digits").max(20, "Phone number too long").regex(/^[\+]?[0-9\s\-\(\)\.]+$/, "Invalid phone number format").refine((phone) => {
+  const digitsOnly = phone.replace(/\D/g, "");
+  return digitsOnly.length >= 10 && digitsOnly.length <= 15;
+}, "Phone number must be between 10 and 15 digits");
+var urlSchema = z2.string().min(1, "URL is required").max(2048, "URL too long").refine((url) => {
+  try {
+    const parsed = new URL(url);
+    return ["http:", "https:"].includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}, "Invalid URL format").refine((url) => {
+  const dangerousPatterns = [
+    /javascript:/i,
+    /data:/i,
+    /vbscript:/i,
+    /file:/i,
+    /mailto:/i
+  ];
+  return !dangerousPatterns.some((pattern) => pattern.test(url));
+}, "URL contains invalid protocol");
+
+// src/utils/security.ts
+function logSecurityEvent(event) {
+  console.warn("[SECURITY EVENT]", {
+    ...event,
+    timestamp: event.timestamp.toISOString()
+  });
+}
+function getSecurityHeaders() {
+  return {
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+    "X-XSS-Protection": "1; mode=block",
+    "Referrer-Policy": "strict-origin-when-cross-origin",
+    "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
+  };
+}
+function validateSecurityHeaders(headers) {
+  const requiredHeaders = ["X-Content-Type-Options", "X-Frame-Options"];
+  const missingHeaders = requiredHeaders.filter((header) => !headers[header]);
+  if (missingHeaders.length > 0) {
+    logSecurityEvent({
+      type: "missing_security_headers",
+      timestamp: /* @__PURE__ */ new Date(),
+      details: { missingHeaders }
+    });
+    return false;
+  }
+  return true;
+}
+
+// src/constants/performance.ts
+var PERFORMANCE_THRESHOLDS = {
+  RENDER_TIME: 16,
+  // 60fps target
+  INTERACTION_TIME: 100,
+  // 100ms for interactions
+  ANIMATION_TIME: 300,
+  // 300ms for animations
+  LOAD_TIME: 1e3,
+  // 1 second for initial load
+  MEMORY_USAGE: 50 * 1024 * 1024,
+  // 50MB memory limit
+  BUNDLE_SIZE: 250 * 1024
+  // 250KB bundle size limit
+};
+
+// src/utils/performanceBenchmark.ts
+function createPerformanceBenchmark(name) {
+  const startTime = performance.now();
+  const startMemory = performance.memory?.usedJSHeapSize || 0;
+  return {
+    end: () => {
+      const endTime = performance.now();
+      const endMemory = performance.memory?.usedJSHeapSize || 0;
+      const metrics = {
+        renderTime: endTime - startTime,
+        interactionTime: 0,
+        // Would be measured separately
+        memoryUsage: endMemory - startMemory,
+        bundleSize: 0
+        // Would be measured at build time
+      };
+      const _unused = {
+        benchmark: `Performance Benchmark [${name}]`,
+        metrics
+      };
+      return metrics;
+    }
+  };
+}
+function measureRenderPerformance(componentName, renderFn) {
+  const startTime = performance.now();
+  const startMemory = performance.memory?.usedJSHeapSize || 0;
+  renderFn();
+  const endTime = performance.now();
+  const endMemory = performance.memory?.usedJSHeapSize || 0;
+  const metrics = {
+    renderTime: endTime - startTime,
+    interactionTime: 0,
+    memoryUsage: endMemory - startMemory,
+    bundleSize: 0
+  };
+  const _unused = {
+    benchmark: `Render Performance [${componentName}]`,
+    metrics
+  };
+  return metrics;
+}
+
+// src/utils/bundleAnalysis.ts
+var BundleAnalyzer = class {
+  constructor() {
+    this.enabled = false;
+  }
+  analyzeBundle() {
+    if (!this.enabled) return null;
+    console.log("Bundle analysis would run here in development");
+    console.log("To enable real bundle analysis:");
+    console.log("1. Install webpack-bundle-analyzer");
+    console.log("2. Add bundle analysis to build scripts");
+    console.log("3. Integrate with performance budgets");
+    return {
+      totalSize: 0,
+      gzippedSize: 0,
+      chunks: [],
+      treeshakingEffectiveness: 0
+    };
+  }
+  checkTreeshaking() {
+    if (!this.enabled) return;
+    const potentialIssues = [
+      "Check for unused exports in index files",
+      "Verify side-effect free modules in package.json",
+      "Ensure proper ES module syntax",
+      "Check for circular dependencies"
+    ];
+    console.group("Tree-shaking Analysis");
+    potentialIssues.forEach((issue) => console.log("- " + issue));
+    console.groupEnd();
+  }
+  validateExports() {
+    if (!this.enabled) return;
+    console.group("Export Validation");
+    console.log("Checking for optimal export patterns...");
+    console.log("- Prefer named exports over default exports");
+    console.log("- Avoid barrel exports for large modules");
+    console.log("- Use dynamic imports for large dependencies");
+    console.groupEnd();
+  }
+  generateReport() {
+    const report = `
+# Bundle Analysis Report
+
+## Recommendations for @jmruthers/pace-core
+
+### 1. Code Splitting Opportunities
+- \u2705 DataTable virtualization is lazy-loaded
+- \u26A0\uFE0F  Consider splitting auth providers by use case
+- \u26A0\uFE0F  Lazy load heavy UI components (charts, complex forms)
+
+### 2. Tree-shaking Optimization
+- \u2705 Using ES modules throughout
+- \u2705 Proper sideEffects configuration
+- \u26A0\uFE0F  Check for unused utility functions
+
+### 3. Bundle Size Targets
+- Core components: < 50KB gzipped
+- Auth module: < 30KB gzipped  
+- Utilities: < 20KB gzipped
+- Total package: < 150KB gzipped
+
+### 4. Performance Monitoring
+- Monitor component render times
+- Track bundle size changes
+- Validate tree-shaking effectiveness
+    `;
+    return report.trim();
+  }
+};
+var bundleAnalyzer = new BundleAnalyzer();
+function validateImportPattern(moduleId, importedItems) {
+  if (true) return;
+  const largeModules = ["lodash", "moment", "rxjs"];
+  const isLargeModule = largeModules.some((mod) => moduleId.includes(mod));
+  if (isLargeModule && importedItems.length > 5) {
+    console.warn(
+      "Large import detected: importing " + importedItems.length + " items from " + moduleId + ". Consider splitting imports or using more specific imports."
+    );
+  }
+}
+function trackDynamicImport(moduleName) {
+  if (true) return;
+  console.log("Dynamic import: " + moduleName + " - Good for code splitting!");
+}
+
+// src/utils/dynamicUtils.ts
+var loadLodash = async () => {
+  const [debounceModule, throttleModule] = await Promise.all([
+    import("lodash.debounce"),
+    import("lodash.throttle")
+  ]);
+  return {
+    debounce: debounceModule.default || debounceModule,
+    throttle: throttleModule.default || throttleModule
+  };
+};
+var loadDateUtils = async () => {
+  const dateFns = await import("date-fns");
+  return dateFns;
+};
+var loadChartUtils = async () => {
+  const recharts = await import("recharts");
+  return recharts;
+};
+var loadFormUtils = async () => {
+  const [reactHookForm, zodResolvers] = await Promise.all([
+    import("react-hook-form"),
+    import("@hookform/resolvers/zod")
+  ]);
+  return {
+    ...reactHookForm,
+    zodResolver: zodResolvers.zodResolver
+  };
+};
+var loadCSVUtils = async () => {
+  const papaparse = await import("papaparse");
+  return papaparse.default;
+};
+function createLazyUtility(loader) {
+  let cached = null;
+  let loading = null;
+  return {
+    load: async () => {
+      if (cached) return cached;
+      if (loading) return loading;
+      loading = loader().then((result) => {
+        cached = result;
+        loading = null;
+        return result;
+      });
+      return loading;
+    },
+    getCached: () => cached,
+    isLoaded: () => cached !== null
+  };
+}
+var lazyLodash = createLazyUtility(loadLodash);
+var lazyDateUtils = createLazyUtility(loadDateUtils);
+var lazyChartUtils = createLazyUtility(loadChartUtils);
+var lazyFormUtils = createLazyUtility(loadFormUtils);
+var lazyCSVUtils = createLazyUtility(loadCSVUtils);
+
+// src/utils/lazyLoad.tsx
+import { Suspense, lazy } from "react";
+import { jsx } from "react/jsx-runtime";
+function createLazyComponent(importFn, componentName, options = {}) {
+  const LazyComponent = lazy(importFn);
+  const WrappedComponent = (props) => {
+    const content = /* @__PURE__ */ jsx(Suspense, { fallback: options.fallback || /* @__PURE__ */ jsx(LoadingSpinner, {}), children: /* @__PURE__ */ jsx(LazyComponent, { ...props }) });
+    if (options.errorBoundary) {
+      const ErrorBoundary = options.errorBoundary;
+      return /* @__PURE__ */ jsx(ErrorBoundary, { children: content });
+    }
+    return content;
+  };
+  WrappedComponent.displayName = `Lazy${componentName}`;
+  return WrappedComponent;
+}
+var LazyDataTable = createLazyComponent(
+  () => import("./DataTable-GEY5U7OI.js").then((module) => ({ default: module.DataTable })),
+  "DataTable"
+);
+
+// src/utils/permissionUtils.ts
+function transformPermissionMapToBoolean(permissions) {
+  const result = {};
+  Object.entries(permissions).forEach(([key, value]) => {
+    if (typeof value === "string") {
+      result[key] = value !== "" && value.toLowerCase() !== "false";
+    } else {
+      result[key] = Boolean(value);
+    }
+  });
+  return result;
+}
+function hasPermission(permissions, permission) {
+  return Boolean(permissions[permission]);
+}
+function hasAnyPermission(permissions, permissionList) {
+  return permissionList.some((permission) => hasPermission(permissions, permission));
+}
+function hasAllPermissions(permissions, permissionList) {
+  return permissionList.every((permission) => hasPermission(permissions, permission));
+}
+
+// src/utils/permissionTypes.ts
+var PermissionType = /* @__PURE__ */ ((PermissionType2) => {
+  PermissionType2["READ"] = "read";
+  PermissionType2["WRITE"] = "write";
+  PermissionType2["DELETE"] = "delete";
+  PermissionType2["ADMIN"] = "admin";
+  return PermissionType2;
+})(PermissionType || {});
+function parsePermission(permission) {
+  if (!permission || typeof permission !== "string") {
+    return null;
+  }
+  const parts = permission.split(":");
+  if (parts.length !== 2) {
+    return null;
+  }
+  const [action, resource] = parts;
+  if (action === void 0 || resource === void 0 || action === "" || resource === "") {
+    return null;
+  }
+  return {
+    resource,
+    action
+  };
+}
+
+// src/utils/schemaUtils.ts
+import { z as z3 } from "zod";
+function pickSchema(schema, keys) {
+  const shape = Object.entries(schema.shape).filter(([key]) => keys.includes(key)).reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+  return z3.object(shape);
+}
+function combineSchemas(schemas) {
+  return schemas.reduce(
+    (merged, schema) => merged.merge(schema),
+    z3.object({})
+  );
+}
+
+// src/utils/securityMonitor.ts
+var SecurityMonitor = class {
+  constructor() {
+    this.events = [];
+  }
+  logEvent(event) {
+    const eventWithId = {
+      ...event,
+      id: Math.random().toString(36).substr(2, 9),
+      timestamp: Date.now()
+    };
+    this.events.push(eventWithId);
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  clearEvents() {
+    this.events = [];
+  }
+  createAlert(alert) {
+    return {
+      ...alert,
+      id: Math.random().toString(36).substr(2, 9),
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+};
+var securityMonitor = new SecurityMonitor();
+
+// src/utils/sessionTracking.ts
+function useSessionTracking(supabaseClient, appName) {
+  const resolveAppId = async () => {
+    if (!appName) return void 0;
+    try {
+      const { data, error } = await supabaseClient.from("rbac_apps").select("id").eq("name", appName).eq("is_active", true).single();
+      if (error || !data) {
+        console.warn("App not found or inactive:", appName);
+        return void 0;
+      }
+      return data.id;
+    } catch (error) {
+      console.error("Failed to resolve app ID:", error);
+      return void 0;
+    }
+  };
+  const trackLogin = async (eventId) => {
+    try {
+      const { data: { user } } = await supabaseClient.auth.getUser();
+      if (!user) {
+        console.warn("No authenticated user found for session tracking");
+        return;
+      }
+      const appId = await resolveAppId();
+      const params = {
+        p_session_type: "login",
+        p_event_id: eventId,
+        p_app_id: appId
+      };
+      const { error } = await supabaseClient.rpc("track_user_session", params);
+      if (error) {
+        console.error("Failed to track login session:", error);
+      } else {
+        console.log("Login session tracked successfully");
+      }
+    } catch (error) {
+      console.error("Failed to track login:", error);
+    }
+  };
+  const trackEventSwitch = async (eventId) => {
+    try {
+      const { data: { user } } = await supabaseClient.auth.getUser();
+      if (!user) {
+        console.warn("No authenticated user found for session tracking");
+        return;
+      }
+      const appId = await resolveAppId();
+      const params = {
+        p_session_type: "event_switch",
+        p_event_id: eventId,
+        p_app_id: appId
+      };
+      const { error } = await supabaseClient.rpc("track_user_session", params);
+      if (error) {
+        console.error("Failed to track event switch session:", error);
+      } else {
+        console.log("Event switch session tracked successfully");
+      }
+    } catch (error) {
+      console.error("Failed to track event switch:", error);
+    }
+  };
+  const trackLogout = async () => {
+    try {
+      const { data: { user } } = await supabaseClient.auth.getUser();
+      if (!user) {
+        console.warn("No authenticated user found for session tracking");
+        return;
+      }
+      const appId = await resolveAppId();
+      const params = {
+        p_session_type: "logout",
+        p_app_id: appId
+      };
+      const { error } = await supabaseClient.rpc("track_user_session", params);
+      if (error) {
+        console.error("Failed to track logout session:", error);
+      } else {
+        console.log("Logout session tracked successfully");
+      }
+    } catch (error) {
+      console.error("Failed to track logout:", error);
+    }
+  };
+  const trackSessionExpired = async () => {
+    try {
+      const { data: { user } } = await supabaseClient.auth.getUser();
+      if (!user) {
+        console.warn("No authenticated user found for session tracking");
+        return;
+      }
+      const appId = await resolveAppId();
+      const params = {
+        p_session_type: "session_expired",
+        p_app_id: appId
+      };
+      const { error } = await supabaseClient.rpc("track_user_session", params);
+      if (error) {
+        console.error("Failed to track session expiration:", error);
+      } else {
+        console.log("Session expiration tracked successfully");
+      }
+    } catch (error) {
+      console.error("Failed to track session expiration:", error);
+    }
+  };
+  return {
+    trackLogin,
+    trackEventSwitch,
+    trackLogout,
+    trackSessionExpired
+  };
+}
+
+// src/utils/audit.ts
+var AuditLogger = class {
+  constructor() {
+    this.events = [];
+  }
+  log(event) {
+    const eventWithTimestamp = {
+      ...event,
+      timestamp: Date.now()
+    };
+    this.events.push(eventWithTimestamp);
+  }
+  async logPermissionEvent(event) {
+    this.log({
+      type: "permission",
+      event: event.event,
+      userId: event.userId,
+      data: event.data
+    });
+  }
+  async logSecurityEvent(event) {
+    this.log({
+      type: "security",
+      event: event.event,
+      data: event.data
+    });
+  }
+  async logAuthEvent(event) {
+    this.log({
+      type: "auth",
+      event: event.event,
+      userId: event.userId,
+      data: event.data
+    });
+  }
+  async getSecurityEvents() {
+    return this.events.filter((event) => event.type === "security");
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  clearEvents() {
+    this.events = [];
+  }
+};
+var auditLogger = new AuditLogger();
+var auditLog = auditLogger;
+function logAuthEvent(action, user, details) {
+  auditLogger.log({
+    type: "auth",
+    action,
+    user,
+    details
+  });
+}
+function logPermissionEvent(action, user, details) {
+  auditLogger.log({
+    type: "permission",
+    action,
+    user,
+    details
+  });
+}
+function logSecurityEvent2(action, user, details) {
+  auditLogger.log({
+    type: "security",
+    action,
+    user,
+    details
+  });
+}
+function logAuditEvent(action, user, details) {
+  auditLogger.log({
+    type: "auth",
+    // Default to auth type for general audit events
+    action,
+    user,
+    details
+  });
+}
+
+// src/utils/deviceFingerprint.ts
+function generateDeviceFingerprint() {
+  try {
+    const components = {
+      userAgent: getHashedUserAgent(),
+      language: navigator.language || "unknown",
+      platform: navigator.platform || "unknown",
+      screen: `${screen.width}x${screen.height}x${screen.colorDepth}`,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown",
+      canvas: getCanvasFingerprint(),
+      webgl: getWebGLFingerprint()
+    };
+    const entropy = calculateEntropy(components);
+    const fingerprintData = JSON.stringify(components);
+    const hash = hashStringSync(fingerprintData);
+    const fingerprint = {
+      hash,
+      timestamp: Date.now(),
+      components,
+      entropy
+    };
+    secureStorage.setItem("device_fingerprint", JSON.stringify(fingerprint));
+    return fingerprint;
+  } catch (error) {
+    return generateFallbackFingerprint();
+  }
+}
+function validateDeviceFingerprint(storedFingerprint, currentFingerprint) {
+  const reasons = [];
+  let matchingComponents = 0;
+  const totalComponents = Object.keys(storedFingerprint.components).length;
+  Object.entries(storedFingerprint.components).forEach(([key, value]) => {
+    if (currentFingerprint.components[key] === value) {
+      matchingComponents++;
+    } else {
+      reasons.push(`Component mismatch: ${key}`);
+    }
+  });
+  const confidence = matchingComponents / totalComponents * 100;
+  const isValid = confidence >= 80;
+  const timeDiff = currentFingerprint.timestamp - storedFingerprint.timestamp;
+  const maxAge = 30 * 24 * 60 * 60 * 1e3;
+  if (timeDiff > maxAge) {
+    reasons.push("Fingerprint too old");
+    return { isValid: false, confidence, reasons };
+  }
+  if (confidence < 60) {
+    reasons.push("Device signature changed significantly");
+  }
+  return { isValid, confidence, reasons };
+}
+function getCanvasFingerprint() {
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return "canvas-unavailable";
+    ctx.textBaseline = "top";
+    ctx.font = "14px Arial";
+    ctx.fillStyle = "#f60";
+    ctx.fillRect(125, 1, 62, 20);
+    ctx.fillStyle = "#069";
+    ctx.fillText("Device fingerprint \u{1F512}", 2, 15);
+    ctx.fillStyle = "rgba(102, 204, 0, 0.2)";
+    ctx.fillText("Device fingerprint \u{1F512}", 4, 17);
+    const dataURL = canvas.toDataURL();
+    return hashStringSync(dataURL);
+  } catch (error) {
+    return "canvas-error";
+  }
+}
+function getWebGLFingerprint() {
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl) return "webgl-unavailable";
+    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+    if (!debugInfo) return "webgl-no-debug";
+    const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+    const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+    return `${vendor}|${renderer}`;
+  } catch (error) {
+    return "webgl-error";
+  }
+}
+function getHashedUserAgent() {
+  const ua = navigator.userAgent;
+  return hashStringSync(ua).substring(0, 16);
+}
+function calculateEntropy(components) {
+  const values = Object.values(components).join("");
+  const charCounts = /* @__PURE__ */ new Map();
+  for (const char of values) {
+    charCounts.set(char, (charCounts.get(char) || 0) + 1);
+  }
+  let entropy = 0;
+  for (const count of charCounts.values()) {
+    const probability = count / values.length;
+    entropy -= probability * Math.log2(probability);
+  }
+  return entropy;
+}
+function hashStringSync(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function generateFallbackFingerprint() {
+  const components = {
+    userAgent: "fallback",
+    language: "unknown",
+    platform: "unknown",
+    screen: "unknown",
+    timezone: "unknown"
+  };
+  return {
+    hash: `fallback_${Date.now()}_${Math.random().toString(36)}`,
+    timestamp: Date.now(),
+    components,
+    entropy: 1
+    // Low entropy for fallback
+  };
+}
+
+// src/utils/formatting.ts
+function formatDate(date) {
+  const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
+  return dateObj.toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatCurrency(value, currencyCode = "USD", locale = "en-US") {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode
+  }).format(value);
+}
+function formatNumber(value, options = {}, locale = "en-US") {
+  return new Intl.NumberFormat(locale, options).format(value);
+}
+function formatPercent(value, locale = "en-US", decimals = 1) {
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value / 100);
+}
+function formatCompactNumber(value, locale = "en-US") {
+  return new Intl.NumberFormat(locale, {
+    notation: "compact",
+    compactDisplay: "short"
+  }).format(value);
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+
+// src/utils/index.ts
+init_organisationContext();
+export {
+  CSP_DIRECTIVES,
+  DebugLogger,
+  LazyDataTable,
+  PERFORMANCE_BUDGETS,
+  PERFORMANCE_THRESHOLDS,
+  PermissionType,
+  RateLimiter,
+  auditLog,
+  auditLogger,
+  bundleAnalyzer,
+  clearOrganisationContext,
+  cn,
+  combineSchemas,
+  createLazyComponent,
+  createLazyUtility,
+  createPerformanceBenchmark,
+  deepMerge,
+  emailSchema,
+  formatCompactNumber,
+  formatCurrency,
+  formatDate,
+  formatFileSize,
+  formatNumber,
+  formatPercent,
+  generateCSPHeader,
+  generateDeviceFingerprint,
+  getAppConfig,
+  getAppNameFromBuildTime,
+  getAppNameFromEnvironment,
+  getAppNameFromGlobal,
+  getAppNameFromPackageJson,
+  getCurrentAppId,
+  getCurrentAppName,
+  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,
+  logSecurityEvent2 as logSecurityEvent,
+  matchesPattern,
+  measureRenderPerformance,
+  nameSchema,
+  parsePermission,
+  passwordSchema,
+  performanceBudgetMonitor,
+  phoneSchema,
+  pickSchema,
+  sanitizeEmail,
+  sanitizeFileName,
+  sanitizeFormData,
+  sanitizePhoneNumber,
+  sanitizeSqlInput,
+  sanitizeUrl,
+  sanitizeUserInput,
+  sanitizeUserInput_deprecated,
+  securityMonitor,
+  setAppConfig,
+  setOrganisationContext,
+  setRBACAppName,
+  trackDynamicImport,
+  transformPermissionMapToBoolean,
+  urlSchema,
+  useComponentPerformance,
+  useSessionTracking,
+  usernameSchema,
+  validateDeviceFingerprint,
+  validateImportPattern,
+  validateSecurityHeaders,
+  validateUserInput
+};
+//# sourceMappingURL=utils.js.map