@yuneta/gobj-ui 7.23.140 → 7.23.142

package/src/schema_model.js

@@ -183,7 +183,7 @@ function sort_by_order(list)
  *              schema_version, c_schema_version, system_schema_version,
  *              topics: [{
  *                  id, name, order, record,
- *                  pkey, topic_version, system_topic,
+ *                  pkey, topic_version, system_topic, main_topic,
  *                  cols: [{id, name, order, record}]
  *              }]
  *          }],
@@ -239,6 +239,7 @@ function build_schema_model(records)
             tkey:          record.tkey || "",
             topic_version: record.topic_version,
             system_topic:  !!record.system_topic,
+            main_topic:    !!record.main_topic,
             cols:          []
         };
         by_topic_id[entry.id] = entry;

package/src/schema_to_c.js

@@ -47,7 +47,7 @@ const DEFAULT_PAD = 68;
  *  and every export diffs against the last one.  */
 const TOPIC_KEY_ORDER = [
     "id", "pkey", "pkey2s", "system_flag", "tkey",
-    "topic_version", "system_topic"
+    "topic_version", "system_topic", "main_topic"
 ];
 
 /*  Same for a column, in the order the .c literals write it.  */

package/src/schema_validate.js

@@ -189,6 +189,26 @@ function validate_schema(treedb, options)
         }
     }
 
