@yuneta/gobj-ui 7.23.66 → 7.23.68

package/src/treedb_fold_model.js

@@ -140,7 +140,7 @@ function parents_of(descs, desc, record)
  *          topics: [topic_name, ...]  topics with records, in desc order
  *      }
  ************************************************************/
-export function fold_build_model(descs, records)
+export function fold_build_model(descs, records, opts)
 {
     let nodes = new Map();
     let groups = new Map();
@@ -148,8 +148,21 @@ export function fold_build_model(descs, records)
 
     descs = is_object(descs)? descs : {};
     records = is_object(records)? records : {};
+    opts = is_object(opts)? opts : {};
 
-    /*  Pass 1: every record is a node.  */
+    let hidden = new Set(is_array(opts.hidden_topics)? opts.hidden_topics : []);
+    let loose_shown = new Set(is_array(opts.loose_topics)? opts.loose_topics : []);
+    let main_topic = opts.main_topic || fold_main_topic(descs);
+    if(main_topic && (!descs[main_topic] || hidden.has(main_topic))) {
+        main_topic = "";    /*  a main topic that is not drawn governs nothing  */
+    }
+    let linked = fold_linked_topics(descs, main_topic);
+    let totals = {};
+
+    /*  Pass 1: every record is a node -- of the topics that are SHOWN.
+     *  A hidden topic leaves the model whole: no pills count it, no
+     *  edge reaches it, and the records that hung from it alone become
+     *  roots, the way any record with no drawable parent does.  */
     for(let topic_name of Object.keys(descs)) {
         if(topic_name.substring(0, 2) === "__") {
             continue;
@@ -159,6 +172,10 @@ export function fold_build_model(descs, records)
         if(!is_array(list)) {
             continue;
         }
+        totals[topic_name] = list.length;
+        if(hidden.has(topic_name)) {
+            continue;
+        }
         topics.push(topic_name);
         for(let i = 0; i < list.length; i++) {
             let record = list[i];
@@ -203,28 +220,60 @@ export function fold_build_model(descs, records)
         }
     }
 
-    /*  Roots: no drawable parent. Then whatever the roots cannot reach
-     *  -- a cycle with no way in -- becomes a root too, so that every
-     *  record has a place on screen to be opened from.  */
+    /*  Roots: no drawable parent -- with one distinction when there is
+     *  a MAIN topic. A record of a topic the schema hangs from the main
+     *  one (`linked`) that has no parent is LOOSE: a device with no
+     *  place. It should hang and does not, so it is not a root of the
+     *  tree; it is counted per topic and shown only on request
+     *  (`loose_topics`). A topic the schema does not tie to the main
+     *  one at all is a tree of its own, and its parentless records are
+     *  its roots, as before.
+     *
+     *  Then whatever the roots cannot reach -- a cycle with no way in
+     *  -- becomes a root too, so that every record has a place on
+     *  screen to be opened from.  */
     let roots = {};
+    let loose = {};
     for(let topic_name of topics) {
         roots[topic_name] = [];
+        loose[topic_name] = [];
     }
     for(let node of nodes.values()) {
-        if(node.parents.length === 0) {
-            roots[node.topic_name].push(node.key);
+        if(node.parents.length > 0) {
+            continue;
+        }
+        let t = node.topic_name;
+        if(main_topic && t !== main_topic && linked.has(t)) {
+            loose[t].push(node.key);
+            if(loose_shown.has(t)) {
+                roots[t].push(node.key);
+            }
+        } else {
+            roots[t].push(node.key);
         }
     }
     let reached = reach_from(nodes, [].concat(...Object.values(roots)));
     for(let node of nodes.values()) {
-        if(!reached.has(node.key)) {
-            roots[node.topic_name].push(node.key);
-            /*  Its own subtree is reachable now; mark it so a whole
-             *  cycle does not become a row of roots.  */
-            for(let k of reach_from(nodes, [node.key])) {
-                reached.add(k);
+        if(reached.has(node.key)) {
+            continue;
+        }
+        let t = node.topic_name;
+        if(main_topic && t !== main_topic && linked.has(t)) {
+            /*  Reachable through a loose record that is not shown, or
+             *  through a hidden topic: loose as well, not a root.  */
+            if(node.parents.length > 0) {
+                loose[t].push(node.key);
+            }
+            if(!loose_shown.has(t)) {
+                continue;
             }
         }
+        roots[t].push(node.key);
+        /*  Its own subtree is reachable now; mark it so a whole
+         *  cycle does not become a row of roots.  */
+        for(let k of reach_from(nodes, [node.key])) {
+            reached.add(k);
+        }
     }
     for(let topic_name of topics) {
         if(roots[topic_name].length > 0) {
@@ -232,7 +281,103 @@ export function fold_build_model(descs, records)
         }
     }
 
-    return {nodes: nodes, groups: groups, topics: topics};
+    return {
+        nodes: nodes,
+        groups: groups,
+        topics: topics,
+        totals: totals,         /*  {topic: records}, hidden topics included  */
+        hidden: hidden,         /*  Set of hidden topics  */
+        main_topic: main_topic, /*  "" when nothing governs the tree  */
+        linked: linked,         /*  Set of topics the schema hangs from main  */
+        loose: loose,           /*  {topic: [key, ...]} records that should hang and do not  */
+        loose_shown: loose_shown,
+    };
+}
+
+/************************************************************
+ *  The topic the schema hangs the others from: the one whose hooks
+ *  reach the most OTHER topics, a self-referent hook breaking a tie
+ *  (a tree of places over a flat list of groups), schema order
+ *  breaking the rest. "" when no topic reaches another -- a treedb of
+ *  unrelated lists has no trunk, and every topic is a tree of its own.
+ ************************************************************/
+export function fold_main_topic(descs)
+{
+    descs = is_object(descs)? descs : {};
+    let best = "";
+    let best_score = 0;
+    let best_self = false;
+
+    for(let topic_name of Object.keys(descs)) {
+        if(topic_name.substring(0, 2) === "__") {
+            continue;
+        }
+        let reach = hook_targets(descs, topic_name);
+        let self = reach.has(topic_name);
+        reach.delete(topic_name);
+        let score = reach.size;
+        if(score === 0) {
+            continue;
+        }
+        if(score > best_score || (score === best_score && self && !best_self)) {
+            best = topic_name;
+            best_score = score;
+            best_self = self;
+        }
+    }
+    return best;
+}
+
+/*  The topics a topic's hooks name (drawn topics only). An `extended`
+ *  topic names nothing: the engine draws no edge from one, so its
+ *  records hang nothing and it can govern no tree.  */
+function hook_targets(descs, topic_name)
+{
+    let out = new Set();
+    let desc = descs[topic_name];
+    if(!desc || desc.node_treedb_type === "extended") {
+        return out;
+    }
+    let cols = is_array(desc.cols)? desc.cols : [];
+    for(let col of cols) {
+        if(!is_object(col.hook) || !is_array(col.flag) || col.flag.indexOf("hook") < 0) {
+            continue;
+        }
+        for(let child of Object.keys(col.hook)) {
+            if(child.substring(0, 2) !== "__" && descs[child]) {
+                out.add(child);
+            }
+        }
+    }
+    return out;
+}
+
+/************************************************************
+ *  The topics the schema hangs from `main_topic`, main included:
+ *  reached by following hooks from it. A record of one of these
+ *  with no parent is LOOSE; a topic outside the set is its own tree.
+ *  Empty when there is no main topic.
+ ************************************************************/
+export function fold_linked_topics(descs, main_topic)
+{
+    let linked = new Set();
+    if(!main_topic || !is_object(descs) || !descs[main_topic]) {
+        return linked;
+    }
+    let queue = [main_topic];
+    while(queue.length) {
+        let t = queue.shift();
+        if(linked.has(t)) {
+            continue;
+        }
+        linked.add(t);
+        for(let child of hook_targets(descs, t)) {
+            if(!linked.has(child)) {
+                queue.push(child);
+            }
+        }
+    }
+    return linked;
 }
 
 /************************************************************
@@ -283,7 +428,18 @@ export function fold_group_total(model, group_key)
 export function fold_group_shown(model, state, group_key)
 {
     let total = fold_group_total(model, group_key);
-    let n = state.shown.get(group_key) || 0;
+    let n;
+    if(state.shown.has(group_key)) {
+        n = state.shown.get(group_key);
+    } else if(group_key.charAt(0) === "|") {
+        /*  A ROOT group nobody has set is open on its first page: no
+         *  pill folds the roots, so "unset" cannot mean "folded" -- a
+         *  topic shown again after being hidden, or one that appears
+         *  when the main topic moves, would otherwise draw nothing.  */
+        n = state.page_size;
+    } else {
+        n = 0;
+    }
     return Math.min(n, total);
 }
 

package/src/treedb_fold_model.test.js

@@ -24,6 +24,8 @@ import {
     fold_group_key,
     fold_root_group_key,
     fold_split_group_key,
+    fold_main_topic,
+    fold_group_shown,
 } from "./treedb_fold_model.js";
 
 const places_desc = {
@@ -133,12 +135,21 @@ describe("the model", () => {
         expect(m.groups.get(fold_root_group_key("device_groups"))).toEqual([K("device_groups", "g1")]);
     });
 
-    test("a child of an `extended` parent only is a root: the engine draws no edge to one", () => {
+    test("a child of an `extended` parent only has no parent: the engine draws no edge to one", () => {
         let recs = make_records(1);
         recs.devices[0] = {id: "d0", group: "device_groups^g1^members"};
         let m = fold_build_model(descs, recs);
-        expect(m.groups.get(fold_root_group_key("devices"))).toEqual([K("devices", "d0")]);
         expect(m.nodes.get(K("device_groups", "g1")).hooks).toEqual({});
+        /*  devices hang from places (the main topic), so a device with
+         *  no parent is LOOSE, not a root -- see the "main topic" block  */
+        expect(m.loose.devices).toEqual([K("devices", "d0")]);
+        expect(m.groups.get(fold_root_group_key("devices"))).toBeUndefined();
+        /*  and with no main topic it is a plain root  */
+        let m2 = fold_build_model({places: places_desc, devices: devices_desc, device_groups: groups_desc}, recs, {main_topic: ""});
+        expect(m2.main_topic).toBe("places");   /*  "" means "deduce", and places reaches devices  */
+        let m3 = fold_build_model({devices: devices_desc, device_groups: groups_desc}, recs);
+        expect(m3.main_topic).toBe("");
+        expect(m3.groups.get(fold_root_group_key("devices"))).toEqual([K("devices", "d0")]);
     });
 
     test("a cycle with no way in gets one root, not a row of them", () => {
@@ -164,6 +175,113 @@ describe("the model", () => {
     });
 });
 
+describe("main topic, hidden topics, loose records", () => {
+    test("the main topic is the one whose hooks reach the most others; places, not device_groups", () => {
+        expect(fold_main_topic(descs)).toBe("places");
+        let m = fold_build_model(descs, make_records(3));
+        expect(m.main_topic).toBe("places");
+        expect([...m.linked].sort()).toEqual(["controllers", "devices", "places"]);
+        expect(m.linked.has("device_groups")).toBe(false);
+    });
+
+    test("a self-referent hook breaks a tie", () => {
+        let a = {topic_name: "a", node_treedb_type: "extended",
+                 cols: [{id: "id", flag: []}, {id: "xs", flag: ["hook"], hook: {x: "a"}}]};
+        let b = {topic_name: "b", node_treedb_type: "hierarchical",
+                 cols: [{id: "id", flag: []}, {id: "xs", flag: ["hook"], hook: {x: "b"}},
+                        {id: "bs", flag: ["hook"], hook: {b: "parent"}},
+                        {id: "parent", flag: ["fkey"], fkey: {b: "bs"}}]};
+        let x = {topic_name: "x", node_treedb_type: "child", cols: [{id: "id", flag: []}]};
+        expect(fold_main_topic({a: a, b: b, x: x})).toBe("b");
+        expect(fold_main_topic({x: x})).toBe("");
+    });
+
+    test("an explicit main topic wins over the deduced one", () => {
+        let m = fold_build_model(descs, make_records(3), {main_topic: "controllers"});
+        expect(m.main_topic).toBe("controllers");
+        expect([...m.linked].sort()).toEqual(["controllers", "devices"]);
+        /*  places is not linked to controllers, so its roots are roots  */
+        expect(m.groups.get(fold_root_group_key("places"))).toEqual([K("places", "es")]);
+    });
+
+    test("a device with no place is LOOSE: counted, not a root, unless asked for", () => {
+        let recs = make_records(3);
+        recs.devices.push({id: "d_loose"});
+        let m = fold_build_model(descs, recs);
+        expect(m.loose.devices).toEqual([K("devices", "d_loose")]);
+        expect(m.groups.get(fold_root_group_key("devices"))).toBeUndefined();
+        expect(m.totals.devices).toBe(4);
+        let m2 = fold_build_model(descs, recs, {loose_topics: ["devices"]});
+        expect(m2.groups.get(fold_root_group_key("devices"))).toEqual([K("devices", "d_loose")]);
+        expect(m2.loose.devices).toEqual([K("devices", "d_loose")]);
+    });
+
+    test("a device hanging from a loose controller only is loose too, and follows it", () => {
+        let recs = make_records(0);
+        recs.controllers.push({id: "c_loose"});
+        recs.devices.push({id: "d_under", controller: ["controllers^c_loose^devices"]});
+        let m = fold_build_model(descs, recs);
+        expect(m.loose.controllers).toEqual([K("controllers", "c_loose")]);
+        expect(m.loose.devices).toEqual([K("devices", "d_under")]);
+        let st = fold_new_state(24);
+        fold_expand_all(m, st);
+        expect(fold_visible_set(m, st).has(K("devices", "d_under"))).toBe(false);
+        let m2 = fold_build_model(descs, recs, {loose_topics: ["controllers"]});
+        fold_expand_all(m2, st);
+        expect(fold_visible_set(m2, st).has(K("devices", "d_under"))).toBe(true);
+    });
+
+    test("a hidden topic leaves the model whole: no node, no pill, no edge", () => {
+        let m = fold_build_model(descs, make_records(30), {hidden_topics: ["devices"]});
+        expect(m.topics).toEqual(["places", "controllers", "device_groups"]);
+        expect(m.totals.devices).toBe(30);
+        expect(m.nodes.get(K("places", "nave1")).hooks.devices).toBeUndefined();
+        expect(fold_pills_of(m, fold_new_state(24), K("places", "nave1")).map((p) => p.hook))
+            .toEqual(["controllers"]);
+        expect(m.hidden.has("devices")).toBe(true);
+    });
+
+    test("hiding a topic in the middle: what hung from it alone becomes loose", () => {
+        let m = fold_build_model(descs, make_records(12), {hidden_topics: ["controllers"]});
+        /*  d0..d9 hang from nave1 AND c1: still under nave1  */
+        expect(m.nodes.get(K("devices", "d0")).parents.length).toBe(1);
+        expect(m.loose.devices).toEqual([]);
+        /*  places hidden = the main topic gone: nothing governs, and
+         *  whatever has no parent left is a root -- c1, with d0 and d1
+         *  still hanging from it  */
+        let m2 = fold_build_model(descs, make_records(2), {hidden_topics: ["places"]});
+        expect(m2.main_topic).toBe("");
+        expect(m2.groups.get(fold_root_group_key("controllers"))).toEqual([K("controllers", "c1")]);
+        expect(m2.groups.get(fold_root_group_key("devices"))).toBeUndefined();
+        let m3 = fold_build_model(descs, {devices: [{id: "d9"}]}, {hidden_topics: ["places"]});
+        expect(m3.groups.get(fold_root_group_key("devices"))).toEqual([K("devices", "d9")]);
+    });
+
+    test("a topic shown again opens on its roots' first page: nobody folds the roots", () => {
+        let recs = make_records(3);
+        let st = fold_new_state(24);
+        let m = fold_build_model(descs, recs, {hidden_topics: ["device_groups"]});
+        fold_expand_to_depth(m, st, 2);
+        expect(fold_visible_set(m, st).has(K("device_groups", "g1"))).toBe(false);
+        let m2 = fold_build_model(descs, recs);
+        expect(fold_visible_set(m2, st).has(K("device_groups", "g1"))).toBe(true);
+        expect(fold_pending_groups(m2, st, fold_visible_set(m2, st))).toEqual([]);
+    });
+
+    test("the fold state survives a hide and a show", () => {
+        let recs = make_records(30);
+        let st = fold_new_state(24);
+        let m = fold_build_model(descs, recs);
+        fold_expand_to_depth(m, st, 4);
+        let g = fold_group_key(K("places", "nave1"), "devices");
+        expect(fold_group_shown(m, st, g)).toBe(24);
+        let m_hidden = fold_build_model(descs, recs, {hidden_topics: ["devices"]});
+        expect(fold_group_shown(m_hidden, st, g)).toBe(0);      /*  no group: nothing shown  */
+        let m_back = fold_build_model(descs, recs);
+        expect(fold_group_shown(m_back, st, g)).toBe(24);       /*  remembered  */
+    });
+});
+
 describe("depth", () => {
     test("depth 1 is the roots alone", () => {
         let m = fold_build_model(descs, make_records(30));