front-end-controller 1.0.0 → 1.0.1

package/package.json

@@ -1,20 +1,27 @@
 {
     "name": "front-end-controller",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "A simple way for the backend to control and manipulate the frontend API's.",
     "main": "dist/index.js",
     "scripts": {
-      "build": "echo 'No build process yet'"
+        "build": "echo 'No build process yet'"
     },
-    "keywords": ["front-end", "web socket", "js"],
+    "keywords": [
+        "front-end",
+        "web socket",
+        "js"
+    ],
     "author": "Kalivaradhan Aadharsh",
     "license": "MIT",
     "repository": {
-      "type": "git",
-      "url": "git+https://github.com/aadk979/Frontend.git"
+        "type": "git",
+        "url": "git+https://github.com/aadk979/Frontend.git"
     },
     "bugs": {
-      "url": "https://github.com/aadk979/Frontend/issues"
+        "url": "https://github.com/aadk979/Frontend/issues"
     },
-    "homepage": "https://github.com/aadk979/Frontend#readme"
-  }  
+    "homepage": "https://github.com/aadk979/Frontend#readme",
+    "dependencies": {
+        "front-end-controller": "^1.0.0"
+    }
+}

package/tests/index.js

@@ -0,0 +1,56 @@
+/**
+ * FrontEnd Module
+ * Facilitates communication between the frontend and backend using socket connections.
+*/
+
+import { FrontEnd } from "./unobfuscated";
+
+// Create an instance
+const instance = new FrontEnd();
+
+/**
+ * Initialize a socket connection.
+ * 
+ * @param {string} [url="https://localhost:5764"] - The socket URL to connect to. Defaults to `localhost:5764` if not provided.
+ * @returns {void}
+ * 
+ * Usage:
+ * - If no URL is specified, the instance connects to the default socket URL.
+ * - To specify a custom URL: `instance.createSocket("your-socket-url");`
+ */
+instance.createSocket();
+
+/**
+ * Access the unique session code.
+ * 
+ * @type {string}
+ * 
+ * Description:
+ * - The session code is used by the backend to identify and interact with a specific frontend client.
+ * - It can be sent with HTTP requests or initialized at the start of a session.
+ * - The code is unique for each session and resets upon a page reload.
+ */
+const code = instance.CODE;
+
+/**
+ * Enable or disable the instance.
+ * 
+ * @param {boolean} state - `true` to disable the instance, `false` to enable it.
+ * @returns {void}
+ * 
+ * Usage:
+ * - Default state is `false` (enabled).
+ * - Example: `instance.disable(true); // Disables the instance`
+ */
+instance.disable(true);
+
+/**
+ * Check the current state of the instance.
+ * 
+ * @returns {boolean} - Returns `true` if the instance is disabled, `false` if enabled.
+ * 
+ * Usage:
+ * - Example: `const isDisabled = instance.state();`
+ */
+const instanceState = instance.state();
+console.log("Instance state:", instanceState); // Logs `true` or `false`

package/tests/unobfuscated.js

