@yuneta/gobj-ui 7.23.141 → 7.23.143

package/src/c_yui_treedb_graph.js

@@ -111,7 +111,7 @@ SDATA(data_type_t.DTP_LIST,     "operation_modes",  0,
 '["reading", "operation", "writing", "edition"]',
 "Available **permission** or behaviour modes. These operation modes are required to be accomplish by the graph handler (G6 child). TODO permissions must match treedb permissions."),
 SDATA(data_type_t.DTP_BOOLEAN,  "with_treedb_tables",0, false,  "Include treedb tables"),
-SDATA(data_type_t.DTP_INTEGER,  "expand_depth",     0,  2,      "Levels of the treedb open when it loads: 1 = the roots alone, 2 = the roots and their children. Forwarded to the G6 child"),
+SDATA(data_type_t.DTP_INTEGER,  "expand_depth",     0,  1,      "Levels of the treedb open when it loads, until the reader steps (`fold_level`): 1 = the roots alone (the default), 2 = the roots and their children. Forwarded to the G6 child"),
 SDATA(data_type_t.DTP_INTEGER,  "fold_page_size",   0,  24,     "Children of one hook shown per page in the graph; a `+N` chip opens the next page. Forwarded to the G6 child"),
 
 /*---------------- Forwarded to the G6 child (its own defaults) ----------------*/
@@ -2699,6 +2699,11 @@ function refresh_legend(gobj)
         return String(a.topic).localeCompare(String(b.topic));
     });
 
+    /*  Only a topic hooked to ITSELF can be the main one, so only those
+     *  offer the star -- and only when there is more than one to pick
+     *  from: with a single hierarchical topic the choice is made.  */
+    let hierarchical_count = topics.filter((e) => e.hierarchical && !e.hidden).length;
+
     for(let entry of topics) {
         let topic_name = entry.topic;
         let is_main = (topic_name === state.main_topic);
@@ -2813,7 +2818,7 @@ function refresh_legend(gobj)
                                   style: 'padding:0 .5rem; cursor:default;',
                                   title: t('main topic'), 'data-i18n-title': 'main topic'},
                          [['span', {style: LEGEND_STAR_MAIN_STYLE}, '★']]]);
