📘 Singleton Pattern: Ensuring Single Instance

🎯 Introduction

Hey there, TypeScript explorer! 👋 Have you ever been to a party where there’s only ONE DJ booth? 🎧 No matter how many people want to play music, they all have to use the same equipment. That’s exactly what the Singleton pattern is all about – ensuring there’s only ONE instance of something in your entire application!

Today, we’re diving into one of the most famous (and sometimes controversial) design patterns. Whether you’re building a game engine 🎮, managing app settings ⚙️, or handling database connections 🗄️, the Singleton pattern is your ticket to maintaining control and consistency. Let’s master this powerful pattern together! 💪

📚 Understanding Singleton Pattern

Think of the Singleton pattern like the president of a country 🏛️ – there can only be ONE at any given time! No matter how many times people refer to “the president,” they’re all talking about the same person. That’s the essence of Singleton!

What Makes a Singleton Special? 🌟

The Singleton pattern ensures:

• Single Instance: Only ONE instance exists throughout your app’s lifetime
• Global Access: Available from anywhere in your application
• Lazy Initialization: Created only when first needed
• Thread Safety: Handles concurrent access properly (we’ll cover this!)

It’s like having a single remote control 📺 for your TV – everyone in the house uses the same one!

🔧 Basic Syntax and Usage

Let’s start with a simple Singleton implementation in TypeScript! 🚀

// 👋 Basic Singleton class
class ConfigManager {
  private static instance: ConfigManager;
  private config: Record<string, any> = {};

  // 🚫 Private constructor prevents direct instantiation
  private constructor() {
    console.log("🎉 ConfigManager initialized!");
  }

  // 🎯 Static method to get the instance
  public static getInstance(): ConfigManager {
    if (!ConfigManager.instance) {
      ConfigManager.instance = new ConfigManager();
    }
    return ConfigManager.instance;
  }

  // 📝 Add configuration
  public set(key: string, value: any): void {
    this.config[key] = value;
  }

  // 📖 Get configuration
  public get(key: string): any {
    return this.config[key];
  }
}

// 🎮 Let's use it!
const config1 = ConfigManager.getInstance();
const config2 = ConfigManager.getInstance();

console.log(config1 === config2); // true ✅ Same instance!

config1.set("theme", "🌙 dark");
console.log(config2.get("theme")); // "🌙 dark" - Same data!

See how both config1 and config2 point to the exact same instance? That’s the magic! ✨

💡 Practical Examples

Let’s explore some real-world scenarios where Singleton shines! 🌟

Example 1: Game Score Manager 🎮

// 🏆 Managing game scores across your app
class ScoreManager {
  private static instance: ScoreManager;
  private scores: Map<string, number> = new Map();
  private highScore: number = 0;

  private constructor() {
    console.log("🎯 ScoreManager ready!");
  }

  public static getInstance(): ScoreManager {
    if (!ScoreManager.instance) {
      ScoreManager.instance = new ScoreManager();
    }
    return ScoreManager.instance;
  }

  // 📈 Add player score
  public addScore(player: string, points: number): void {
    const currentScore = this.scores.get(player) || 0;
    const newScore = currentScore + points;
    this.scores.set(player, newScore);
    
    // 🏅 Update high score if needed
    if (newScore > this.highScore) {
      this.highScore = newScore;
      console.log(`🎊 New high score: ${newScore} by ${player}!`);
    }
  }

  // 📊 Get leaderboard
  public getLeaderboard(): Array<{player: string, score: number}> {
    return Array.from(this.scores.entries())
      .map(([player, score]) => ({ player, score }))
      .sort((a, b) => b.score - a.score);
  }

  // 🏆 Get high score
  public getHighScore(): number {
    return this.highScore;
  }
}

// 🎮 Game components using the singleton
class GameLevel {
  private scoreManager = ScoreManager.getInstance();

  completeLevel(player: string, levelScore: number): void {
    console.log(`✅ Level complete! Adding ${levelScore} points`);
    this.scoreManager.addScore(player, levelScore);
  }
}

class BonusRound {
  private scoreManager = ScoreManager.getInstance();

  collectBonus(player: string, bonus: number): void {
    console.log(`🎁 Bonus collected! +${bonus} points`);
    this.scoreManager.addScore(player, bonus);
  }
}

// 🎯 Playing the game
const level = new GameLevel();
const bonus = new BonusRound();

