blacktrigram 0.7.2

package/lib/utils/mobileUIUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobileUIUtils.js","names":[],"sources":["../../src/utils/mobileUIUtils.ts"],"sourcesContent":["/**\n * Mobile UI utilities for responsive touch-optimized interfaces\n * \n * Provides helpers for touch target sizing, responsive font scaling,\n * and mobile-specific layout calculations following iOS/Android guidelines.\n * \n * PRIORITY: High-end mobile devices (Super HD, 2K+) are top priority and get:\n * - Enhanced touch targets (56px vs 48px)\n * - Larger Korean fonts (+10% for better readability)\n * - Optimized spacing and layout\n * - Full feature parity with desktop\n * \n * Supported Devices (Priority Order):\n * 1. Super HD Mobile (≥768px): Motorola Edge 60 Pro, Galaxy S-series\n * 2. Standard Mobile (375-767px): iPhone 12/13/14, standard Android\n * 3. Small Mobile (<375px): iPhone SE, budget devices\n * \n * @module utils/mobileUIUtils\n * @category Mobile Utilities\n * @korean 모바일UI유틸리티\n */\n\nimport { UI_DIMENSIONS, SPACING } from \"../types/constants/ui\";\nimport {\n  KOREAN_MOBILE_FONT_SIZES,\n  getKoreanFontSize,\n} from \"../types/constants/typography\";\n\n/**\n * Viewport size category for responsive design\n * \n * @category Mobile UI\n * @korean 뷰포트크기범주\n */\nexport type ViewportSize = \"xs\" | \"sm\" | \"md\" | \"lg\" | \"xl\";\n\n/**\n * Touch target size configuration\n * \n * @category Mobile UI\n * @korean 터치타겟크기설정\n */\nexport interface TouchTargetSize {\n  readonly minWidth: number;\n  readonly minHeight: number;\n  readonly padding: number;\n  readonly spacing: number;\n}\n\n/**\n * Get viewport size category from width\n * \n * PRIORITY: High-end mobile devices (Super HD, 2K+) are treated as 'md' for optimal layout\n * \n * @param width - Viewport width in pixels\n * @returns Viewport size category\n * \n * @example\n * ```typescript\n * getViewportSize(375); // 'xs' (iPhone SE)\n * getViewportSize(768); // 'sm' (Standard phones, high-end mobiles start here)\n * getViewportSize(2712); // 'md' (Motorola Edge 60 Pro Super HD)\n * getViewportSize(1200); // 'lg' (Desktop)\n * ```\n * \n * @public\n * @korean 뷰포트크기얻기\n */\nexport function getViewportSize(width: number): ViewportSize {\n  if (width < 375) return \"xs\"; // Extra small phones\n  if (width < 768) return \"sm\"; // Standard phones\n  if (width < 1024) return \"md\"; // High-end mobile (Super HD), tablets\n  if (width < 1440) return \"lg\"; // Small desktop\n  return \"xl\"; // Large desktop\n}\n\n/**\n * Get touch-optimized button size configuration\n * Ensures minimum 48px touch targets per iOS/Android guidelines\n * \n * PRIORITY: High-end mobile devices (Super HD, 2K+) get enhanced touch targets (56px)\n * for better precision on high-resolution displays\n * \n * @param isMobile - Whether on mobile device\n * @param viewportWidth - Optional viewport width for fine-tuning\n * @returns Touch target size configuration\n * \n * @example\n * ```typescript\n * const buttonSize = getTouchTargetSize(true, 375);\n * // { minWidth: 48, minHeight: 48, padding: 12, spacing: 8 }\n * \n * const superHDButtonSize = getTouchTargetSize(true, 2712);\n * // { minWidth: 56, minHeight: 56, padding: 16, spacing: 12 }\n * ```\n * \n * @public\n * @korean 터치타겟크기얻기\n */\nexport function getTouchTargetSize(\n  isMobile: boolean,\n  viewportWidth?: number\n): TouchTargetSize {\n  if (!isMobile) {\n    return {\n      minWidth: 120,\n      minHeight: 44,\n      padding: SPACING.MD,\n      spacing: SPACING.MD,\n    };\n  }\n\n  const width = viewportWidth ?? 375;\n  const isExtraSmall = width < 360;\n  const isSuperHD = width >= 768; // High-end mobile (Motorola Edge 60 Pro, etc.)\n\n  // Super HD devices get enhanced touch targets for better precision\n  if (isSuperHD) {\n    return {\n      minWidth: UI_DIMENSIONS.TOUCH_TARGET_COMFORTABLE,\n      minHeight: UI_DIMENSIONS.TOUCH_TARGET_COMFORTABLE,\n      padding: SPACING.MD,\n      spacing: SPACING.COMPACT,\n    };\n  }\n\n  return {\n    minWidth: UI_DIMENSIONS.TOUCH_TARGET_MIN,\n    minHeight: UI_DIMENSIONS.TOUCH_TARGET_MIN,\n    padding: isExtraSmall ? SPACING.SM : SPACING.COMPACT,\n    spacing: UI_DIMENSIONS.TOUCH_TARGET_SPACING,\n  };\n}\n\n/**\n * Get responsive Korean font size for mobile\n * Ensures minimum 16px for body text on mobile\n * \n * PRIORITY: High-end mobile (Super HD, 2K+) get enhanced font sizes for better readability\n * \n * @param size - Size category ('SMALL', 'MEDIUM', 'LARGE')\n * @param viewportWidth - Viewport width in pixels\n * @returns Font size in pixels\n * \n * @example\n * ```typescript\n * getMobileKoreanFontSize('SMALL', 375); // 16\n * getMobileKoreanFontSize('MEDIUM', 410); // 18\n * getMobileKoreanFontSize('MEDIUM', 2712); // 20 (Super HD enhanced)\n * getMobileKoreanFontSize('LARGE', 768); // 24\n * ```\n * \n * @public\n * @korean 모바일한글글꼴크기얻기\n */\nexport function getMobileKoreanFontSize(\n  size: keyof typeof KOREAN_MOBILE_FONT_SIZES,\n  viewportWidth: number\n): number {\n  const fontSize = getKoreanFontSize(size, viewportWidth);\n  \n  // Super HD mobile devices (≥768px) get enhanced font sizes\n  // for better readability on high-resolution displays\n  if (viewportWidth >= 768) {\n    return Math.ceil(fontSize * 1.1); // 10% larger for Super HD\n  }\n  \n  return fontSize;\n}\n\n/**\n * Get responsive spacing value\n * Scales spacing based on viewport size\n * \n * @param baseSpacing - Base spacing value from SPACING constant\n * @param isMobile - Whether on mobile device\n * @returns Scaled spacing in pixels\n * \n * @example\n * ```typescript\n * getResponsiveSpacing(SPACING.MD, true); // 12 (COMPACT on mobile)\n * getResponsiveSpacing(SPACING.MD, false); // 16 (original)\n * ```\n * \n * @public\n * @korean 반응형간격얻기\n */\nexport function getResponsiveSpacing(\n  baseSpacing: number,\n  isMobile: boolean\n): number {\n  return isMobile ? Math.max(SPACING.SM, baseSpacing * 0.75) : baseSpacing;\n}\n\n/**\n * Calculate responsive panel width\n * Ensures panels fit within viewport with proper margins\n * \n * @param viewportWidth - Viewport width in pixels\n * @param isMobile - Whether on mobile device\n * @param minMargin - Minimum margin on each side (default: 20px)\n * @returns Panel width in pixels\n * \n * @example\n * ```typescript\n * getResponsivePanelWidth(375, true); // ~335px (375 - 40 margin)\n * getResponsivePanelWidth(1200, false); // ~400px (max width applied)\n * ```\n * \n * @public\n * @korean 반응형패널폭얻기\n */\nexport function getResponsivePanelWidth(\n  viewportWidth: number,\n  isMobile: boolean,\n  minMargin = 20\n): number {\n  if (!isMobile) {\n    return Math.min(400, viewportWidth - minMargin * 2);\n  }\n\n  // Mobile: use most of screen width\n  return Math.min(viewportWidth - minMargin * 2, 360);\n}\n\n/**\n * Check if viewport is in landscape orientation\n * \n * @param viewportWidth - Viewport width in pixels\n * @param viewportHeight - Viewport height in pixels\n * @returns Whether in landscape orientation\n * \n * @example\n * ```typescript\n * isLandscape(812, 375); // true (iPhone X landscape)\n * isLandscape(375, 812); // false (iPhone X portrait)\n * ```\n * \n * @public\n * @korean 가로모드여부\n */\nexport function isLandscape(\n  viewportWidth: number,\n  viewportHeight: number\n): boolean {\n  return viewportWidth > viewportHeight;\n}\n\n/**\n * Get responsive button styles for touch optimization\n * \n * @param isMobile - Whether on mobile device\n * @param viewportWidth - Optional viewport width\n * @returns CSS properties for button\n * \n * @example\n * ```typescript\n * const buttonStyles = getResponsiveButtonStyles(true, 375);\n * // {\n * //   minWidth: '48px',\n * //   minHeight: '48px',\n * //   padding: '12px',\n * //   fontSize: '16px',\n * //   ...\n * // }\n * ```\n * \n * @public\n * @korean 반응형버튼스타일얻기\n */\nexport function getResponsiveButtonStyles(\n  isMobile: boolean,\n  viewportWidth?: number\n): React.CSSProperties {\n  const touchTarget = getTouchTargetSize(isMobile, viewportWidth);\n  const fontSize = isMobile\n    ? getMobileKoreanFontSize(\"SMALL\", viewportWidth ?? 375)\n    : 16;\n\n  return {\n    minWidth: `${touchTarget.minWidth}px`,\n    minHeight: `${touchTarget.minHeight}px`,\n    padding: `${touchTarget.padding}px`,\n    fontSize: `${fontSize}px`,\n    lineHeight: \"1.4\",\n    cursor: \"pointer\",\n    userSelect: \"none\",\n    WebkitTapHighlightColor: \"transparent\",\n  };\n}\n\n/**\n * Get responsive text styles with proper Korean font sizing\n * \n * @param size - Font size category\n * @param isMobile - Whether on mobile device\n * @param viewportWidth - Viewport width in pixels\n * @returns CSS properties for text\n * \n * @example\n * ```typescript\n * const textStyles = getResponsiveTextStyles('MEDIUM', true, 375);\n * // {\n * //   fontSize: '18px',\n * //   lineHeight: '1.5',\n * //   letterSpacing: '0.02em',\n * // }\n * ```\n * \n * @public\n * @korean 반응형텍스트스타일얻기\n */\nexport function getResponsiveTextStyles(\n  size: keyof typeof KOREAN_MOBILE_FONT_SIZES,\n  isMobile: boolean,\n  viewportWidth: number\n): React.CSSProperties {\n  const fontSize = isMobile\n    ? getMobileKoreanFontSize(size, viewportWidth)\n    : KOREAN_MOBILE_FONT_SIZES[size].regular;\n\n  return {\n    fontSize: `${fontSize}px`,\n    lineHeight: isMobile ? \"1.5\" : \"1.4\",\n    letterSpacing: \"0.02em\",\n  };\n}\n\n/**\n * Calculate minimum spacing between interactive elements\n * Ensures adequate spacing for touch accuracy\n * \n * @param isMobile - Whether on mobile device\n * @returns Minimum spacing in pixels\n * \n * @example\n * ```typescript\n * getMinimumInteractiveSpacing(true); // 8px (mobile)\n * getMinimumInteractiveSpacing(false); // 12px (desktop)\n * ```\n * \n * @public\n * @korean 최소상호작용간격얻기\n */\nexport function getMinimumInteractiveSpacing(isMobile: boolean): number {\n  return isMobile\n    ? UI_DIMENSIONS.TOUCH_TARGET_SPACING\n    : SPACING.COMPACT;\n}\n\n/**\n * Viewport detection utilities\n * \n * PRIORITY: High-end mobile devices (Super HD, 2K+) are explicitly supported\n * \n * @category Mobile UI\n * @korean 뷰포트감지\n */\nexport const ViewportDetection = {\n  /**\n   * Check if iPhone SE or similar small device\n   * @korean iPhone SE여부\n   */\n  isSmallMobile: (width: number) => width <= 375,\n\n  /**\n   * Check if standard mobile device (excluding high-end)\n   * @korean 표준모바일여부\n   */\n  isMobile: (width: number) => width < 768,\n\n  /**\n   * Check if high-end mobile device (Super HD, 2K+)\n   * Uses height + DPR to distinguish phones from tablets\n   * High-end phones: short side 400-600px, long side >=800px, DPR >=2\n   * @korean 고급모바일여부\n   */\n  isSuperHDMobile: (width: number, height: number = window.innerHeight) => {\n    const shortSide = Math.min(width, height);\n    const longSide = Math.max(width, height);\n    const dpr = window.devicePixelRatio || 1;\n    return shortSide >= 400 && shortSide <= 600 && longSide >= 800 && dpr >= 2;\n  },\n\n  /**\n   * Check if tablet device\n   * @korean 태블릿여부\n   */\n  isTablet: (width: number) => width >= 768 && width < 1024,\n\n  /**\n   * Check if desktop device\n   * @korean 데스크톱여부\n   */\n  isDesktop: (width: number) => width >= 1024,\n\n  /**\n   * Check if device has notch (iPhone X+)\n   * @korean 노치여부\n   */\n  hasNotch: (width: number, height: number) =>\n    (width === 375 && height === 812) || // iPhone X, XS, 11 Pro\n    (width === 414 && height === 896) || // iPhone XR, XS Max, 11, 11 Pro Max\n    (width === 390 && height === 844) || // iPhone 12, 12 Pro, 13, 13 Pro, 14\n    (width === 393 && height === 852) || // iPhone 14 Pro\n    (width === 428 && height === 926), // iPhone 12/13/14 Pro Max\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA2JA,SAAgB,wBACd,MACA,eACQ;CACR,MAAM,WAAW,kBAAkB,MAAM,cAAc;AAIvD,KAAI,iBAAiB,IACnB,QAAO,KAAK,KAAK,WAAW,IAAI;AAGlC,QAAO"}

