what a mess

app.js

@@ -1,12 +1,11 @@
 import FSHandle from "./store.js";
 
+
 const Rooms = {};
 
 async function getFolderHandle() {
   try {
     const dirHandle = await globalThis.showDirectoryPicker();
-    console.log("Folder selected:", dirHandle);
-    
 
     const roomsFolder = await dirHandle.getDirectoryHandle("room");
     if(roomsFolder)
@@ -31,10 +30,11 @@ async function getFolderHandle() {
             const roomObj =
             {
               meta: metaData,
-              pass: {}
+              pass: {},
-            };
+              live: false,
-            Rooms[roomFolder.name] = roomObj;
+              async load()
-
+              {
+                if(this.live) return;
                 for await (const [_, passFolder] of roomFolder.entries())
                 {
                   if(passFolder.kind == "directory")
@@ -53,10 +53,10 @@ async function getFolderHandle() {
                         console.warn(`Couldn't parse pass meta:  ${roomFolder.name} / ${passFolder.name} / ${passMeta.name}`, e);
                       }
 
-                  const passObj = {
+                      const passObj = [
-                    meta: metaData,
+                        metaData,
-                    user: {}
+                        {}
-                  }
+                      ]
                       roomObj.pass[passFolder.name] = passObj;
 
                       for await (const [_, userFile] of passFolder.entries())
@@ -66,7 +66,7 @@ async function getFolderHandle() {
                           const userID = userFile.name.substring(0, userFile.name.length-5)
                           try
                           {
-                        passObj.user[userID] = await userFile.getFile().then(d=>d.text()).then(t=>JSON.parse(t));
+                            passObj[1][userID] = await userFile.getFile().then(d=>d.text()).then(t=>JSON.parse(t));
                           }
                           catch (e)
                           {
@@ -78,6 +78,28 @@ async function getFolderHandle() {
                     }
                   }
                 }
+                this.live = true;
+                
+                globalThis.Pass = this.pass;
+                
+                if (navigator.serviceWorker.controller)
+                {
+                  navigator.serviceWorker.controller.postMessage(this.pass);
+                }
+
+
+                //await import(`./room/${roomFolder.name}/room.js`);
+
+              },
+              async dump()
+              {
+                this.live = false;
+                this.pass = {};
+              }
+            };
+
+            Rooms[roomFolder.name] = roomObj;
+
           }
 
 
@@ -87,11 +109,14 @@ async function getFolderHandle() {
 
     console.log("Rooms:", Rooms);
 
+    globalThis.Rooms = Rooms;
+
   } catch (err) {
     console.error("Folder selection cancelled or failed:", err);
   }
 }
 
+
 function Init()
 {
   const d =(...args)=> document.createElement(...args);

graph.js

@@ -1,51 +1,51 @@
 /** @import * as TYPES from "./types.ts" */
 
 /** @type {TYPES.GraphBuilder} */
-export default function({users, roles, parts, desks, passes})
+export default function Builder({user, role, part, desk, pass})
 {
 
 // mutate users
     /** @type {Record<string, TYPES.User>} */
     //@ts-ignore
-    const UserList = users;
+    const UserList = user;
-    for(let userId in users)
+    for(let userId in user)
     {
-        const name = users[userId];
+        const name = user[userId];
         UserList[userId] = {name, desk:new Set()};
     }
 
 // mutate roles
     /** @type {Record<string, TYPES.Role>} */
     //@ts-ignore
-    const RoleList = roles;
+    const RoleList = role;
-    for(let roleId in roles)
+    for(let roleId in role)
     {
-        const [name, ...userIds] = roles[roleId];
+        const [name, ...userIds] = role[roleId];
         RoleList[roleId] = {name, user:userIds.map(uId=>UserList[/**@type{string}*/(uId)])};
     }
 
 // mutate parts
     /** @type {Record<string, TYPES.Part>} */
     //@ts-ignore
-    const PartList = parts;
+    const PartList = part;
-    for(let partId in parts)
+    for(let partId in part)
     {
-        const name = parts[partId];
+        const name = part[partId];
         PartList[partId] = /** @type {TYPES.Part} */({name, need:[], make:[], pass:new Map()});
     }
 
 // mutate desks
     /** @type {Record<string, TYPES.Desk>} */
     //@ts-ignore
-    const DeskList = desks;
+    const DeskList = desk;
-    for(let deskId in desks)
+    for(let deskId in desk)
     {
-        const [name, roleIDs, mode, needObj, ...makePartIDs] = desks[deskId];
+        const [name, roleIDs, mode, needObj, ...makePartIDs] = desk[deskId];
         /** @type {TYPES.Part[]}*/ const need =[];
         /** @type {number[]}*/ const time =[];
 
         /** @type {TYPES.Desk} */
-        const desk = {
+        const deskObj = {
             name,
             mode,
             need,
@@ -58,33 +58,33 @@ export default function({users, roles, parts, desks, passes})
         {   
             const part = PartList[partId];
             need.push(part);
-            part.need.push(desk);
+            part.need.push(deskObj);
             time.push(needObj[partId]);
         }
 
-        desk.role = roleIDs.map(roleId=>
+        deskObj.role = roleIDs.map(roleId=>
         {
             const role = RoleList[/**@type{string}*/(roleId)];
-            role.user.forEach(u =>u.desk.add(desk));
+            role.user.forEach(u =>u.desk.add(deskObj));
             return role;
         }); 
 
-        desk.make = makePartIDs.map( partId=>
+        deskObj.make = makePartIDs.map( partId=>
         {
             const part = PartList[/**@type{string}*/(partId)];
-            part.make.push(desk);
+            part.make.push(deskObj);
             return part;
         } )
 
-        DeskList[deskId] = desk;
+        DeskList[deskId] = deskObj;
     }
 
 // Apply passes
-    for(let passID in passes)
+    for(let passID in pass)
     {
-        const [name, users] = passes[passID];
+        const [name, users] = pass[passID];
         /** @type {TYPES.Pass} */
-        const pass = {name, path:passID};
+        const passObj = {name, path:passID};
         
         for(let userID in users)
         {
@@ -98,11 +98,11 @@ export default function({users, roles, parts, desks, passes})
                     /** @type {TYPES.Work} */
                     const work = [user, time, data];
 
-                    let partPass = part.pass.get(pass);
+                    let partPass = part.pass.get(passObj);
                     if(!partPass)
                     {
                         partPass = {time:0, work:[]}
-                        part.pass.set(pass, partPass);
+                        part.pass.set(passObj, partPass);
                     }
                     partPass.work.push(work);
                     if(partPass.time < time)
@@ -114,7 +114,14 @@ export default function({users, roles, parts, desks, passes})
         }
     }
 
-    console.log(users, parts, desks);
+    console.log(user, part, desk);
+}
+
+/** @type {TYPES.GraphLoader} */
+export function Loader(params)
+{
+    params.pass = globalThis.Pass;
+    Builder(params);
 }
 
 const Scan =(desk)=>

index.html

@@ -5,6 +5,15 @@
     <title>Document</title>
 </head>
 <body>
+    <script>
+        
+if ('serviceWorker' in navigator) {
+navigator.serviceWorker.register('/service-worker.js')
+.then(reg => console.log('Service Worker registered:', reg))
+.catch(err => console.error('Service Worker registration failed:', err));
+}
+
+    </script>
     <script src="app.js" type="module">
     </script>
 </body>

index.js

@@ -2,21 +2,21 @@ import Graph from "./graph.js";
 import User from "./data/users.js"
 
 Graph({
-    users:User,
+    user:User,
-    roles:
+    role:
     {
         dev:["Development", "u1"]
     },
-    parts:
+    part:
     {
         p1:"hey",
         p2:"sup"
     },
-    desks:
+    desk:
     {
         d1:["Desk 01", ["dev"], "all", {p2:3}, "p1"]
     },
-    passes:
+    pass:
     {
         pass1:
         [

room/room_01/_room_meta.json

@@ -0,0 +1 @@
+{"name":"a room!"}

room/room_01/room.js

@@ -0,0 +1,23 @@
+console.log("CUSTOM ROOM IMPORTED", import.meta.resolve("./"))
+                      
+import {Loader} from "../../graph.js";
+import User from "../../data/users.js";
+
+Loader({
+    user:User,
+    role:
+    {
+        dev:["Development", "u1"]
+    },
+    part:
+    {
+        p1:"hey",
+        p2:"sup"
+    },
+    desk:
+    {
+        d1:["Desk 01", ["dev"], "all", {p2:3}, "p1"]
+    }
+});
+
+console.log("Graph loaded !!");

service-worker.js

@@ -0,0 +1,31 @@
+self.addEventListener('install', (event) => {
+  console.log('[Service Worker] Installed');
+  self.skipWaiting(); // Activate worker immediately
+});
+
+self.addEventListener('activate', (event) => {
+  console.log('[Service Worker] Activated');
+  return self.clients.claim(); // Become available to all pages
+});
+
+self.addEventListener('fetch', (event) => {
+  const url = new URL(event.request.url);
+
+  // Intercept only JavaScript files
+  if (url.pathname.endsWith('/room.js')) {
+    console.log('[Service Worker] Intercepted JS request:', url.href);
+
+    console.log(globalThis.Rooms);
+
+    // You can modify this to return a custom response if needed
+    event.respondWith(fetch(event.request));
+  }
+});
+
+
+self.addEventListener('message', (event) => {
+  console.log('Received message in Service Worker:', event.data);
+
+  // You can respond or act based on the message
+});
+

types.ts

@@ -20,11 +20,43 @@ export type GraphBuilder=
 >
 (
     params:{
-        users:Users,
+        user:Users,
-        roles:Roles,
+        role:Roles,
-        parts:Parts,
+        part:Parts,
-        desks:Desks,
+        desk:Desks,
-        passes:Pass,
+        pass:Pass,
+    }
+)
+=>void
+
+
+export type GraphLoader=
+<
+    Users extends Record<string, string>,
+    Roles extends Record<string, [ name:string, ...users:Array<keyof Users>]>,
+    Parts extends Record<string, string>,
+    Desks extends Record<string, [ name:string, roles:Array<keyof Roles>, mode:"all"|"one", need:Partial<Record<keyof Parts, number>>, ...make:Array<keyof Parts>]>,
+    Passes extends Record<
+        string,
+        [
+            name:string,
+            user:Partial<Record<
+            keyof Users,
+                Partial<Record<
+                    keyof Parts,
+                    Array<[time:number, data:string]>
+                >>
+            >>
+        ]
+    >
+>
+(
+    params:{
+        user:Users,
+        role:Roles,
+        part:Parts,
+        desk:Desks,
+        pass?:Passes,
     }
 )
 =>void