@soham20/smart-offline-sdk 0.1.0 → 0.1.1

package/README.md

@@ -1,3 +1,7 @@
+<<<<<<< HEAD
+# Hackvision2026
+    
+=======
 # Hackvision2026 SDK (JavaScript)
 
 This repository contains the JavaScript SDK for Hackvision2026.
@@ -12,3 +16,4 @@ client.echo('hello').then(console.log);
 ```
 
 See `examples/` for a runnable example.
+>>>>>>> 061641ebd342b507a49884dd32b30125a6525011

package/demo/index.html

@@ -12,14 +12,14 @@
 
   SmartOffline.init({
     pages: ["/demo/index.html","/demo/api/profile.json"],
-    apis: ["https://jsonplaceholder.typicode.com/posts"],
+    apis: ["https://jsonplaceholder.typicode.com/posts/2"],
     debug: true
   });
 
- fetch("https://jsonplaceholder.typicode.com/posts")
+ fetch("https://jsonplaceholder.typicode.com/posts/2")
   .then(res => res.json())
   .then(data => {
-    document.body.innerHTML += `<pre>${data}</pre>`;
+    document.body.innerHTML += `<pre>${JSON.stringify(data, null, 2)}</pre>`;
   })
   .catch(err => {
     document.body.innerHTML += "<p>API failed</p>";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soham20/smart-offline-sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Smart offline-first JavaScript SDK with intelligent caching for web applications",
   "main": "src/sdk/index.js",
   "scripts": {

package/smart-offline-sw.js

@@ -22,11 +22,81 @@ self.addEventListener("message", (event) => {
   }
 });
 
+/**
+ * -------- Usage Tracking (IndexedDB) --------
+ * Tracks frequency + recency per URL
+ */
+function trackUsage(url) {
+  const request = indexedDB.open("smart-offline-usage", 1);
+
+  request.onupgradeneeded = () => {
+    const db = request.result;
+    if (!db.objectStoreNames.contains("usage")) {
+      db.createObjectStore("usage", { keyPath: "url" });
+    }
+  };
+
+  request.onsuccess = () => {
+    const db = request.result;
+    const tx = db.transaction("usage", "readwrite");
+    const store = tx.objectStore("usage");
+
+    const getReq = store.get(url);
+    getReq.onsuccess = () => {
+      const data = getReq.result || {
+        url,
+        count: 0,
+        lastAccessed: 0,
+      };
+
+      data.count += 1;
+      data.lastAccessed = Date.now();
+      store.put(data);
+    };
+  };
+}
+
+/**
+ * Read usage info
+ */
+function getUsage(url) {
+  return new Promise((resolve) => {
+    const request = indexedDB.open("smart-offline-usage", 1);
+
+    request.onsuccess = () => {
+      const db = request.result;
+      const tx = db.transaction("usage", "readonly");
+      const store = tx.objectStore("usage");
+
+      const getReq = store.get(url);
+      getReq.onsuccess = () => resolve(getReq.result);
+      getReq.onerror = () => resolve(null);
+    };
+
+    request.onerror = () => resolve(null);
+  });
+}
+
+/**
+ * Decide priority based on real usage
+ */
+function isHighPriority(usage) {
+  if (!usage) return false;
+
+  const FREQUENT_THRESHOLD = 3;
+  const RECENT_THRESHOLD = 24 * 60 * 60 * 1000; // 24h
+
+  const frequent = usage.count >= FREQUENT_THRESHOLD;
+  const recent = Date.now() - usage.lastAccessed <= RECENT_THRESHOLD;
+
+  return frequent || recent;
+}
+
 /**
  * Install event
  */
 self.addEventListener("install", (event) => {
-  self.skipWaiting(); // 🔥 REQUIRED
+  self.skipWaiting();
   event.waitUntil(caches.open(CACHE_NAME));
 });
 
@@ -36,69 +106,80 @@ self.addEventListener("install", (event) => {
 self.addEventListener("activate", (event) => {
   event.waitUntil(
     Promise.all([
-      self.clients.claim(), // 🔥 REQUIRED
+      self.clients.claim(),
       caches.keys().then((cacheNames) =>
         Promise.all(
           cacheNames.map((name) => {
             if (name !== CACHE_NAME) {
               return caches.delete(name);
             }
-          }),
-        ),
+          })
+        )
       ),
-    ]),
+    ])
   );
 });
 
-
 /**
- * Fetch event – SMART logic
+ * Fetch event — SMART + PRIORITY logic
  */
 self.addEventListener("fetch", (event) => {
   const request = event.request;
 
   if (request.method !== "GET") return;
 
-  console.log("[SW] Intercepted:", request.url);
-
   const isPage = SDK_CONFIG.pages.some((p) =>
     request.url.includes(p)
   );
-
   const isAPI = SDK_CONFIG.apis.some((a) =>
     request.url.includes(a)
   );
 
   if (!isPage && !isAPI) return;
 
+  if (SDK_CONFIG.debug) {
+    console.log("[SW] Intercepted:", request.url);
+  }
+
   event.respondWith(
     fetch(request)
       .then((response) => {
-        const clone = response.clone();
-        const cacheKey = request.url;
+        // Network success
+        trackUsage(request.url);
 
+        const clone = response.clone();
         caches.open(CACHE_NAME).then((cache) => {
-          cache.put(cacheKey, clone);
+          cache.put(request.url, clone);
         });
 
         if (SDK_CONFIG.debug) {
           console.log(
             `[SmartOffline] Cached ${isAPI ? "API" : "PAGE"}:`,
-            cacheKey
+            request.url
           );
         }
 
         return response;
       })
       .catch(() => {
-        if (SDK_CONFIG.debug) {
-          console.log(
-            `[SmartOffline] Served from cache ${isAPI ? "API" : "PAGE"}:`,
-            request.url
-          );
-        }
-        return caches.match(request.url);
-      }),
+        // Offline / network failure
+        trackUsage(request.url);
+
+        return getUsage(request.url).then((usage) => {
+          const highPriority = isHighPriority(usage);
+
+          if (SDK_CONFIG.debug) {
+            console.log(
+              `[SmartOffline] ${
+                highPriority ? "HIGH" : "NORMAL"
+              } priority:`,
+              request.url
+            );
+          }
+
+          // v1 behavior: both return cache, but priority is decided & logged
+          return caches.match(request.url);
+        });
+      })
   );
 });
-

package/src/usageTracker.js

@@ -0,0 +1,37 @@
+const DB_NAME = "smart-offline-usage";
+const STORE_NAME = "usage";
+const DB_VERSION = 1;
+
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: "url" });
+      }
+    };
+
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export async function trackUsage(url) {
+  const db = await openDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  const store = tx.objectStore(STORE_NAME);
+
+  const existing = await new Promise(resolve => {
+    const req = store.get(url);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => resolve(null);
+  });
+
+  const data = existing || { url, count: 0, lastAccessed: 0 };
+  data.count += 1;
+  data.lastAccessed = Date.now();
+
+  store.put(data);
+}