package/lib/utils/objectPool.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Object Pool Utility
+ *
+ * Generic object pooling for reducing garbage collection pressure.
+ * Useful for frequently created/destroyed objects like damage numbers,
+ * particles, or temporary game objects.
+ *
+ * @module utils/objectPool
+ * @category Performance
+ * @korean 객체 풀
+ */
+/**
+ * Interface for poolable objects
+ * Objects must implement reset() to be reused
+ */
+export interface Poolable {
+    /**
+     * Reset object to initial state for reuse
+     */
+    reset(...args: unknown[]): void;
+}
+/**
+ * Generic object pool
+ *
+ * @example
+ * ```typescript
+ * class DamageNumber implements Poolable {
+ *   value = 0;
+ *   position = { x: 0, y: 0 };
+ *
+ *   reset(value: number, x: number, y: number) {
+ *     this.value = value;
+ *     this.position.x = x;
+ *     this.position.y = y;
+ *   }
+ * }
+ *
+ * const pool = new ObjectPool(() => new DamageNumber(), 50);
+ *
+ * // Acquire from pool
+ * const damage = pool.acquire();
+ * damage.reset(100, 10, 20);
+ *
+ * // Return to pool when done
+ * pool.release(damage);
+ * ```
+ */
+export declare class ObjectPool<T extends Poolable> {
+    private pool;
+    private readonly factory;
+    private readonly maxSize;
+    /**
+     * Create a new object pool
+     *
+     * @param factory - Function to create new objects
+     * @param maxSize - Maximum pool size (default: 100)
+     */
+    constructor(factory: () => T, maxSize?: number);
+    /**
+     * Acquire an object from the pool
+     * Creates a new object if pool is empty
+     *
+     * @returns Object from pool or newly created
+     */
+    acquire(): T;
+    /**
+     * Return an object to the pool for reuse
+     *
+     * @param obj - Object to return to pool
+     */
+    release(obj: T): void;
+    /**
+     * Clear all objects from the pool
+     */
+    clear(): void;
+    /**
+     * Get current pool size
+     */
+    get size(): number;
+    /**
+     * Get maximum pool size
+     */
+    get capacity(): number;
+}
+/**
+ * Pre-populate a pool with objects
+ *
+ * @param pool - Object pool to populate
+ * @param count - Number of objects to create
+ */
+export declare function prewarmPool<T extends Poolable>(pool: ObjectPool<T>, count: number): void;
+//# sourceMappingURL=objectPool.d.ts.map

