shogun-core 2.0.3 → 3.0.0

package/dist/core.js

@@ -1,12 +1,9 @@
-import { ShogunEventEmitter } from "./types/events";
-import { ErrorHandler, ErrorType } from "./utils/errorHandler";
-import { ShogunStorage } from "./storage/storage";
-import { CorePlugins, } from "./types/shogun";
-import { WebauthnPlugin } from "./plugins/webauthn/webauthnPlugin";
-import { Web3ConnectorPlugin } from "./plugins/web3/web3ConnectorPlugin";
-import { NostrConnectorPlugin } from "./plugins/nostr/nostrConnectorPlugin";
-import { OAuthPlugin } from "./plugins/oauth/oauthPlugin";
-import { restrictedPut, DataBase, RxJS, createGun, Gun, derive, } from "./gundb";
+import { ErrorHandler } from "./utils/errorHandler";
+// Import managers
+import { PluginManager } from "./managers/PluginManager";
+import { AuthManager } from "./managers/AuthManager";
+import { EventManager } from "./managers/EventManager";
+import { CoreInitializer } from "./managers/CoreInitializer";
 /**
  * Main ShogunCore class - implements the IShogunCore interface
  *
@@ -27,10 +24,12 @@ export class ShogunCore {
     rx;
     _gun;
     _user = null;
-    eventEmitter;
-    plugins = new Map();
-    currentAuthMethod;
     wallets;
+    // Managers
+    pluginManager;
+    authManager;
+    eventManager;
+    coreInitializer;
     /**
      * Initialize the Shogun SDK
      * @param config - SDK Configuration object
@@ -39,113 +38,19 @@ export class ShogunCore {
      * and plugin system.
      */
     constructor(config) {
-        // Polyfill console for environments where it might be missing
-        if (typeof console === "undefined") {
-            global.console = {
-                log: () => { },
-                warn: () => { },
-                error: () => { },
-                info: () => { },
-                debug: () => { },
-            };
-        }
         this.config = config;
-        this.storage = new ShogunStorage();
-        this.eventEmitter = new ShogunEventEmitter();
-        ErrorHandler.addListener((error) => {
-            this.eventEmitter.emit("error", {
-                action: error.code,
-                message: error.message,
-                type: error.type,
-            });
-        });
-        if (config.authToken) {
-            restrictedPut(Gun, config.authToken);
-        }
-        try {
-            if (config.gunInstance) {
-                this._gun = config.gunInstance;
-            }
-            else {
-                this._gun = createGun({
-                    peers: config.peers || [],
-                    radisk: config.radisk || false,
-                    localStorage: config.localStorage || false,
-                });
-            }
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error creating Gun instance:", error);
-            }
-            throw new Error(`Failed to create Gun instance: ${error}`);
-        }
-        try {
-            this.db = new DataBase(this._gun, config.scope || "");
-            this._gun = this.db.gun;
-            this.setupGunEventForwarding();
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing GunInstance:", error);
-            }
-            throw new Error(`Failed to initialize GunInstance: ${error}`);
-        }
-        try {
-            this._user = this._gun.user().recall({ sessionStorage: true });
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing Gun user:", error);
-            }
-            throw new Error(`Failed to initialize Gun user: ${error}`);
-        }
-        this._gun.on("auth", (user) => {
-            this._user = this._gun.user().recall({ sessionStorage: true });
-            this.eventEmitter.emit("auth:login", {
-                userPub: user.pub,
-                method: "password",
-            });
-        });
-        // ascolta gun se user è loggato crei i wallets
-        this._gun.on("auth", async (user) => {
-            if (!user)
-                return;
-            const priv = user._?.sea?.epriv;
-            const pub = user._?.sea?.epub;
-            this.wallets = await derive(priv, pub, {
-                includeSecp256k1Bitcoin: true,
-                includeSecp256k1Ethereum: true,
-            });
-        });
-        this.rx = new RxJS(this._gun);
-        this.registerBuiltinPlugins(config);
+        // Initialize managers
+        this.eventManager = new EventManager();
+        this.pluginManager = new PluginManager(this);
+        this.authManager = new AuthManager(this);
+        this.coreInitializer = new CoreInitializer(this);
         // Initialize async components
