more wiring up functions

data/users.js

@@ -0,0 +1,4 @@
+export default {
+    u1:"seth",
+    u2:"seth2"
+}

graph.js

@@ -0,0 +1,128 @@
+/** @import * as TYPES from "./types.ts" */
+
+/** @type {TYPES.GraphBuilder} */
+export default function({users, roles, parts, desks})
+{
+
+// mutate users
+    /** @type {Record<string, TYPES.User>} */
+    //@ts-ignore
+    const UserList = users;
+    for(let userId in users)
+    {
+        const name = users[userId];
+        UserList[userId] = {name, desk:new Set()};
+    }
+
+// mutate roles
+    /** @type {Record<string, TYPES.Role>} */
+    //@ts-ignore
+    const RoleList = roles;
+    for(let roleId in roles)
+    {
+        const [name, ...userIds] = roles[roleId];
+        RoleList[roleId] = {name, user:userIds.map(uId=>UserList[uId])};
+    }
+
+// mutate parts
+    /** @type {Record<string, TYPES.Part>} */
+    //@ts-ignore
+    const PartList = parts;
+    for(let partId in parts)
+    {
+        const name = parts[partId];
+        PartList[partId] = /** @type {TYPES.Part} */({name, work:[], time:0, need:[], make:[]});
+    }
+
+
+// mutate desks
+    /** @type {Record<string, TYPES.Desk>} */
+    //@ts-ignore
+    const DeskList = desks;
+
+    for(let deskId in desks)
+    {
+        const [name, roleIDs, mode, needObj, ...makePartIDs] = desks[deskId];
+        const need =[];
+        const time =[];
+
+        /** @type {TYPES.Desk} */
+        const desk = {
+            name,
+            mode,
+            need,
+            time,
+            make:[],
+            role:[]
+        };
+
+        for(const partId in needObj)
+        {   
+            const part = PartList[partId];
+            need.push(part);
+            part.need.push(desk);
+            time.push(needObj[partId]);
+        }
+
+        desk.role = roleIDs.map(roleId=>
+        {
+            const role = RoleList[/**@type{string}*/(roleId)];
+            role.user.forEach(u =>u.desk.add(desk));
+            return role;
+        }); 
+
+        desk.make = makePartIDs.map( partId=>
+        {
+            const part = PartList[/**@type{string}*/(partId)];
+            part.make.push(desk);
+            return part;
+        } )
+
+        DeskList[deskId] = desk;
+    }
+
+    console.log(users, parts, desks);
+}
+
+const Scan =(desk)=>
+{
+    const need = Object.keys(desk.need);
+    const make = desk.make;
+
+    const dirtyNeed = [];
+    const dirtyMake = [];
+
+    let makeMin = Infinity;
+    let needMax = -Infinity;
+
+    for(let i=0; i<need.length; i++)
+    {
+        const id = need[i];
+        const part = Part.find(id);
+        if(part.time > needMax) needMax = part.time;
+    }
+
+    for(let i=0; i<make.length; i++)
+    {
+        const id = make[i];
+        const part = Part.find(make[i]);
+        if(part.time < makeMin) makeMin = part.time;
+        if(part.time < needMax)
+        {
+            dirtyMake.push(id);
+        } 
+    }
+
+    for(let i=0; i<need.length; i++)
+    {
+        const id = need[i];
+        const part = Part.find(id);
+        if(part.time > makeMin)
+        {
+            dirtyNeed.push(id);
+        }
+    }
+
+    console.log("scan", dirtyNeed, dirtyMake);
+    return [dirtyNeed, dirtyMake];
+};

index.js

@@ -1,62 +1,19 @@
-/** @import * as TYPES from "./types.ts" */
+import Graph from "./graph.js";
+import User from "./data/users.js"
 
-/** @type {TYPES.GraphBuilder} */
+Graph({
-function Desk(users, roles, parts, ...desks)
+    users:User,
-{
+    roles:
-    for(let id in parts)
-    {
-        const name = parts[id];
-        parts[id] = {name, work:[], time:0, need:[], make:[]}
-    }
-
-    for(let i=0; i<desks.length; i++)
-    {
-        const [name, mode, needObj, ...makePartIDs] = desks[i];
-        const need =[];
-        const time =[];
-
-        const desk = {
-            name,
-            mode,
-            need,
-            time
-        };
-
-        for(const partId in needObj)
-        {   
-            const part = parts[partId];
-            need.push(part);
-            part.need.push(desk);
-            time.push(needObj[partId]);
-        }
-
-        desk.make = makePartIDs.map( p=>
-        {
-            const part = parts[p]
-            part.make.push(desk);
-            return part;
-        } )
-
-        desks[i] = desk;
-    }
-
-    console.log(parts, desks);
-
-}
-
-const users = {
-    u1:"seth2"
-}
-
-Desk
-(
-    users,
     {
         dev:["Development", "u1"]
     },
+    parts:
     {
         p1:"hey",
         p2:"sup"
     },
-    ["d1", ["dev"], "all", {p2:3}, "p1"]
+    desks:
-)
+    {
+        d1:["Desk 01", ["dev"], "all", {p2:3}, "p1"]
+    }
+});

types.ts

@@ -6,12 +6,20 @@ export type GraphBuilder=
     Users extends Record<string, UserBlueprint>,
     Roles extends Record<string, [ name:string, ...users:Array<keyof Users>]>,
     Parts extends Record<string, PartBlueprint>,
-    Desk extends [ name:string, roles:Array<keyof Roles>, mode:"all"|"one", need:Partial<Record<keyof Parts, number>>, ...make:Array<keyof Parts>]
+    Desks extends Record<string, [ name:string, roles:Array<keyof Roles>, mode:"all"|"one", need:Partial<Record<keyof Parts, number>>, ...make:Array<keyof Parts>]>
 >
 (
-    users:Users,
+    params:{users:Users,
     roles:Roles,
     parts:Parts,
-    ...desks:Desk[]
+    desks:Desks}
 )
 =>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, part:Part, time:number, data:string];
+export type Part = {name:string, time:number, work:Work[], need:Desk[], make:Desk[]};
+