holosphere 1.0.4 → 1.0.6

package/holosphere.d.ts

@@ -0,0 +1,22 @@
+declare module 'holosphere' {
+    export default class HoloSphere {
+        constructor(name: string, openaikey?: string | null);
+        subscribe(hex: string, lense: string, callback: (item: any, key: string) => void): void;
+        put(hex: string, lense: string, content: any): Promise<void>;
+        delete(id: string, tag: string): Promise<void>;
+        get(hex: string, lense: string): Promise<any[]>;
+        getKey(hex: string, lense: string, key: string): Promise<any | null>;
+        getNode(hex: string, lense: string, key: string): Promise<any | null>;
+        compute(hex: string, lense: string, operation: string): Promise<void>;
+        clearlense(hex: string, lense: string): Promise<void>;
+        summarize(history: string): Promise<string>;
+        upcast(hex: string, lense: string, content: any): Promise<any>;
+        updateParent(id: string, report: string): Promise<any>;
+        getHex(lat: number, lng: number, resolution: number): Promise<string>;
+        getScalespace(lat: number, lng: number): string[];
+        getHexScalespace(hex: string): string[];
+        aggregateVotes(hexId: string, topic: string): object;
+        delegateVote(userId: string, topic: string, delegateTo: string): Promise<void>;
+        vote(userId: string, hexId: string, topic: string, vote: string): Promise<void>;
+    }
+}

package/{index.js → holosphere.js}

