shogun-core 3.0.3 → 3.0.4

package/dist/storage/storage.js

@@ -1,147 +0,0 @@
-/**
- * Storage implementation based on StorageMock
- * Provides a unified storage interface that works in both browser and non-browser environments
- * In browser environments, data is persisted to localStorage as a backup
- */
-export class ShogunStorage {
-    store;
-    isTestMode;
-    useLocalStorage;
-    /**
-     * Initializes storage and loads any existing keypair from localStorage if available
-     */
-    constructor() {
-        this.store = new Map();
-        this.isTestMode = process.env.NODE_ENV === "test";
-        this.useLocalStorage = false;
-        // Debug: log the environment
-        console.log("ShogunStorage: NODE_ENV =", process.env.NODE_ENV);
-        console.log("ShogunStorage: isTestMode =", this.isTestMode);
-        // In test mode, don't use localStorage to avoid test pollution
-        if (this.isTestMode) {
-            this.useLocalStorage = false;
-            console.log("ShogunStorage: Test mode detected, localStorage disabled");
-            return;
-        }
-        if (typeof localStorage !== "undefined") {
-            console.log("ShogunStorage: localStorage is defined");
-            try {
-                // Probe localStorage without polluting expectations in tests
-                const testKey = "_shogun_test";
-                localStorage.setItem(testKey, testKey);
-                localStorage.removeItem(testKey);
-                this.useLocalStorage = true;
-                console.log("ShogunStorage: localStorage enabled");
-                const storedPair = localStorage.getItem("shogun_keypair");
-                if (storedPair) {
-                    this.store.set("keypair", JSON.parse(storedPair));
-                }
-            }
-            catch (error) {
-                this.useLocalStorage = false;
-                // Silence logs in tests; tests expect no console.error during constructor
-                console.log("ShogunStorage: localStorage error:", error.message);
-            }
-        }
-        else {
-            console.log("ShogunStorage: localStorage is undefined");
-        }
-    }
-    /**
-     * Gets the stored keypair asynchronously
-     * @returns Promise resolving to the keypair or null if not found
-     */
-    async getPair() {
-        return this.getPairSync();
-    }
-    /**
-     * Gets the stored keypair synchronously
-     * @returns The keypair or null if not found
-     */
-    getPairSync() {
-        return this.store.get("keypair") || null;
-    }
-    /**
-     * Stores a keypair both in memory and localStorage if available
-     * @param pair - The keypair to store
-     */
-    async setPair(pair) {
-        this.store.set("keypair", pair);
-        // Also save to localStorage in browser environments
-        if (this.useLocalStorage) {
-            try {
-                localStorage.setItem("shogun_keypair", JSON.stringify(pair));
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error("Error saving data to localStorage:", error);
-                }
-            }
-        }
-    }
-    /**
-     * Clears all stored data from both memory and localStorage
-     */
-    clearAll() {
-        this.store.clear();
-        // Also clear localStorage in browser environments
-        if (this.useLocalStorage) {
-            try {
-                localStorage.removeItem("shogun_keypair");
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error("Error removing data from localStorage:", error);
-                }
-            }
-        }
-    }
-    /**
-     * Gets an item from storage
-     * @param key - The key to retrieve
-     * @returns The stored value, or null if not found
-     */
-    getItem(key) {
-        const value = this.store.get(key);
-        if (value === undefined) {
-            return null;
-        }
-        return value;
-    }
-    /**
-     * Stores an item in both memory and localStorage if available
-     * @param key - The key to store under
-     * @param value - The value to store (must be JSON stringifiable)
-     */
-    setItem(key, value) {
-        // Store the raw value as-is to preserve formatting
-        this.store.set(key, value);
-        if (this.useLocalStorage) {
-            try {
-                localStorage.setItem(key, typeof value === "string" ? value : JSON.stringify(value));
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error(`Error saving ${key} to localStorage:`, error);
-                }
-            }
-        }
-    }
-    /**
-     * Removes an item from both memory and localStorage if available
-     * @param key - The key to remove
-     */
-    removeItem(key) {
-        this.store.delete(key);
-        if (this.useLocalStorage) {
-            try {
-                localStorage.removeItem(key);
-            }
-            catch (error) {
-                if (!this.isTestMode) {
-                    console.error(`Error removing ${key} from localStorage:`, error);
-                }
-            }
-        }
-    }
-}