level.completeLevel("Alice 🦄", 100);
bonus.collectBonus("Alice 🦄", 50);
level.completeLevel("Bob 🐻", 120);

const scores = ScoreManager.getInstance();
console.log("🏆 Leaderboard:", scores.getLeaderboard());

Example 2: Theme Manager for Your App 🎨

// 🎨 Managing app theme consistently
interface Theme {
  name: string;
  primary: string;
  secondary: string;
  background: string;
  text: string;
}

class ThemeManager {
  private static instance: ThemeManager;
  private currentTheme: Theme;
  private themes: Map<string, Theme> = new Map();
  private listeners: Array<(theme: Theme) => void> = [];

  private constructor() {
    // 🌈 Initialize with default themes
    this.themes.set("light", {
      name: "☀️ Light",
      primary: "#3498db",
      secondary: "#2ecc71",
      background: "#ffffff",
      text: "#2c3e50"
    });

    this.themes.set("dark", {
      name: "🌙 Dark",
      primary: "#9b59b6",
      secondary: "#e74c3c",
      background: "#2c3e50",
      text: "#ecf0f1"
    });

    this.themes.set("ocean", {
      name: "🌊 Ocean",
      primary: "#006994",
      secondary: "#00a8cc",
      background: "#e8f5f5",
      text: "#004e71"
    });

    this.currentTheme = this.themes.get("light")!;
  }

  public static getInstance(): ThemeManager {
    if (!ThemeManager.instance) {
      ThemeManager.instance = new ThemeManager();
    }
    return ThemeManager.instance;
  }

  // 🎨 Get current theme
  public getCurrentTheme(): Theme {
    return this.currentTheme;
  }

  // 🔄 Switch theme
  public switchTheme(themeName: string): void {
    const theme = this.themes.get(themeName);
    if (theme) {
      this.currentTheme = theme;
      console.log(`✨ Switched to ${theme.name} theme!`);
      this.notifyListeners();
    }
  }

  // 👂 Subscribe to theme changes
  public subscribe(listener: (theme: Theme) => void): void {
    this.listeners.push(listener);
  }

  // 📢 Notify all listeners
  private notifyListeners(): void {
    this.listeners.forEach(listener => listener(this.currentTheme));
  }

  // 📝 Get available themes
  public getAvailableThemes(): string[] {
    return Array.from(this.themes.keys());
  }
}

// 🎨 UI Components using the theme
class Header {
  private themeManager = ThemeManager.getInstance();

  constructor() {
    this.themeManager.subscribe((theme) => {
      console.log(`📱 Header updated with ${theme.name} colors!`);
    });
  }

  render(): void {
    const theme = this.themeManager.getCurrentTheme();
    console.log(`🎨 Header: Background ${theme.primary}, Text ${theme.text}`);
  }
}

class Sidebar {
  private themeManager = ThemeManager.getInstance();

  constructor() {
    this.themeManager.subscribe((theme) => {
      console.log(`📂 Sidebar updated with ${theme.name} colors!`);
    });
  }
}

// 🎮 Using the theme system
const header = new Header();
const sidebar = new Sidebar();
const theme = ThemeManager.getInstance();

header.render();
theme.switchTheme("dark");
theme.switchTheme("ocean");

Example 3: Database Connection Pool 🗄️

// 🗄️ Managing database connections efficiently
interface DBConnection {
  id: string;
  isActive: boolean;
  query: (sql: string) => Promise<any>;
}

class DatabasePool {
  private static instance: DatabasePool;
  private connections: DBConnection[] = [];
  private maxConnections: number = 5;
  private activeQueries: number = 0;

  private constructor() {
    console.log("🚀 Database pool initialized!");
    this.initializeConnections();
  }

  public static getInstance(): DatabasePool {
    if (!DatabasePool.instance) {
      DatabasePool.instance = new DatabasePool();
    }
    return DatabasePool.instance;
  }

  // 🔧 Initialize connection pool
  private initializeConnections(): void {
    for (let i = 0; i < this.maxConnections; i++) {
      this.connections.push({
        id: `conn-${i + 1}`,
        isActive: false,
        query: async (sql: string) => {
          // 🎭 Simulate database query
          console.log(`📊 Executing: ${sql}`);
          await new Promise(resolve => setTimeout(resolve, 100));
          return { success: true, data: "Query result 📦" };
        }
      });
    }
  }