@@ -4,10 +4,15 @@ import Gun from 'gun'
 import Ajv2019 from 'ajv/dist/2019.js'
 
 class HoloSphere {
+    /**
+     * Initializes a new instance of the HoloSphere class.
+     * @param {string} appname - The name of the application.
+     * @param {string|null} openaikey - The OpenAI API key.
+     */
     constructor(appname, openaikey = null) {
         this.validator = new Ajv2019({ allErrors: false, strict: false });
         this.gun = Gun({
-            peers: ['http://gun.holons.io', 'https://59.src.eco/gun'],
+            peers: ['https://59.src.eco/gun'],
             axe: false,
             // uuid: (content) => { // generate a unique id for each node
             //     console.log('uuid', content);
@@ -15,119 +20,22 @@ class HoloSphere {
         });
 
         this.gun = this.gun.get(appname)
+        this.users = {}; // Initialize users
+        this.hexagonVotes = {}; // Initialize hexagonVotes
 
         if (openaikey != null) {
             this.openai = new OpenAI({
                 apiKey: openaikey,
             });
         }
-
-        //this.bot.command('sethex', async (ctx) => { this.setHex(ctx) }) TODO: MOVE HERE FROM SETTINGS
-
-        // this.bot.command('resethex', async (ctx) => {
-        //     let chatID = ctx.message.chat.id;
-        //     let hex = (await this.db.get('settings', chatID)).hex
-        //     this.delete(hex, ctx.message.text.split(' ')[1])
-        // })
-
-        // this.bot.command('get', async (ctx) => {
-        //     const chatID = ctx.message.chat.id;
-        //     const lense = ctx.message.text.split(' ')[1];
-        //     if (!lense) {
-        //         return ctx.reply('Please specify a tag.');
-        //     }
-        //     let hex = (await this.db.get('settings', chatID)).hex
-        //     //let hex = settings.hex
-        //     console.log('hex', hex)
-
-        //     let data = await this.get(ctx, hex, lense)
-
-        // })
-
-        // this.bot.command('gethex', async (ctx) => {
-        //     let settings = await this.db.get('settings', chatID)
-        //     let id = settings.hex ? settings.hex : 'Hex not set, use /sethex'
-        //     ctx.reply(id)
-        // })
-
-        // this.bot.command('compute', async (ctx) => {
-        //     const chatID = ctx.message.chat.id;
-        //     let operation = ctx.message.text.split(' ')[1];
-        //     if (operation != 'sum') {
-        //         ctx.reply('Operation not implemented')
-        //         return
-        //     }
-        //     let lense = ctx.message.text.split(' ')[2]
-        //     if (!lense) {
-        //         ctx.reply('Please specify a lense where to perform the operation ')
-        //         return
-        //     }
-        //     let hex = (await this.db.get('settings', chatID)).hex
-        //     await this.compute(hex, lense, operation)
-
-        //     // let parentInfo = await this.getCellInfo(parent)
-        //     // parentInfo.wisdom[id] = report
-        //     // //update summary
-        //     // let summary = await this.summarize(Object.values(parentInfo.wisdom).join('\n'))
-        //     // parentInfo.summary = summary
-
-        //     // await this.db.put('cell', parentInfo)
-        //     // return parentInfo
-
-        //     // let content = await this.db.getAll(hex+'/tags')
-        // })
-
-
-
-
-        // this.bot.command('cast', async (ctx) => {
-        //     if (!ctx.message.reply_to_message) {
-        //         return ctx.reply('Please reply to a message you want to tag.');
-        //     }
-        //     const tags = ctx.message.text.split(' ').slice(1);
-        //     if (tags.length === 0) {
-        //         return ctx.reply('Please provide at least one tag.');
-        //     }
-
-        //     const messageID = ctx.message.reply_to_message.message_id;
-        //     const chatID = ctx.message.chat.id;
-        //     const messageContent = ctx.message.reply_to_message.text;
-        //     let settings = await this.db.get('settings', chatID)
-        //     let id = settings.hex ? settings.hex : 'Hex not set, use /sethex'
-        //     //create root node for the item
-        //     let node = await this.gun.get(chatID + '/' + messageID).put({ id: chatID + '/' + messageID, content: messageContent })
-        //     for (let tag of tags) {
-        //         await this.gun.get(id).get(tag).set(node)
-        //         this.upcast(id, tag, node)
-        //     }
-        // })
-
-        // this.bot.command('publish', async (ctx) => {
-        //     console.log(ctx.message)
-        //     if (!ctx.message.reply_to_message) {
-        //         return ctx.reply('Please reply to a message you want to tag.');
-        //     }
-        //     const tags = ctx.message.text.split(' ').slice(1);
-        //     if (tags.length === 0) {
-        //         return ctx.reply('Please provide at least one tag.');
-        //     }
-
-        //     const messageID = ctx.message.reply_to_message.message_id;
-        //     const chatID = ctx.message.chat.id;
-        //     const messageContent = ctx.message.reply_to_message.text;
-        //     let settings = await this.db.get('settings', chatID)
-        //     let hex = settings.hex
-
-        //     for (let tag of tags) {
-        //         let node = await this.gun.get(chatID + '/' + messageID).put({ id: chatID + '/' + messageID, content: messageContent })
-        //         await this.put(hex, tag, node)
-        //     }
-
-        //     ctx.reply('Tag published.');
-        // });
-
     }
 
+    /**
+     * Sets the JSON schema for a specific lense.
+     * @param {string} lense - The lense identifier.
+     * @param {object} schema - The JSON schema to set.
+     * @returns {Promise} - Resolves when the schema is set.
+     */
     async setSchema(lense, schema) {
         return new Promise((resolve, reject) => {
             this.gun.get(lense).get('schema').put(JSON.stringify(schema), ack => {
@@ -141,6 +49,11 @@ class HoloSphere {
         })
     }
 
+    /**
+     * Retrieves the JSON schema for a specific lense.
+     * @param {string} lense - The lense identifier.
+     * @returns {Promise<object|null>} - The retrieved schema or null if not found.
+     */
     async getSchema(lense) {
         return new Promise((resolve) => {
             this.gun.get(lense).get('schema').once(data => {
@@ -159,28 +72,21 @@ class HoloSphere {
             })
         })
     }
-
-    async setHex(ctx) {
-        const chatID = ctx.message.chat.id;
-        const hex = ctx.message.text.split(' ')[1];
-        this.db.gun.get(hex).set('chats').put(chatID)
-        this.db.gun.get('settings').get(chatID).put(hex)
-        return hex
-    }
-
-    async getHexContent(ctx) {
-        const chatID = ctx.message.chat.id;
-        let settings = await this.getSettings(chatID)
-        let hex = settings.hex
-        let content = await this.db.getAll(hex + '/tags')
-        //console.log(content)
-        return content ? content[0].id : 'not found'
-    }
-
+    /**
+     * Deletes a specific tag from a given ID.
+     * @param {string} id - The identifier from which to delete the tag.
+     * @param {string} tag - The tag to delete.
+     */
     async delete(id, tag) {
         await this.gun.get(id).get(tag).put(null)
     }
 
+    /**
+     * Stores content in the specified hex and lense.
+     * @param {string} hex - The hex identifier.
+     * @param {string} lense - The lense under which to store the content.
+     * @param {object} content - The content to store.
+     */
     async put(hex, lense, content) {
         // Retrieve the schema for the lense
         let schema = await this.getSchema(lense)
@@ -202,28 +108,47 @@ class HoloSphere {
             noderef = this.gun.get(lense).get(content.id).put(payload)
             this.gun.get(hex.toString()).get(lense).get(content.id).put(payload)
         } else { // create a content-addressable reference like IPFS. Note: no updates possible using put
-            //const hash = createHash("sha256").update(payload).digest("hex");
-            const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
-            // const hashHex = Array.from(new Uint8Array(hash))
-            //     .map(byte => byte.toString(16).padStart(2, "0"))
-            //     .join("");
-            noderef = this.gun.get(lense).get(hash).put(payload)
-            this.gun.get(hex.toString()).get(lense).get(hash).put(payload)
+            const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
+            const hashArray = Array.from(new Uint8Array(hashBuffer));
+            const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, "0")).join("");
+            noderef = this.gun.get(lense).get(hashHex).put(payload)
+            this.gun.get(hex.toString()).get(lense).get(hashHex).put(payload)
         }
 
-        // return new Promise((resolve, reject) => {
-        //     this.gun.get(hex.toString()).get(lense).set(noderef, ack => {
-        //         if (ack.err) {
-        //             reject(new Error('Failed to add content: ' + ack.err));
-        //         } else {
-        //             console.log('Content added successfully under tag:', lense);
-        //             resolve(ack);
-        //         }
-        //     });
-        // });
+    }
+
+    async putNode(hex, lense, node) {
+        this.gun.get(hex).get(lense).set(node)
+    }
 
+    async parse(data) {
+        var parsed = {}
+
+        if (data._ && data._["#"]) {
+            // If the data is a reference, fetch the actual content
+            let query  = data._['#'].split('/')
+            let hex = query[1]
+            let lense = query[2]
+            let key = query[3]
+            parsed = await this.getKey(hex, lense, key)
+
+        } else 
+      
+        try {
+            parsed = JSON.parse(data);
+        } catch (e) {
+            console.log('Invalid JSON:', data);
+            parsed = data //return the raw data
+        }
+        return parsed
     }
 
+    /**
+     * Retrieves content from the specified hex and lense.
+     * @param {string} hex - The hex identifier.
+     * @param {string} lense - The lense from which to retrieve content.
+     * @returns {Promise<Array<object>>} - The retrieved content.
+     */
     async get(hex, lense) {
         // Wrap the GunDB operation in a promise
         //retrieve lense schema
@@ -244,18 +169,8 @@ class HoloSphere {
                     this.gun.get(hex.toString()).get(lense).map().once(async (itemdata, key) => {
                         counter += 1
                         if (itemdata) {
-                            // if (itemdata._["#"]) {
-                            //     // If the data is a reference, fetch the actual content
-                            //     itemdata = await this.gun.get(itemdata._['#']).then();
-                            //     console.log("Data :",itemdata)
-                            // }
-                            var parsed = {}
-                            try {
-                                parsed = JSON.parse(itemdata);
-                            } catch (e) {
-                                console.log('Invalid JSON:', itemdata);
-                                parsed = itemdata //return the raw data
-                            }
+                            let parsed = await this.parse (itemdata)
+                          
 
                             if (schema) {
                                 let valid = this.validator.validate(schema, parsed);
@@ -283,8 +198,47 @@ class HoloSphere {
         );
     }
 
-    // Operations
+       /**
+     * Retrieves a specific key from the specified hex and lense.
+     * @param {string} hex - The hex identifier.
+     * @param {string} lense - The lense from which to retrieve the key.
+     * @param {string} key - The specific key to retrieve.
+     * @returns {Promise<object|null>} - The retrieved content or null if not found.
+     */
+       async getKey(hex, lense, key) {
+        return new Promise((resolve) => {
+            // Use Gun to get the data
+            this.gun.get(hex).get(lense).get(key).once((data, key) => {
+                if (data) {
+                    resolve(JSON.parse(data)); // Resolve the promise with the data if data is found
+                } else {
+                    resolve(null); // Reject the promise if no data is found
+                }
+            });
+        });
+
+    }
+
+    /**
+   * Retrieves a specific gundb node from the specified hex and lense.
+   * @param {string} hex - The hex identifier.
+   * @param {string} lense - The lense from which to retrieve the key.
+   * @param {string} key - The specific key to retrieve.
+   * @returns {Promise<object|null>} - The retrieved content or null if not found.
+   */
+     getNode(hex, lense, key) {
+        // Use Gun to get the data
+        return this.gun.get(hex).get(lense).get(key)
+    }
+
 
+
+    /**
+     * Computes summaries based on the content within a hex and lense.
+     * @param {string} hex - The hex identifier.
+     * @param {string} lense - The lense to compute.
+     * @param {string} operation - The operation to perform.
+     */
     async compute(hex, lense, operation) {
 
         let res = h3.getResolution(hex);
@@ -304,7 +258,7 @@ class HoloSphere {
                     resolve(); // Resolve the promise to prevent it from hanging
                 }, 1000); // Timeout of 5 seconds
 
-                this.db.gun.get(siblings[i]).get(lense).map().once((data, key) => {
+                this.gun.get(siblings[i]).get(lense).map().once((data, key) => {
                     clearTimeout(timeout); // Clear the timeout if data is received
                     if (data) {
                         content.push(data.content);
@@ -324,6 +278,11 @@ class HoloSphere {
         this.compute(parent, lense, operation)
     }
 
+    /**
+     * Clears all entities under a specific hex and lense.
+     * @param {string} hex - The hex identifier.
+     * @param {string} lense - The lense to clear.
+     */
     async clearlense(hex, lense) {
         let entities = {};
 
@@ -336,6 +295,11 @@ class HoloSphere {
     }
 
 
+    /**
+     * Summarizes provided history text using OpenAI.
+     * @param {string} history - The history text to summarize.
+     * @returns {Promise<string>} - The summarized text.
+     */
     async summarize(history) {
         if (!this.openai) {
             return 'OpenAI not initialized, please specify the API key in the constructor.'
@@ -368,21 +332,34 @@ class HoloSphere {
         return summary
     }
 
+    /**
+     * Upcasts content to parent hexagons recursively.
+     * @param {string} hex - The current hex identifier.
+     * @param {string} lense - The lense under which to upcast.
+     * @param {object} content - The content to upcast.
+     * @returns {Promise<object>} - The upcasted content.
+     */
     async upcast(hex, lense, content) {
         let res = h3.getResolution(hex)
-
-
-        console.log('Upcasting ', hex, lense, content)
-        let parent = h3.cellToParent(hex, res - 1)
-        await this.put(parent, lense, content)
-        if (res == 0)
+        if (res == 0) {
+            await this.putNode(hex, lense, content)
             return content
-        else
+        }
+        else {
+            console.log('Upcasting ', hex, lense, content, res)
+            await this.putNode(hex, lense, content)
+            let parent = h3.cellToParent(hex, res - 1)
             return this.upcast(parent, lense, content)
+        }
     }
 
 
-    // send information upwards, triggers the parent to update its summary
+    /**
+     * Updates the parent hexagon with a new report.
+     * @param {string} id - The child hex identifier.
+     * @param {string} report - The report to update.
+     * @returns {Promise<object>} - The updated parent information.
+     */
     async updateParent(id, report) {
         let cellinfo = await this.getCellInfo(id)
         let res = h3.getResolution(id)
@@ -398,11 +375,23 @@ class HoloSphere {
     }
 
 
+    /**
+     * Converts latitude and longitude to a hex identifier.
+     * @param {number} lat - The latitude.
+     * @param {number} lng - The longitude.
+     * @param {number} resolution - The resolution level.
+     * @returns {Promise<string>} - The resulting hex identifier.
+     */
     async getHex(lat, lng, resolution) {
         return h3.latLngToCell(lat, lng, resolution);
     }
 
-    // returns the list of all the containing hexagons at xall scales
+    /**
+     * Retrieves all containing hexagons at all scales for given coordinates.
+     * @param {number} lat - The latitude.
+     * @param {number} lng - The longitude.
+     * @returns {Array<string>} - List of hex identifiers.
+     */
     getScalespace(lat, lng) {
         let list = []
         let cell = h3.latLngToCell(lat, lng, 14);
@@ -413,7 +402,11 @@ class HoloSphere {
         return list
     }
 
-    // returns the list of all the containing hexagons at xall scales
+    /**
+     * Retrieves all containing hexagons at all scales for a given hex.
+     * @param {string} hex - The hex identifier.
+     * @returns {Array<string>} - List of hex identifiers.
+     */
     getHexScalespace(hex) {
         let list = []
         let res = h3.getResolution(hex)
@@ -423,43 +416,73 @@ class HoloSphere {
         return list
     }
 
+    /**
+     * Subscribes to changes in a specific hex and lense.
+     * @param {string} hex - The hex identifier.
+     * @param {string} lense - The lense to subscribe to.
+     * @param {function} callback - The callback to execute on changes.
+     */
     subscribe(hex, lense, callback) {
         this.gun.get(hex).get(lense).map().on((data, key) => {
             callback(data, key)
         })
     }
 
-    // VOTING SYSTEM
+    /**
+     * Retrieves the final vote for a user, considering delegations.
+     * @param {string} userId - The user's identifier.
+     * @param {string} topic - The voting topic.
+     * @param {object} votes - The current votes.
+     * @param {Set<string>} [visited=new Set()] - Set of visited users to prevent cycles.
+     * @returns {string|null} - The final vote or null if not found.
+     */
+    getFinalVote(userId, topic, votes, visited = new Set()) {
+        if (this.users[userId]) { // Added this.users
+            if (visited.has(userId)) {
+                return null; // Avoid circular delegations
+            }
+            visited.add(userId);
 
-     getFinalVote(userId, topic, votes, visited = new Set()) {
-  if (visited.has(userId)) {
-    return null; // Avoid circular delegations
-  }
-  visited.add(userId);
+            const delegation = this.users[userId].delegations[topic];
+            if (delegation && votes[delegation] === undefined) {
+                return this.getFinalVote(delegation, topic, votes, visited); // Prefixed with this
+            }
 
-  const delegation = users[userId].delegations[topic];
-  if (delegation && votes[delegation] === undefined) {
-    return getFinalVote(delegation, topic, votes, visited); // Follow delegation
-  }
+            return votes[userId] !== undefined ? votes[userId] : null;
+        }
+        return null;
+    }
 
-  return votes[userId] !== undefined ? votes[userId] : null; // Return direct vote or null
-}
+    /**
+     * Aggregates votes for a specific hex and topic.
+     * @param {string} hexId - The hex identifier.
+     * @param {string} topic - The voting topic.
+     * @returns {object} - Aggregated vote counts.
+     */
+    aggregateVotes(hexId, topic) {
+        if (!this.hexagonVotes[hexId] || !this.hexagonVotes[hexId][topic]) {
+            return {}; // Handle undefined votes
+        }
+        const votes = this.hexagonVotes[hexId][topic];
+        const aggregatedVotes = {};
 
- aggregateVotes(hexId, topic) {
-  const votes = hexagonVotes[hexId][topic];
-  const aggregatedVotes = {};
+        Object.keys(votes).forEach(userId => {
+            const finalVote = this.getFinalVote(userId, topic, votes); // Prefixed with this
+            if (finalVote !== null) {
+                aggregatedVotes[finalVote] = (aggregatedVotes[finalVote] || 0) + 1;
+            }
+        });
 
-  Object.keys(votes).forEach(userId => {
-    const finalVote = getFinalVote(userId, topic, votes);
-    if (finalVote !== null) {
-      aggregatedVotes[finalVote] = (aggregatedVotes[finalVote] || 0) + 1;
+        return aggregatedVotes;
     }
-  });
-
-  return aggregatedVotes;
-}
 
-async delegateVote(userId, topic, delegateTo) {
+    /**
+     * Delegates a user's vote to another user.
+     * @param {string} userId - The user's identifier.
+     * @param {string} topic - The voting topic.
+     * @param {string} delegateTo - The user to delegate the vote to.
+     */
+    async delegateVote(userId, topic, delegateTo) {
         const response = await fetch('/delegate', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
@@ -468,6 +491,13 @@ async delegateVote(userId, topic, delegateTo) {
         alert(await response.text());
     }
 
+    /**
+     * Casts a vote for a user on a specific topic and hex.
+     * @param {string} userId - The user's identifier.
+     * @param {string} hexId - The hex identifier.
+     * @param {string} topic - The voting topic.
+     * @param {string} vote - The vote choice.
+     */
     async vote(userId, hexId, topic, vote) {
         const response = await fetch('/vote', {
             method: 'POST',
@@ -478,6 +508,8 @@ async delegateVote(userId, topic, delegateTo) {
     }
 
 
+
+
 }
 
 export default HoloSphere;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "holosphere",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Holonic Geospatial Communication Infrastructure based on h3.js and gun.js",
-  "main": "index.js",
+  "main": "holosphere.js",
   "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"