+    /*  The topic the tree hangs from (`main_topic`): ONE per treedb, and
+     *  only a topic hooked to itself. treedb_open_db logs either mistake
+     *  and ignores the mark, so the restart succeeds and the graph goes
+     *  on deducing -- better said here, before it.  */
+    let marked = treedb.topics.filter((topic) => topic.main_topic);
+    if(marked.length > 1) {
+        add("error", "more than one main topic", marked[1].name, "",
+            marked.map((topic) => topic.name).join(", "));
+    }
+    for(let topic of marked) {
+        let hooks_itself = topic.cols.some((col) => {
+            let hook = col_hook(col.record);
+            return col_flags(col.record).indexOf("hook") >= 0 &&
+                   !!hook && Object.prototype.hasOwnProperty.call(hook, topic.name);
+        });
+        if(!hooks_itself) {
+            add("error", "main topic not hooked to itself", topic.name, "", "");
+        }
+    }
+
     /*  How many hooks name each fkey column. Both answers are a
      *  finding: NONE and the parent side of the link was renamed or
      *  deleted, so the references are written by nobody; TWO and the

package/src/schema_validate.test.js

@@ -94,6 +94,50 @@ describe("the topic will not open", () => {
     });
 });
 
+describe("the main topic mark", () => {
+    /*  departments hooked to itself: the one topic the mark can go on  */
+    const self_hook = {
+        id: "db.departments.departments", value: "departments", order: 3,
+        type: "dict", flag: ["hook"], hook: {departments: "departments"},
+        topics: ["topics^db.departments^cols"]
+    };
+
+    test("on a topic hooked to itself, says nothing", () => {
+        const t = schema({extra_col: self_hook});
+        t.topics[0].main_topic = true;
+        const c = codes(validate_schema(t));
+        expect(c).not.toContain("main topic not hooked to itself");
+        expect(c).not.toContain("more than one main topic");
+    });
+
+    test("on a topic that is not hooked to itself", () => {
+        const t = schema();
+        t.topics[1].main_topic = true;
+        const f = validate_schema(t);
+        expect(codes(f)).toContain("main topic not hooked to itself");
+        expect(has_errors(f)).toBe(true);
+    });
+
+    test("on two topics", () => {
+        const t = schema({extra_col: self_hook});
+        t.topics[0].main_topic = true;
+        t.topics[1].main_topic = true;
+        const f = validate_schema(t);
+        expect(codes(f)).toContain("more than one main topic");
+        expect(f.find((x) => x.code === "more than one main topic").detail)
+            .toBe("departments, users");
+    });
+
+    test("the model reads the mark from the record", () => {
+        const model = build_schema_model({
+            treedbs: [{id: "db"}],
+            topics:  [{id: "db.a", value: "a", main_topic: true, treedbs: ["treedbs^db^topics"]}],
+            cols:    [],
+        });
+        expect(model.treedbs[0].topics[0].main_topic).toBe(true);
+    });
+});
+
 describe("the link does nothing, and the write succeeded", () => {
     test("a hook with no mapping", () => {
         expect(codes(validate_schema(schema({hook: null})))).toContain("hook has no mapping");

package/src/treedb_fold_model.js

@@ -152,7 +152,13 @@ export function fold_build_model(descs, records, opts)
 
     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);
+    let main_topic = opts.main_topic || "";
+    if(main_topic && !fold_is_hierarchical(descs, main_topic)) {
+        main_topic = "";    /*  a pick the rule does not allow (see fold_main_topic): deduce  */
+    }
+    if(!main_topic) {
+        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  */
     }
@@ -281,7 +287,7 @@ export function fold_build_model(descs, records, opts)
         }
     }
 
-    return {
+    let model = {
         nodes: nodes,
         groups: groups,
         topics: topics,
@@ -291,38 +297,124 @@ export function fold_build_model(descs, records, opts)
         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,
+        level_of: null,         /*  Map<node_key, level> of the MAIN tree, see below  */
+        levels: 0,              /*  its deepest level (0 = no tree to step through)  */
     };
+    count_levels(model);
+    return model;
 }
 
 /************************************************************
- *  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.
+ *  The LEVELS of the main tree: the roots of the main topic --
+ *  and of the topics hung from it, whose roots are the loose
+ *  records the reader asked for -- are level 1, their children
+ *  level 2, and so on down every hook of every topic that is not
+ *  hidden. A node reached by two paths takes the shallowest.
+ *
+ *  With no main topic every topic is a tree of its own and all
+ *  of them count. A topic the schema does not tie to the main
+ *  one is a separate tree, and has no level: the stepper of the
+ *  toolbar speaks for the main tree and nothing else, those
+ *  trees are opened by their own pills.
+ ************************************************************/
+function count_levels(model)
+{
+    let level_of = new Map();
+    let queue = [];
+    let deepest = 0;
+
+    for(let topic_name of model.topics) {
+        if(model.main_topic && !model.linked.has(topic_name)) {
+            continue;
+        }
+        let roots = model.groups.get(fold_root_group_key(topic_name)) || [];
+        for(let key of roots) {
+            if(!level_of.has(key)) {
+                level_of.set(key, 1);
+                queue.push(key);
+            }
+        }
+    }
+    let head = 0;
+    while(head < queue.length) {
+        let key = queue[head++];
+        let lv = level_of.get(key);
+        if(lv > deepest) {
+            deepest = lv;
+        }
+        let node = model.nodes.get(key);
+        if(!node) {
+            continue;
+        }
+        for(let hook of Object.keys(node.hooks)) {
+            for(let child of node.hooks[hook]) {
+                if(!level_of.has(child)) {
+                    level_of.set(child, lv + 1);
+                    queue.push(child);
+                }
+            }
+        }
+    }
+
+    model.level_of = level_of;
+    model.levels = deepest;
+}
+
+/************************************************************
+ *  A HIERARCHICAL topic: one hooked to ITSELF -- places inside
+ *  places, groups inside groups, roles inside roles. It is the
+ *  only kind of topic a tree can hang from: a topic that only
+ *  reaches OTHER topics is a list with children, and making it
+ *  the trunk drew the agent's treedb from `yunos` instead of
+ *  `realms`.
+ *
+ *  (Not the engine's `entity` tier, which is any topic with
+ *  hooks AND fkeys: that one sizes a card and says nothing about
+ *  where a tree starts.)
+ ************************************************************/
+export function fold_is_hierarchical(descs, topic_name)
+{
+    if(!is_object(descs) || !descs[topic_name]) {
+        return false;
+    }
+    return hook_targets(descs, topic_name).has(topic_name);
+}
+
+/************************************************************
+ *  The topic the tree hangs from. Only a HIERARCHICAL topic can
+ *  be it, and in this order:
+ *
+ *      the one the schema MARKS (`main_topic: true` on the topic,
+ *      sent by the backend in its desc since SDK 7.19; the first
+ *      one in schema order if a schema marks two);
+ *      else the one whose hooks reach the most OTHER topics,
+ *      schema order breaking a tie.
+ *
+ *  "" when no topic is hooked to itself: there is no trunk, and
+ *  every topic is a tree of its own. (A pick by the reader comes
+ *  first of all, and is fold_build_model's business.)
  ************************************************************/
 export function fold_main_topic(descs)
 {
     descs = is_object(descs)? descs : {};
-    let best = "";
-    let best_score = 0;
-    let best_self = false;
+    let candidates = Object.keys(descs).filter((topic_name) => {
+        return topic_name.substring(0, 2) !== "__" && fold_is_hierarchical(descs, topic_name);
+    });
 
-    for(let topic_name of Object.keys(descs)) {
-        if(topic_name.substring(0, 2) === "__") {
-            continue;
+    for(let topic_name of candidates) {
+        if(descs[topic_name].main_topic === true) {
+            return topic_name;
         }
+    }
+
+    let best = "";
+    let best_score = -1;
+    for(let topic_name of candidates) {
         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)) {
+        if(reach.size > best_score) {
             best = topic_name;
-            best_score = score;
-            best_self = self;
+            best_score = reach.size;
         }
     }
     return best;
@@ -565,6 +657,78 @@ export function fold_expand_to_depth(model, state, depth)
     }
 }
 
+/************************************************************
+ *  The toolbar's STEPPER over the levels of the main tree (see
+ *  count_levels): level N shows the roots and N-1 levels under
+ *  them. A level is a floor of what is open, not a picture that
+ *  replaces it:
+ *
+ *      opening to N   opens, on its first page, every hook of
+ *                     every node above level N that is folded;
+ *                     what the reader opened, and every page
+ *                     already shown, stays
+ *      closing to N   folds every hook of every node at level N
+ *                     or below, and touches nothing above it
+ *
+ *  A separate tree (a topic not tied to the main one) has no
+ *  level, so neither ever touches it.
+ ************************************************************/
+export function fold_level_clamp(model, level)
+{
+    let top = (model.levels > 0)? model.levels : 1;
+    level = Math.floor(Number(level)) || 1;
+    if(level < 1) {
+        return 1;
+    }
+    if(level > top) {
+        return top;
+    }
+    return level;
+}
+
+export function fold_open_levels(model, state, level)
+{
+    for(let [key, lv] of model.level_of) {
+        if(lv >= level) {
+            continue;
+        }
+        let node = model.nodes.get(key);
+        if(!node) {
+            continue;
+        }
+        for(let hook of Object.keys(node.hooks)) {
+            let group_key = fold_group_key(key, hook);
+            if(node.hooks[hook].length > 0 && !fold_is_open(state, group_key)) {
+                state.shown.set(group_key, state.page_size);
+            }
+        }
+    }
+}
+
+export function fold_close_levels(model, state, level)
+{
+    for(let [key, lv] of model.level_of) {
+        if(lv < level) {
+            continue;
+        }
+        let node = model.nodes.get(key);
+        if(!node) {
+            continue;
+        }
+        for(let hook of Object.keys(node.hooks)) {
+            state.shown.delete(fold_group_key(key, hook));
+        }
+    }
+}
+
+/*  From scratch: the roots of every tree on their first page, and
+ *  the main tree open down to `level`. What a load opens.  */
+export function fold_expand_to_level(model, state, level)
+{
+    fold_collapse_all(model, state);
+    fold_open_levels(model, state, fold_level_clamp(model, level));
+}
+
 /************************************************************
  *  The set of node keys on screen, from the roots down through
  *  every open group -- and only through open groups whose parent

package/src/treedb_fold_model.test.js

@@ -26,11 +26,17 @@ import {
     fold_split_group_key,
     fold_main_topic,
     fold_group_shown,
+    fold_is_open,
+    fold_level_clamp,
+    fold_open_levels,
+    fold_close_levels,
+    fold_expand_to_level,
+    fold_is_hierarchical,
 } from "./treedb_fold_model.js";
 
 const places_desc = {
     topic_name: "places",
-    node_treedb_type: "hierarchical",
+    node_treedb_type: "entity",
     cols: [
         {id: "id", flag: []},
         {id: "place", flag: ["fkey"], fkey: {places: "places"}},
@@ -51,13 +57,20 @@ const devices_desc = {
 };
 const controllers_desc = {
     topic_name: "controllers",
-    node_treedb_type: "hierarchical",
+    node_treedb_type: "entity",
     cols: [
         {id: "id", flag: []},
         {id: "place", flag: ["fkey"], fkey: {places: "controllers"}},
         {id: "devices", flag: ["hook"], hook: {devices: "controller"}},
     ],
 };
+/*  controllers inside controllers: a second HIERARCHICAL topic  */
+const controllers_self = Object.assign({}, controllers_desc, {
+    cols: controllers_desc.cols.concat([
+        {id: "controllers", flag: ["hook"], hook: {controllers: "parent"}},
+        {id: "parent", flag: ["fkey"], fkey: {controllers: "controllers"}},
+    ]),
+});
 const groups_desc = {
     topic_name: "device_groups",
     node_treedb_type: "extended",
@@ -184,10 +197,33 @@ describe("main topic, hidden topics, loose records", () => {
         expect(m.linked.has("device_groups")).toBe(false);
     });
 
+    test("only a topic hooked to ITSELF can be the main one", () => {
+        expect(fold_is_hierarchical(descs, "places")).toBe(true);
+        expect(fold_is_hierarchical(descs, "controllers")).toBe(false);
+        expect(fold_is_hierarchical(descs, "device_groups")).toBe(false);
+        /*  c reaches x and nothing reaches itself: no trunk at all  */
+        let c = {topic_name: "c", cols: [{id: "id", flag: []},
+                 {id: "xs", flag: ["hook"], hook: {x: "c"}}]};
+        let x = {topic_name: "x", cols: [{id: "id", flag: []}, {id: "c", flag: ["fkey"]}]};
+        expect(fold_main_topic({c: c, x: x})).toBe("");
+        /*  a tree of places alone, reaching no other topic, is still a trunk  */
+        expect(fold_main_topic({places: places_desc})).toBe("places");
+    });
+
+    test("the schema's mark wins over the deduction, among hierarchical topics", () => {
+        let d = Object.assign({}, descs, {controllers: controllers_self});
+        expect(fold_main_topic(d)).toBe("places");  /*  places reaches more  */
+        let marked = Object.assign({}, d, {controllers: Object.assign({}, controllers_self, {main_topic: true})});
+        expect(fold_main_topic(marked)).toBe("controllers");
+        /*  a mark on a topic that is not hierarchical is not a trunk  */
+        let wrong = Object.assign({}, descs, {devices: Object.assign({}, devices_desc, {main_topic: true})});
+        expect(fold_main_topic(wrong)).toBe("places");
+    });
+
     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",
+        let b = {topic_name: "b", node_treedb_type: "entity",
                  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"}}]};
@@ -196,12 +232,16 @@ describe("main topic, hidden topics, loose records", () => {
         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"});
+    test("the reader's pick wins -- if it is a hierarchical topic", () => {
+        let d = Object.assign({}, descs, {controllers: controllers_self});
+        let m = fold_build_model(d, 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")]);
+        /*  a pick the rule refuses is ignored, and the trunk is deduced  */
+        let m2 = fold_build_model(descs, make_records(3), {main_topic: "controllers"});
+        expect(m2.main_topic).toBe("places");
     });
 
     test("a device with no place is LOOSE: counted, not a root, unless asked for", () => {
@@ -323,6 +363,81 @@ describe("depth", () => {
     });
 });
 
+describe("levels of the main tree (the toolbar's stepper)", () => {
+    test("levels count from the main topic's roots, down every hook", () => {
+        let m = fold_build_model(descs, make_records(30));
+        /*  es 1, norte/sur 2, nave1 3, its devices and c1 4  */
+        expect(m.levels).toBe(4);
+        expect(m.level_of.get(K("places", "es"))).toBe(1);
+        expect(m.level_of.get(K("places", "nave1"))).toBe(3);
+        /*  d0 hangs from nave1 (3) and c1 (4): the shallowest wins  */
+        expect(m.level_of.get(K("devices", "d0"))).toBe(4);
+        /*  device_groups is not tied to places: a tree of its own, no level  */
+        expect(m.level_of.has(K("device_groups", "g1"))).toBe(false);
+    });
+
+    test("a hidden topic takes its levels with it", () => {
+        let m = fold_build_model(descs, make_records(30), {hidden_topics: ["devices", "controllers"]});
+        expect(m.levels).toBe(3);
+        let m0 = fold_build_model({}, {});
+        expect(m0.levels).toBe(0);
+        expect(fold_level_clamp(m0, 5)).toBe(1);
+    });
+
+    test("clamp keeps a level between 1 and the deepest one", () => {
+        let m = fold_build_model(descs, make_records(3));
+        expect(fold_level_clamp(m, 0)).toBe(1);
+        expect(fold_level_clamp(m, 3)).toBe(3);
+        expect(fold_level_clamp(m, 9)).toBe(4);
+        expect(fold_level_clamp(m, "2")).toBe(2);
+    });
+
+    test("level 1 is the roots of every tree, and each step opens one more", () => {
+        let m = fold_build_model(descs, make_records(30));
+        let st = fold_new_state(24);
+        fold_expand_to_level(m, st, 1);
+        expect([...fold_visible_set(m, st)].sort())
+            .toEqual([K("device_groups", "g1"), K("places", "es")]);
+        fold_open_levels(m, st, 2);
+        let v = fold_visible_set(m, st);
+        expect(v.has(K("places", "norte"))).toBe(true);
+        expect(v.has(K("places", "nave1"))).toBe(false);
+        fold_open_levels(m, st, 3);
+        expect(fold_visible_set(m, st).has(K("places", "nave1"))).toBe(true);
+        expect(fold_visible_set(m, st).has(K("devices", "d0"))).toBe(false);
+        fold_open_levels(m, st, 4);
+        v = fold_visible_set(m, st);
+        expect(v.has(K("devices", "d23"))).toBe(true);
+        expect(v.has(K("devices", "d24"))).toBe(false);  /*  one page  */
+        expect(v.has(K("controllers", "c1"))).toBe(true);
+    });
+
+    test("opening keeps the pages already shown; closing folds only from its level down", () => {
+        let m = fold_build_model(descs, make_records(30));
+        let st = fold_new_state(24);
+        fold_expand_to_level(m, st, 4);
+        let g = fold_group_key(K("places", "nave1"), "devices");
+        fold_show_more(m, st, g);                           /*  30  */
+        fold_open_levels(m, st, 4);
+        expect(fold_group_shown(m, st, g)).toBe(30);
+        fold_close_levels(m, st, 3);
+        let v = fold_visible_set(m, st);
+        expect(v.has(K("places", "nave1"))).toBe(true);     /*  level 3 stays  */
+        expect(v.has(K("devices", "d0"))).toBe(false);      /*  its hooks folded  */
+        expect(v.has(K("controllers", "c1"))).toBe(false);
+        expect(fold_is_open(st, fold_group_key(K("places", "norte"), "places"))).toBe(true);
+    });
+
+    test("closing does not reopen what the reader folded above the level", () => {
+        let m = fold_build_model(descs, make_records(3));
+        let st = fold_new_state(24);
+        fold_expand_to_level(m, st, 4);
+        fold_toggle(m, st, fold_group_key(K("places", "es"), "places"));   /*  fold es  */
+        fold_close_levels(m, st, 3);
+        expect(fold_is_open(st, fold_group_key(K("places", "es"), "places"))).toBe(false);
+    });
+});
+
 describe("toggle and pages", () => {
     test("a folded group opens on its first page and closes again", () => {
         let m = fold_build_model(descs, make_records(30));