  // 🎯 Get available connection
  private async getConnection(): Promise<DBConnection> {
    // 🔍 Find available connection
    let connection = this.connections.find(conn => !conn.isActive);
    
    if (!connection) {
      console.log("⏳ All connections busy, waiting...");
      await new Promise(resolve => setTimeout(resolve, 200));
      return this.getConnection();
    }

    connection.isActive = true;
    this.activeQueries++;
    console.log(`🔗 Using connection: ${connection.id}`);
    return connection;
  }

  // 📊 Execute query
  public async executeQuery(sql: string): Promise<any> {
    const connection = await this.getConnection();
    
    try {
      const result = await connection.query(sql);
      console.log(`✅ Query completed on ${connection.id}`);
      return result;
    } finally {
      // 🔓 Release connection
      connection.isActive = false;
      this.activeQueries--;
      console.log(`🔓 Released connection: ${connection.id}`);
    }
  }

  // 📈 Get pool statistics
  public getStats(): { total: number; active: number; available: number } {
    const active = this.connections.filter(conn => conn.isActive).length;
    return {
      total: this.maxConnections,
      active,
      available: this.maxConnections - active
    };
  }
}

// 🎮 Using the database pool
async function runDatabaseOperations() {
  const db = DatabasePool.getInstance();

  // 📊 Multiple queries from different parts of the app
  const queries = [
    db.executeQuery("SELECT * FROM users 👥"),
    db.executeQuery("SELECT * FROM products 📦"),
    db.executeQuery("SELECT * FROM orders 🛒"),
    db.executeQuery("UPDATE inventory SET stock = stock - 1 📉"),
    db.executeQuery("INSERT INTO logs VALUES ('Action logged') 📝"),
    db.executeQuery("SELECT * FROM analytics 📊")
  ];

  console.log("🚀 Starting queries...");
  console.log("📈 Pool stats:", db.getStats());

  await Promise.all(queries);

  console.log("🎉 All queries completed!");
  console.log("📈 Final pool stats:", db.getStats());
}

// 🏃‍♂️ Run the example
runDatabaseOperations();

🚀 Advanced Concepts

Ready to level up your Singleton game? Let’s explore some advanced techniques! 🎯

Thread-Safe Singleton (for async operations) 🔒

// 🔒 Thread-safe singleton with async initialization
class AsyncSingleton {
  private static instance: AsyncSingleton;
  private static initPromise: Promise<AsyncSingleton>;
  private data: any;

  private constructor() {}

  // 🚀 Async initialization
  private async initialize(): Promise<void> {
    console.log("⏳ Starting async initialization...");
    // 🎭 Simulate async operation (like loading config from API)
    await new Promise(resolve => setTimeout(resolve, 1000));
    this.data = { 
      apiKey: "🔑 secret-key-123",
      serverUrl: "🌐 https://api.example.com"
    };
    console.log("✅ Initialization complete!");
  }

  // 🎯 Get instance with async initialization
  public static async getInstance(): Promise<AsyncSingleton> {
    if (!AsyncSingleton.instance) {
      if (!AsyncSingleton.initPromise) {
        // 🔒 Ensure only one initialization happens
        AsyncSingleton.initPromise = (async () => {
          AsyncSingleton.instance = new AsyncSingleton();
          await AsyncSingleton.instance.initialize();
          return AsyncSingleton.instance;
        })();
      }
      return AsyncSingleton.initPromise;
    }
    return AsyncSingleton.instance;
  }

  public getData(): any {
    return this.data;
  }
}

// 🎮 Using async singleton
async function useAsyncSingleton() {
  console.log("🚀 Getting instance 1...");
  const instance1 = await AsyncSingleton.getInstance();
  
  console.log("🚀 Getting instance 2...");
  const instance2 = await AsyncSingleton.getInstance();
  
  console.log("Same instance?", instance1 === instance2); // true ✅
  console.log("Data:", instance1.getData());
}

useAsyncSingleton();

Singleton with Dependency Injection 💉

// 💉 Singleton that can be configured
interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string): void {
    console.log(`📝 Console: ${message}`);
  }
}

class FileLogger implements Logger {
  log(message: string): void {
    console.log(`📄 File: ${message}`);
  }
}

class LogManager {
  private static instance: LogManager;
  private logger: Logger;
  private logHistory: string[] = [];

