shogun-core 6.2.3 → 6.3.0

package/dist/{gundb → src/gundb}/rxjs.js

@@ -1,18 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RxJS = void 0;
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
+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 { Observable } from "rxjs";
+import { distinctUntilChanged } from "rxjs/operators";
 /**
  * RxJS Integration for GunDB
  * Provides reactive programming capabilities for GunDB data
  */
-class RxJS {
+var RxJS = /** @class */ (function () {
     /**
      * Initialize GunRxJS with a GunDB instance
      * @param gun - GunDB instance
      */
-    constructor(gun) {
+    function RxJS(gun) {
         this.gun = gun;
         this.user = gun.user();
     }
@@ -20,46 +42,48 @@ class RxJS {
      * Get the current user
      * @returns The current user
      */
-    getUser() {
+    RxJS.prototype.getUser = function () {
         return this.user;
-    }
+    };
     /**
      * Get the current user's public key
      * @returns The current user's public key
      */
-    getUserPub() {
-        return this.user.is?.pub;
-    }
+    RxJS.prototype.getUserPub = function () {
+        var _a;
+        return (_a = this.user.is) === null || _a === void 0 ? void 0 : _a.pub;
+    };
     /**
      * Observe a Gun node for changes
      * @param path - Path to observe (can be a string or a Gun chain)
      * @returns Observable that emits whenever the node changes
      */
-    observe(path) {
-        return new rxjs_1.Observable((subscriber) => {
-            let node;
+    RxJS.prototype.observe = function (path) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            var node;
             if (Array.isArray(path)) {
                 // Support array paths by chaining get calls
-                node = this.gun.get(path[0]);
-                for (let i = 1; i < path.length; i++) {
+                node = _this.gun.get(path[0]);
+                for (var i = 1; i < path.length; i++) {
                     node = node.get(path[i]);
                 }
             }
             else if (typeof path === "string") {
-                node = this.gun.get(path);
+                node = _this.gun.get(path);
             }
             else {
                 node = path;
             }
             // Subscribe to changes
-            const unsub = node.on((data, key) => {
+            var unsub = node.on(function (data, key) {
                 if (data === null || data === undefined) {
                     subscriber.next(null);
                     return;
                 }
                 // Remove Gun metadata before emitting
                 if (typeof data === "object" && data !== null) {
-                    const cleanData = this.removeGunMeta(data);
+                    var cleanData = _this.removeGunMeta(data);
                     subscriber.next(cleanData);
                 }
                 else {
@@ -67,32 +91,33 @@ class RxJS {
                 }
             });
             // Return teardown logic
-            return () => {
+            return function () {
                 if (unsub && typeof unsub === "function") {
                     unsub();
                 }
                 node.off();
             };
-        }).pipe((0, operators_1.distinctUntilChanged)((prev, curr) => {
+        }).pipe(distinctUntilChanged(function (prev, curr) {
             return JSON.stringify(prev) === JSON.stringify(curr);
         }));
-    }
+    };
     /**
      * Match data based on Gun's '.map()' and convert to Observable
      * @param path - Path to the collection
      * @param matchFn - Optional function to filter results
      * @returns Observable array of matched items
      */
-    match(path, matchFn) {
-        return new rxjs_1.Observable((subscriber) => {
+    RxJS.prototype.match = function (path, matchFn) {
+        var _this = this;
+        return new Observable(function (subscriber) {
             if (!path) {
                 subscriber.next([]);
                 subscriber.complete();
                 return;
             }
-            const node = typeof path === "string" ? this.gun.get(path) : path;
-            const results = {};
-            const unsub = node.map().on((data, key) => {
+            var node = typeof path === "string" ? _this.gun.get(path) : path;
+            var results = {};
+            var unsub = node.map().on(function (data, key) {
                 // Skip soul key which is Gun's internal reference
                 if (key === "_" || !data)
                     return;
@@ -104,29 +129,30 @@ class RxJS {
                     }
                     return;
                 }
-                const cleanData = typeof data === "object" ? this.removeGunMeta(data) : data;
+                var cleanData = typeof data === "object" ? _this.removeGunMeta(data) : data;
                 results[key] = cleanData;
                 subscriber.next(Object.values(results));
             });
             // Return teardown logic
-            return () => {
+            return function () {
                 if (unsub && typeof unsub === "function") {
                     unsub();
                 }
                 node.off();
             };
         });
-    }
+    };
     /**
      * Put data and return an Observable
      * @param path - Path where to put the data
      * @param data - Data to put
      * @returns Observable that completes when the put is acknowledged
      */
-    put(path, data) {
-        return new rxjs_1.Observable((subscriber) => {
-            const performPut = (target, value) => {
-                target.put(value, (ack) => {
+    RxJS.prototype.put = function (path, data) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            var performPut = function (target, value) {
+                target.put(value, function (ack) {
                     if (ack.err) {
                         subscriber.error(new Error(ack.err));
                     }
@@ -138,29 +164,30 @@ class RxJS {
             };
             if (typeof path === "string" || Array.isArray(path)) {
                 // Path-based put
-                let node;
+                var node = void 0;
                 if (Array.isArray(path)) {
-                    node = this.gun.get(path[0]);
-                    for (let i = 1; i < path.length; i++)
+                    node = _this.gun.get(path[0]);
+                    for (var i = 1; i < path.length; i++)
                         node = node.get(path[i]);
                 }
                 else {
-                    node = this.gun.get(path);
+                    node = _this.gun.get(path);
                 }
                 performPut(node, data);
             }
             else {
                 // Root-level put
-                performPut(this.gun, path);
+                performPut(_this.gun, path);
             }
         });
-    }
+    };
     /**
      * Backward-compatible overload that accepts optional callback like tests expect
      */
-    putCompat(data, callback) {
-        return new rxjs_1.Observable((subscriber) => {
-            this.gun.put(data, (ack) => {
+    RxJS.prototype.putCompat = function (data, callback) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            _this.gun.put(data, function (ack) {
                 if (callback)
                     callback(ack);
                 if (ack.err) {
@@ -172,17 +199,18 @@ class RxJS {
                 }
             });
         });
-    }
+    };
     /**
      * Set data on a node and return an Observable
      * @param path - Path to the collection
      * @param data - Data to set
      * @returns Observable that completes when the set is acknowledged
      */
-    set(path, data) {
-        return new rxjs_1.Observable((subscriber) => {
-            const performSet = (target, value) => {
-                target.set(value, (ack) => {
+    RxJS.prototype.set = function (path, data) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            var performSet = function (target, value) {
+                target.set(value, function (ack) {
                     if (ack.err) {
                         subscriber.error(new Error(ack.err));
                     }
@@ -193,25 +221,26 @@ class RxJS {
                 });
             };
             if (typeof path === "string" || Array.isArray(path)) {
-                let node;
+                var node = void 0;
                 if (Array.isArray(path)) {
-                    node = this.gun.get(path[0]);
-                    for (let i = 1; i < path.length; i++)
+                    node = _this.gun.get(path[0]);
+                    for (var i = 1; i < path.length; i++)
                         node = node.get(path[i]);
                 }
                 else {
-                    node = this.gun.get(path);
+                    node = _this.gun.get(path);
                 }
                 performSet(node, data);
             }
             else {
-                performSet(this.gun, path);
+                performSet(_this.gun, path);
             }
         });
-    }
-    setCompat(data, callback) {
-        return new rxjs_1.Observable((subscriber) => {
-            this.gun.set(data, (ack) => {
+    };
+    RxJS.prototype.setCompat = function (data, callback) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            _this.gun.set(data, function (ack) {
                 if (callback)
                     callback(ack);
                 if (ack.err) {
@@ -223,14 +252,15 @@ class RxJS {
                 }
             });
         });
-    }
+    };
     /**
      * Get data once and return as Observable
      * @param path - Path to get data from
      * @returns Observable that emits the data once
      */
-    once(path) {
-        let node;
+    RxJS.prototype.once = function (path) {
+        var _this = this;
+        var node;
         if (typeof path === "string") {
             node = this.gun.get(path);
         }
@@ -240,45 +270,46 @@ class RxJS {
         else {
             node = this.gun;
         }
-        return new rxjs_1.Observable((subscriber) => {
-            node.once((data) => {
+        return new Observable(function (subscriber) {
+            node.once(function (data) {
                 if (data === undefined || data === null) {
                     subscriber.next(null);
                     subscriber.complete();
                     return;
                 }
-                const cleanData = typeof data === "object" ? this.removeGunMeta(data) : data;
+                var cleanData = typeof data === "object" ? _this.removeGunMeta(data) : data;
                 subscriber.next(cleanData);
                 subscriber.complete();
             });
         });
-    }
+    };
     /**
      * Compute derived values from gun data
      * @param sources - Array of paths or observables to compute from
      * @param computeFn - Function that computes a new value from the sources
      * @returns Observable of computed values
      */
-    compute(sources, computeFn) {
+    RxJS.prototype.compute = function (sources, computeFn) {
+        var _this = this;
         // Convert all sources to observables
-        const observables = sources.map((source) => {
+        var observables = sources.map(function (source) {
             if (typeof source === "string") {
-                return this.observe(source);
+                return _this.observe(source);
             }
             return source;
         });
         // Combine the latest values from all sources
-        return new rxjs_1.Observable((subscriber) => {
-            let values = new Array(sources.length).fill(undefined);
-            let completed = new Array(sources.length).fill(false);
-            const subscriptions = observables.map((obs, index) => {
+        return new Observable(function (subscriber) {
+            var values = new Array(sources.length).fill(undefined);
+            var completed = new Array(sources.length).fill(false);
+            var subscriptions = observables.map(function (obs, index) {
                 return obs.subscribe({
-                    next: (value) => {
+                    next: function (value) {
                         values[index] = value;
                         // Only compute if we have all values
-                        if (values.every((v) => v !== undefined)) {
+                        if (values.every(function (v) { return v !== undefined; })) {
                             try {
-                                const result = computeFn(...values);
+                                var result = computeFn.apply(void 0, __spreadArray([], __read(values), false));
                                 subscriber.next(result);
                             }
                             catch (error) {
@@ -286,32 +317,33 @@ class RxJS {
                             }
                         }
                     },
-                    error: (err) => subscriber.error(err),
-                    complete: () => {
+                    error: function (err) { return subscriber.error(err); },
+                    complete: function () {
                         completed[index] = true;
-                        if (completed.every((c) => c)) {
+                        if (completed.every(function (c) { return c; })) {
                             subscriber.complete();
                         }
                     },
                 });
             });
             // Return teardown logic
-            return () => {
-                subscriptions.forEach((sub) => sub.unsubscribe());
+            return function () {
+                subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
             };
         });
-    }
+    };
     /**
      * User put data and return an Observable (for authenticated users)
      * @param path - Path where to put the data
      * @param data - Data to put
      * @returns Observable that completes when the put is acknowledged
      */
-    userPut(dataOrPath, maybeData, callback) {
-        return new rxjs_1.Observable((subscriber) => {
-            const user = this.gun.user();
+    RxJS.prototype.userPut = function (dataOrPath, maybeData, callback) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            var user = _this.gun.user();
             if (typeof dataOrPath === "string") {
-                user.get(dataOrPath).put(maybeData, (ack) => {
+                user.get(dataOrPath).put(maybeData, function (ack) {
                     if (callback)
                         callback(ack);
                     if (ack.err) {
@@ -324,7 +356,7 @@ class RxJS {
                 });
             }
             else {
-                user.put(dataOrPath, (ack) => {
+                user.put(dataOrPath, function (ack) {
                     if (callback)
                         callback(ack);
                     if (ack.err) {
@@ -337,7 +369,7 @@ class RxJS {
                 });
             }
         });
-    }
+    };
     /**
      * User set data and return an Observable (for authenticated users)
      * @param dataOrPath - Data to set or path where to set the data
@@ -345,11 +377,12 @@ class RxJS {
      * @param callback - Optional callback function
      * @returns Observable that completes when the set is acknowledged
      */
-    userSet(dataOrPath, maybeData, callback) {
-        return new rxjs_1.Observable((subscriber) => {
-            const user = this.gun.user();
+    RxJS.prototype.userSet = function (dataOrPath, maybeData, callback) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            var user = _this.gun.user();
             if (typeof dataOrPath === "string") {
-                user.get(dataOrPath).set(maybeData, (ack) => {
+                user.get(dataOrPath).set(maybeData, function (ack) {
                     if (callback)
                         callback(ack);
                     if (ack.err) {
@@ -362,7 +395,7 @@ class RxJS {
                 });
             }
             else {
-                user.set(dataOrPath, (ack) => {
+                user.set(dataOrPath, function (ack) {
                     if (callback)
                         callback(ack);
                     if (ack.err) {
@@ -375,18 +408,19 @@ class RxJS {
                 });
             }
         });
-    }
+    };
     /**
      * User once data and return an Observable (for authenticated users)
      * @param path - Optional path to get data from
      * @param callback - Optional callback function
      * @returns Observable that emits the data once
      */
-    userOnce(path, callback) {
-        return new rxjs_1.Observable((subscriber) => {
-            const user = this.gun.user();
-            const target = path ? user.get(path) : user;
-            target.once((data, ack) => {
+    RxJS.prototype.userOnce = function (path, callback) {
+        var _this = this;
+        return new Observable(function (subscriber) {
+            var user = _this.gun.user();
+            var target = path ? user.get(path) : user;
+            target.once(function (data, ack) {
                 if (callback)
                     callback(ack);
                 if (ack && ack.err) {
@@ -398,50 +432,52 @@ class RxJS {
                 }
             });
         });
-    }
+    };
     /**
      * Get user data
      * @param path - Path to get data from
      * @returns Observable that emits the data once
      */
-    userGet(path) {
+    RxJS.prototype.userGet = function (path) {
         return this.observe(this.gun.user().get(path));
-    }
+    };
     /**
      * Observe user data
      * @param path - Path to observe in user space
      * @returns Observable that emits whenever the user data changes
      */
-    observeUser(path) {
+    RxJS.prototype.observeUser = function (path) {
         if (path) {
             return this.observe(this.gun.user().get(path));
         }
         return this.observe(this.gun.user().get("~"));
-    }
+    };
     /**
      * Remove Gun metadata from an object
      * @param obj - Object to clean
      * @returns Cleaned object without Gun metadata
      */
-    removeGunMeta(obj) {
+    RxJS.prototype.removeGunMeta = function (obj) {
+        var _this = this;
         if (!obj || typeof obj !== "object")
             return obj;
         // Create a clean copy
-        const cleanObj = Array.isArray(obj) ? [] : {};
+        var cleanObj = Array.isArray(obj) ? [] : {};
         // Copy properties, skipping Gun metadata
-        Object.keys(obj).forEach((key) => {
+        Object.keys(obj).forEach(function (key) {
             // Skip Gun metadata
             if (key === "_" || key === "#")
                 return;
-            const val = obj[key];
+            var val = obj[key];
             if (val && typeof val === "object") {
-                cleanObj[key] = this.removeGunMeta(val);
+                cleanObj[key] = _this.removeGunMeta(val);
             }
             else {
                 cleanObj[key] = val;
             }
         });
         return cleanObj;
-    }
-}
-exports.RxJS = RxJS;
+    };
+    return RxJS;
+}());
+export { RxJS };

package/dist/{gundb → src/gundb}/types.js

@@ -1,8 +1,7 @@
-"use strict";
 /**
  * Type definitions for GunDB to replace 'any' usage
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 // Removed unused types:
 // - TypedAuthCallback (never imported/used)
 // - TypedGunConfig (never imported/used)

package/dist/src/index.js

@@ -0,0 +1,19 @@
+import { ShogunCore } from "./core.js";
+import { RxJS, crypto, derive, GunErrors, DataBase } from "./gundb/db.js";
+// Gun and SEA imports removed - users should import them directly from 'gun' package
+// This prevents bundling issues in build systems like Vite
+export * from "./utils/errorHandler.js";
+export * from "./plugins/index.js";
+export * from "./interfaces/shogun.js";
+export * from "./gundb/gun-es.js";
+export { ShogunCore, RxJS, crypto, derive, GunErrors, DataBase };
+// Note: Gun and SEA are not exported to avoid bundling issues
+// Users should import Gun and SEA directly from the 'gun' package
+// Export seed phrase utilities for WebAuthn multi-device support
+export { generateSeedPhrase, validateSeedPhrase, mnemonicToSeed, seedToPassword, deriveCredentialsFromMnemonic, formatSeedPhrase, normalizeSeedPhrase, } from "./utils/seedPhrase.js";
+// Export crypto module
+export * from "./crypto/index.js";
+// Export managers
+export { CryptoIdentityManager } from "./managers/CryptoIdentityManager.js";
+// Export storage
+export { ShogunStorage } from "./storage/storage.js";

package/dist/src/interfaces/events.js

@@ -0,0 +1,57 @@
+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 __());
+    };
+})();
+import { EventEmitter } from "../utils/eventEmitter.js";
+/**
+ * Extended EventEmitter class with typed events for Shogun
+ * @class ShogunEventEmitter
+ * @extends EventEmitter
+ */
+var ShogunEventEmitter = /** @class */ (function (_super) {
+    __extends(ShogunEventEmitter, _super);
+    function ShogunEventEmitter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Emit a typed Shogun event
+     * @template K - Event key type
+     * @param {K} event - Event name
+     * @param {ShogunEventMap[K]} data - Event data
+     * @returns {boolean} - Returns true if the event had listeners, false otherwise
+     */
+    ShogunEventEmitter.prototype.emit = function (event, data) {
+        return _super.prototype.emit.call(this, event, data);
+    };
+    /**
+     * Register a listener for a typed Shogun event
+     * @template K - Event key type
+     * @param {K} event - Event name
+     * @param {(data: ShogunEventMap[K]) => void} listener - Event listener function
+     */
+    ShogunEventEmitter.prototype.on = function (event, listener) {
+        _super.prototype.on.call(this, event, listener);
+    };
+    /**
+     * Remove a listener for a typed Shogun event
+     * @template K - Event key type
+     * @param {K} event - Event name
+     * @param {(data: ShogunEventMap[K]) => void} listener - Event listener function to remove
+     */
+    ShogunEventEmitter.prototype.off = function (event, listener) {
+        _super.prototype.off.call(this, event, listener);
+    };
+    return ShogunEventEmitter;
+}(EventEmitter));
+export { ShogunEventEmitter };

package/dist/{interfaces → src/interfaces}/shogun.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CorePlugins = exports.PluginCategory = void 0;
 /**
  * Standard plugin categories in ShogunCore
  */
-var PluginCategory;
+export var PluginCategory;
 (function (PluginCategory) {
     /** Authentication plugins (WebAuthn, MetaMask, Bitcoin) */
     PluginCategory["Authentication"] = "authentication";
@@ -20,11 +17,11 @@ var PluginCategory;
     PluginCategory["Messages"] = "messages";
     /** Messaging plugins */
     PluginCategory["Other"] = "other";
-})(PluginCategory || (exports.PluginCategory = PluginCategory = {}));
+})(PluginCategory || (PluginCategory = {}));
 /**
  * Standard names for built-in plugins
  */
-var CorePlugins;
+export var CorePlugins;
 (function (CorePlugins) {
     /** WebAuthn plugin */
     CorePlugins["WebAuthn"] = "webauthn";
@@ -34,4 +31,4 @@ var CorePlugins;
     CorePlugins["Nostr"] = "nostr";
     /** Zero-Knowledge Proof plugin */
     CorePlugins["ZkProof"] = "zkproof";
-})(CorePlugins || (exports.CorePlugins = CorePlugins = {}));
+})(CorePlugins || (CorePlugins = {}));