@skewedaspect/sage 0.3.0

package/src/utils/logger.ts

@@ -0,0 +1,225 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Logger Utility
+//----------------------------------------------------------------------------------------------------------------------
+
+import type {
+    LogLevel,
+    LoggerInterface,
+    LoggingBackend,
+} from '../interfaces/logger.ts';
+
+import { ConsoleBackend } from '../classes/loggers/consoleBackend.ts';
+import { NullBackend } from '../classes/loggers/nullBackend.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Implementation of Logger interface.
+ * Each instance is bound to a specific category and backend.
+ */
+export class SAGELogger implements LoggerInterface
+{
+    private category : string;
+    private backend : LoggingBackend;
+    private minLevel : LogLevel;
+
+    constructor(category : string, minLevel : LogLevel = 'none', backend : LoggingBackend = new NullBackend())
+    {
+        this.category = category;
+        this.backend = backend;
+        this.minLevel = minLevel;
+    }
+
+    /**
+     * Update the logger's backend and minimum level
+     */
+    public updateSettings(backend : LoggingBackend, minLevel : LogLevel) : void
+    {
+        this.backend = backend;
+        this.minLevel = minLevel;
+    }
+
+    trace(message : string, ...args : any[]) : void
+    {
+        if(this.shouldLog('trace'))
+        {
+            this.backend.trace(this.category, message, ...args);
+        }
+    }
+
+    debug(message : string, ...args : any[]) : void
+    {
+        if(this.shouldLog('debug'))
+        {
+            this.backend.debug(this.category, message, ...args);
+        }
+    }
+
+    info(message : string, ...args : any[]) : void
+    {
+        if(this.shouldLog('info'))
+        {
+            this.backend.info(this.category, message, ...args);
+        }
+    }
+
+    warn(message : string, ...args : any[]) : void
+    {
+        if(this.shouldLog('warn'))
+        {
+            this.backend.warn(this.category, message, ...args);
+        }
+    }
+
+    error(message : string, ...args : any[]) : void
+    {
+        if(this.shouldLog('error'))
+        {
+            this.backend.error(this.category, message, ...args);
+        }
+    }
+
+    time(label : string) : void
+    {
+        if(this.minLevel !== 'none')
+        {
+            this.backend.time(this.category, label);
+        }
+    }
+
+    timeEnd(label : string) : void
+    {
+        if(this.minLevel !== 'none')
+        {
+            this.backend.timeEnd(this.category, label);
+        }
+    }
+
+    /**
+     * Determine if a message at the given level should be logged based on the current minimum level.
+     */
+    private shouldLog(level : LogLevel) : boolean
+    {
+        if(this.minLevel === 'none')
+        {
+            return false;
+        }
+
+        switch (this.minLevel)
+        {
+            case 'trace':
+                return true;
+            case 'debug':
+                return level !== 'trace';
+            case 'info':
+                return level === 'info' || level === 'warn' || level === 'error';
+            case 'warn':
+                return level === 'warn' || level === 'error';
+            case 'error':
+                return level === 'error';
+            default:
+                return false;
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * A utility for creating loggers and managing logging configuration.
+ */
+export class LoggingUtility
+{
+    private backend : LoggingBackend;
+    private level : LogLevel;
+    private loggers : Map<string, LoggerInterface>;
+
+    /**
+     * Create a new LoggingUtility.
+     *
+     * @param level - The minimum logging level (defaults to INFO)
+     * @param backend - The logging backend to use (defaults to ConsoleBackend)
+     */
+    constructor(level : LogLevel = 'debug', backend : LoggingBackend = new ConsoleBackend())
+    {
+        this.backend = backend;
+        this.level = level;
+        this.loggers = new Map();
+    }
+
+    /**
+     * Set the logging backend.
+     *
+     * @param backend - The logging backend to use
+     */
+    public setBackend(backend : LoggingBackend) : void
+    {
+        this.backend = backend;
+
+        // Update all existing loggers to use the new backend
+        this.loggers.forEach((logger) =>
+        {
+            if(logger instanceof SAGELogger)
+            {
+                logger.updateSettings(this.backend, this.level);
+            }
+        });
+    }
+
+    /**
+     * Set the minimum logging level.
+     *
+     * @param level - The minimum logging level to display
+     */
+    public setLevel(level : LogLevel) : void
+    {
+        this.level = level;
+
+        // Update all existing loggers to use the new level
+        this.loggers.forEach((logger) =>
+        {
+            if(logger instanceof SAGELogger)
+            {
+                logger.updateSettings(this.backend, this.level);
+            }
+        });
+    }
+
+    /**
+     * Get the current minimum logging level.
+     */
+    public getLevel() : LogLevel
+    {
+        return this.level;
+    }
+
+    /**
+     * Get a logger for the specified category.
+     *
+     * @param category - The category for this logger (typically class/module name)
+     * @returns A Logger instance for the specified category
+     */
+    public getLogger(category : string) : LoggerInterface
+    {
+        if(!this.loggers.has(category))
+        {
+            this.loggers.set(category, new SAGELogger(category, this.level, this.backend));
+        }
+
+        const logger = this.loggers.get(category);
+        // Check for undefined instead of using non-null assertion
+        if(logger === undefined)
+        {
+            throw new Error(`Failed to create logger for category: ${ category }`);
+        }
+
+        return logger;
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+export { ConsoleBackend } from '../classes/loggers/consoleBackend.ts';
+export { NullBackend } from '../classes/loggers/nullBackend.ts';
+
+//----------------------------------------------------------------------------------------------------------------------

package/src/utils/physics.ts

@@ -0,0 +1,16 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Physics Utility
+//----------------------------------------------------------------------------------------------------------------------
+
+import HavokPhysics from '@babylonjs/havok';
+import { HavokPlugin } from '@babylonjs/core';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+export async function createPhysics() : Promise<HavokPlugin>
+{
+    const hk = await HavokPhysics();
+    return new HavokPlugin(true, hk);
+}
+
+//----------------------------------------------------------------------------------------------------------------------

package/src/utils/version.ts

@@ -0,0 +1,11 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Version utility for SAGE
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * The current version of the SAGE engine.
+ * This is automatically pulled from package.json during build.
+ */
+export const VERSION = __APP_VERSION__ ?? '0.0.0';
+
+//----------------------------------------------------------------------------------------------------------------------