webfast 0.1.35 → 0.1.38

package/app/content/js/webfast.js

@@ -1,6 +1,34 @@
 console.log(`WebFast!`);
-window.WebFast = {
-    ts : Date.now()
+let web= {};
+web.fast = {
+    ts : Date.now(),
+    action : function(data,ell) {
+        console.log(`Action Function`,data,ell);
+    },
+    functions : {
+        form : function(data,ell) {
+            console.log(`Handle Form Function`);
+        }
+    },
+    que : {
+        list : [],
+        state : false,
+        run : function(count){
+            // Grab first before sending
+            item = web.fast.que.list[0];
+            if (item != undefined) {
+                delete web.fast.que.list[0];
+                web.fast.que.list.slice(1);
+                console.log(`Sending Item`,item);
+                
+                web.fast.socket.send(JSON.stringify(item)); // Send data to the server
+            }
+        }
+    },
+    tmp : {
+        int : {}
+    },
+    socket : undefined
 }
 // Connect to the Socket.IO server
 const telegram = window.Telegram.WebApp;
@@ -18,25 +46,129 @@ if (telegram.initData == ``) {
 
 const socketURL = `wss://${webfastSocket.replace(`https://`,``)}socket.io/?qbt=${setData}`;
 
-try {
-    new WebSocket(socketURL,`test`,{
-        timeout : 0
-    });
+// Assuming you have a variable `socketURL` containing your WebSocket URL
+web.fast.connectWebSocket = function(socketURL,maxRetries = 40, retries = 0) {
+    web.fast.createWebSocket = function(socketURL, maxRetries, retries) {
+        const ws = new WebSocket(socketURL);
+        web.fast.socket = ws;
+        ws.onopen = () => {
+            console.log('WebSocket connected');
+            // Start other things (e.g., send initial data)
+            web.fast.que.state = true;
+        };
+
+        ws.onmessage = (event) => {
+            console.log('Received:', event.data);
+            // Handle received data
+            web.fast.que.state = Date.now();
+            web.fast.receive(`socket`,event.data); // Placeholder for processing response
+        };
+
+        ws.onclose = (event) => {
+            web.fast.que.state = false;
+            if (retries < maxRetries) {
+                retries++;
+                console.log(`WebSocket closed. Retrying in 10 seconds...`);
+                setTimeout(web.fast.createWebSocket(socketURL,maxRetries,retries), 10000); // Retry after 10 seconds
+            } else {
+                console.log(`WebSocket connection failed after ${maxRetries} attempts.`);
+                // Handle failure (e.g., show an error message)
+            }
+        };
+
+        ws.onerror = (error) => {
+            console.error('WebSocket error:', error);
+            // Handle error (e.g., show an error message)
+            web.fast.que.state = false;
+        };
+
+        // Send message to path for example api.example.event
+        web.fast.sendMessage = function(path,message) {
+            // Add to que
+            web.fast.que.list.push({
+                path : path,
+                message : message});
+        }
+    };
+
+    web.fast.createWebSocket(socketURL, maxRetries, retries); // Initial connection
+}
 
-    // Start the other things
-    //alert(telegram.initData);
-} catch (err) {
-    alert(`Err`);
-    console.error(err);
+// Call the function to start the WebSocket connection
+web.fast.connectWebSocket(socketURL);
+web.fast.receive = function(data) {
+    // Placeholder for processing the received data
+    // Implement your logic here (e.g., update UI, handle specific messages)
+    console.log('Processing received data:', data);
 }
 
 // On Ready desable all forms with jquery
 jQuery(document).ready(function() {
-    jQuery('form').submit(function(e) {
-        e.preventDefault(); // Prevent the default form submission
+
+    // Make function
+    web.fast.tmp.int.que = setInterval(function(){
+        // This is the function
+        if (web.fast.que.state != false && web.fast.que.list.length > 0) {
+            // State check
+            web.fast.que.run();
+        }
+    },10);
+
+    // Scan for all webfast ellements
+    jQuery(`[webfast]`).each(function() {
+        let elementType = jQuery(this).prop('nodeName');
+        console.log('Element type:', elementType);
+
+        // Get now the data 
+        let webAction = jQuery(this).attr(`webfast`);
+        let action = jQuery(this).attr(`webfast-${webAction}`);
+        console.log(`Data Actions webAction, action`,webAction,action);
+
+        // Create action runner
+        // Check if id
+        if (jQuery(this).attr(`id`) == undefined) {
+            const array = new Uint32Array(1);
+            window.crypto.getRandomValues(array);
+            const randomValue = array[0];
+
+            console.log(`Set UUID: ${randomValue}`);
+            jQuery(this).attr(`id`,randomValue);
+        }
         
-        // Check what to do like socketpath
-        alert(`Form Submit`);
-        return false;
+        switch (elementType) {
+            case "FORM":
+                jQuery(this).submit(function(e) {
+                    e.preventDefault(); // Prevent the default form submission
+                    
+                    // Check what to do like socketpath
+                    web.fast.action(action,this,e);
+                    return false;
+                });
+            break;
+            case "DIV":
+                // We will do the div element part
+                // check whyt type etc
+                // Make request to server with websocket thingy
+                // Set in QUE
+                let other;
+                if (action == `list`) {
+                    other = {
+                        type : action,
+                        html : jQuery(this).html()
+                    }
+                }
+                web.fast.sendMessage(`socket.api.${webAction}`,{
+                    ts : Date.now(),
+                    ell : jQuery(this).attr(`id`),
+                    other : other
+                })
+            break;
+            case "BUTTON":
+                // Check button interaction
+                console.error(`SETUP BUTTON INTERACTION`);
+            break;
+            default:
+                console.error(`No Action for : ${elementType}`);
+        }
     });
 });

package/example/content/js/test.js

@@ -0,0 +1,2 @@
+console.log(`Test`);
+console.log(web.fast);

package/example.js

@@ -1,5 +1,10 @@
 const path = require(`path`);
+const contentPath = path.join(__dirname,`example`,`content`)
 let program = require(path.join(__dirname,`index.js`))({
-    wget : '/usr/local/bin/wget'
+    wget : '/usr/local/bin/wget',
+    process : {
+        ts : Date.now()
+    },
+    contentPath : contentPath
 });
 console.log(`Required`);

package/modules/bots/applications/telegram/middleware/message/location.js

@@ -5,6 +5,10 @@ module.exports = async function(req,res,body,params,command,middleValue) {
     if (middleValue.location != undefined) {
         locSendMessage = `Thank you for sending your location\n ${middleValue.location.longitude}\n${middleValue.location.latitude}`;
     }
+
+    const scripting = await program.modules.telegram.script.function.check(program,command,middleValue.chat.id,middleValue,body);
+    console.log(scripting);
+
     return {
         message : locSendMessage,
         response : {

package/modules/bots/applications/telegram/middleware/message/photo.js

@@ -49,11 +49,15 @@ module.exports = async function(program,req,res,body,params,command,middleValue)
     console.log(scripting);
     
     // Send back
-    return {
-        message : locSendMessage,
-        response : {
+    if (scripting == true) {
+        return true;
+    } else {
+        return {
             message : locSendMessage,
-            uuid : uuid
+            response : {
+                message : locSendMessage,
+                uuid : uuid
+            }
         }
     }
 }

package/modules/bots/applications/telegram/scripts/function.js

@@ -34,6 +34,7 @@ module.exports = {
         } catch(err) {
             console.error(err);
             console.error(`Error Scripting`);
+            return false;
         }
     },
     response : async function() {

package/modules/express/init.js

@@ -2,6 +2,7 @@ module.exports = async function (program) {
   console.log(`Starting UP Express`);
   program.express = {
       ts: Date.now(),
+      process : program.set.process
   };
 
   const express = require('express');
@@ -138,12 +139,18 @@ module.exports = async function (program) {
 
           // Check if minify at the end
           const fileName = req.params.file;
-          const isMinified = /-min\.js$/.test(fileName);
+          const isExtend = /-extend\.js$/.test(fileName);
 
-          if (isMinified) {
-              console.log(`${fileName} ends with -min.js`);
-              const toRequestFile = req.params.file.replace(`-min.js`, `.js`);
+          // Check if extending
+          if (isExtend) {
+              console.log(`${fileName} ends with -extend.js`);
+              // IS extended file include loading in
+
+              const toRequestFile = req.params.file.replace(`-extend.js`, `.js`);
               contentFolder = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, toRequestFile);
+              // check if file exists in process, if not make it before giving out
+              // Check i
+              console.log(`Content Folder`);
           } else {
               console.log(`${fileName} does not end with -min.js`);
           }
@@ -155,6 +162,33 @@ module.exports = async function (program) {
       }
   })
 
+  // Walkt through for paths to be open 
+  if (program.set.contentPath != undefined) {
+    // Loop Through
+    const readDir = program.fs.readdirSync(program.set.contentPath);
+    
+    // Create request app path for it
+    //loop through
+    for (let rdi in readDir) {
+        // Loop
+        const dirItem = readDir[rdi];
+        const dirPath = program.path.join(program.set.contentPath,dirItem);
+        // Now read the dir
+        // Create app.get
+        try {
+            const theRoute = `/inc/${dirItem}/*`;
+            app.get(theRoute, async (req, res) => {
+                const params = req.params;
+                console.log(`The Route is there`, theRoute);
+            });
+
+        } catch (err) {
+            console.error(`Errro for path read dir including something`, diritem);
+        }
+    }
+    console.log(`We have directory`);
+  }
+
   app.listen(port, () => {
       console.log(`Server Listening`, port, basePath);
   });
@@ -267,16 +301,46 @@ module.exports = async function (program) {
     });
 
     // WebSocket on message event
-    ws.on('message', (message) => {
+    ws.on('message', async (message) => {
         console.log(`Received message from ${clientId}: ${message}`);
 
-        // Add your custom on message logic here
-        // For example, you can broadcast the message to all connected clients
-        clients.forEach((client, id) => {
-            if (client.readyState === WebSocket.OPEN && id !== clientId) {
-                client.send(`Broadcast from ${clientId}: ${message}`);
+        try {
+            // Check for function
+            const json = JSON.parse(message.toString(`utf-8`));
+            const data = json.message;
+            const path = json.path;
+            const split = path.split(".")
+            
+            // Check if function is running in program modules that you can add in the init scirpt when using remote
+            if (program.express.process != undefined) {
+                try {
+                    let resp = await program.express.process[split[0]][split[1]][split[2]](program,ws,json,data,path);
+                    if (resp != false) {
+                        ws.send(JSON.stringify(resp));
+                    }
+                } catch (err) {
+                    console.error(`Error Running program.express.process for `,split[0],split[1],split[2]);
+                    ws.send(JSON.stringify({
+                        ts : Date.now(),
+                        error : true,
+                        message : `Error Event Program receive`
+                    }));
+                }
             }
-        });
+
+            // Add your custom on message logic here
+            // For example, you can broadcast the message to all connected clients
+            clients.forEach((client, id) => {
+                if (client.readyState === WebSocket.OPEN && id !== clientId) {
+                    //ws.send(`Broadcast from ${clientId}: ${message}`);
+                }
+            });
+
+            // Check if 
+        } catch(err) {
+            console.error(`Error Something`);
+
+        }
     });
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.1.35",
+  "version": "0.1.38",
   "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {