shogun-core 5.2.0 → 5.2.2

package/dist/gundb/rxjs.js

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RxJS = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+/**
+ * RxJS Integration for GunDB
+ * Provides reactive programming capabilities for GunDB data
+ */
+class RxJS {
+    /**
+     * Initialize GunRxJS with a GunDB instance
+     * @param gun - GunDB instance
+     */
+    constructor(gun) {
+        this.gun = gun;
+        this.user = gun.user();
+    }
+    /**
+     * Get the current user
+     * @returns The current user
+     */
+    getUser() {
+        return this.user;
+    }
+    /**
+     * Get the current user's public key
+     * @returns The current user's public key
+     */
+    getUserPub() {
+        return this.user.is?.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;
+            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 = node.get(path[i]);
+                }
+            }
+            else if (typeof path === "string") {
+                node = this.gun.get(path);
+            }
+            else {
+                node = path;
+            }
+            // Subscribe to changes
+            const unsub = node.on((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);
+                    subscriber.next(cleanData);
+                }
+                else {
+                    subscriber.next(data);
+                }
+            });
+            // Return teardown logic
+            return () => {
+                if (unsub && typeof unsub === "function") {
+                    unsub();
+                }
+                node.off();
+            };
+        }).pipe((0, operators_1.distinctUntilChanged)((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) => {
+            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) => {
+                // Skip soul key which is Gun's internal reference
+                if (key === "_" || !data)
+                    return;
+                if (matchFn && !matchFn(data)) {
+                    // If matchFn is provided and returns false, remove item
+                    if (results[key]) {
+                        delete results[key];
+                        subscriber.next(Object.values(results));
+                    }
+                    return;
+                }
+                const cleanData = typeof data === "object" ? this.removeGunMeta(data) : data;
+                results[key] = cleanData;
+                subscriber.next(Object.values(results));
+            });
+            // Return teardown logic
+            return () => {
+                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) => {
+                    if (ack.err) {
+                        subscriber.error(new Error(ack.err));
+                    }
+                    else {
+                        subscriber.next(value);
+                        subscriber.complete();
+                    }
+                });
+            };
+            if (typeof path === "string" || Array.isArray(path)) {
+                // Path-based put
+                let node;
+                if (Array.isArray(path)) {
+                    node = this.gun.get(path[0]);
+                    for (let i = 1; i < path.length; i++)
+                        node = node.get(path[i]);
+                }
+                else {
+                    node = this.gun.get(path);
+                }
+                performPut(node, data);
+            }
+            else {
+                // Root-level put
+                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) => {
+                if (callback)
+                    callback(ack);
+                if (ack.err) {
+                    subscriber.error(new Error(ack.err));
+                }
+                else {
+                    subscriber.next(data);
+                    subscriber.complete();
+                }
+            });
+        });
+    }
+    /**
+     * 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) => {
+                    if (ack.err) {
+                        subscriber.error(new Error(ack.err));
+                    }
+                    else {
+                        subscriber.next(value);
+                        subscriber.complete();
+                    }
+                });
+            };
+            if (typeof path === "string" || Array.isArray(path)) {
+                let node;
+                if (Array.isArray(path)) {
+                    node = this.gun.get(path[0]);
+                    for (let i = 1; i < path.length; i++)
+                        node = node.get(path[i]);
+                }
+                else {
+                    node = this.gun.get(path);
+                }
+                performSet(node, data);
+            }
+            else {
+                performSet(this.gun, path);
+            }
+        });
+    }
+    setCompat(data, callback) {
+        return new rxjs_1.Observable((subscriber) => {
+            this.gun.set(data, (ack) => {
+                if (callback)
+                    callback(ack);
+                if (ack.err) {
+                    subscriber.error(new Error(ack.err));
+                }
+                else {
+                    subscriber.next(data);
+                    subscriber.complete();
+                }
+            });
+        });
+    }
+    /**
+     * 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;
+        if (typeof path === "string") {
+            node = this.gun.get(path);
+        }
+        else if (path) {
+            node = path;
+        }
+        else {
+            node = this.gun;
+        }
+        return new rxjs_1.Observable((subscriber) => {
+            node.once((data) => {
+                if (data === undefined || data === null) {
+                    subscriber.next(null);
+                    subscriber.complete();
+                    return;
+                }
+                const 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) {
+        // Convert all sources to observables
+        const observables = sources.map((source) => {
+            if (typeof source === "string") {
+                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 obs.subscribe({
+                    next: (value) => {
+                        values[index] = value;
+                        // Only compute if we have all values
+                        if (values.every((v) => v !== undefined)) {
+                            try {
+                                const result = computeFn(...values);
+                                subscriber.next(result);
+                            }
+                            catch (error) {
+                                subscriber.error(error);
+                            }
+                        }
+                    },
+                    error: (err) => subscriber.error(err),
+                    complete: () => {
+                        completed[index] = true;
+                        if (completed.every((c) => c)) {
+                            subscriber.complete();
+                        }
+                    },
+                });
+            });
+            // Return teardown logic
+            return () => {
+                subscriptions.forEach((sub) => 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();
+            if (typeof dataOrPath === "string") {
+                user.get(dataOrPath).put(maybeData, (ack) => {
+                    if (callback)
+                        callback(ack);
+                    if (ack.err) {
+                        subscriber.error(new Error(ack.err));
+                    }
+                    else {
+                        subscriber.next(maybeData);
+                        subscriber.complete();
+                    }
+                });
+            }
+            else {
+                user.put(dataOrPath, (ack) => {
+                    if (callback)
+                        callback(ack);
+                    if (ack.err) {
+                        subscriber.error(new Error(ack.err));
+                    }
+                    else {
+                        subscriber.next(dataOrPath);
+                        subscriber.complete();
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * User set data and return an Observable (for authenticated users)
+     * @param dataOrPath - Data to set or path where to set the data
+     * @param maybeData - Data to set (if first parameter is path)
+     * @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();
+            if (typeof dataOrPath === "string") {
+                user.get(dataOrPath).set(maybeData, (ack) => {
+                    if (callback)
+                        callback(ack);
+                    if (ack.err) {
+                        subscriber.error(new Error(ack.err));
+                    }
+                    else {
+                        subscriber.next(maybeData);
+                        subscriber.complete();
+                    }
+                });
+            }
+            else {
+                user.set(dataOrPath, (ack) => {
+                    if (callback)
+                        callback(ack);
+                    if (ack.err) {
+                        subscriber.error(new Error(ack.err));
+                    }
+                    else {
+                        subscriber.next(dataOrPath);
+                        subscriber.complete();
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * 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) => {
+                if (callback)
+                    callback(ack);
+                if (ack && ack.err) {
+                    subscriber.error(new Error(ack.err));
+                }
+                else {
+                    subscriber.next(data);
+                    subscriber.complete();
+                }
+            });
+        });
+    }
+    /**
+     * Get user data
+     * @param path - Path to get data from
+     * @returns Observable that emits the data once
+     */
+    userGet(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) {
+        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) {
+        if (!obj || typeof obj !== "object")
+            return obj;
+        // Create a clean copy
+        const cleanObj = Array.isArray(obj) ? [] : {};
+        // Copy properties, skipping Gun metadata
+        Object.keys(obj).forEach((key) => {
+            // Skip Gun metadata
+            if (key === "_" || key === "#")
+                return;
+            const val = obj[key];
+            if (val && typeof val === "object") {
+                cleanObj[key] = this.removeGunMeta(val);
+            }
+            else {
+                cleanObj[key] = val;
+            }
+        });
+        return cleanObj;
+    }
+}
+exports.RxJS = RxJS;