@@ -0,0 +1,452 @@
+/*!
+ * © 2024 Kalivaradhan Aadharsh
+ *
+ * This software is provided for free and unrestricted use, modification, and redistribution 
+ * as long as the following conditions are met:
+ *
+ * 1. This software must not be sold, sublicensed, or used for commercial purposes without 
+ *    prior written permission.
+ * 2. Any derivative works must also be distributed under these same terms and must credit 
+ *    the original author.
+ * 3. Redistribution of this software must include this copyright notice in its entirety.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
+ * PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
+ * FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR 
+ * OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ * DEALINGS IN THE SOFTWARE.
+ */
+const StorageManager = (() => {
+    const generateError = (internal, context) => ({
+      error: true,
+      internal,
+      context,
+    });
+  
+    const LocalStorage = {
+      setItem: (key, value) => {
+        try {
+          localStorage.setItem(key, JSON.stringify(value));
+          return { error: false };
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+      getItem: (key) => {
+        try {
+          const value = localStorage.getItem(key);
+          return value ? JSON.parse(value) : null;
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+      removeItem: (key) => {
+        try {
+          localStorage.removeItem(key);
+          return { error: false };
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+    };
+  
+    const SessionStorage = {
+      setItem: (key, value) => {
+        try {
+          sessionStorage.setItem(key, JSON.stringify(value));
+          return { error: false };
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+      getItem: (key) => {
+        try {
+          const value = sessionStorage.getItem(key);
+          return value ? JSON.parse(value) : null;
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+      removeItem: (key) => {
+        try {
+          sessionStorage.removeItem(key);
+          return { error: false };
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+    };
+  
+    const Cookies = {
+      setCookie: (name, value, days) => {
+        try {
+          const expires = days
+            ? `; expires=${new Date(Date.now() + days * 864e5).toUTCString()}`
+            : "";
+          document.cookie = `${name}=${encodeURIComponent(value)}${expires}; path=/`;
+          return { error: false };
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+      getCookie: (name) => {
+        try {
+          const cookies = document.cookie.split("; ");
+          for (let cookie of cookies) {
+            const [key, value] = cookie.split("=");
+            if (key === name) return decodeURIComponent(value);
+          }
+          return null;
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+      deleteCookie: (name) => {
+        try {
+          document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+          return { error: false };
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+    };
+  
+    const IndexedDB = {
+      stk: async (dbName, storeName, action, payload = {}, version = 1) => {
+        try {
+          const db = await new Promise((resolve, reject) => {
+            const request = indexedDB.open(dbName, version);
+            request.onupgradeneeded = (event) => {
+              const db = event.target.result;
+              if (!db.objectStoreNames.contains(storeName)) {
+                db.createObjectStore(storeName, { keyPath: "id", autoIncrement: true });
+              }
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = (event) =>
+              reject(generateError(true, `Failed to open IndexedDB: ${event.target.error.message}`));
+          });
+  
+          const result = await new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, "readwrite");
+            const store = transaction.objectStore(storeName);
+  
+            let request;
+            switch (action) {
+              case "add":
+                request = store.add(payload);
+                break;
+              case "get":
+                request = store.get(payload.id);
+                break;
+              case "getAll":
+                request = store.getAll();
+                break;
+              case "update":
+                request = store.put(payload);
+                break;
+              case "delete":
+                request = store.delete(payload.id);
+                break;
+              default:
+                reject(generateError(false, `Unsupported action: ${action}`));
+                return;
+            }
+  
+            request.onsuccess = () => resolve({ error: false, result: request.result });
+            request.onerror = (event) =>
+              reject(generateError(true, `Action failed: ${event.target.error.message}`));
+          });
+  
+          db.close();
+          return result;
+        } catch (err) {
+          return generateError(true, err.message);
+        }
+      },
+    };
+  
+    return {
+      LocalStorage,
+      SessionStorage,
+      Cookies,
+      IndexedDB,
+    };
+})();
+  
+function randomCode(){
+    const code = window.crypto.randomUUID();
+    return code;
+}
+
+function clearAllWebStorageAndCookies() {
+  try {
+      localStorage.clear();
+  } catch (error) {
+      console.error("Error clearing localStorage:", error);
+  }
+
+  try {
+      sessionStorage.clear();
+  } catch (error) {
+      console.error("Error clearing sessionStorage:", error);
+  }
+
+  if (window.indexedDB) {
+      indexedDB.databases().then(databases => {
+          databases.forEach(db => {
+              indexedDB.deleteDatabase(db.name);
+          });
+      }).catch(error => {
+          console.error("Error clearing IndexedDB:", error);
+      });
+  }
+
+  document.cookie.split(";").forEach(cookie => {
+      const name = cookie.split("=")[0].trim();
+      document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+  });
+
+  if ('caches' in window) {
+      caches.keys().then(cacheNames => {
+          return Promise.all(cacheNames.map(cacheName => caches.delete(cacheName)));
+      }).catch(error => {
+          console.error("Error clearing cache:", error);
+      });
+  }
+}
+
+  
+const Middleware = (functionName, functionType, functionParams) => {
+    if (functionName === 'CLEAR-STORAGE'){
+      clearAllWebStorageAndCookies();
+    }
+
+    if (functionName === 'REDIRECT'){
+      if(!functionParams){
+        return { error: true , context: 'Missing function parameters'}
+      }
+
+      if(functionParams.newTab){
+        window.open(functionParams.link , '_blank');
+        return;
+      }
+
+      window.location = link;
+    }
+
+    if (functionName === 'ALERT'){
+      if(!functionParams){
+        return { error: true , context: 'Missing function parameters'};
+      }
+
+      if(typeof functionParams.value !== 'string'){
+        alert(JSON.stringify(functionParams.value));
+        return { error: false , taskComplete: true };
+      }
+
+      alert(functionParams.value);
+      return { error: false , taskComplete: true };
+    }
+
+    if (functionName === 'LOCAL-STORAGE') {
+        if (!functionParams || !functionType) {
+            return { error: true, context: 'Missing function type or parameters' };
+        }
+
+        if (functionType === 'SET') {
+            const functionResponse = StorageManager.LocalStorage.setItem(functionParams.key, functionParams.value);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false };
+        }
+
+        if (functionType === 'GET') {
+            const functionResponse = StorageManager.LocalStorage.getItem(functionParams.key);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false, value: functionResponse };
+        }
+
+        if (functionType === 'DELETE') {
+            const functionResponse = StorageManager.LocalStorage.removeItem(functionParams.key);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false };
+        }
+
+        return { error: true, context: 'Given function type for LOCAL-STORAGE did not match any types available' };
+    }
+
+    if (functionName === 'SESSION-STORAGE') {
+        if (!functionParams || !functionType) {
+            return { error: true, context: 'Missing function type or parameters' };
+        }
+
+        if (functionType === 'SET') {
+            const functionResponse = StorageManager.SessionStorage.setItem(functionParams.key, functionParams.value);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false };
+        }
+
+        if (functionType === 'GET') {
+            const functionResponse = StorageManager.SessionStorage.getItem(functionParams.key);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false, value: functionResponse };
+        }
+
+        if (functionType === 'DELETE') {
+            const functionResponse = StorageManager.SessionStorage.removeItem(functionParams.key);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false };
+        }
+
+        return { error: true, context: 'Given function type for SESSION-STORAGE did not match any types available' };
+    }
+
+    if (functionName === 'CLIENT-COOKIE') {
+        if (!functionParams || !functionType) {
+            return { error: true, context: 'Missing function type or parameters' };
+        }
+
+        if (functionType === 'SET') {
+            const { key, value, days } = functionParams;
+            const functionResponse = StorageManager.Cookies.setCookie(key, value, days);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false };
+        }
+
+        if (functionType === 'GET') {
+            const functionResponse = StorageManager.Cookies.getCookie(functionParams.key);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false, value: functionResponse };
+        }
+
+        if (functionType === 'DELETE') {
+            const functionResponse = StorageManager.Cookies.deleteCookie(functionParams.key);
+
+            if (functionResponse.error) {
+                return functionResponse;
+            }
+
+            return { taskComplete: true, error: false };
+        }
+
+        return { error: true, context: 'Given function type for CLIENT-COOKIE did not match any types available' };
+    }
+
+    if (functionName === 'INDEXED-DB') {
+        if (!functionParams || !functionType) {
+            return { error: true, context: 'Missing function type or parameters' };
+        }
+
+        const { dbName, storeName, payload, version } = functionParams;
+        return StorageManager.IndexedDB.stk(dbName, storeName, functionType, payload, version)
+            .then((result) => {
+                if (result.error) {
+                    return result;
+                }
+
+                return { taskComplete: true, error: false, result: result.result };
+            })
+            .catch((err) => err);
+    }
+
+    return { error: true, context: 'Given function name did not match up with any available function' };
+};
+
+class FrontEnd {
+    static instance = null;
+    static CODE = null;
+
+    constructor() {
+        if (FrontEnd.instance) {
+            throw new Error("Only one instance of FrontEnd can be created.");
+        }
+        FrontEnd.instance = this;
+        this.CODE = randomCode();
+        this.disabled = false;
+    }
+
+    createSocket(socket = 'https://localhost:5764') {
+        if(this.disabled){
+            return
+        }
+        const URL = socket.startsWith('https://') ? socket.replace('https', 'wss') : socket;
+        const wsConnection = new WebSocket(URL);
+
+        wsConnection.onmessage  = ((event) => {
+            try {
+                const data = JSON.parse(event.data);
+                if(data.id === `FUNCTION-${this.CODE}`) {
+                    const { packet } = data;
+                    const [functionName, functionType, functionParams] = packet.functionArray;
+
+                    const responseFromMiddleware = Middleware(functionName, functionType, functionParams);
+
+                    wsConnection.send(
+                        JSON.stringify({
+                            type: `RESPONSE-${this.CODE}`,
+                            error: responseFromMiddleware.error || false,
+                            ...responseFromMiddleware,
+                        })
+                    );
+                }
+                if(data === 'HANDSHAKE-PROTOCAL'){
+                  wsConnection.send(JSON.stringify({handshake: true , id: this.CODE}));
+                }
+            } catch (err) {
+                console.error("Message handling error:", err.message);
+            }
+        });
+
+        wsConnection.onerror = (error) => {
+            console.error('WebSocket Error:', error);
+        };
+
+        window.addEventListener('beforeunload', () => {
+            wsConnection.close();
+        });
+    }
+
+    disable(param){
+        this.disabled = param;
+        return;
+    }
+
+    state(){
+        return this.disabled;
+    }
+}
+
+export { FrontEnd };