package/lib/utils/objectPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectPool.d.ts","sourceRoot":"","sources":["../../src/utils/objectPool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,UAAU,CAAC,CAAC,SAAS,QAAQ;IACxC,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,SAAM;IAK3C;;;;;OAKG;IACH,OAAO,IAAI,CAAC;IAQZ;;;;OAIG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IAMrB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;CACF;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAMxF"}

package/lib/utils/particlePool.d.ts

@@ -0,0 +1,138 @@
+/**
+ * ParticlePool - Object pooling system for Three.js particle systems
+ *
+ * Provides efficient memory management for particle effects by reusing
+ * Three.js Points objects instead of creating/destroying them repeatedly.
+ * Essential for maintaining 60fps during intense combat with many effects.
+ *
+ * Features:
+ * - Object pooling to avoid GC pressure
+ * - Automatic pool size management
+ * - Lifetime tracking for automatic cleanup
+ * - Memory-efficient particle reuse
+ *
+ * @module utils/particlePool
+ * @category Performance
+ * @korean 입자풀
+ */
+import * as THREE from "three";
+/**
+ * Configuration for particle pool
+ */
+export interface ParticlePoolConfig {
+    /** Maximum number of particle systems to pool */
+    readonly maxSize?: number;
+    /** Maximum particles per system */
+    readonly particlesPerSystem?: number;
+    /** Whether to enable debug logging */
+    readonly debug?: boolean;
+}
+/**
+ * ParticlePool Class
+ *
+ * Manages a pool of reusable Three.js Points objects for particle effects.
+ * Reduces garbage collection pressure by reusing existing objects.
+ *
+ * @example
+ * ```typescript
+ * const pool = new ParticlePool({ maxSize: 50, particlesPerSystem: 100 });
+ *
+ * // Acquire a particle system
+ * const material = new THREE.PointsMaterial({ color: 0xff0000, size: 0.1 });
+ * const points = pool.acquire(100, material);
+ * scene.add(points);
+ *
+ * // Later, when effect completes
+ * scene.remove(points);
+ * pool.release(points);
+ *
+ * // Cleanup when done
+ * pool.dispose();
+ * ```
+ */
+export declare class ParticlePool {
+    private pool;
+    private readonly maxSize;
+    private readonly particlesPerSystem;
+    private readonly debug;
+    private nextId;
+    /**
+     * Create a new particle pool
+     *
+     * @param config - Pool configuration
+     */
+    constructor(config?: ParticlePoolConfig);
+    /**
+     * Acquire a particle system from the pool
+     *
+     * Returns an existing inactive system if available, otherwise creates a new one.
+     * If pool is full, reuses the oldest active system.
+     *
+     * @param particleCount - Number of particles needed
+     * @param material - Material to use for the particles
+     * @returns A Three.js Points object ready to use
+     */
+    acquire(particleCount: number, material: THREE.PointsMaterial): THREE.Points;
+    /**
+     * Release a particle system back to the pool
+     *
+     * Marks the system as inactive so it can be reused. The material
+     * is NOT disposed as it may be shared or reused.
+     *
+     * @param points - The Points object to release
+     */
+    release(points: THREE.Points): void;
+    /**
+     * Update all active particle systems
+     *
+     * Call this once per frame to track lifetimes. Useful for debugging
+     * and automatic cleanup.
+     *
+     * @param delta - Time elapsed since last update (seconds)
+     */
+    update(delta: number): void;
+    /**
+     * Get pool statistics
+     *
+     * @returns Object containing pool stats
+     */
+    getStats(): {
+        total: number;
+        active: number;
+        inactive: number;
+        maxSize: number;
+    };
+    /**
+     * Dispose all pooled particle systems
+     *
+     * Cleans up all geometries and materials. Call this when the pool
+     * is no longer needed.
+     *
+     * ⚠️ Warning: Materials are disposed! If materials are shared between
+     * multiple particle systems outside the pool, dispose them separately.
+     */
+    dispose(): void;
+    /**
+     * Clear inactive particle systems
+     *
+     * Removes inactive systems from the pool to free memory.
+     * Useful for managing memory in long-running sessions.
+     */
+    clearInactive(): void;
+}
+/**
+ * Global particle pool instance
+ *
+ * Shared pool for all particle effects in the application.
+ * Use this for most cases unless you need a separate pool.
+ *
+ * @example
+ * ```typescript
+ * import { globalParticlePool } from './particlePool';
+ *
+ * const material = new THREE.PointsMaterial({ color: 0xff0000 });
+ * const points = globalParticlePool.acquire(100, material);
+ * ```
+ */
+export declare const globalParticlePool: ParticlePool;
+//# sourceMappingURL=particlePool.d.ts.map