package/dist/types/config/simplified-config.d.ts

@@ -1,114 +0,0 @@
-/**
- * Simplified configuration options to reduce complexity
- * Provides sensible defaults and easy-to-use presets
- */
-import { ShogunCoreConfig } from "../interfaces/shogun";
-/**
- * Preset configurations for common use cases
- */
-export declare const ShogunPresets: {
-    /**
-     * Minimal configuration for simple apps
-     */
-    minimal: () => ShogunCoreConfig;
-    /**
-     * Development configuration with local storage
-     */
-    development: () => ShogunCoreConfig;
-    /**
-     * Production configuration with multiple peers
-     */
-    production: (customPeers?: string[]) => ShogunCoreConfig;
-    /**
-     * Offline-first configuration
-     */
-    offline: () => ShogunCoreConfig;
-    /**
-     * Web3-enabled configuration
-     */
-    web3: () => ShogunCoreConfig;
-    /**
-     * WebAuthn-enabled configuration
-     */
-    webauthn: () => ShogunCoreConfig;
-};
-/**
- * Configuration builder for custom setups
- */
-export declare class ShogunConfigBuilder {
-    private config;
-    /**
-     * Set Gun options
-     */
-    gunOptions(options: any): this;
-    /**
-     * Add peers
-     */
-    peers(peerList: string[]): this;
-    /**
-     * Enable WebAuthn
-     */
-    enableWebAuthn(rpName?: string, rpId?: string): this;
-    /**
-     * Enable Web3
-     */
-    enableWeb3(): this;
-    /**
-     * Enable Nostr
-     */
-    enableNostr(): this;
-    /**
-     * Set timeouts
-     */
-    timeouts(timeouts: {
-        login?: number;
-        signup?: number;
-        operation?: number;
-    }): this;
-    /**
-     * Build the final configuration
-     */
-    build(): ShogunCoreConfig;
-}
-/**
- * Helper functions for common configuration patterns
- */
-export declare const ConfigHelpers: {
-    /**
-     * Create a configuration for a specific environment
-     */
-    forEnvironment(env: "development" | "production" | "test"): ShogunCoreConfig;
-    /**
-     * Create a configuration with custom peers
-     */
-    withPeers(peers: string[]): ShogunCoreConfig;
-    /**
-     * Create a configuration for a specific use case
-     */
-    forUseCase(useCase: "chat" | "social" | "gaming" | "finance"): ShogunCoreConfig;
-};
-/**
- * Quick configuration functions
- */
-export declare const QuickConfig: {
-    /**
-     * Minimal setup for quick testing
-     */
-    test: () => ShogunCoreConfig;
-    /**
-     * Standard setup for most apps
-     */
-    standard: () => ShogunCoreConfig;
-    /**
-     * Setup with WebAuthn for secure apps
-     */
-    secure: () => ShogunCoreConfig;
-    /**
-     * Setup with Web3 for crypto apps
-     */
-    crypto: () => ShogunCoreConfig;
-    /**
-     * Offline setup for local development
-     */
-    local: () => ShogunCoreConfig;
-};

package/dist/types/core.d.ts

