mass room definitionand loading works

graph.js

@@ -1,7 +1,7 @@
 /** @import * as TYPES from "./types.ts" */
 
 /** @type {TYPES.GraphBuilder} */
-export default function Builder({user, role, part, desk, pass})
+export default function Builder({user, role, part, desk, pass}, folderHandle, folderName)
 {
 
 // mutate users
@@ -80,92 +80,93 @@ export default function Builder({user, role, part, desk, pass})
     }
 
 // Apply passes
+    /** @type {Record<string, TYPES.Pass>} */
+    const PassList = {};
 
-//   for(let passID in pass)
+    for(let passID in pass)
-//   {
+    {
-//       const [name, users] = pass[passID];
+        const [passName] = pass[passID];
-//       /** @type {TYPES.Pass} */
+        /** @type {TYPES.Pass} */
-//       const passObj = {name, path:passID};
+        PassList[passID] = {
-//       
+            name: passName,
-//       for(let userID in users)
+            path:passID,
-//       {
+            async load(){
-//           const userPart = users[userID];
-//           const user = UserList[userID];
-//           for(let partID in userPart)
-//           {
-//               const part = PartList[partID];
-//               const entries = userPart[partID];
-//               entries.forEach(([time, data]) => {
-//                   /** @type {TYPES.Work} */
-//                   const work = [user, time, data];
-//
-//                   let partPass = part.pass.get(passObj);
-//                   if(!partPass)
-//                   {
-//                       partPass = {time:0, work:[]}
-//                       part.pass.set(passObj, partPass);
-//                   }
-//                   partPass.work.push(work);
-//                   if(partPass.time < time)
-//                   {
-//                       partPass.time = time;
-//                   }      
-//               });
-//           }
-//       }
-//   }
 
-    console.log(user, part, desk);
+                const roomFolder = await folderHandle.getDirectoryHandle(folderName);
+                const passFolder = await roomFolder.getDirectoryHandle(passID);
+
+                for await (const [_, userFile] of passFolder.entries())
+                {
+                    if(userFile.name.endsWith(".json"))
+                    {
+                        const userID = userFile.name.substring(0, userFile.name.length-5);
+                        const userObject = UserList[userID];
+                        try
+                        {
+                            /** @type {Record<string, Array<[time:number, data:string]>>} */
+                            const loadedData = await userFile.getFile().then(d=>d.text()).then(t=>JSON.parse(t));
+
+                            Object.entries(loadedData).forEach(([partID, payload])=>{
+
+                                let latest = 0;
+                                payload.forEach((condensedWork)=>{
+                                    if(condensedWork[0] > latest)
+                                    {
+                                        latest = condensedWork[0];
+                                    }
+                                    condensedWork.push(userObject);
+                                });
+
+                                let passCheck = PartList[partID].pass.get(this);
+                                if(!passCheck)
+                                {
+                                    passCheck = {time:0, work:[]}
+                                    PartList[partID].pass.set(this, passCheck);
+                                }
+
+                                if(latest > passCheck.time)
+                                {
+                                    passCheck.time = latest;
+                                }
+
+                                passCheck.work = /** @type {TYPES.Work[]}*/(payload)
+                            })
+                        }
+                        catch (e)
+                        {
+                            console.warn(`Couldn't parse user data:  ${roomFolder.name} / ${passFolder.name} / ${userFile.name}`, e);
+                        }
+                    }
+                }
+                this.live = true;
+            },
+            dump(){
+                Object.entries(PartList).forEach(([partID, partObj])=>{
+                    partObj.pass.delete(this);
+                });
+                this.live = false;
+            },
+            live:false
+        };
+    }
+
+    return {
+        Desk:DeskList,
+        Part:PartList,
+        User:UserList,
+        Role:RoleList,
+        Pass:PassList
+    };
 }
 
 /** @type {TYPES.MassDscription} */
 export function Graph(params)
 {   
-    Object.entries(params).forEach(([roomFolderName, roomData])=>
+    Object.entries(params).forEach( ([roomFolderName, roomData])=>
     {
-        Object.entries(roomData.pass).forEach(([passFolderName, passData])=>{
+        globalThis.ROOMS = Builder(roomData, globalThis.FOLDER, roomFolderName);
-            const RebuiltPass = {
+        console.log(globalThis.ROOMS);
-                async load(){
-
-                    const roomFolder = await globalThis.FOLDER.getDirectoryHandle(roomFolderName);
-                    const passFolder = await roomFolder.getDirectoryHandle(passFolderName);
-
-                    console.log(passFolder);
-
-                    for await (const [_, userFile] of passFolder.entries())
-                    {
-                        if(userFile.name.endsWith(".json"))
-                        {
-                            const userID = userFile.name.substring(0, userFile.name.length-5)
-                            try
-                            {
-                                /** @type {Record<string, Array<[time:number, data:string]>>} */
-                                const loadedData = await userFile.getFile().then(d=>d.text()).then(t=>JSON.parse(t));
-
-                                Object.entries(loadedData).forEach(([partID, payload])=>{
-                                    const part = roomData.part[partID]
-                                    payload = [...payload, roomData.user[userID]]
-                                })
-                            }
-                            catch (e)
-                            {
-                                console.warn(`Couldn't parse user data:  ${roomFolder.name} / ${passFolder.name} / ${userFile.name}`, e);
-                            }
-                        }
-                    }
-                    this.live = true;
-                },
-                dump(){
-                    this.data = {};
-                    this.live = false;
-                },
-                live:false
-            }
-            roomData.pass[passFolderName] = RebuiltPass;
-        })
     });
-    globalThis.ROOMS = params;
-    console.log(globalThis.ROOMS);
 }
 
 const Scan =(desk)=>

types.ts

@@ -1,92 +1,39 @@
+export type User = {name:string, desk:Set<Desk>};
+export type Role = {name:string, user:User[]};
+export type Desk = {name:string, need:Part[], time:number[], make:Part[], mode:string, role:Role[]};
+export type Work = [user:User, time:number, data:string];
+export type Pass = {name:string, path:string, live:boolean, load:()=Promise<void>, dump:()=>void};
+export type Part = {name:string, pass:Map<Pass, {time:number, work:Work[]}>, need:Desk[], make:Desk[]};
+
 export type GraphBuilder=
 <
     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>]>,
