shogun-button-react 1.5.1 → 1.5.6

package/dist/components/ShogunButton.d.ts

@@ -2,6 +2,7 @@ import React from "react";
 import { ShogunCore } from "shogun-core";
 import { Observable } from "rxjs";
 import "../styles/index.css";
+import { GunAdvancedPlugin } from "../plugins/GunAdvancedPlugin";
 type ShogunContextType = {
     sdk: ShogunCore | null;
     options: any;
@@ -16,6 +17,22 @@ type ShogunContextType = {
     getPlugin: <T>(name: string) => T | undefined;
     exportGunPair: (password?: string) => Promise<string>;
     importGunPair: (pairData: string, password?: string) => Promise<boolean>;
+    gunPlugin: GunAdvancedPlugin | null;
+    useGunState: <T>(path: string, defaultValue?: T) => any;
+    useGunCollection: <T>(path: string, options?: any) => any;
+    useGunConnection: (path: string) => {
+        isConnected: boolean;
+        lastSeen: Date | null;
+        error: string | null;
+    };
+    useGunDebug: (path: string, enabled?: boolean) => void;
+    useGunRealtime: <T>(path: string, callback?: (data: T, key: string) => void) => {
+        data: T | null;
+        key: string | null;
+    };
+    put: (path: string, data: any) => Promise<void>;
+    get: (path: string) => any;
+    remove: (path: string) => Promise<void>;
 };
 export declare const useShogun: () => ShogunContextType;
 type ShogunButtonProviderProps = {

package/dist/components/ShogunButton.js

@@ -1,6 +1,7 @@
 import React, { useContext, useState, createContext, useEffect, useRef, } from "react";
 import { Observable } from "rxjs";
 import "../styles/index.css";
+import { GunAdvancedPlugin } from "../plugins/GunAdvancedPlugin";
 // Default context
 const defaultShogunContext = {
     sdk: null,
@@ -16,6 +17,15 @@ const defaultShogunContext = {
     getPlugin: () => undefined,
     exportGunPair: async () => "",
     importGunPair: async () => false,
+    gunPlugin: null,
+    useGunState: () => ({}),
+    useGunCollection: () => ({}),
+    useGunConnection: () => ({ isConnected: false, lastSeen: null, error: null }),
+    useGunDebug: () => { },
+    useGunRealtime: () => ({ data: null, key: null }),
+    put: async () => { },
+    get: () => null,
+    remove: async () => { },
 };
 // Create context using React's createContext directly
 const ShogunContext = createContext(defaultShogunContext);
@@ -330,22 +340,94 @@ export function ShogunButtonProvider({ children, sdk, options, onLoginSuccess, o
             throw new Error(`Failed to import Gun pair: ${error.message}`);
         }
     };
+    // Inizializza il plugin
+    const gunPlugin = React.useMemo(() => {
+        if (!sdk)
+            return null;
+        return new GunAdvancedPlugin(sdk, {
+            enableDebug: options.enableGunDebug !== false,
+            enableConnectionMonitoring: options.enableConnectionMonitoring !== false,
+            defaultPageSize: options.defaultPageSize || 20,
+            connectionTimeout: options.connectionTimeout || 10000,
+            debounceInterval: options.debounceInterval || 100,
+        });
+    }, [sdk, options]);
+    // Effetto per pulizia del plugin
+    React.useEffect(() => {
+        return () => {
+            if (gunPlugin) {
+                gunPlugin.cleanup();
+            }
+        };
+    }, [gunPlugin]);
+    // Crea gli hook del plugin
+    const pluginHooks = React.useMemo(() => {
+        if (!gunPlugin)
+            return {};
+        return gunPlugin.createHooks();
+    }, [gunPlugin]);
+    // Create a properly typed context value
+    const contextValue = React.useMemo(() => ({
+        sdk,
+        options,
+        isLoggedIn,
+        userPub,
+        username,
+        login,
+        signUp,
+        logout,
+        observe,
+        hasPlugin,
+        getPlugin,
+        exportGunPair,
+        importGunPair,
+        gunPlugin,
+        // Ensure all required hooks are present with proper fallbacks
+        useGunState: pluginHooks.useGunState || (() => ({
+            data: null,
+            isLoading: false,
+            error: null,
+            update: async () => { },
+            set: async () => { },
+            remove: async () => { },
+            refresh: () => { }
+        })),
+        useGunCollection: pluginHooks.useGunCollection || (() => ({
+            items: [],
+            currentPage: 0,
+            totalPages: 0,
+            hasNextPage: false,
+            hasPrevPage: false,
+            nextPage: () => { },
+            prevPage: () => { },
+            goToPage: () => { },
+            isLoading: false,
+            error: null,
+            refresh: () => { },
+            addItem: async () => { },
+            updateItem: async () => { },
+            removeItem: async () => { }
+        })),
+        useGunConnection: pluginHooks.useGunConnection || (() => ({
+            isConnected: false,
+            lastSeen: null,
+            error: null
+        })),
+        useGunDebug: pluginHooks.useGunDebug || (() => { }),
+        useGunRealtime: pluginHooks.useGunRealtime || (() => ({
+            data: null,
+            key: null
+        })),
+        put: (gunPlugin === null || gunPlugin === void 0 ? void 0 : gunPlugin.put.bind(gunPlugin)) || (async () => { }),
+        get: (gunPlugin === null || gunPlugin === void 0 ? void 0 : gunPlugin.get.bind(gunPlugin)) || (() => null),
+        remove: (gunPlugin === null || gunPlugin === void 0 ? void 0 : gunPlugin.remove.bind(gunPlugin)) || (async () => { }),
+    }), [
+        sdk, options, isLoggedIn, userPub, username, login, signUp, logout,
+        observe, hasPlugin, getPlugin, exportGunPair, importGunPair,
+        gunPlugin, pluginHooks
+    ]);
     // Provide the context value to children
-    return (React.createElement(ShogunContext.Provider, { value: {
-            sdk,
-            options,
-            isLoggedIn,
-            userPub,
-            username,
-            login,
-            signUp,
-            logout,
-            observe,
-            hasPlugin,
-            getPlugin,
-            exportGunPair,
-            importGunPair,
-        } }, children));
+    return (React.createElement(ShogunContext.Provider, { value: contextValue }, children));
 }
 // SVG Icons Components
 const WalletIcon = () => (React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" },

package/dist/connector.js

@@ -1,6 +1,9 @@
 import { ShogunCore } from "shogun-core";
+import { GunAdvancedPlugin } from "./plugins/GunAdvancedPlugin";
 export function shogunConnector(options) {
-    const { peers = ["https://gun-manhattan.herokuapp.com/gun"], appName, logging, timeouts, oauth, ...restOptions } = options;
+    const { peers = ["https://gun-manhattan.herokuapp.com/gun"], appName, logging, timeouts, oauth, 
+    // Nuove opzioni per il plugin
+    enableGunDebug = true, enableConnectionMonitoring = true, defaultPageSize = 20, connectionTimeout = 10000, debounceInterval = 100, ...restOptions } = options;
     const sdk = new ShogunCore({
         peers,
         scope: appName,
@@ -24,10 +27,23 @@ export function shogunConnector(options) {
     const hasPlugin = (name) => {
         return sdk ? sdk.hasPlugin(name) : false;
     };
+    // Registra automaticamente il plugin Gun avanzato
+    let gunPlugin = null;
+    if (sdk) {
+        gunPlugin = new GunAdvancedPlugin(sdk, {
+            enableDebug: enableGunDebug,
+            enableConnectionMonitoring,
+            defaultPageSize,
+            connectionTimeout,
+            debounceInterval,
+        });
+        registerPlugin(gunPlugin);
+    }
     return {
         sdk,
         options,
         registerPlugin,
         hasPlugin,
+        gunPlugin, // Esporta il plugin per uso esterno
     };
 }

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { ShogunButton, ShogunButtonProvider, useShogun } from './components/ShogunButton.js';
 import { ShogunConnectorOptions, ShogunConnectorResult } from './types/connector-options.js';
 import { shogunConnector } from './connector.js';
+import { GunAdvancedPlugin } from './plugins/GunAdvancedPlugin.js';
 export { ShogunButton, ShogunButtonProvider, useShogun };
 export { shogunConnector };
+export { GunAdvancedPlugin };
 export { ShogunConnectorOptions, ShogunConnectorResult };

package/dist/index.js

@@ -1,6 +1,9 @@
 import { ShogunButton, ShogunButtonProvider, useShogun } from './components/ShogunButton.js';
 import { shogunConnector } from './connector.js';
+import { GunAdvancedPlugin } from './plugins/GunAdvancedPlugin.js';
 // Export components
 export { ShogunButton, ShogunButtonProvider, useShogun };
 // Export connector function
 export { shogunConnector };
+// Export plugin
+export { GunAdvancedPlugin };

package/dist/plugins/GunAdvancedPlugin.d.ts

@@ -0,0 +1,79 @@
+import { ShogunCore } from "shogun-core";
+export interface GunAdvancedPluginConfig {
+    enableDebug?: boolean;
+    enableConnectionMonitoring?: boolean;
+    defaultPageSize?: number;
+    connectionTimeout?: number;
+    debounceInterval?: number;
+}
+export interface GunCollectionOptions<T> {
+    pageSize?: number;
+    sortBy?: keyof T | ((a: T, b: T) => number);
+    sortOrder?: 'asc' | 'desc';
+    filter?: (item: T) => boolean;
+    enableRealtime?: boolean;
+}
+export interface GunCollectionResult<T> {
+    items: T[];
+    currentPage: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    nextPage: () => void;
+    prevPage: () => void;
+    goToPage: (page: number) => void;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => void;
+    addItem: (item: T) => Promise<void>;
+    updateItem: (id: string, updates: Partial<T>) => Promise<void>;
+    removeItem: (id: string) => Promise<void>;
+}
+export interface GunStateResult<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: string | null;
+    update: (updates: Partial<T>) => Promise<void>;
+    set: (data: T) => Promise<void>;
+    remove: () => Promise<void>;
+    refresh: () => void;
+}
+export declare class GunAdvancedPlugin {
+    private sdk;
+    private config;
+    private debugEnabled;
+    private connectionMonitors;
+    private collectionCache;
+    constructor(sdk: ShogunCore, config?: GunAdvancedPluginConfig);
+    setDebugEnabled(enabled: boolean): void;
+    private log;
+    createHooks(): {
+        useGunState: any;
+        useGunCollection: any;
+        useGunConnection: any;
+        useGunDebug: any;
+        useGunRealtime: any;
+    };
+    useGunState<T>(path: string, defaultValue?: T): GunStateResult<T>;
+    useGunCollection<T>(path: string, options?: GunCollectionOptions<T>): GunCollectionResult<T>;
+    useGunConnection(path: string): {
+        isConnected: boolean;
+        lastSeen: Date;
+        error: string;
+    };
+    useGunDebug(path: string, enabled?: boolean): void;
+    useGunRealtime<T>(path: string, callback?: (data: T, key: string) => void): {
+        data: T;
+        key: string;
+    };
+    put(path: string, data: any): Promise<void>;
+    get(path: string): any;
+    remove(path: string): Promise<void>;
+    cleanup(): void;
+    getStats(): {
+        activeConnections: number;
+        cachedCollections: number;
+        debugEnabled: boolean;
+        config: GunAdvancedPluginConfig;
+    };
+}