package/dist/gundb/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for GunDB to replace 'any' usage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoIdentityManager = exports.normalizeSeedPhrase = exports.formatSeedPhrase = exports.deriveCredentialsFromMnemonic = exports.seedToPassword = exports.mnemonicToSeed = exports.validateSeedPhrase = exports.generateSeedPhrase = exports.autoQuickStart = exports.AutoQuickStart = exports.createSimpleAPI = exports.quickStart = exports.QuickStart = exports.SimpleGunAPI = exports.DataBase = exports.GunErrors = exports.derive = exports.crypto = exports.RxJS = exports.SEA = exports.ShogunCore = exports.Gun = void 0;
+const core_1 = require("./core");
+Object.defineProperty(exports, "ShogunCore", { enumerable: true, get: function () { return core_1.ShogunCore; } });
+const db_1 = require("./gundb/db");
+Object.defineProperty(exports, "RxJS", { enumerable: true, get: function () { return db_1.RxJS; } });
+Object.defineProperty(exports, "crypto", { enumerable: true, get: function () { return db_1.crypto; } });
+Object.defineProperty(exports, "derive", { enumerable: true, get: function () { return db_1.derive; } });
+Object.defineProperty(exports, "GunErrors", { enumerable: true, get: function () { return db_1.GunErrors; } });
+Object.defineProperty(exports, "DataBase", { enumerable: true, get: function () { return db_1.DataBase; } });
+// Import Simple API and improved types
+const gundb_1 = require("./gundb");
+Object.defineProperty(exports, "SimpleGunAPI", { enumerable: true, get: function () { return gundb_1.SimpleGunAPI; } });
+Object.defineProperty(exports, "QuickStart", { enumerable: true, get: function () { return gundb_1.QuickStart; } });
+Object.defineProperty(exports, "quickStart", { enumerable: true, get: function () { return gundb_1.quickStart; } });
+Object.defineProperty(exports, "createSimpleAPI", { enumerable: true, get: function () { return gundb_1.createSimpleAPI; } });
+Object.defineProperty(exports, "AutoQuickStart", { enumerable: true, get: function () { return gundb_1.AutoQuickStart; } });
+Object.defineProperty(exports, "autoQuickStart", { enumerable: true, get: function () { return gundb_1.autoQuickStart; } });
+const db_2 = require("./gundb/db");
+Object.defineProperty(exports, "SEA", { enumerable: true, get: function () { return db_2.SEA; } });
+const db_3 = __importDefault(require("./gundb/db"));
+exports.Gun = db_3.default;
+__exportStar(require("./utils/errorHandler"), exports);
+__exportStar(require("./plugins"), exports);
+__exportStar(require("./interfaces/shogun"), exports);
+__exportStar(require("./config/simplified-config"), exports);
+// Export seed phrase utilities for WebAuthn multi-device support
+var seedPhrase_1 = require("./utils/seedPhrase");
+Object.defineProperty(exports, "generateSeedPhrase", { enumerable: true, get: function () { return seedPhrase_1.generateSeedPhrase; } });
+Object.defineProperty(exports, "validateSeedPhrase", { enumerable: true, get: function () { return seedPhrase_1.validateSeedPhrase; } });
+Object.defineProperty(exports, "mnemonicToSeed", { enumerable: true, get: function () { return seedPhrase_1.mnemonicToSeed; } });
+Object.defineProperty(exports, "seedToPassword", { enumerable: true, get: function () { return seedPhrase_1.seedToPassword; } });
+Object.defineProperty(exports, "deriveCredentialsFromMnemonic", { enumerable: true, get: function () { return seedPhrase_1.deriveCredentialsFromMnemonic; } });
+Object.defineProperty(exports, "formatSeedPhrase", { enumerable: true, get: function () { return seedPhrase_1.formatSeedPhrase; } });
+Object.defineProperty(exports, "normalizeSeedPhrase", { enumerable: true, get: function () { return seedPhrase_1.normalizeSeedPhrase; } });
+// Export crypto module
+__exportStar(require("./crypto"), exports);
+// Export managers
+var CryptoIdentityManager_1 = require("./managers/CryptoIdentityManager");
+Object.defineProperty(exports, "CryptoIdentityManager", { enumerable: true, get: function () { return CryptoIdentityManager_1.CryptoIdentityManager; } });

