@myned-ai/gsplat-flame-avatar-renderer 1.0.6 → 1.0.7

package/src/utils/LoaderUtils.js

@@ -1,66 +0,0 @@
-/**
- * LoaderUtils
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * Loader utilities for decoding text and resolving URLs.
- */
-
-export class LoaderUtils {
-
-    /**
-     * @deprecated Use TextDecoder instead
-     */
-    static decodeText(array) {
-        if (typeof TextDecoder !== 'undefined') {
-            return new TextDecoder().decode(array);
-        }
-
-        // Fallback for environments without TextDecoder
-        let s = '';
-
-        for (let i = 0, il = array.length; i < il; i++) {
-            // Implicitly assumes little-endian.
-            s += String.fromCharCode(array[i]);
-        }
-
-        try {
-            // merges multi-byte utf-8 characters.
-            return decodeURIComponent(escape(s));
-        } catch {
-            // see #16358 - ignore decoding errors
-            return s;
-        }
-    }
-
-    static extractUrlBase(url) {
-        const index = url.lastIndexOf('/');
-
-        if (index === -1) return './';
-
-        return url.slice(0, index + 1);
-    }
-
-    static resolveURL(url, path) {
-        // Invalid URL
-        if (typeof url !== 'string' || url === '') return '';
-
-        // Host Relative URL
-        if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
-            path = path.replace(/(^https?:\/\/[^/]+).*/i, '$1');
-        }
-
-        // Absolute URL http://,https://,//
-        if (/^(https?:)?\/\//i.test(url)) return url;
-
-        // Data URI
-        if (/^data:.*,.*$/i.test(url)) return url;
-
-        // Blob URL
-        if (/^blob:.*$/i.test(url)) return url;
-
-        // Relative URL
-        return path + url;
-    }
-}

package/src/utils/Logger.js

@@ -1,171 +0,0 @@
-/**
- * Logger - Structured logging system
- *
- * Provides leveled logging with optional output suppression for production.
- * Replaces direct console.log calls for better control and debugging.
- */
-
-/**
- * Logger levels in order of severity
- * Note: Named LoggerLevel to avoid conflict with existing LogLevel enum
- */
-export const LoggerLevel = Object.freeze({
-    DEBUG: 0,
-    INFO: 1,
-    WARN: 2,
-    ERROR: 3,
-    NONE: 4
-});
-
-/**
- * Logger class for structured application logging
- */
-export class Logger {
-    /**
-     * Create a Logger instance
-     * @param {string} namespace - Logger namespace (e.g., 'Renderer', 'Loader')
-     * @param {number} [minLevel=LoggerLevel.INFO] - Minimum log level to output
-     */
-    constructor(namespace, minLevel = LoggerLevel.INFO) {
-        this.namespace = namespace;
-        this.minLevel = minLevel;
-    }
-
-    /**
-     * Set minimum log level
-     * @param {number} level - Minimum level from LoggerLevel enum
-     */
-    setLevel(level) {
-        this.minLevel = level;
-    }
-
-    /**
-     * Format log message with namespace and timestamp
-     * @private
-     * @param {string} level - Log level name
-     * @param {Array} args - Log arguments
-     * @returns {Array} Formatted arguments
-     */
-    _format(level, args) {
-        const timestamp = new Date().toISOString();
-        const prefix = `[${timestamp}] [${level}] [${this.namespace}]`;
-        return [prefix, ...args];
-    }
-
-    /**
-     * Log debug message (most verbose)
-     * @param {...*} args - Arguments to log
-     */
-    debug(...args) {
-        if (this.minLevel <= LoggerLevel.DEBUG) {
-            console.debug(...this._format('DEBUG', args));
-        }
-    }
-
-    /**
-     * Log info message
-     * @param {...*} args - Arguments to log
-     */
-    info(...args) {
-        if (this.minLevel <= LoggerLevel.INFO) {
-            console.info(...this._format('INFO', args));
-        }
-    }
-
-    /**
-     * Log warning message
-     * @param {...*} args - Arguments to log
-     */
-    warn(...args) {
-        if (this.minLevel <= LoggerLevel.WARN) {
-            console.warn(...this._format('WARN', args));
-        }
-    }
-
-    /**
-     * Log error message
-     * @param {...*} args - Arguments to log
-     */
-    error(...args) {
-        if (this.minLevel <= LoggerLevel.ERROR) {
-            console.error(...this._format('ERROR', args));
-        }
-    }
-
-    /**
-     * Log error with stack trace
-     * @param {Error} error - Error object
-     * @param {string} [context] - Additional context
-     */
-    errorWithTrace(error, context = '') {
-        if (this.minLevel <= LoggerLevel.ERROR) {
-            const contextStr = context ? ` Context: ${context}` : '';
-            console.error(...this._format('ERROR', [
-                `${error.message}${contextStr}`,
-                '\nStack:', error.stack
-            ]));
-        }
-    }
-
-    /**
-     * Create a child logger with extended namespace
-     * @param {string} childNamespace - Child namespace to append
-     * @returns {Logger} New logger with combined namespace
-     */
-    child(childNamespace) {
-        return new Logger(`${this.namespace}:${childNamespace}`, this.minLevel);
-    }
-}
-
-/**
- * Global logger registry
- * @private
- */
-const loggers = new Map();
-
-/**
- * Global log level (affects all new loggers)
- * @private
- */
-let globalLogLevel = LoggerLevel.INFO;
-
-/**
- * Set global log level for all loggers
- * @param {number} level - Log level from LoggerLevel enum
- */
-export function setGlobalLogLevel(level) {
-    globalLogLevel = level;
-    // Update existing loggers
-    for (const logger of loggers.values()) {
-        logger.setLevel(level);
-    }
-}
-
-/**
- * Get or create a logger for a namespace
- * @param {string} namespace - Logger namespace
- * @returns {Logger} Logger instance
- */
-export function getLogger(namespace) {
-    if (!loggers.has(namespace)) {
-        loggers.set(namespace, new Logger(namespace, globalLogLevel));
-    }
-    return loggers.get(namespace);
-}
-
-/**
- * Configure logging for production (suppress all logs)
- */
-export function configureForProduction() {
-    setGlobalLogLevel(LoggerLevel.NONE);
-}
-
-/**
- * Configure logging for development (show all logs)
- */
-export function configureForDevelopment() {
-    setGlobalLogLevel(LoggerLevel.DEBUG);
-}
-
-// Export default logger for convenience
-export default getLogger('App');