-        } else if(!hidden) {
+        } else if(!hidden && entry.hierarchical && hierarchical_count > 1) {
             extras.push(['button', {class: 'GRAPH_LEGEND_STAR button',
                                     type: 'button', style: 'padding:0 .5rem;',
                                     title: t('main topic'), 'data-i18n-title': 'main topic',

package/src/c_yui_treedb_topic_with_form.js

@@ -1522,6 +1522,20 @@ function create_tabulator(gobj)
      *  had once opened the table. Only a real change is written.  */
     gobj.priv._page_size = tabulator_settings.paginationSize;
 
+    /*  Normalized records are read by their KEY: a topic table opens
+     *  sorted by `id` (the pkey), ascending and natural (`d2` before
+     *  `d10`) -- unless the app set its own order, or the table pages
+     *  from the backend, where a sort in the browser would reorder one
+     *  page and say nothing about the others.  */
+    let pkey_col = columns.find((c) => c && c.field === pkey);
+    if(pkey_col && !tabulator_settings.initialSort &&
+            !gobj_read_bool_attr(gobj, "with_remote_paging")) {
+        if(!pkey_col.sorter) {
+            pkey_col.sorter = "alphanum";
+        }
+        tabulator_settings.initialSort = [{column: pkey, dir: "asc"}];
+    }
+
     Object.assign(tabulator_settings, {
         index: pkey,
         columns: columns,

package/src/schema_import.js

@@ -38,7 +38,8 @@ import {
  *  the fkey, `order`) is composed, and `_geometry` belongs to whoever
  *  laid the graph out — an import must not move their boxes.  */
 const TOPIC_FIELDS = [
-    "pkey", "pkey2s", "system_flag", "tkey", "topic_version", "system_topic"
+    "pkey", "pkey2s", "system_flag", "tkey", "topic_version", "system_topic",
+    "main_topic"
 ];
 
 /*  Same for a `cols` record.  */

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  */
     }
@@ -355,34 +361,60 @@ function count_levels(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.
+ *  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;

package/src/treedb_fold_model.test.js

@@ -31,11 +31,12 @@ import {
     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"}},
@@ -56,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",
@@ -189,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"}}]};
@@ -201,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", () => {

package/src/yui_json_pad.js

@@ -0,0 +1,109 @@
+/***********************************************************************
+ *          yui_json_pad.js
+ *
+ *          JSON viewer -- a blank C_YUI_JSON_PAD in a floating window,
+ *          to paste JSON from outside and read it with the library's own
+ *          viewer.  Peer of the frontend view (yui_frontend_view.js), and
+ *          opened the same way: an entry of the account menu.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {
+    createElement2,
+    gclass_find_by_name,
+    gobj_create_service,
+    gobj_create_pure_child,
+    gobj_find_service,
+    gobj_read_attr,
+    gobj_start_tree,
+    log_error,
+} from "@yuneta/gobj-js";
+
+import {register_c_yui_json_pad} from "./c_yui_json_pad.js";
+
+/*  Service name of the window. The host toggles the entry by looking
+ *  it up, exactly as it does with "Frontend-View-Window". */
+const WIN_NAME = "Json-Viewer-Window";
+
+
+                    /******************************
+                     *      Public API
+                     ******************************/
+
+
+/************************************************************
+ *  Open a blank JSON pad (C_YUI_JSON_PAD) inside a non-modal
+ *  C_YUI_WINDOW, the same shape as the frontend view.
+ *
+ *  Self-contained: it registers C_YUI_JSON_PAD (and the
+ *  C_YUI_JSON it hosts) if the app did not, so an app gets the
+ *  viewer with one menu entry and one action.
+ *
+ *  Returns the window gobj, or null.
+ ************************************************************/
+function setup_json_pad(self)
+{
+    if(gobj_find_service(WIN_NAME, false)) {
+        return null;
+    }
+    if(!gclass_find_by_name("C_YUI_JSON_PAD", false)) {
+        register_c_yui_json_pad();
+    }
+
+    /*  The pad is created AFTER the window, as a pure child of it, so
+     *  every teardown path (the ✕, or the host destroying the window to
+     *  toggle the entry off) takes the pad down with it -- which is why
+     *  the body is a placeholder: C_YUI_WINDOW builds its UI in
+     *  mt_create, before the pad exists. */
+    let $body = createElement2(
+        ["div", {class: "YJSONPAD_BODY",
+            style: "height:100%; display:flex; flex-direction:column;"}, []]
+    );
+
+    let win = gobj_create_service(
+        WIN_NAME,
+        "C_YUI_WINDOW",
+        {
+            $parent: (typeof document !== "undefined" &&
+                document.getElementById("top-layer")) || null,
+            subscriber: null,
+            modal: false,
+            showMax: true,
+            showFooter: false,
+            resizable: true,
+            center: false,
+            auto_save_size_and_position: true,
+            width: 900,
+            height: 640,
+            logical_class: "JSON_VIEWER_WINDOW",
+            title: "json viewer",
+            icon: "yi-code",
+            body: $body,
+            /*  `|| null`: an undefined attr value logs "attr undefined:
+             *  manager" in an app without a window manager.  */
+            manager: gobj_find_service("__window_manager__", false) || null,
+        },
+        self
+    );
+    if(!win) {
+        log_error("yui_json_pad: cannot create the json-viewer window");
+        return null;
+    }
+
+    /*  The window is mounted by its mt_create, so $body is live DOM here:
+     *  the viewer's graph measures its canvas when it is first shown.  */
+    let pad = gobj_create_pure_child("json_pad", "C_YUI_JSON_PAD", {}, win);
+    let $pad = pad? gobj_read_attr(pad, "$container") : null;
+    if(!$pad) {
+        log_error("yui_json_pad: C_YUI_JSON_PAD without $container");
+        return win;
+    }
+    $body.appendChild($pad);
+
+    gobj_start_tree(win);
+
+    return win;
+}
+
+export {setup_json_pad};