@@ -1,305 +0,0 @@
-import { ShogunEventMap } from "./interfaces/events";
-import { ShogunError } from "./utils/errorHandler";
-import { ShogunStorage } from "./storage/storage";
-import { IShogunCore, ShogunCoreConfig, AuthResult, SignUpResult, PluginCategory, AuthMethod, Wallets } from "./interfaces/shogun";
-import { ethers } from "ethers";
-import { ShogunPlugin } from "./interfaces/plugin";
-import { ISEAPair } from "gun";
-import { DataBase, RxJS, GunInstance, GunUserInstance } from "./gundb";
-import { PluginManager } from "./managers/PluginManager";
-/**
- * Main ShogunCore class - implements the IShogunCore interface
- *
- * This is the primary entry point for the Shogun SDK, providing access to:
- * - Decentralized database (GunInstance)
- * - Authentication methods (traditional, WebAuthn, MetaMask)
- * - Plugin system for extensibility
- * - RxJS integration for reactive programming
- *
- * @since 2.0.0
- */
-export declare class ShogunCore implements IShogunCore {
-    static readonly API_VERSION = "^3.0.1";
-    db: DataBase;
-    storage: ShogunStorage;
-    provider?: ethers.Provider;
-    config: ShogunCoreConfig;
-    rx: RxJS;
-    _gun: GunInstance;
-    _user: GunUserInstance | null;
-    wallets: Wallets | undefined;
-    pluginManager: PluginManager;
-    private authManager;
-    private eventManager;
-    private coreInitializer;
-    /**
-     * Initialize the Shogun SDK
-     * @param config - SDK Configuration object
-     * @description Creates a new instance of ShogunCore with the provided configuration.
-     * Initializes all required components including storage, event emitter, GunInstance connection,
-     * and plugin system.
-     */
-    constructor(config: ShogunCoreConfig);
-    /**
-     * Access to the Gun instance
-     * @returns The Gun instance
-     */
-    get gun(): GunInstance;
-    /**
-     * Access to the current user
-     * @returns The current Gun user instance
-     */
-    get user(): GunUserInstance | null;
-    /**
-     * Gets the current user information
-     * @returns Current user object or null
-     */
-    getCurrentUser(): {
-        pub: string;
-        user?: any;
-    } | null;
-    /**
-     * 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: ShogunPlugin): void;
-    /**
-     * Unregisters a plugin from the Shogun SDK
-     * @param pluginName Name of the plugin to unregister
-     */
-    unregister(pluginName: string): void;
-    /**
-     * Retrieve a registered plugin by name
-     * @param name Name of the plugin
-     * @returns The requested plugin or undefined if not found
-     * @template T Type of the plugin or its public interface
-     */
-    getPlugin<T = ShogunPlugin>(name: string): T | undefined;
-    /**
-     * Get information about all registered plugins
-     * @returns Array of plugin information objects
-     */
-    getPluginsInfo(): Array<{
-        name: string;
-        version: string;
-        category?: PluginCategory;
-        description?: string;
-    }>;
-    /**
-     * Get the total number of registered plugins
-     * @returns Number of registered plugins
-     */
-    getPluginCount(): number;
-    /**
-     * Check if all plugins are properly initialized
-     * @returns Object with initialization status for each plugin
-     */
-    getPluginsInitializationStatus(): Record<string, {
-        initialized: boolean;
-        error?: string;
-    }>;
-    /**
-     * Validate plugin system integrity
-     * @returns Object with validation results
-     */
-    validatePluginSystem(): {
-        totalPlugins: number;
-        initializedPlugins: number;
-        failedPlugins: string[];
-        warnings: string[];
-    };
-    /**
-     * Attempt to reinitialize failed plugins
-     * @returns Object with reinitialization results
-     */
-    reinitializeFailedPlugins(): {
-        success: string[];
-        failed: Array<{
-            name: string;
-            error: string;
-        }>;
-    };
-    /**
-     * Check plugin compatibility with current ShogunCore version
-     * @returns Object with compatibility information
-     */
-    checkPluginCompatibility(): {
-        compatible: Array<{
-            name: string;
-            version: string;
-        }>;
-        incompatible: Array<{
-            name: string;
-            version: string;
-            reason: string;
-        }>;
-        unknown: Array<{
-            name: string;
-            version: string;
-        }>;
-    };
-    /**
-     * Get comprehensive debug information about the plugin system
-     * @returns Complete plugin system debug information
-     */
-    getPluginSystemDebugInfo(): {
-        shogunCoreVersion: string;
-        totalPlugins: number;
-        plugins: Array<{
-            name: string;
-            version: string;
-            category?: PluginCategory;
-            description?: string;
-            initialized: boolean;
-            error?: string;
-        }>;
-        initializationStatus: Record<string, {
-            initialized: boolean;
-            error?: string;
-        }>;
-        validation: {
-            totalPlugins: number;
-            initializedPlugins: number;
-            failedPlugins: string[];
-            warnings: string[];
-        };
-        compatibility: {
-            compatible: Array<{
-                name: string;
-                version: string;
-            }>;
-            incompatible: Array<{
-                name: string;
-                version: string;
-                reason: string;
-            }>;
-            unknown: Array<{
-                name: string;
-                version: string;
-            }>;
-        };
-    };
-    /**
-     * Check if a plugin is registered
-     * @param name Name of the plugin to check
-     * @returns true if the plugin is registered, false otherwise
-     */
-    hasPlugin(name: string): boolean;
-    /**
-     * Get all plugins of a specific category
-     * @param category Category of plugins to filter
-     * @returns Array of plugins in the specified category
-     */
-    getPluginsByCategory(category: PluginCategory): ShogunPlugin[];
-    /**
-     * Get an authentication method plugin by type
-     * @param type The type of authentication method
-     * @returns The authentication plugin or undefined if not available
-     * This is a more modern approach to accessing authentication methods
-     */
-    getAuthenticationMethod(type: AuthMethod): ShogunPlugin | {
-        login: (username: string, password: string) => Promise<AuthResult>;
-        signUp: (username: string, password: string, confirm?: string) => Promise<SignUpResult>;
-    } | undefined;
-    /**
-     * Retrieve recent errors logged by the system
-     * @param count - Number of errors to retrieve (default: 10)
-     * @returns List of most recent errors
-     */
-    getRecentErrors(count?: number): ShogunError[];
-    /**
-     * Check if user is logged in
-     * @returns {boolean} True if user is logged in, false otherwise
-     * @description Verifies authentication status by checking GunInstance login state
-     * and presence of authentication credentials in storage
-     */
-    isLoggedIn(): boolean;
-    /**
-     * Perform user logout
-     * @description Logs out the current user from GunInstance and emits logout event.
-     * If user is not authenticated, the logout operation is ignored.
-     */
-    logout(): void;
-    /**
-     * Authenticate user with username and password
-     * @param username - Username
-     * @param password - User password
-     * @returns {Promise<AuthResult>} Promise with authentication result
-     * @description Attempts to log in user with provided credentials.
-     * Emits login event on success.
-     */
-    login(username: string, password: string, pair?: ISEAPair | null): Promise<AuthResult>;
-    /**
-     * Login with GunDB pair directly
-     * @param pair - GunDB SEA pair for authentication
-     * @returns {Promise<AuthResult>} Promise with authentication result
-     * @description Authenticates user using a GunDB pair directly.
-     * Emits login event on success.
-     */
-    loginWithPair(pair: ISEAPair): Promise<AuthResult>;
-    /**
-     * Register a new user with provided credentials
-     * @param username - Username
-     * @param password - Password
-     * @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.
-     */
-    signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
-    /**
-     * Emits an event through the core's event emitter.
-     * Plugins should use this method to emit events instead of accessing the private eventEmitter directly.
-     * @param eventName The name of the event to emit.
-     * @param data The data to pass with the event.
-     * @returns {boolean} Indicates if the event had listeners.
-     */
-    emit<K extends keyof ShogunEventMap>(eventName: K, data?: ShogunEventMap[K] extends void ? never : ShogunEventMap[K]): boolean;
-    /**
-     * Add an event listener
-     * @param eventName The name of the event to listen for
-     * @param listener The callback function to execute when the event is emitted
-     * @returns {this} Returns this instance for method chaining
-     */
-    on<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
-    /**
-     * Add a one-time event listener
-     * @param eventName The name of the event to listen for
-     * @param listener The callback function to execute when the event is emitted
-     * @returns {this} Returns this instance for method chaining
-     */
-    once<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
-    /**
-     * Remove an event listener
-     * @param eventName The name of the event to stop listening for
-     * @param listener The callback function to remove
-     * @returns {this} Returns this instance for method chaining
-     */
-    off<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
-    /**
-     * Remove all listeners for a specific event or all events
-     * @param eventName Optional. The name of the event to remove listeners for.
-     * If not provided, all listeners for all events are removed.
-     * @returns {this} Returns this instance for method chaining
-     */
-    removeAllListeners(eventName?: string | symbol): this;
-    /**
-     * Set the current authentication method
-     * This is used by plugins to indicate which authentication method was used
-     * @param method The authentication method used
-     */
-    setAuthMethod(method: AuthMethod): void;
-    /**
-     * Get the current authentication method
-     * @returns The current authentication method or undefined if not set
-     */
-    getAuthMethod(): AuthMethod | undefined;
-    /**
-     * Saves the current user credentials to storage
-     */
-    saveCredentials(credentials: any): Promise<void>;
-    getIsLoggedIn(): boolean;
-}
-export default ShogunCore;