package/src/utils/ObjectPool.js

@@ -1,248 +0,0 @@
-/**
- * ObjectPool - Memory-efficient object pooling
- *
- * Reduces garbage collection pressure by reusing objects instead of
- * repeatedly allocating and deallocating them. Critical for real-time rendering.
- */
-
-import { Vector3, Matrix4, Quaternion, Euler } from 'three';
-
-/**
- * Generic object pool
- */
-export class ObjectPool {
-    /**
-     * Create an ObjectPool
-     * @param {Function} factory - Function that creates new objects
-     * @param {Function} reset - Function that resets an object to initial state
-     * @param {number} [initialSize=10] - Number of objects to pre-allocate
-     */
-    constructor(factory, reset, initialSize = 10) {
-        this._factory = factory;
-        this._reset = reset;
-        this._pool = [];
-        this._allocated = 0;
-        this._maxSize = initialSize * 10; // Prevent unbounded growth
-
-        // Pre-allocate initial objects
-        for (let i = 0; i < initialSize; i++) {
-            this._pool.push(factory());
-        }
-    }
-
-    /**
-     * Acquire an object from the pool
-     * @returns {*} Pooled object
-     */
-    acquire() {
-        this._allocated++;
-        if (this._pool.length > 0) {
-            return this._pool.pop();
-        }
-        // Pool exhausted, create new object
-        return this._factory();
-    }
-
-    /**
-     * Release an object back to the pool
-     * @param {*} obj - Object to return to pool
-     */
-    release(obj) {
-        this._allocated--;
-        if (this._pool.length < this._maxSize) {
-            this._reset(obj);
-            this._pool.push(obj);
-        }
-        // If pool is at max size, let object be garbage collected
-    }
-
-    /**
-     * Release multiple objects
-     * @param {Array} objects - Objects to return to pool
-     */
-    releaseAll(objects) {
-        for (const obj of objects) {
-            this.release(obj);
-        }
-    }
-
-    /**
-     * Get pool statistics
-     * @returns {object} Pool stats
-     */
-    getStats() {
-        return {
-            available: this._pool.length,
-            allocated: this._allocated,
-            maxSize: this._maxSize
-        };
-    }
-
-    /**
-     * Clear the pool and release all objects
-     */
-    dispose() {
-        this._pool.length = 0;
-        this._allocated = 0;
-    }
-}
-
-/**
- * Pre-configured pools for common Three.js objects
- */
-
-/**
- * Vector3 pool
- * @type {ObjectPool}
- */
-export const vector3Pool = new ObjectPool(
-    () => new Vector3(),
-    (v) => v.set(0, 0, 0),
-    50 // Pre-allocate 50 vectors
-);
-
-/**
- * Matrix4 pool
- * @type {ObjectPool}
- */
-export const matrix4Pool = new ObjectPool(
-    () => new Matrix4(),
-    (m) => m.identity(),
-    20 // Pre-allocate 20 matrices
-);
-
-/**
- * Quaternion pool
- * @type {ObjectPool}
- */
-export const quaternionPool = new ObjectPool(
-    () => new Quaternion(),
-    (q) => q.set(0, 0, 0, 1),
-    30 // Pre-allocate 30 quaternions
-);
-
-/**
- * Euler pool
- * @type {ObjectPool}
- */
-export const eulerPool = new ObjectPool(
-    () => new Euler(),
-    (e) => e.set(0, 0, 0),
-    30 // Pre-allocate 30 eulers
-);
-
-/**
- * Scoped pool allocation helper
- *
- * Automatically releases pooled objects when scope exits.
- * Use with try/finally to ensure cleanup.
- *
- * @example
- * const scope = new PoolScope();
- * try {
- *   const v1 = scope.vector3();
- *   const v2 = scope.vector3();
- *   // Use vectors...
- * } finally {
- *   scope.releaseAll();
- * }
- */
-export class PoolScope {
-    constructor() {
-        this._allocated = [];
-    }
-
-    /**
-     * Acquire a Vector3 from pool
-     * @returns {Vector3} Pooled vector
-     */
-    vector3() {
-        const obj = vector3Pool.acquire();
-        this._allocated.push({ pool: vector3Pool, obj });
-        return obj;
-    }
-
-    /**
-     * Acquire a Matrix4 from pool
-     * @returns {Matrix4} Pooled matrix
-     */
-    matrix4() {
-        const obj = matrix4Pool.acquire();
-        this._allocated.push({ pool: matrix4Pool, obj });
-        return obj;
-    }
-
-    /**
-     * Acquire a Quaternion from pool
-     * @returns {Quaternion} Pooled quaternion
-     */
-    quaternion() {
-        const obj = quaternionPool.acquire();
-        this._allocated.push({ pool: quaternionPool, obj });
-        return obj;
-    }
-
-    /**
-     * Acquire an Euler from pool
-     * @returns {Euler} Pooled euler
-     */
-    euler() {
-        const obj = eulerPool.acquire();
-        this._allocated.push({ pool: eulerPool, obj });
-        return obj;
-    }
-
-    /**
-     * Release all objects allocated in this scope
-     */
-    releaseAll() {
-        for (const { pool, obj } of this._allocated) {
-            pool.release(obj);
-        }
-        this._allocated.length = 0;
-    }
-
-    /**
-     * Get count of allocated objects in this scope
-     * @returns {number} Number of allocated objects
-     */
-    getAllocatedCount() {
-        return this._allocated.length;
-    }
-}
-
-/**
- * Module-level temporary objects for hot-path reuse
- * IMPORTANT: These are NOT thread-safe. Only use in single-threaded contexts.
- * Reset these before use to avoid stale data.
- */
-export const tempVector3A = new Vector3();
-export const tempVector3B = new Vector3();
-export const tempVector3C = new Vector3();
-export const tempMatrix4A = new Matrix4();
-export const tempMatrix4B = new Matrix4();
-export const tempQuaternionA = new Quaternion();
-export const tempQuaternionB = new Quaternion();
-
-/**
- * Get pool statistics for all pre-configured pools
- * @returns {object} Statistics for all pools
- */
-export function getPoolStats() {
-    return {
-        vector3: vector3Pool.getStats(),
-        matrix4: matrix4Pool.getStats(),
-        quaternion: quaternionPool.getStats(),
-        euler: eulerPool.getStats()
-    };
-}
-
-/**
- * Dispose all pre-configured pools
- */
-export function disposeAllPools() {
-    vector3Pool.dispose();
-    matrix4Pool.dispose();
-    quaternionPool.dispose();
-    eulerPool.dispose();
-}