package/lib/utils/particlePool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particlePool.d.ts","sourceRoot":"","sources":["../../src/utils/particlePool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAgB/B;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,mCAAmC;IACnC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,sCAAsC;IACtC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;IAChC,OAAO,CAAC,MAAM,CAAK;IAEnB;;;;OAIG;gBACS,MAAM,GAAE,kBAAuB;IAY3C;;;;;;;;;OASG;IACH,OAAO,CACL,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,KAAK,CAAC,cAAc,GAC7B,KAAK,CAAC,MAAM;IA4Ff;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI;IAiBnC;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQ3B;;;;OAIG;IACH,QAAQ,IAAI;QACV,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB;IAUD;;;;;;;;OAQG;IACH,OAAO,IAAI,IAAI;IAgBf;;;;;OAKG;IACH,aAAa,IAAI,IAAI;CAqBtB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,cAI7B,CAAC"}

package/lib/utils/performance/PerformanceMonitor.d.ts

@@ -0,0 +1,93 @@
+/**
+ * PerformanceMonitor - Real-time FPS and performance tracking for Three.js
+ *
+ * Monitors frame rate, memory usage, and draw calls to maintain 60fps target.
+ * Provides warnings in development mode when performance degrades.
+ */
+import * as THREE from "three";
+export interface PerformanceMetrics {
+    readonly fps: number;
+    readonly avgFps: number;
+    readonly minFps: number;
+    readonly maxFps: number;
+    readonly frameTime: number;
+    readonly memoryMB: number;
+    readonly drawCalls: number;
+    readonly triangles: number;
+}
+export interface PerformanceThresholds {
+    readonly targetFps: number;
+    readonly minAcceptableFps: number;
+    readonly maxMemoryMB: number;
+    readonly maxDrawCalls: number;
+}
+/**
+ * PerformanceMonitor class for real-time performance tracking
+ */
+export declare class PerformanceMonitor {
+    private frames;
+    private lastTime;
+    private frameCount;
+    private readonly maxFrameSamples;
+    private minFps;
+    private maxFps;
+    private readonly thresholds;
+    private performanceWarnings;
+    constructor(thresholds?: Partial<PerformanceThresholds>);
+    /**
+     * Update performance metrics (call once per frame)
+     * @param renderer Optional Three.js renderer for draw call tracking
+     * @returns Current FPS
+     */
+    update(renderer?: THREE.WebGLRenderer): number;
+    /**
+     * Get current FPS
+     */
+    getCurrentFPS(): number;
+    /**
+     * Get average FPS over the sampling window
+     */
+    getAverageFPS(): number;
+    /**
+     * Get minimum FPS recorded
+     */
+    getMinFPS(): number;
+    /**
+     * Get maximum FPS recorded
+     */
+    getMaxFPS(): number;
+    /**
+     * Check if performance is good (above minimum threshold)
+     */
+    isPerformanceGood(): boolean;
+    /**
+     * Get comprehensive performance metrics
+     */
+    getMetrics(renderer?: THREE.WebGLRenderer): PerformanceMetrics;
+    /**
+     * Get current memory usage in MB (Chrome only)
+     */
+    private getMemoryUsageMB;
+    /**
+     * Check performance thresholds and log warnings
+     */
+    private checkPerformanceThresholds;
+    /**
+     * Get current performance warnings
+     */
+    getWarnings(): readonly string[];
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+    /**
+     * Get formatted performance summary string
+     */
+    getSummary(renderer?: THREE.WebGLRenderer): string;
+}
+/**
+ * Create a performance monitor with optional custom thresholds
+ */
+export declare function createPerformanceMonitor(thresholds?: Partial<PerformanceThresholds>): PerformanceMonitor;
+export default PerformanceMonitor;
+//# sourceMappingURL=PerformanceMonitor.d.ts.map