package/dist/types/gundb/crypto.d.ts

@@ -1,95 +0,0 @@
-/**
- * Cryptographic utilities for GunDB integration.
- * Based on GunDB's SEA (Security, Encryption, Authorization) module.
- * @see https://github.com/amark/gun/wiki/Snippets
- */
-import { ISEAPair } from "gun";
-/**
- * Checks if a string is a valid GunDB hash
- * @param str - String to check
- * @returns True if string matches GunDB hash format (44 chars ending with =)
- */
-export declare function isHash(str: string): boolean;
-/**
- * Encrypts data with Gun.SEA
- * @param data Data to encrypt
- * @param key Encryption key
- * @returns Promise that resolves with the encrypted data
- */
-export declare function encrypt(data: any, key: string): Promise<string>;
-/**
- * Decrypts data with Gun.SEA
- * @param encryptedData Encrypted data
- * @param key Decryption key
- * @returns Promise that resolves with the decrypted data
- */
-export declare function decrypt(encryptedData: string, key: string): Promise<string | any>;
-/**
- * Encrypts data from a sender to a receiver using their public keys
- * @param data - Data to encrypt
- * @param sender - Sender's key pair
- * @param receiver - Receiver's public encryption key
- * @returns Promise resolving to encrypted data
- */
-export declare function encFor(data: any, sender: ISEAPair, receiver: {
-    epub: string;
-}): Promise<any>;
-/**
- * Decrypts data from a sender using receiver's private key
- * @param data - Data to decrypt
- * @param sender - Sender's public encryption key
- * @param receiver - Receiver's key pair
- * @returns Promise resolving to decrypted data
- */
-export declare function decFrom(data: any, sender: {
-    epub: string;
-}, receiver: ISEAPair): Promise<any>;
-/**
- * Creates a SHA-256 hash of text
- * @param text - Text to hash
- * @returns Promise resolving to hash string
- */
-export declare function hashText(text: string): Promise<any>;
-/**
- * Creates a hash of an object by stringifying it first
- * @param obj - Object to hash
- * @returns Promise resolving to hash and original stringified data
- */
-export declare function hashObj(obj: any): Promise<{
-    hash: any;
-    hashed: string;
-}>;
-/**
- * Generates a shared secret between two parties
- * @param epub - Public encryption key
- * @param pair - Key pair
- * @returns Promise resolving to shared secret
- */
-export declare function secret(epub: string, pair: ISEAPair): Promise<string>;
-/**
- * Creates a short hash using PBKDF2
- * @param text - Text to hash
- * @param salt - Salt for hashing
- * @returns Promise resolving to hex-encoded hash
- */
-export declare function getShortHash(text: string, salt?: string): Promise<any>;
-/**
- * Converts unsafe characters in hash to URL-safe versions
- * @param unsafe - String containing unsafe characters
- * @returns URL-safe string with encoded characters
- */
-export declare function safeHash(unsafe: string): any;
-/**
- * Converts URL-safe characters back to original hash characters
- * @param safe - URL-safe string
- * @returns Original string with decoded characters
- */
-export declare function unsafeHash(safe: string): any;
-/**
- * Safely parses JSON with fallback to default value
- * @param input - String to parse as JSON
- * @param def - Default value if parsing fails
- * @returns Parsed object or default value
- */
-export declare function safeJSONParse(input: any, def?: any): any;
-export declare function randomUUID(): string;