-    Pass extends Record<
-        string,
-        [
-            name:string,
-            user:Partial<Record<
-            keyof Users,
-                Partial<Record<
-                    keyof Parts,
-                    Array<[time:number, data:string]>
-                >>
-            >>
-        ]
-    >
 >
 (
     params:{
+        meta?:{name:string},
         user:Users,
         role:Roles,
         part:Parts,
         desk:Desks,
-        pass:Pass,
+        pass:Record<string, [name:string]>,
-    }
+    },
+    folderHandle:FileSystemDirectoryHandle,
+    folderName:string
 )
-=>void
+=>{
+    Desk:Record<string, Desk>,
+    Part:Record<string, Part>,
+    User:Record<string, User>,
+    Role:Record<string, Role>,
+    Pass:Record<string, Pass>
+}
 
-
-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
-
-
-export type User = {name:string, desk:Set<Desk>};
-export type Role = {name:string, user:User[]};
-export type Desk = {name:string, need:Part[], time:number[], make:Part[], mode:string, role:Role[]};
-export type Work = [user:User, time:number, data:string];
-export type Pass = {name:string, path:string};
-export type Part = {name:string, pass:Map<Pass, {time:number, work:Work[]}>, need:Desk[], make:Desk[]};
-
-
-type MassRoomMeta = {name:string}
-type MassPassMeta = [name:string]
 export type MassDscription=
-<
-    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>]>,
->
 (
-    params:Record<string, {
+    params:Record<string, Parameters<GraphBuilder>[0]>
-        meta?:MassRoomMeta,
-        user:Users,
-        role:Roles,
-        part:Parts,
-        desk:Desks,
-        pass:Record<string, MassPassMeta>,
-    }>
 )
 =>void