  private constructor(logger: Logger) {
    this.logger = logger;
  }

  // 🎯 Configure and get instance
  public static configure(logger: Logger): void {
    if (!LogManager.instance) {
      LogManager.instance = new LogManager(logger);
    } else {
      console.warn("⚠️ LogManager already configured!");
    }
  }

  public static getInstance(): LogManager {
    if (!LogManager.instance) {
      // 🎯 Default to console logger
      LogManager.instance = new LogManager(new ConsoleLogger());
    }
    return LogManager.instance;
  }

  // 📝 Log with history
  public log(level: string, message: string): void {
    const timestamp = new Date().toISOString();
    const logEntry = `[${timestamp}] ${level}: ${message}`;
    
    this.logger.log(logEntry);
    this.logHistory.push(logEntry);
    
    // 🧹 Keep only last 100 entries
    if (this.logHistory.length > 100) {
      this.logHistory.shift();
    }
  }

  // 📊 Get log history
  public getHistory(): string[] {
    return [...this.logHistory];
  }

  // 🎨 Log with style
  public info(message: string): void {
    this.log("ℹ️ INFO", message);
  }

  public warn(message: string): void {
    this.log("⚠️ WARN", message);
  }

  public error(message: string): void {
    this.log("❌ ERROR", message);
  }

  public success(message: string): void {
    this.log("✅ SUCCESS", message);
  }
}

// 🎮 Configure and use
LogManager.configure(new FileLogger());

const log = LogManager.getInstance();
log.info("Application started");
log.success("User logged in");
log.warn("Low memory");
log.error("Connection failed");

console.log("📜 Log history:", log.getHistory());

Registry Pattern (Multiple Named Singletons) 📚

// 📚 Managing multiple singleton instances
class ServiceRegistry {
  private static instance: ServiceRegistry;
  private services: Map<string, any> = new Map();

  private constructor() {}

  public static getInstance(): ServiceRegistry {
    if (!ServiceRegistry.instance) {
      ServiceRegistry.instance = new ServiceRegistry();
    }
    return ServiceRegistry.instance;
  }

  // 📝 Register a service
  public register<T>(name: string, factory: () => T): void {
    if (this.services.has(name)) {
      console.warn(`⚠️ Service '${name}' already registered!`);
      return;
    }
    
    // 🔒 Lazy singleton creation
    let instance: T | null = null;
    const serviceGetter = () => {
      if (!instance) {
        instance = factory();
        console.log(`✨ Created singleton service: ${name}`);
      }
      return instance;
    };
    
    this.services.set(name, serviceGetter);
  }

  // 🎯 Get a service
  public get<T>(name: string): T {
    const serviceGetter = this.services.get(name);
    if (!serviceGetter) {
      throw new Error(`❌ Service '${name}' not found!`);
    }
    return serviceGetter();
  }

  // 📊 List registered services
  public listServices(): string[] {
    return Array.from(this.services.keys());
  }
}

// 🎨 Example services
class EmailService {
  send(to: string, message: string): void {
    console.log(`📧 Sending email to ${to}: ${message}`);
  }
}

class NotificationService {
  notify(user: string, message: string): void {
    console.log(`🔔 Notifying ${user}: ${message}`);
  }
}

class CacheService {
  private cache: Map<string, any> = new Map();
  
  set(key: string, value: any): void {
    this.cache.set(key, value);
    console.log(`💾 Cached: ${key}`);
  }
  
  get(key: string): any {
    return this.cache.get(key);
  }
}

// 🎮 Register and use services
const registry = ServiceRegistry.getInstance();

registry.register("email", () => new EmailService());
registry.register("notifications", () => new NotificationService());
registry.register("cache", () => new CacheService());

// 🚀 Use services from anywhere
const email1 = registry.get<EmailService>("email");
const email2 = registry.get<EmailService>("email");
console.log("Same email service?", email1 === email2); // true ✅

email1.send("[email protected]", "Welcome! 🎉");

const notifications = registry.get<NotificationService>("notifications");
notifications.notify("Alice", "New message! 💬");

const cache = registry.get<CacheService>("cache");
cache.set("user:123", { name: "Bob 🐻", level: 42 });

console.log("📋 Available services:", registry.listServices());

⚠️ Common Pitfalls and Solutions

Let’s avoid the common mistakes developers make with Singletons! 🛡️