package/dist/interfaces/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/events.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShogunEventEmitter = void 0;
+const eventEmitter_1 = require("../utils/eventEmitter");
+/**
+ * Extended EventEmitter class with typed events for Shogun
+ * @class ShogunEventEmitter
+ * @extends EventEmitter
+ */
+class ShogunEventEmitter extends eventEmitter_1.EventEmitter {
+    /**
+     * 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
+     */
+    emit(event, data) {
+        return super.emit(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
+     */
+    on(event, listener) {
+        super.on(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
+     */
+    off(event, listener) {
+        super.off(event, listener);
+    }
+}
+exports.ShogunEventEmitter = ShogunEventEmitter;

package/dist/interfaces/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/shogun.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorePlugins = exports.PluginCategory = void 0;
+/**
+ * Standard plugin categories in ShogunCore
+ */
+var PluginCategory;
+(function (PluginCategory) {
+    /** Authentication plugins (WebAuthn, MetaMask, Bitcoin) */
+    PluginCategory["Authentication"] = "authentication";
+    /** Wallet management plugins */
+    PluginCategory["Wallet"] = "wallet";
+    /** Privacy and anonymity plugins */
+    PluginCategory["Privacy"] = "privacy";
+    /** Decentralized identity plugins */
+    PluginCategory["Identity"] = "identity";
+    /** Other utility plugins */
+    PluginCategory["Utility"] = "utility";
+    /** Messages plugins */
+    PluginCategory["Messages"] = "messages";
+    /** Messaging plugins */
+    PluginCategory["Other"] = "other";
+})(PluginCategory || (exports.PluginCategory = PluginCategory = {}));
+/**
+ * Standard names for built-in plugins
+ */
+var CorePlugins;
+(function (CorePlugins) {
+    /** WebAuthn plugin */
+    CorePlugins["WebAuthn"] = "webauthn";
+    /** Ethereum plugin */
+    CorePlugins["Web3"] = "web3";
+    /** Bitcoin wallet plugin */
+    CorePlugins["Nostr"] = "nostr";
+    /** Zero-Knowledge Proof plugin */
+    CorePlugins["ZkProof"] = "zkproof";
+})(CorePlugins || (exports.CorePlugins = CorePlugins = {}));