package/lib/utils/performance/PerformanceMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceMonitor.d.ts","sourceRoot":"","sources":["../../../src/utils/performance/PerformanceMonitor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAaD;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAM;IAEtC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAK;IAEnB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;IACnD,OAAO,CAAC,mBAAmB,CAAgB;gBAE/B,UAAU,GAAE,OAAO,CAAC,qBAAqB,CAAM;IAI3D;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,MAAM;IA8B9C;;OAEG;IACH,aAAa,IAAI,MAAM;IAKvB;;OAEG;IACH,aAAa,IAAI,MAAM;IAKvB;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAK5B;;OAEG;IACH,UAAU,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,kBAAkB;IAgB9D;;OAEG;IACH,OAAO,CAAC,gBAAgB;IASxB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,WAAW,IAAI,SAAS,MAAM,EAAE;IAIhC;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,UAAU,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,MAAM;CAanD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAC1C,kBAAkB,CAEpB;AAED,eAAe,kBAAkB,CAAC"}

package/lib/utils/performance/PerformanceMonitor.js

@@ -0,0 +1,155 @@
+//#region src/utils/performance/PerformanceMonitor.ts
+var DEFAULT_THRESHOLDS = {
+	targetFps: 60,
+	minAcceptableFps: 55,
+	maxMemoryMB: 300,
+	maxDrawCalls: 100
+};
+var MAX_SAMPLE_FPS = 180;
+var MIN_FRAME_TIME_MS = 1e3 / MAX_SAMPLE_FPS;
+/**
+* PerformanceMonitor class for real-time performance tracking
+*/
+var PerformanceMonitor = class {
+	frames = [];
+	lastTime = performance.now();
+	frameCount = 0;
+	maxFrameSamples = 60;
+	minFps = Infinity;
+	maxFps = 0;
+	thresholds;
+	performanceWarnings = [];
+	constructor(thresholds = {}) {
+		this.thresholds = {
+			...DEFAULT_THRESHOLDS,
+			...thresholds
+		};
+	}
+	/**
+	* Update performance metrics (call once per frame)
+	* @param renderer Optional Three.js renderer for draw call tracking
+	* @returns Current FPS
+	*/
+	update(renderer) {
+		const now = performance.now();
+		const delta = now - this.lastTime;
+		this.lastTime = now;
+		if (delta <= 0) return 0;
+		const fps = Math.min(1e3 / Math.max(delta, MIN_FRAME_TIME_MS), MAX_SAMPLE_FPS);
+		this.frames.push(fps);
+		if (fps < this.minFps) this.minFps = fps;
+		if (fps > this.maxFps) this.maxFps = fps;
+		if (this.frames.length > this.maxFrameSamples) this.frames.shift();
+		this.frameCount++;
+		return fps;
+	}
+	/**
+	* Get current FPS
+	*/
+	getCurrentFPS() {
+		if (this.frames.length === 0) return 0;
+		return this.frames[this.frames.length - 1];
+	}
+	/**
+	* Get average FPS over the sampling window
+	*/
+	getAverageFPS() {
+		if (this.frames.length === 0) return 0;
+		return this.frames.reduce((a, b) => a + b, 0) / this.frames.length;
+	}
+	/**
+	* Get minimum FPS recorded
+	*/
+	getMinFPS() {
+		return this.minFps === Infinity ? 0 : this.minFps;
+	}
+	/**
+	* Get maximum FPS recorded
+	*/
+	getMaxFPS() {
+		return this.maxFps;
+	}
+	/**
+	* Check if performance is good (above minimum threshold)
+	*/
+	isPerformanceGood() {
+		return this.getAverageFPS() >= this.thresholds.minAcceptableFps;
+	}
+	/**
+	* Get comprehensive performance metrics
+	*/
+	getMetrics(renderer) {
+		const avgFps = this.getAverageFPS();
+		const currentFps = this.getCurrentFPS();
+		return {
+			fps: currentFps,
+			avgFps,
+			minFps: this.getMinFPS(),
+			maxFps: this.getMaxFPS(),
+			frameTime: currentFps > 0 ? 1e3 / currentFps : 0,
+			memoryMB: this.getMemoryUsageMB(),
+			drawCalls: renderer?.info?.render?.calls ?? 0,
+			triangles: renderer?.info?.render?.triangles ?? 0
+		};
+	}
+	/**
+	* Get current memory usage in MB (Chrome only)
+	*/
+	getMemoryUsageMB() {
+		const perf = performance;
+		if (perf.memory) return perf.memory.usedJSHeapSize / 1024 / 1024;
+		return 0;
+	}
+	/**
+	* Check performance thresholds and log warnings
+	*/
+	checkPerformanceThresholds(renderer) {
+		this.performanceWarnings = [];
+		const avgFps = this.getAverageFPS();
+		const memoryMB = this.getMemoryUsageMB();
+		const drawCalls = renderer?.info?.render?.calls ?? 0;
+		if (avgFps < this.thresholds.minAcceptableFps) {
+			const warning = `⚠️ FPS below threshold: ${avgFps.toFixed(1)} < ${this.thresholds.minAcceptableFps}`;
+			this.performanceWarnings.push(warning);
+			console.warn(warning);
+		}
+		if (memoryMB > 0 && memoryMB > this.thresholds.maxMemoryMB) {
+			const warning = `⚠️ Memory usage high: ${memoryMB.toFixed(1)}MB > ${this.thresholds.maxMemoryMB}MB`;
+			this.performanceWarnings.push(warning);
+			console.warn(warning);
+		}
+		if (drawCalls > this.thresholds.maxDrawCalls) {
+			const warning = `⚠️ Draw calls high: ${drawCalls} > ${this.thresholds.maxDrawCalls}`;
+			this.performanceWarnings.push(warning);
+			console.warn(warning);
+		}
+	}
+	/**
+	* Get current performance warnings
+	*/
+	getWarnings() {
+		return this.performanceWarnings;
+	}
+	/**
+	* Reset all metrics
+	*/
+	reset() {
+		this.frames = [];
+		this.lastTime = performance.now();
+		this.frameCount = 0;
+		this.minFps = Infinity;
+		this.maxFps = 0;
+		this.performanceWarnings = [];
+	}
+	/**
+	* Get formatted performance summary string
+	*/
+	getSummary(renderer) {
+		const metrics = this.getMetrics(renderer);
+		return `FPS: ${metrics.fps.toFixed(1)} | Avg: ${metrics.avgFps.toFixed(1)} | Min: ${metrics.minFps.toFixed(1)} | Max: ${metrics.maxFps.toFixed(1)} | Frame: ${metrics.frameTime.toFixed(2)}ms | Mem: ${metrics.memoryMB.toFixed(1)}MB | Draws: ${metrics.drawCalls} | Tris: ${(metrics.triangles / 1e3).toFixed(1)}k`;
+	}
+};
+//#endregion
+export { PerformanceMonitor as default };
+
+//# sourceMappingURL=PerformanceMonitor.js.map