❌ Wrong: Multiple Instance Creation

// ❌ BAD: Forgetting to make constructor private
class BadSingleton {
  static instance: BadSingleton;

  constructor() { // 🚨 Public constructor!
    console.log("Creating instance...");
  }

  static getInstance(): BadSingleton {
    if (!this.instance) {
      this.instance = new BadSingleton();
    }
    return this.instance;
  }
}

// 😱 This creates multiple instances!
const bad1 = new BadSingleton(); // Oops!
const bad2 = new BadSingleton(); // Double oops!
const bad3 = BadSingleton.getInstance();

console.log(bad1 === bad2); // false ❌

✅ Correct: Private Constructor

// ✅ GOOD: Private constructor prevents direct instantiation
class GoodSingleton {
  private static instance: GoodSingleton;

  private constructor() { // 🔒 Private!
    console.log("✨ Singleton created!");
  }

  public static getInstance(): GoodSingleton {
    if (!GoodSingleton.instance) {
      GoodSingleton.instance = new GoodSingleton();
    }
    return GoodSingleton.instance;
  }
}

// const wrong = new GoodSingleton(); // 🚫 TypeScript error!
const good1 = GoodSingleton.getInstance();
const good2 = GoodSingleton.getInstance();

console.log(good1 === good2); // true ✅

❌ Wrong: Testing Difficulties

// ❌ BAD: Hard to test singleton
class HardToTestService {
  private static instance: HardToTestService;
  
  private constructor() {}
  
  static getInstance(): HardToTestService {
    if (!this.instance) {
      this.instance = new HardToTestService();
    }
    return this.instance;
  }

  fetchData(): string {
    // 🚨 Hard-coded dependency!
    return "production data";
  }
}

✅ Correct: Testable Singleton

// ✅ GOOD: Testable singleton with reset capability
class TestableSingleton {
  private static instance: TestableSingleton;
  private dataSource: () => string;

  private constructor(dataSource?: () => string) {
    this.dataSource = dataSource || (() => "production data");
  }

  public static getInstance(dataSource?: () => string): TestableSingleton {
    if (!TestableSingleton.instance) {
      TestableSingleton.instance = new TestableSingleton(dataSource);
    }
    return TestableSingleton.instance;
  }

  // 🧪 For testing only
  public static resetInstance(): void {
    TestableSingleton.instance = null as any;
  }

  public fetchData(): string {
    return this.dataSource();
  }
}

// 🧪 In tests
TestableSingleton.resetInstance();
const testInstance = TestableSingleton.getInstance(() => "test data");
console.log(testInstance.fetchData()); // "test data" ✅

🛠️ Best Practices

Here are the golden rules for using Singletons effectively! 🏆

1. Use Singletons Sparingly 🎯

// 👍 Good use cases:
// - Application configuration
// - Logger instances
// - Connection pools
// - Cache managers

// 👎 Avoid for:
// - Business logic classes
// - Data models
// - UI components

2. Make It Thread-Safe 🔒

class ThreadSafeSingleton {
  private static instance: ThreadSafeSingleton;
  private static isInitializing = false;

  private constructor() {}

  public static async getInstance(): Promise<ThreadSafeSingleton> {
    if (!ThreadSafeSingleton.instance) {
      if (!ThreadSafeSingleton.isInitializing) {
        ThreadSafeSingleton.isInitializing = true;
        ThreadSafeSingleton.instance = new ThreadSafeSingleton();
        ThreadSafeSingleton.isInitializing = false;
      } else {
        // ⏳ Wait for initialization
        while (ThreadSafeSingleton.isInitializing) {
          await new Promise(resolve => setTimeout(resolve, 10));
        }
      }
    }
    return ThreadSafeSingleton.instance;
  }
}

3. Consider Dependency Injection 💉

// 🎯 Better than hard-coded singletons
interface IConfigService {
  get(key: string): any;
}

class AppComponent {
  constructor(private config: IConfigService) {
    // 💪 Easy to test and swap implementations
  }
}

4. Document Singleton Usage 📝

/**
 * 🔒 Application-wide settings manager (Singleton)
 * 
 * @example
 * const settings = SettingsManager.getInstance();
 * settings.set('theme', 'dark');
 * 
 * @singleton This class maintains a single instance
 */
class SettingsManager {
  // Implementation...
}