-        this.initialize().catch((error) => {
+        this.coreInitializer.initialize(config).catch((error) => {
             if (typeof console !== "undefined" && console.warn) {
                 console.warn("Error during async initialization:", error);
             }
         });
     }
-    /**
-     * Initialize the Shogun SDK asynchronously
-     * This method handles initialization tasks that require async operations
-     */
-    async initialize() {
-        try {
-            await this.db.initialize();
-            this.eventEmitter.emit("debug", {
-                action: "core_initialized",
-                timestamp: Date.now(),
-            });
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error during Shogun Core initialization:", error);
-            }
-            throw error;
-        }
-    }
     /**
      * Access to the Gun instance
      * @returns The Gun instance
@@ -170,170 +75,23 @@ export class ShogunCore {
         }
         return this.db.getCurrentUser();
     }
-    /**
-     * Setup event forwarding from GunInstance to main event emitter
-     * @private
-     */
-    setupGunEventForwarding() {
-        const gunEvents = ["gun:put", "gun:get", "gun:set", "gun:remove"];
-        gunEvents.forEach((eventName) => {
-            this.db.on(eventName, (data) => {
-                this.eventEmitter.emit(eventName, data);
-            });
-        });
-        const peerEvents = [
-            "gun:peer:add",
-            "gun:peer:remove",
-            "gun:peer:connect",
-            "gun:peer:disconnect",
-        ];
-        peerEvents.forEach((eventName) => {
-            this.db.on(eventName, (data) => {
-                this.eventEmitter.emit(eventName, data);
-            });
-        });
-    }
-    /**
-     * Register built-in plugins based on configuration
-     * @private
-     */
-    registerBuiltinPlugins(config) {
-        try {
-            // Register OAuth plugin if configuration is provided
-            if (config.oauth) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("OAuth plugin will be registered with provided configuration");
-                }
-                const oauthPlugin = new OAuthPlugin();
-                if (typeof oauthPlugin.configure === "function") {
-                    oauthPlugin.configure(config.oauth);
-                }
-                this.registerPlugin(oauthPlugin);
-            }
-            // Register WebAuthn plugin if configuration is provided
-            if (config.webauthn) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("WebAuthn plugin will be registered with provided configuration");
-                }
-                const webauthnPlugin = new WebauthnPlugin();
-                if (typeof webauthnPlugin.configure === "function") {
-                    webauthnPlugin.configure(config.webauthn);
-                }
-                this.registerPlugin(webauthnPlugin);
-            }
-            // Register Web3 plugin if configuration is provided
-            if (config.web3) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("Web3 plugin will be registered with provided configuration");
-                }
-                const web3Plugin = new Web3ConnectorPlugin();
-                if (typeof web3Plugin.configure === "function") {
-                    web3Plugin.configure(config.web3);
-                }
-                this.registerPlugin(web3Plugin);
-            }
-            // Register Nostr plugin if configuration is provided
-            if (config.nostr) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("Nostr plugin will be registered with provided configuration");
-                }
-                const nostrPlugin = new NostrConnectorPlugin();
-                if (typeof nostrPlugin.configure === "function") {
-                    nostrPlugin.configure(config.nostr);
-                }
-                this.registerPlugin(nostrPlugin);
-            }
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error registering builtin plugins:", error);
-            }
-        }
-    }
+    // *********************************************************************************************************
+    // 🔌 PLUGIN MANAGEMENT 🔌
+    // *********************************************************************************************************
     /**
      * Registers a plugin with the Shogun SDK
      * @param plugin Plugin instance to register
      * @throws Error if a plugin with the same name is already registered
      */
     register(plugin) {
-        this.registerPlugin(plugin);
+        this.pluginManager.register(plugin);
     }
     /**
      * Unregisters a plugin from the Shogun SDK
      * @param pluginName Name of the plugin to unregister
      */
     unregister(pluginName) {
-        this.unregisterPlugin(pluginName);
-    }
-    /**
-     * Internal method to register a plugin
-     * @param plugin Plugin instance to register
-     */
-    registerPlugin(plugin) {
-        try {
-            if (!plugin.name) {
-                if (typeof console !== "undefined" && console.error) {
-                    console.error("Plugin registration failed: Plugin must have a name");
-                }
-                return;
-            }
-            if (this.plugins.has(plugin.name)) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn(`Plugin "${plugin.name}" is already registered. Skipping.`);
-                }
-                return;
-            }
-            // Initialize plugin with core instance
-            plugin.initialize(this);
-            this.plugins.set(plugin.name, plugin);
-            this.eventEmitter.emit("plugin:registered", {
-                name: plugin.name,
-                version: plugin.version || "unknown",
-                category: plugin._category || "unknown",
-            });
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error(`Error registering plugin "${plugin.name}":`, error);
-            }
-        }
-    }
-    /**
-     * Internal method to unregister a plugin
-     * @param name Name of the plugin to unregister
-     */
-    unregisterPlugin(name) {
-        try {
-            const plugin = this.plugins.get(name);
-            if (!plugin) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn(`Plugin "${name}" not found for unregistration`);
-                }
-                return false;
-            }
-            // Destroy plugin if it has a destroy method
-            if (typeof plugin.destroy === "function") {
-                try {
-                    plugin.destroy();
-                }
-                catch (destroyError) {
-                    if (typeof console !== "undefined" && console.error) {
-                        console.error(`Error destroying plugin "${name}":`, destroyError);
-                    }
-                }
-            }
-            this.plugins.delete(name);
-            this.eventEmitter.emit("plugin:unregistered", {
-                name: plugin.name,
-            });
-            return true;
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error(`Error unregistering plugin "${name}":`, error);
-            }
-            return false;
-        }
+        this.pluginManager.unregister(pluginName);
     }
     /**
      * Retrieve a registered plugin by name
@@ -342,198 +100,56 @@ export class ShogunCore {
      * @template T Type of the plugin or its public interface
      */
     getPlugin(name) {
-        if (!name || typeof name !== "string") {
-            if (typeof console !== "undefined" && console.warn) {
-                console.warn("Invalid plugin name provided to getPlugin");
-            }
-            return undefined;
-        }
-        const plugin = this.plugins.get(name);
-        if (!plugin) {
-            if (typeof console !== "undefined" && console.warn) {
-                console.warn(`Plugin "${name}" not found`);
-            }
-            return undefined;
-        }
-        return plugin;
+        return this.pluginManager.getPlugin(name);
     }
     /**
      * Get information about all registered plugins
      * @returns Array of plugin information objects
      */
     getPluginsInfo() {
-        const pluginsInfo = [];
-        this.plugins.forEach((plugin) => {
-            pluginsInfo.push({
-                name: plugin.name,
-                version: plugin.version || "unknown",
-                category: plugin._category,
-                description: plugin.description,
-            });
-        });
-        return pluginsInfo;
+        return this.pluginManager.getPluginsInfo();
     }
     /**
      * Get the total number of registered plugins
      * @returns Number of registered plugins
      */
     getPluginCount() {
-        return this.plugins.size;
+        return this.pluginManager.getPluginCount();
     }
     /**
      * Check if all plugins are properly initialized
      * @returns Object with initialization status for each plugin
      */
     getPluginsInitializationStatus() {
-        const status = {};
-        this.plugins.forEach((plugin, name) => {
-            try {
-                // Verifica se il plugin ha un metodo per controllare l'inizializzazione
-                if (typeof plugin.assertInitialized === "function") {
-                    plugin.assertInitialized();
-                    status[name] = { initialized: true };
-                }
-                else {
-                    // Fallback: verifica se il plugin ha un riferimento al core
-                    status[name] = {
-                        initialized: !!plugin.core,
-                        error: !plugin.core
-                            ? "No core reference found"
-                            : undefined,
-                    };
-                }
-            }
-            catch (error) {
-                status[name] = {
-                    initialized: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        });
-        return status;
+        return this.pluginManager.getPluginsInitializationStatus();
     }
     /**
      * Validate plugin system integrity
      * @returns Object with validation results
      */
     validatePluginSystem() {
-        const status = this.getPluginsInitializationStatus();
-        const totalPlugins = Object.keys(status).length;
-        const initializedPlugins = Object.values(status).filter((s) => s.initialized).length;
-        const failedPlugins = Object.entries(status)
-            .filter(([_, s]) => !s.initialized)
-            .map(([name, _]) => name);
-        const warnings = [];
-        if (totalPlugins === 0) {
-            warnings.push("No plugins registered");
-        }
-        if (failedPlugins.length > 0) {
-            warnings.push(`Failed plugins: ${failedPlugins.join(", ")}`);
-        }
-        return {
-            totalPlugins,
-            initializedPlugins,
-            failedPlugins,
-            warnings,
-        };
+        return this.pluginManager.validatePluginSystem();
     }
     /**
      * Attempt to reinitialize failed plugins
      * @returns Object with reinitialization results
      */
     reinitializeFailedPlugins() {
-        const status = this.getPluginsInitializationStatus();
-        const failedPlugins = Object.entries(status)
-            .filter(([_, s]) => !s.initialized)
-            .map(([name, _]) => name);
-        const success = [];
-        const failed = [];
-        failedPlugins.forEach((pluginName) => {
-            try {
-                const plugin = this.plugins.get(pluginName);
-                if (!plugin) {
-                    failed.push({ name: pluginName, error: "Plugin not found" });
-                    return;
-                }
-                // Reinizializza il plugin
-                if (pluginName === CorePlugins.OAuth) {
-                    // Rimuovo la chiamata a initialize
-                    plugin.initialize(this);
-                }
-                else {
-                    // Rimuovo la chiamata a initialize
-                    plugin.initialize(this);
-                }
-                success.push(pluginName);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                failed.push({ name: pluginName, error: errorMessage });
-                if (typeof console !== "undefined" && console.error) {
-                    console.error(`[ShogunCore] Failed to reinitialize plugin ${pluginName}:`, error);
-                }
-            }
-        });
-        return { success, failed };
+        return this.pluginManager.reinitializeFailedPlugins();
     }
     /**
      * Check plugin compatibility with current ShogunCore version
      * @returns Object with compatibility information
      */
     checkPluginCompatibility() {
-        const compatible = [];
-        const incompatible = [];
-        const unknown = [];
-        this.plugins.forEach((plugin) => {
-            const pluginInfo = {
-                name: plugin.name,
-                version: plugin.version || "unknown",
-            };
-            // Verifica se il plugin ha informazioni di compatibilità
-            if (typeof plugin.getCompatibilityInfo === "function") {
-                try {
-                    const compatibilityInfo = plugin.getCompatibilityInfo();
-                    if (compatibilityInfo && compatibilityInfo.compatible) {
-                        compatible.push(pluginInfo);
-                    }
-                    else {
-                        incompatible.push({
-                            ...pluginInfo,
-                            reason: compatibilityInfo?.reason || "Unknown compatibility issue",
-                        });
-                    }
-                }
-                catch (error) {
-                    unknown.push(pluginInfo);
-                }
-            }
-            else {
-                // Se non ha informazioni di compatibilità, considera sconosciuto
-                unknown.push(pluginInfo);
-            }
-        });
-        return { compatible, incompatible, unknown };
+        return this.pluginManager.checkPluginCompatibility();
     }
     /**
      * Get comprehensive debug information about the plugin system
      * @returns Complete plugin system debug information
      */
     getPluginSystemDebugInfo() {
-        const pluginsInfo = this.getPluginsInfo();
-        const initializationStatus = this.getPluginsInitializationStatus();
-        const plugins = pluginsInfo.map((info) => ({
-            ...info,
-            initialized: initializationStatus[info.name]?.initialized || false,
-            error: initializationStatus[info.name]?.error,
-        }));
-        return {
-            shogunCoreVersion: ShogunCore.API_VERSION,
-            totalPlugins: this.getPluginCount(),
-            plugins,
-            initializationStatus,
-            validation: this.validatePluginSystem(),
-            compatibility: this.checkPluginCompatibility(),
-        };
+        return this.pluginManager.getPluginSystemDebugInfo();
     }
     /**
      * Check if a plugin is registered
@@ -541,7 +157,7 @@ export class ShogunCore {
      * @returns true if the plugin is registered, false otherwise
      */
     hasPlugin(name) {
-        return this.plugins.has(name);
+        return this.pluginManager.hasPlugin(name);
     }
     /**
      * Get all plugins of a specific category
@@ -549,13 +165,7 @@ export class ShogunCore {
      * @returns Array of plugins in the specified category
      */
     getPluginsByCategory(category) {
-        const result = [];
-        this.plugins.forEach((plugin) => {
-            if (plugin._category === category) {
-                result.push(plugin);
-            }
-        });
-        return result;
+        return this.pluginManager.getPluginsByCategory(category);
     }
     /**
      * Get an authentication method plugin by type
@@ -564,26 +174,7 @@ export class ShogunCore {
      * This is a more modern approach to accessing authentication methods
      */
     getAuthenticationMethod(type) {
-        switch (type) {
-            case "webauthn":
-                return this.getPlugin(CorePlugins.WebAuthn);
-            case "web3":
-                return this.getPlugin(CorePlugins.Web3);
-            case "nostr":
-                return this.getPlugin(CorePlugins.Nostr);
-            case "oauth":
-                return this.getPlugin(CorePlugins.OAuth);
-            case "password":
-            default:
-                return {
-                    login: async (username, password) => {
-                        return await this.login(username, password);
-                    },
-                    signUp: async (username, password, confirm) => {
-                        return await this.signUp(username, password, confirm);
-                    },
-                };
-        }
+        return this.authManager.getAuthenticationMethod(type);
     }
     // *********************************************************************************************************
     // 🔐 ERROR HANDLER 🔐
@@ -606,7 +197,7 @@ export class ShogunCore {
      * and presence of authentication credentials in storage
      */
     isLoggedIn() {
-        return this.db.isLoggedIn();
+        return this.authManager.isLoggedIn();
     }
     /**
      * Perform user logout
@@ -614,16 +205,7 @@ export class ShogunCore {
      * If user is not authenticated, the logout operation is ignored.
      */
     logout() {
-        try {
-            if (!this.isLoggedIn()) {
-                return;
-            }
-            this.db.logout();
-            this.eventEmitter.emit("auth:logout");
-        }
-        catch (error) {
-            ErrorHandler.handle(ErrorType.AUTHENTICATION, "LOGOUT_FAILED", error instanceof Error ? error.message : "Error during logout", error);
-        }
+        this.authManager.logout();
     }
     /**
      * Authenticate user with username and password
@@ -634,36 +216,7 @@ export class ShogunCore {
      * Emits login event on success.
      */
     async login(username, password, pair) {
-        try {
-            if (!this.currentAuthMethod) {
-                this.currentAuthMethod = "password";
-            }
-            const result = await this.db.login(username, password, pair);
-            if (result.success) {
-                // Include SEA pair in the response
-                const seaPair = this.user?._?.sea;
-                if (seaPair) {
-                    result.sea = seaPair;
-                }
-                this.eventEmitter.emit("auth:login", {
-                    userPub: result.userPub ?? "",
-                    method: this.currentAuthMethod === "pair"
-                        ? "password"
-                        : this.currentAuthMethod || "password",
-                });
-            }
-            else {
-                result.error = result.error || "Wrong user or password";
-            }
-            return result;
-        }
-        catch (error) {
-            ErrorHandler.handle(ErrorType.AUTHENTICATION, "LOGIN_FAILED", error.message ?? "Unknown error during login", error);
-            return {
-                success: false,
-                error: error.message ?? "Unknown error during login",
-            };
-        }
+        return this.authManager.login(username, password, pair);
     }
     /**
      * Login with GunDB pair directly
@@ -673,94 +226,20 @@ export class ShogunCore {
      * Emits login event on success.
      */
     async loginWithPair(pair) {
-        try {
-            if (!pair || !pair.pub || !pair.priv || !pair.epub || !pair.epriv) {
-                return {
-                    success: false,
-                    error: "Invalid pair structure - missing required keys",
-                };
-            }
-            // Use the new loginWithPair method from GunInstance
-            const result = await this.db.login("", "", pair);
-            if (result.success) {
-                // Include SEA pair in the response
-                const seaPair = this.user?._?.sea;
-                if (seaPair) {
-                    result.sea = seaPair;
-                }
-                this.currentAuthMethod = "pair";
-                this.eventEmitter.emit("auth:login", {
-                    userPub: result.userPub ?? "",
-                    method: "password",
-                });
-            }
-            else {
-                result.error =
-                    result.error || "Authentication failed with provided pair";
-            }
-            return result;
-        }
-        catch (error) {
-            ErrorHandler.handle(ErrorType.AUTHENTICATION, "PAIR_LOGIN_FAILED", error.message ?? "Unknown error during pair login", error);
-            return {
-                success: false,
-                error: error.message ?? "Unknown error during pair login",
-            };
-        }
+        return this.authManager.loginWithPair(pair);
     }
     /**
      * Register a new user with provided credentials
      * @param username - Username
      * @param password - Password
-     * @param passwordConfirmation - Password confirmation
+     * @param email - Email (optional)
      * @param pair - Pair of keys
      * @returns {Promise<SignUpResult>} Registration result
      * @description Creates a new user account with the provided credentials.
      * Validates password requirements and emits signup event on success.
      */
-    async signUp(username, password = "", email = "", pair) {
-        try {
-            if (!this.db) {
-                throw new Error("Database not initialized");
-            }
-            const result = await this.db.signUp(username, password, pair);
-            if (result.success) {
-                // Update current authentication method
-                this.currentAuthMethod = pair ? "web3" : "password";
-                this.eventEmitter.emit("auth:signup", {
-                    userPub: result.userPub,
-                    username,
-                    method: this.currentAuthMethod,
-                });
-                this.eventEmitter.emit("debug", {
-                    action: "signup_success",
-                    userPub: result.userPub,
-                    method: this.currentAuthMethod,
-                });
-            }
-            else {
-                this.eventEmitter.emit("debug", {
-                    action: "signup_failed",
-                    error: result.error,
-                    username,
-                });
-            }
-            return result;
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error(`Error during registration for user ${username}:`, error);
-            }
-            this.eventEmitter.emit("debug", {
-                action: "signup_error",
-                error: error instanceof Error ? error.message : String(error),
-                username,
-            });
-            return {
-                success: false,
-                error: `Registration failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
+    async signUp(username, password, pair) {
+        return this.authManager.signUp(username, password, pair);
     }
     // 📢 EVENT EMITTER 📢
     /**
@@ -771,7 +250,7 @@ export class ShogunCore {
      * @returns {boolean} Indicates if the event had listeners.
      */
     emit(eventName, data) {
-        return this.eventEmitter.emit(eventName, data);
+        return this.eventManager.emit(eventName, data);
     }
     /**
      * Add an event listener
@@ -780,7 +259,7 @@ export class ShogunCore {
      * @returns {this} Returns this instance for method chaining
      */
     on(eventName, listener) {
-        this.eventEmitter.on(eventName, listener);
+        this.eventManager.on(eventName, listener);
         return this;
     }
     /**
@@ -790,7 +269,7 @@ export class ShogunCore {
      * @returns {this} Returns this instance for method chaining
      */
     once(eventName, listener) {
-        this.eventEmitter.once(eventName, listener);
+        this.eventManager.once(eventName, listener);
         return this;
     }
     /**
@@ -800,7 +279,7 @@ export class ShogunCore {
      * @returns {this} Returns this instance for method chaining
      */
     off(eventName, listener) {
-        this.eventEmitter.off(eventName, listener);
+        this.eventManager.off(eventName, listener);
         return this;
     }
     /**
@@ -810,7 +289,7 @@ export class ShogunCore {
      * @returns {this} Returns this instance for method chaining
      */
     removeAllListeners(eventName) {
-        this.eventEmitter.removeAllListeners(eventName);
+        this.eventManager.removeAllListeners(eventName);
         return this;
     }
     /**
@@ -819,14 +298,14 @@ export class ShogunCore {
      * @param method The authentication method used
      */
     setAuthMethod(method) {
-        this.currentAuthMethod = method;
+        this.authManager.setAuthMethod(method);
     }
     /**
      * Get the current authentication method
      * @returns The current authentication method or undefined if not set
      */
     getAuthMethod() {
-        return this.currentAuthMethod;
+        return this.authManager.getAuthMethod();
     }
     /**
      * Saves the current user credentials to storage
@@ -848,9 +327,8 @@ export class ShogunCore {
         return !!(this.user && this.user.is);
     }
 }
-if (typeof window !== "undefined") {
-    window.SHOGUN_CORE_CLASS = ShogunCore;
-}
+// Global declarations are handled in the original core.ts file
+// to avoid conflicts, we only set the window properties here
 if (typeof window !== "undefined") {
     window.SHOGUN_CORE = (config) => {
         return new ShogunCore(config);