shogun-core 6.2.4 → 6.3.0

package/dist/{managers → src/managers}/PluginManager.js

@@ -1,11 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginManager = void 0;
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 /**
  * Manages plugin registration, validation, and lifecycle
  */
-class PluginManager {
-    constructor(core) {
+var PluginManager = /** @class */ (function () {
+    function PluginManager(core) {
         this.plugins = new Map();
         this.core = core;
     }
@@ -14,7 +38,7 @@ class PluginManager {
      * @param plugin Plugin instance to register
      * @throws Error if a plugin with the same name is already registered
      */
-    register(plugin) {
+    PluginManager.prototype.register = function (plugin) {
         try {
             if (!plugin.name) {
                 if (typeof console !== "undefined" && console.error) {
@@ -24,7 +48,7 @@ class PluginManager {
             }
             if (this.plugins.has(plugin.name)) {
                 if (typeof console !== "undefined" && console.warn) {
-                    console.warn(`Plugin "${plugin.name}" is already registered. Skipping.`);
+                    console.warn("Plugin \"".concat(plugin.name, "\" is already registered. Skipping."));
                 }
                 return;
             }
@@ -39,20 +63,20 @@ class PluginManager {
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
-                console.error(`Error registering plugin "${plugin.name}":`, error);
+                console.error("Error registering plugin \"".concat(plugin.name, "\":"), error);
             }
         }
-    }
+    };
     /**
      * Unregister a plugin from the Shogun SDK
      * @param name Name of the plugin to unregister
      */
-    unregister(name) {
+    PluginManager.prototype.unregister = function (name) {
         try {
-            const plugin = this.plugins.get(name);
+            var plugin = this.plugins.get(name);
             if (!plugin) {
                 if (typeof console !== "undefined" && console.warn) {
-                    console.warn(`Plugin "${name}" not found for unregistration`);
+                    console.warn("Plugin \"".concat(name, "\" not found for unregistration"));
                 }
                 return false;
             }
@@ -63,7 +87,7 @@ class PluginManager {
                 }
                 catch (destroyError) {
                     if (typeof console !== "undefined" && console.error) {
-                        console.error(`Error destroying plugin "${name}":`, destroyError);
+                        console.error("Error destroying plugin \"".concat(name, "\":"), destroyError);
                     }
                 }
             }
@@ -75,40 +99,40 @@ class PluginManager {
         }
         catch (error) {
             if (typeof console !== "undefined" && console.error) {
-                console.error(`Error unregistering plugin "${name}":`, error);
+                console.error("Error unregistering plugin \"".concat(name, "\":"), error);
             }
             return false;
         }
-    }
+    };
     /**
      * 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(name) {
+    PluginManager.prototype.getPlugin = function (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);
+        var plugin = this.plugins.get(name);
         if (!plugin) {
             if (typeof console !== "undefined" && console.warn) {
-                console.warn(`Plugin "${name}" not found`);
+                console.warn("Plugin \"".concat(name, "\" not found"));
             }
             return undefined;
         }
         return plugin;
-    }
+    };
     /**
      * Get information about all registered plugins
      * @returns Array of plugin information objects
      */
-    getPluginsInfo() {
-        const pluginsInfo = [];
-        this.plugins.forEach((plugin) => {
+    PluginManager.prototype.getPluginsInfo = function () {
+        var pluginsInfo = [];
+        this.plugins.forEach(function (plugin) {
             pluginsInfo.push({
                 name: plugin.name,
                 version: plugin.version || "unknown",
@@ -117,21 +141,21 @@ class PluginManager {
             });
         });
         return pluginsInfo;
-    }
+    };
     /**
      * Get the total number of registered plugins
      * @returns Number of registered plugins
      */
-    getPluginCount() {
+    PluginManager.prototype.getPluginCount = function () {
         return this.plugins.size;
-    }
+    };
     /**
      * Check if all plugins are properly initialized
      * @returns Object with initialization status for each plugin
      */
-    getPluginsInitializationStatus() {
-        const status = {};
-        this.plugins.forEach((plugin, name) => {
+    PluginManager.prototype.getPluginsInitializationStatus = function () {
+        var status = {};
+        this.plugins.forEach(function (plugin, name) {
             try {
                 // Verifica se il plugin ha un metodo per controllare l'inizializzazione
                 if (typeof plugin.assertInitialized === "function") {
@@ -156,89 +180,99 @@ class PluginManager {
             }
         });
         return status;
-    }
+    };
     /**
      * 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 = [];
+    PluginManager.prototype.validatePluginSystem = function () {
+        var status = this.getPluginsInitializationStatus();
+        var totalPlugins = Object.keys(status).length;
+        var initializedPlugins = Object.values(status).filter(function (s) { return s.initialized; }).length;
+        var failedPlugins = Object.entries(status)
+            .filter(function (_a) {
+            var _b = __read(_a, 2), _ = _b[0], s = _b[1];
+            return !s.initialized;
+        })
+            .map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], _ = _b[1];
+            return name;
+        });
+        var warnings = [];
         if (totalPlugins === 0) {
             warnings.push("No plugins registered");
         }
         if (failedPlugins.length > 0) {
-            warnings.push(`Failed plugins: ${failedPlugins.join(", ")}`);
+            warnings.push("Failed plugins: ".concat(failedPlugins.join(", ")));
         }
         return {
-            totalPlugins,
-            initializedPlugins,
-            failedPlugins,
-            warnings,
+            totalPlugins: totalPlugins,
+            initializedPlugins: initializedPlugins,
+            failedPlugins: failedPlugins,
+            warnings: warnings,
         };
-    }
+    };
     /**
      * 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) => {
+    PluginManager.prototype.reinitializeFailedPlugins = function () {
+        var _this = this;
+        var status = this.getPluginsInitializationStatus();
+        var failedPlugins = Object.entries(status)
+            .filter(function (_a) {
+            var _b = __read(_a, 2), _ = _b[0], s = _b[1];
+            return !s.initialized;
+        })
+            .map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], _ = _b[1];
+            return name;
+        });
+        var success = [];
+        var failed = [];
+        failedPlugins.forEach(function (pluginName) {
             try {
-                const plugin = this.plugins.get(pluginName);
+                var plugin = _this.plugins.get(pluginName);
                 if (!plugin) {
                     failed.push({ name: pluginName, error: "Plugin not found" });
                     return;
                 }
                 // Reinizializza il plugin
-                plugin.initialize(this.core);
+                plugin.initialize(_this.core);
                 success.push(pluginName);
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
+                var errorMessage = error instanceof Error ? error.message : String(error);
                 failed.push({ name: pluginName, error: errorMessage });
                 if (typeof console !== "undefined" && console.error) {
-                    console.error(`[PluginManager] Failed to reinitialize plugin ${pluginName}:`, error);
+                    console.error("[PluginManager] Failed to reinitialize plugin ".concat(pluginName, ":"), error);
                 }
             }
         });
-        return { success, failed };
-    }
+        return { success: success, failed: failed };
+    };
     /**
      * 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 = {
+    PluginManager.prototype.checkPluginCompatibility = function () {
+        var compatible = [];
+        var incompatible = [];
+        var unknown = [];
+        this.plugins.forEach(function (plugin) {
+            var 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();
+                    var compatibilityInfo = plugin.getCompatibilityInfo();
                     if (compatibilityInfo && compatibilityInfo.compatible) {
                         compatible.push(pluginInfo);
                     }
                     else {
-                        incompatible.push({
-                            ...pluginInfo,
-                            reason: compatibilityInfo?.reason || "Unknown compatibility issue",
-                        });
+                        incompatible.push(__assign(__assign({}, pluginInfo), { reason: (compatibilityInfo === null || compatibilityInfo === void 0 ? void 0 : compatibilityInfo.reason) || "Unknown compatibility issue" }));
                     }
                 }
                 catch (error) {
@@ -250,50 +284,50 @@ class PluginManager {
                 unknown.push(pluginInfo);
             }
         });
-        return { compatible, incompatible, unknown };
-    }
+        return { compatible: compatible, incompatible: incompatible, unknown: unknown };
+    };
     /**
      * 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,
-        }));
+    PluginManager.prototype.getPluginSystemDebugInfo = function () {
+        var pluginsInfo = this.getPluginsInfo();
+        var initializationStatus = this.getPluginsInitializationStatus();
+        var plugins = pluginsInfo.map(function (info) {
+            var _a, _b;
+            return (__assign(__assign({}, info), { initialized: ((_a = initializationStatus[info.name]) === null || _a === void 0 ? void 0 : _a.initialized) || false, error: (_b = initializationStatus[info.name]) === null || _b === void 0 ? void 0 : _b.error }));
+        });
         return {
             shogunCoreVersion: "^1.6.6",
             totalPlugins: this.getPluginCount(),
-            plugins,
-            initializationStatus,
+            plugins: plugins,
+            initializationStatus: initializationStatus,
             validation: this.validatePluginSystem(),
             compatibility: this.checkPluginCompatibility(),
         };
-    }
+    };
     /**
      * 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) {
+    PluginManager.prototype.hasPlugin = function (name) {
         return this.plugins.has(name);
-    }
+    };
     /**
      * Get all plugins of a specific category
      * @param category Category of plugins to filter
      * @returns Array of plugins in the specified category
      */
-    getPluginsByCategory(category) {
-        const result = [];
-        this.plugins.forEach((plugin) => {
+    PluginManager.prototype.getPluginsByCategory = function (category) {
+        var result = [];
+        this.plugins.forEach(function (plugin) {
             if (plugin._category === category) {
                 result.push(plugin);
             }
         });
         return result;
-    }
-}
-exports.PluginManager = PluginManager;
+    };
+    return PluginManager;
+}());
+export { PluginManager };

package/dist/src/plugins/base.js

@@ -0,0 +1,90 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { EventEmitter } from "../utils/eventEmitter.js";
+/**
+ * Classe base per tutti i plugin di ShogunCore
+ * Fornisce funzionalità comuni e implementazione base dell'interfaccia ShogunPlugin
+ */
+var BasePlugin = /** @class */ (function (_super) {
+    __extends(BasePlugin, _super);
+    function BasePlugin() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        /** Riferimento all'istanza di ShogunCore */
+        _this.core = null;
+        return _this;
+    }
+    /**
+     * Inizializza il plugin con un'istanza di ShogunCore
+     * @param core Istanza di ShogunCore
+     */
+    BasePlugin.prototype.initialize = function (core) {
+        this.core = core;
+    };
+    /**
+     * Distrugge il plugin e libera le risorse
+     */
+    BasePlugin.prototype.destroy = function () {
+        try {
+            // Emetti evento di distruzione
+            this.emit("destroyed", {
+                name: this.name,
+                version: this.version,
+            });
+            this.core = null;
+        }
+        catch (error) {
+            console.error("[".concat(this.name, "] Error during plugin destruction:"), error);
+        }
+    };
+    /**
+     * Verifica che il plugin sia stato inizializzato prima di usare il core
+     * @throws Error se il plugin non è stato inizializzato
+     * @returns L'istanza di ShogunCore non null
+     */
+    BasePlugin.prototype.assertInitialized = function () {
+        if (!this.core) {
+            throw new Error("Plugin ".concat(this.name, " not initialized"));
+        }
+        return this.core;
+    };
+    return BasePlugin;
+}(EventEmitter));
+export { BasePlugin };

package/dist/src/plugins/index.js

@@ -0,0 +1,17 @@
+// Base plugin interface and types
+export { BasePlugin } from "./base.js";
+// WebAuthn plugin exports
+export { Webauthn } from "./webauthn/webauthn.js";
+export { WebauthnPlugin } from "./webauthn/webauthnPlugin.js";
+// Ethereum plugin exports
+export { Web3Connector } from "./web3/web3Connector.js";
+export { Web3ConnectorPlugin } from "./web3/web3ConnectorPlugin.js";
+// Bitcoin plugin exports
+export { NostrConnector } from "./nostr/nostrConnector.js";
+export { NostrConnectorPlugin } from "./nostr/nostrConnectorPlugin.js";
+// ZK-Proof plugin exports
+export { ZkProofConnector } from "./zkproof/zkProofConnector.js";
+export { ZkProofPlugin } from "./zkproof/zkProofPlugin.js";
+export { ZkCredentials, CredentialType } from "./zkproof/zkCredentials.js";
+// Smart Wallet plugin exports
+export { SmartWalletPlugin } from "./smartwallet/smartWalletPlugin.js";

package/dist/src/plugins/nostr/index.js

@@ -0,0 +1,4 @@
+export * from "./nostrConnectorPlugin.js";
+export * from "./nostrConnector.js";
+export * from "./nostrSigner.js";
+export * from "./types.js";