5. Provide Cleanup Methods 🧹

class ResourceManager {
  private static instance: ResourceManager;
  private resources: any[] = [];

  private constructor() {}

  public static getInstance(): ResourceManager {
    if (!ResourceManager.instance) {
      ResourceManager.instance = new ResourceManager();
    }
    return ResourceManager.instance;
  }

  // 🧹 Clean up resources
  public cleanup(): void {
    console.log("🧹 Cleaning up resources...");
    this.resources.forEach(resource => resource.dispose?.());
    this.resources = [];
  }

  // 🔄 Reset for testing
  public static reset(): void {
    if (ResourceManager.instance) {
      ResourceManager.instance.cleanup();
      ResourceManager.instance = null as any;
    }
  }
}

🧪 Hands-On Exercise

Time to put your singleton skills to the test! 💪

🎯 Challenge: Build a Multi-Feature App Manager

Create a singleton AppManager that:

1. Manages user sessions
2. Tracks app analytics
3. Handles feature flags
4. Provides a plugin system

Requirements:

• Single instance throughout the app
• Thread-safe initialization
• Plugin registration system
• Analytics event tracking
• Feature flag management

Starter Code:

interface Plugin {
  name: string;
  init(): void;
}

interface AnalyticsEvent {
  name: string;
  data?: any;
  timestamp: Date;
}

// 🎯 Your challenge: Complete this implementation!
class AppManager {
  // TODO: Implement singleton pattern
  // TODO: Add user session management
  // TODO: Add analytics tracking
  // TODO: Add feature flags
  // TODO: Add plugin system
}

// Test your implementation:
// const app = AppManager.getInstance();
// app.login("user123");
// app.track("page_view", { page: "home" });
// app.isFeatureEnabled("dark_mode");
// app.registerPlugin(myPlugin);

interface Plugin {
  name: string;
  init(): void;
}

interface AnalyticsEvent {
  name: string;
  data?: any;
  timestamp: Date;
}

interface UserSession {
  userId: string;
  loginTime: Date;
  isActive: boolean;
}

class AppManager {
  private static instance: AppManager;
  private static initPromise: Promise<AppManager>;
  
  private currentSession: UserSession | null = null;
  private analytics: AnalyticsEvent[] = [];
  private featureFlags: Map<string, boolean> = new Map();
  private plugins: Map<string, Plugin> = new Map();
  private initialized = false;

  private constructor() {}

  // 🎯 Thread-safe async initialization
  private async initialize(): Promise<void> {
    if (this.initialized) return;
    
    console.log("🚀 Initializing AppManager...");
    
    // 🎭 Simulate async config loading
    await new Promise(resolve => setTimeout(resolve, 100));
    
    // 🏳️ Load default feature flags
    this.featureFlags.set("dark_mode", true);
    this.featureFlags.set("beta_features", false);
    this.featureFlags.set("analytics", true);
    
    this.initialized = true;
    console.log("✅ AppManager ready!");
  }

  // 🔒 Get singleton instance
  public static async getInstance(): Promise<AppManager> {
    if (!AppManager.instance) {
      if (!AppManager.initPromise) {
        AppManager.initPromise = (async () => {
          AppManager.instance = new AppManager();
          await AppManager.instance.initialize();
          return AppManager.instance;
        })();
      }
      return AppManager.initPromise;
    }
    return AppManager.instance;
  }

  // 👤 User session management
  public login(userId: string): void {
    if (this.currentSession?.isActive) {
      this.logout();
    }
    
    this.currentSession = {
      userId,
      loginTime: new Date(),
      isActive: true
    };
    
    console.log(`👤 User ${userId} logged in!`);
    this.track("user_login", { userId });
  }

  public logout(): void {
    if (this.currentSession) {
      const sessionDuration = Date.now() - this.currentSession.loginTime.getTime();
      this.track("user_logout", { 
        userId: this.currentSession.userId,
        sessionDuration 
      });
      
      console.log(`👋 User ${this.currentSession.userId} logged out!`);
      this.currentSession = null;
    }
  }

  public getCurrentUser(): string | null {
    return this.currentSession?.userId || null;
  }