package/lib/utils/performance/PerformanceMonitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceMonitor.js","names":[],"sources":["../../../src/utils/performance/PerformanceMonitor.ts"],"sourcesContent":["/**\n * PerformanceMonitor - Real-time FPS and performance tracking for Three.js\n *\n * Monitors frame rate, memory usage, and draw calls to maintain 60fps target.\n * Provides warnings in development mode when performance degrades.\n */\n\nimport * as THREE from \"three\";\n\nexport interface PerformanceMetrics {\n  readonly fps: number;\n  readonly avgFps: number;\n  readonly minFps: number;\n  readonly maxFps: number;\n  readonly frameTime: number;\n  readonly memoryMB: number;\n  readonly drawCalls: number;\n  readonly triangles: number;\n}\n\nexport interface PerformanceThresholds {\n  readonly targetFps: number;\n  readonly minAcceptableFps: number;\n  readonly maxMemoryMB: number;\n  readonly maxDrawCalls: number;\n}\n\nconst DEFAULT_THRESHOLDS: PerformanceThresholds = {\n  targetFps: 60,\n  minAcceptableFps: 55,\n  maxMemoryMB: 300,\n  maxDrawCalls: 100,\n};\n\n// Prevent unrealistic spikes when frame deltas are extremely small (e.g., mocked timers)\nconst MAX_SAMPLE_FPS = 180;\nconst MIN_FRAME_TIME_MS = 1000 / MAX_SAMPLE_FPS;\n\n/**\n * PerformanceMonitor class for real-time performance tracking\n */\nexport class PerformanceMonitor {\n  private frames: number[] = [];\n  private lastTime = performance.now();\n  private frameCount = 0;\n  private readonly maxFrameSamples = 60; // Track last 60 frames (1 second at 60fps)\n\n  private minFps = Infinity;\n  private maxFps = 0;\n\n  private readonly thresholds: PerformanceThresholds;\n  private performanceWarnings: string[] = [];\n\n  constructor(thresholds: Partial<PerformanceThresholds> = {}) {\n    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };\n  }\n\n  /**\n   * Update performance metrics (call once per frame)\n   * @param renderer Optional Three.js renderer for draw call tracking\n   * @returns Current FPS\n   */\n  update(renderer?: THREE.WebGLRenderer): number {\n    const now = performance.now();\n    const delta = now - this.lastTime;\n    this.lastTime = now;\n\n    if (delta <= 0) return 0; // Skip invalid frames\n\n    const clampedDelta = Math.max(delta, MIN_FRAME_TIME_MS);\n    const fps = Math.min(1000 / clampedDelta, MAX_SAMPLE_FPS);\n    this.frames.push(fps);\n\n    // Track min/max FPS\n    if (fps < this.minFps) this.minFps = fps;\n    if (fps > this.maxFps) this.maxFps = fps;\n\n    // Keep frames array bounded\n    if (this.frames.length > this.maxFrameSamples) {\n      this.frames.shift();\n    }\n\n    this.frameCount++;\n\n    // Check performance thresholds (only in dev mode)\n    if (import.meta.env.DEV && this.frameCount % 60 === 0) {\n      this.checkPerformanceThresholds(renderer);\n    }\n\n    return fps;\n  }\n\n  /**\n   * Get current FPS\n   */\n  getCurrentFPS(): number {\n    if (this.frames.length === 0) return 0;\n    return this.frames[this.frames.length - 1];\n  }\n\n  /**\n   * Get average FPS over the sampling window\n   */\n  getAverageFPS(): number {\n    if (this.frames.length === 0) return 0;\n    return this.frames.reduce((a, b) => a + b, 0) / this.frames.length;\n  }\n\n  /**\n   * Get minimum FPS recorded\n   */\n  getMinFPS(): number {\n    return this.minFps === Infinity ? 0 : this.minFps;\n  }\n\n  /**\n   * Get maximum FPS recorded\n   */\n  getMaxFPS(): number {\n    return this.maxFps;\n  }\n\n  /**\n   * Check if performance is good (above minimum threshold)\n   */\n  isPerformanceGood(): boolean {\n    const avgFps = this.getAverageFPS();\n    return avgFps >= this.thresholds.minAcceptableFps;\n  }\n\n  /**\n   * Get comprehensive performance metrics\n   */\n  getMetrics(renderer?: THREE.WebGLRenderer): PerformanceMetrics {\n    const avgFps = this.getAverageFPS();\n    const currentFps = this.getCurrentFPS();\n\n    return {\n      fps: currentFps,\n      avgFps,\n      minFps: this.getMinFPS(),\n      maxFps: this.getMaxFPS(),\n      frameTime: currentFps > 0 ? 1000 / currentFps : 0,\n      memoryMB: this.getMemoryUsageMB(),\n      drawCalls: renderer?.info?.render?.calls ?? 0,\n      triangles: renderer?.info?.render?.triangles ?? 0,\n    };\n  }\n\n  /**\n   * Get current memory usage in MB (Chrome only)\n   */\n  private getMemoryUsageMB(): number {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Chrome-specific performance.memory API not in standard TS types\n    const perf = performance as any;\n    if (perf.memory) {\n      return perf.memory.usedJSHeapSize / 1024 / 1024;\n    }\n    return 0;\n  }\n\n  /**\n   * Check performance thresholds and log warnings\n   */\n  private checkPerformanceThresholds(renderer?: THREE.WebGLRenderer): void {\n    this.performanceWarnings = [];\n\n    const avgFps = this.getAverageFPS();\n    const memoryMB = this.getMemoryUsageMB();\n    const drawCalls = renderer?.info?.render?.calls ?? 0;\n\n    // Check FPS\n    if (avgFps < this.thresholds.minAcceptableFps) {\n      const warning = `⚠️ FPS below threshold: ${avgFps.toFixed(1)} < ${\n        this.thresholds.minAcceptableFps\n      }`;\n      this.performanceWarnings.push(warning);\n      console.warn(warning);\n    }\n\n    // Check memory\n    if (memoryMB > 0 && memoryMB > this.thresholds.maxMemoryMB) {\n      const warning = `⚠️ Memory usage high: ${memoryMB.toFixed(1)}MB > ${\n        this.thresholds.maxMemoryMB\n      }MB`;\n      this.performanceWarnings.push(warning);\n      console.warn(warning);\n    }\n\n    // Check draw calls\n    if (drawCalls > this.thresholds.maxDrawCalls) {\n      const warning = `⚠️ Draw calls high: ${drawCalls} > ${this.thresholds.maxDrawCalls}`;\n      this.performanceWarnings.push(warning);\n      console.warn(warning);\n    }\n  }\n\n  /**\n   * Get current performance warnings\n   */\n  getWarnings(): readonly string[] {\n    return this.performanceWarnings;\n  }\n\n  /**\n   * Reset all metrics\n   */\n  reset(): void {\n    this.frames = [];\n    this.lastTime = performance.now();\n    this.frameCount = 0;\n    this.minFps = Infinity;\n    this.maxFps = 0;\n    this.performanceWarnings = [];\n  }\n\n  /**\n   * Get formatted performance summary string\n   */\n  getSummary(renderer?: THREE.WebGLRenderer): string {\n    const metrics = this.getMetrics(renderer);\n    return (\n      `FPS: ${metrics.fps.toFixed(1)} | ` +\n      `Avg: ${metrics.avgFps.toFixed(1)} | ` +\n      `Min: ${metrics.minFps.toFixed(1)} | ` +\n      `Max: ${metrics.maxFps.toFixed(1)} | ` +\n      `Frame: ${metrics.frameTime.toFixed(2)}ms | ` +\n      `Mem: ${metrics.memoryMB.toFixed(1)}MB | ` +\n      `Draws: ${metrics.drawCalls} | ` +\n      `Tris: ${(metrics.triangles / 1000).toFixed(1)}k`\n    );\n  }\n}\n\n/**\n * Create a performance monitor with optional custom thresholds\n */\nexport function createPerformanceMonitor(\n  thresholds?: Partial<PerformanceThresholds>,\n): PerformanceMonitor {\n  return new PerformanceMonitor(thresholds);\n}\n\nexport default PerformanceMonitor;\n"],"mappings":"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"}

package/lib/utils/performance/PerformanceOverlay3D.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PerformanceOverlay3D - Development-only performance stats overlay for Three.js
+ *
+ * Displays real-time FPS, memory, and draw call statistics
+ * Only visible in development mode
+ */
+import React from "react";
+export interface PerformanceOverlay3DProps {
+    /** @deprecated Position prop is no longer used - overlay now uses screen-space positioning */
+    readonly position?: [number, number, number];
+    readonly visible?: boolean;
+}
+/**
+ * 3D Performance overlay component for development
+ * Shows FPS, memory, draw calls, and warnings
+ * Uses screen-space positioning (bottom-left corner)
+ */
+export declare const PerformanceOverlay3D: React.FC<PerformanceOverlay3DProps>;
+export default PerformanceOverlay3D;
+//# sourceMappingURL=PerformanceOverlay3D.d.ts.map

package/lib/utils/performance/PerformanceOverlay3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceOverlay3D.d.ts","sourceRoot":"","sources":["../../../src/utils/performance/PerformanceOverlay3D.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,MAAM,WAAW,yBAAyB;IACxC,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CAqNpE,CAAC;AAEF,eAAe,oBAAoB,CAAC"}