  // 📊 Analytics tracking
  public track(eventName: string, data?: any): void {
    if (!this.isFeatureEnabled("analytics")) {
      return;
    }

    const event: AnalyticsEvent = {
      name: eventName,
      data,
      timestamp: new Date()
    };
    
    this.analytics.push(event);
    console.log(`📊 Tracked: ${eventName}`, data || "");
    
    // 🧹 Keep only last 1000 events
    if (this.analytics.length > 1000) {
      this.analytics = this.analytics.slice(-1000);
    }
  }

  public getAnalytics(): AnalyticsEvent[] {
    return [...this.analytics];
  }

  // 🏳️ Feature flags
  public isFeatureEnabled(feature: string): boolean {
    return this.featureFlags.get(feature) || false;
  }

  public setFeatureFlag(feature: string, enabled: boolean): void {
    this.featureFlags.set(feature, enabled);
    console.log(`🏳️ Feature '${feature}' ${enabled ? "enabled" : "disabled"}`);
    this.track("feature_flag_changed", { feature, enabled });
  }

  // 🔌 Plugin system
  public registerPlugin(plugin: Plugin): void {
    if (this.plugins.has(plugin.name)) {
      console.warn(`⚠️ Plugin '${plugin.name}' already registered!`);
      return;
    }
    
    this.plugins.set(plugin.name, plugin);
    plugin.init();
    console.log(`🔌 Plugin '${plugin.name}' registered!`);
    this.track("plugin_registered", { pluginName: plugin.name });
  }

  public getPlugin(name: string): Plugin | undefined {
    return this.plugins.get(name);
  }

  // 📈 App statistics
  public getStats(): any {
    return {
      currentUser: this.getCurrentUser(),
      totalEvents: this.analytics.length,
      activeFeatures: Array.from(this.featureFlags.entries())
        .filter(([_, enabled]) => enabled)
        .map(([feature]) => feature),
      loadedPlugins: Array.from(this.plugins.keys()),
      sessionActive: this.currentSession?.isActive || false
    };
  }
}

// 🧪 Test the implementation
async function testAppManager() {
  // 🎯 Get instance
  const app1 = await AppManager.getInstance();
  const app2 = await AppManager.getInstance();
  
  console.log("Same instance?", app1 === app2); // true ✅
  
  // 👤 User management
  app1.login("alice_123");
  console.log("Current user:", app1.getCurrentUser());
  
  // 📊 Analytics
  app1.track("page_view", { page: "dashboard" });
  app1.track("button_click", { button: "save" });
  
  // 🏳️ Feature flags
  console.log("Dark mode enabled?", app1.isFeatureEnabled("dark_mode"));
  app1.setFeatureFlag("beta_features", true);
  
  // 🔌 Plugins
  const chatPlugin: Plugin = {
    name: "chat",
    init() {
      console.log("💬 Chat plugin initialized!");
    }
  };
  
  const mapPlugin: Plugin = {
    name: "maps",
    init() {
      console.log("🗺️ Maps plugin initialized!");
    }
  };
  
  app1.registerPlugin(chatPlugin);
  app2.registerPlugin(mapPlugin); // Same instance!
  
  // 📈 Stats
  console.log("📊 App Stats:", app1.getStats());
  
  // 👋 Logout
  app1.logout();
}

// 🚀 Run the test
testAppManager();

🎁 Bonus Challenge

Extend the AppManager with:

1. Notification system with subscription
2. Cache manager with TTL (time-to-live)
3. Error tracking with stack traces
4. Performance monitoring

🎓 Key Takeaways

You’ve mastered the Singleton pattern! Here’s what you’ve learned: 🎉

✅ Singleton ensures only ONE instance exists throughout your app
✅ Private constructors prevent direct instantiation
✅ Static getInstance() provides global access point
✅ Thread-safe implementations handle concurrent access
✅ Real-world uses include config, logging, and connection pools

Remember: With great power comes great responsibility! Use singletons wisely – they’re powerful but can make testing harder if overused. 🕷️

🤝 Next Steps

Congratulations on mastering the Singleton pattern! 🎊 Here’s how to continue your design patterns journey:

1. 🏭 Explore Factory Pattern - Learn how to create objects without specifying their exact class
2. 🔨 Try Builder Pattern - Master complex object construction step by step
3. 🎭 Study Observer Pattern - Implement event-driven architectures
4. 🧩 Practice Adapter Pattern - Make incompatible interfaces work together

Keep coding, keep learning, and remember – you’re building amazing things! 🚀✨

Happy Singleton-ing! 💪🎯