@yuneta/gobj-ui 7.23.70 → 7.23.72

package/dist/gobj-ui.cjs.js

@@ -6403,6 +6403,57 @@ function plan_toolbar(wanted) {
 	};
 }
 //#endregion
+//#region src/form_field_readonly.js
+/***********************************************************************
+*          form_field_readonly.js
+*
+*      Is this field of the form read-only?
+*
+*      Pure, so the rule can be tested without a DOM: the gclass turns
+*      the answer into `readonly`/`disabled` on a control, this decides
+*      the answer. Same split as form_toolbar_plan.js and
+*      treedb_write_plan.js.
+*
+*      The rule it exists to state ONCE: **`writable` governs the WRITE
+*      of a column's VALUE, and an fkey is not written — it is LINKED.**
+*      An fkey column is normally declared with no `writable` flag at
+*      all (`treedb_authzs`'s `users.roles` is `['fkey']`, and so is
+*      almost every fkey in the tree), so reading "not writable" as "not
+*      editable" takes away the only way to link a record to its parent
+*      — with `users.roles`, the only way to give a person a role.
+*
+*      The other half of this rule is already written down in
+*      c_yui_treedb_topic_with_form.js, where the record travels back:
+*      the form sends "the writable cols, the fkeys (a link is edited by
+*      linking) and the pkey". The two halves have to agree, and when
+*      they did not, the form disabled the control whose value the save
+*      path was still waiting for.
+*
+*      A `file` column is an fkey too (flagged `['fkey','file']`) and is
+*      NOT covered: it answers `type: "file"`, its bytes travel beside
+*      the record, and the SDK declares as legal a `file` column that
+*      only a load fills.
+*
+*          Copyright (c) 2026, ArtGins.
+*          All Rights Reserved.
+***********************************************************************/
+/***************************************************************
+*  field_is_readonly(form_readonly, field_desc) -> boolean
+*
+*      form_readonly   the FORM is read-only: a record opened to be
+*                      looked at, or a store nobody may write. It is
+*                      a property of the opening, not of the schema,
+*                      and it wins over everything.
+*      field_desc      as treedb_get_field_desc() answers it
+*                      (`type`, `is_writable`).
+***************************************************************/
+function field_is_readonly(form_readonly, field_desc) {
+	if (form_readonly) return true;
+	let desc = field_desc || {};
+	if (desc.type === "fkey") return false;
+	return !desc.is_writable;
+}
+//#endregion
 //#region src/yui_theme.js
 /***********************************************************************
 *          yui_theme.js
@@ -7215,7 +7266,7 @@ function build_form_field_conf(gobj, field_desc) {
 		placeholder: "",
 		options: [],
 		extras: {},
-		readonly: (0, _yuneta_gobj_js.gobj_read_bool_attr)(gobj, "readonly") || !field_desc.is_writable,
+		readonly: field_is_readonly((0, _yuneta_gobj_js.gobj_read_bool_attr)(gobj, "readonly"), field_desc),
 		required: field_desc.is_required,
 		hidden: field_desc.is_hidden,
 		default_value: field_desc.default_value
@@ -25919,6 +25970,7 @@ function ac_paste_rows(gobj, event, kw, src) {
 *  fkeys, times and numbers). Route by the form's mode.
 ************************************************************/
 function ac_form_save_record(gobj, event, kw, src) {
+	let priv = gobj.priv;
 	if (refuse_if_readonly$2(gobj, event)) return -1;
 	let mode = (0, _yuneta_gobj_js.gobj_read_str_attr)(src, "form_mode");
 	if (priv.reading_files) {

package/dist/gobj-ui.es.js

@@ -6398,6 +6398,57 @@ function plan_toolbar(wanted) {
 	};
 }
 //#endregion
+//#region src/form_field_readonly.js
+/***********************************************************************
+*          form_field_readonly.js
+*
+*      Is this field of the form read-only?
+*
+*      Pure, so the rule can be tested without a DOM: the gclass turns
+*      the answer into `readonly`/`disabled` on a control, this decides
+*      the answer. Same split as form_toolbar_plan.js and
+*      treedb_write_plan.js.
+*
+*      The rule it exists to state ONCE: **`writable` governs the WRITE
+*      of a column's VALUE, and an fkey is not written — it is LINKED.**
+*      An fkey column is normally declared with no `writable` flag at
+*      all (`treedb_authzs`'s `users.roles` is `['fkey']`, and so is
+*      almost every fkey in the tree), so reading "not writable" as "not
+*      editable" takes away the only way to link a record to its parent
+*      — with `users.roles`, the only way to give a person a role.
+*
+*      The other half of this rule is already written down in
+*      c_yui_treedb_topic_with_form.js, where the record travels back:
+*      the form sends "the writable cols, the fkeys (a link is edited by
+*      linking) and the pkey". The two halves have to agree, and when
+*      they did not, the form disabled the control whose value the save
+*      path was still waiting for.
+*
+*      A `file` column is an fkey too (flagged `['fkey','file']`) and is
+*      NOT covered: it answers `type: "file"`, its bytes travel beside
+*      the record, and the SDK declares as legal a `file` column that
+*      only a load fills.
+*
+*          Copyright (c) 2026, ArtGins.
+*          All Rights Reserved.
+***********************************************************************/
+/***************************************************************
+*  field_is_readonly(form_readonly, field_desc) -> boolean
+*
+*      form_readonly   the FORM is read-only: a record opened to be
+*                      looked at, or a store nobody may write. It is
+*                      a property of the opening, not of the schema,
+*                      and it wins over everything.
+*      field_desc      as treedb_get_field_desc() answers it
+*                      (`type`, `is_writable`).
+***************************************************************/
+function field_is_readonly(form_readonly, field_desc) {
+	if (form_readonly) return true;
+	let desc = field_desc || {};
+	if (desc.type === "fkey") return false;
+	return !desc.is_writable;
+}
+//#endregion
 //#region src/yui_theme.js
 /***********************************************************************
 *          yui_theme.js
@@ -7210,7 +7261,7 @@ function build_form_field_conf(gobj, field_desc) {
 		placeholder: "",
 		options: [],
 		extras: {},
-		readonly: gobj_read_bool_attr(gobj, "readonly") || !field_desc.is_writable,
+		readonly: field_is_readonly(gobj_read_bool_attr(gobj, "readonly"), field_desc),
 		required: field_desc.is_required,
 		hidden: field_desc.is_hidden,
 		default_value: field_desc.default_value
@@ -25914,6 +25965,7 @@ function ac_paste_rows(gobj, event, kw, src) {
 *  fkeys, times and numbers). Route by the form's mode.
 ************************************************************/
 function ac_form_save_record(gobj, event, kw, src) {
+	let priv = gobj.priv;
 	if (refuse_if_readonly$2(gobj, event)) return -1;
 	let mode = gobj_read_str_attr(src, "form_mode");
 	if (priv.reading_files) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuneta/gobj-ui",
-  "version": "7.23.70",
+  "version": "7.23.72",
   "type": "module",
   "main": "dist/gobj-ui.cjs.js",
   "module": "dist/gobj-ui.es.js",

package/src/c_yui_form.js

@@ -65,6 +65,7 @@ import {
 import "./c_yui_form.css";
 import {attach_clear, refresh_clear} from "./yui_inputs.js";
 import {plan_toolbar, DEFAULT_TOOLBAR} from "./form_toolbar_plan.js";
+import {field_is_readonly} from "./form_field_readonly.js";
 /*  Read at field-build time only — deliberately NOT watched: the hosting
  *  dialog rebuilds the form on every open, and re-rendering a form under
  *  the user mid-edit would throw away what they typed. */
@@ -601,8 +602,13 @@ function build_form_field_conf(gobj, field_desc)
         extras: {},             // extra html input/textarea attributes
         /*  A form opened to LOOK at a record has no editable field, and
          *  that is a property of the opening, not of the schema: the same
-         *  col is writable when the same form is opened to edit.  */
-        readonly: gobj_read_bool_attr(gobj, "readonly") || !field_desc.is_writable,
+         *  col is writable when the same form is opened to edit.  And an
+         *  fkey is editable WITHOUT `writable`, because a link is not
+         *  written, it is linked -- the rule and its why live in
+         *  form_field_readonly.js.  */
+        readonly: field_is_readonly(
+            gobj_read_bool_attr(gobj, "readonly"), field_desc
+        ),
         required: field_desc.is_required,
         hidden: field_desc.is_hidden,
         default_value: field_desc.default_value,

package/src/c_yui_treedb_topic_with_form.js

@@ -3479,6 +3479,8 @@ function ac_paste_rows(gobj, event, kw, src)
  ************************************************************/
 function ac_form_save_record(gobj, event, kw, src)
 {
+    let priv = gobj.priv;
+
     if(refuse_if_readonly(gobj, event)) {
         return -1;      /*  Error already logged  */
     }

package/src/form_field_readonly.js

@@ -0,0 +1,61 @@
+/***********************************************************************
+ *          form_field_readonly.js
+ *
+ *      Is this field of the form read-only?
+ *
+ *      Pure, so the rule can be tested without a DOM: the gclass turns
+ *      the answer into `readonly`/`disabled` on a control, this decides
+ *      the answer. Same split as form_toolbar_plan.js and
+ *      treedb_write_plan.js.
+ *
+ *      The rule it exists to state ONCE: **`writable` governs the WRITE
+ *      of a column's VALUE, and an fkey is not written — it is LINKED.**
+ *      An fkey column is normally declared with no `writable` flag at
+ *      all (`treedb_authzs`'s `users.roles` is `['fkey']`, and so is
+ *      almost every fkey in the tree), so reading "not writable" as "not
+ *      editable" takes away the only way to link a record to its parent
+ *      — with `users.roles`, the only way to give a person a role.
+ *
+ *      The other half of this rule is already written down in
+ *      c_yui_treedb_topic_with_form.js, where the record travels back:
+ *      the form sends "the writable cols, the fkeys (a link is edited by
+ *      linking) and the pkey". The two halves have to agree, and when
+ *      they did not, the form disabled the control whose value the save
+ *      path was still waiting for.
+ *
+ *      A `file` column is an fkey too (flagged `['fkey','file']`) and is
+ *      NOT covered: it answers `type: "file"`, its bytes travel beside
+ *      the record, and the SDK declares as legal a `file` column that
+ *      only a load fills.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+
+
+/***************************************************************
+ *  field_is_readonly(form_readonly, field_desc) -> boolean
+ *
+ *      form_readonly   the FORM is read-only: a record opened to be
+ *                      looked at, or a store nobody may write. It is
+ *                      a property of the opening, not of the schema,
+ *                      and it wins over everything.
+ *      field_desc      as treedb_get_field_desc() answers it
+ *                      (`type`, `is_writable`).
+ ***************************************************************/
+function field_is_readonly(form_readonly, field_desc)
+{
+    if(form_readonly) {
+        return true;
+    }
+
+    let desc = field_desc || {};
+    if(desc.type === "fkey") {
+        return false;
+    }
+
+    return !desc.is_writable;
+}
+
+
+export {field_is_readonly};

package/src/form_field_readonly.test.js

@@ -0,0 +1,50 @@
+import {describe, it, expect} from "vitest";
+import {field_is_readonly} from "./form_field_readonly.js";
+
+describe("field_is_readonly", () => {
+
+    it("a form opened to LOOK has no editable field, fkey included", () => {
+        /*  A record opened to be read: the schema does not enter into it. */
+        expect(field_is_readonly(true, {type: "fkey", is_writable: false}))
+            .toBe(true);
+        expect(field_is_readonly(true, {type: "fkey", is_writable: true}))
+            .toBe(true);
+        expect(field_is_readonly(true, {type: "string", is_writable: true}))
+            .toBe(true);
+    });
+
+    it("an fkey is EDITABLE without `writable`: a link is edited by linking", () => {
+        /*  `treedb_authzs`'s `users.roles` is declared `['fkey']` and
+         *  nothing else -- as almost every fkey in the tree is. Reading
+         *  that as "not editable" left a user with no way to be given a
+         *  role, while the save path was still sending the column. */
+        expect(field_is_readonly(false, {type: "fkey", is_writable: false}))
+            .toBe(false);
+    });
+
+    it("a plain column still needs `writable`", () => {
+        expect(field_is_readonly(false, {type: "string", is_writable: false}))
+            .toBe(true);
+        expect(field_is_readonly(false, {type: "string", is_writable: true}))
+            .toBe(false);
+        expect(field_is_readonly(false, {type: "enum", is_writable: false}))
+            .toBe(true);
+    });
+
+    it("a `file` column is NOT covered by the fkey exemption", () => {
+        /*  It is an fkey (`['fkey','file']`) but answers `type: "file"`,
+         *  and the SDK declares as legal a `file` column that only a load
+         *  fills. */
+        expect(field_is_readonly(false, {type: "file", is_writable: false, is_file: true}))
+            .toBe(true);
+        expect(field_is_readonly(false, {type: "file", is_writable: true, is_file: true}))
+            .toBe(false);
+    });
+
+    it("no descriptor is read-only, not editable", () => {
+        /*  Nothing known about a field is not a reason to let it be
+         *  written. */
+        expect(field_is_readonly(false, undefined)).toBe(true);
+        expect(field_is_readonly(false, {})).toBe(true);
+    });
+});

package/src/priv_declared.test.js

@@ -0,0 +1,212 @@
+/***********************************************************************
+ *          priv_declared.test.js
+ *
+ *      Every function that reads `priv` must have declared it.
+ *
+ *      WHY THIS IS A TEST AND NOT A REVIEW HABIT: a missing
+ *      `let priv = gobj.priv;` is a ReferenceError that throws only
+ *      when its LINE runs, and the line that reads `priv` is usually
+ *      the first line of a path nobody walks every day. One shipped in
+ *      `ac_form_save_record()` (7.23.64, the "form is busy while it
+ *      reads the picked files" guard) and it meant that for three
+ *      releases NO record could be saved from a treedb form dialog, in
+ *      any consumer — the record travelled, the action threw before
+ *      writing it, and the dialog just stayed open.
+ *
+ *      The rule is the one every gclass of this repo already follows:
+ *      the function that uses `priv` opens with `let priv = gobj.priv;`,
+ *      or takes it as an argument, or is nested inside one that did.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, it, expect} from "vitest";
+import {readdirSync, readFileSync} from "node:fs";
+import {dirname, join} from "node:path";
+import {fileURLToPath} from "node:url";
+
+const SRC = dirname(fileURLToPath(import.meta.url));
+
+
+/***************************************************************
+ *  The source with its comments blanked out, line count kept.
+ *
+ *  A doc block that SHOWS the idiom (`priv.theme_observer = ...`)
+ *  is not a use of it, and every early version of this check
+ *  reported four of those before the one real bug.
+ ***************************************************************/
+function without_comments(src)
+{
+    let out = "";
+    let i = 0;
+    let state = "code";     /*  code | line | block | s | d | t  */
+
+    while(i < src.length) {
+        const c = src[i];
+        const d = src[i + 1];
+
+        if(state === "code") {
+            if(c === "/" && d === "/") {
+                state = "line";
+                i += 2;
+                continue;
+            }
+            if(c === "/" && d === "*") {
+                state = "block";
+                out += "  ";
+                i += 2;
+                continue;
+            }
+            if(c === "'") {
+                state = "s";
+            } else if(c === '"') {
+                state = "d";
+            } else if(c === "`") {
+                state = "t";
+            }
+            out += c;
+            i++;
+            continue;
+        }
+
+        if(state === "line") {
+            if(c === "\n") {
+                state = "code";
+                out += c;
+            }
+            i++;
+            continue;
+        }
+
+        if(state === "block") {
+            if(c === "*" && d === "/") {
+                state = "code";
+                out += "  ";
+                i += 2;
+                continue;
+            }
+            out += (c === "\n") ? "\n" : " ";
+            i++;
+            continue;
+        }
+
+        /*  Inside a string: it ends at its own quote, and a backslash
+         *  escapes whatever follows.  */
+        if(c === "\\") {
+            out += "  ";
+            i += 2;
+            continue;
+        }
+        if((state === "s" && c === "'") || (state === "d" && c === '"')
+                || (state === "t" && c === "`")) {
+            state = "code";
+        }
+        out += c;
+        i++;
+    }
+
+    return out;
+}
+
+
+/***************************************************************
+ *  Every top-level function of a file, as {name, line, params,
+ *  body}. A nested function belongs to the body of the one that
+ *  holds it, which is what lets it use the parent's `priv`.
+ ***************************************************************/
+function top_level_functions(src)
+{
+    const lines = src.split("\n");
+    const starts = [];
+    for(let i = 0; i < lines.length; i++) {
+        if(/^(?:async )?function\s+\w+/.test(lines[i])) {
+            starts.push(i);
+        }
+    }
+    starts.push(lines.length);
+
+    const out = [];
+    for(let k = 0; k < starts.length - 1; k++) {
+        const a = starts[k];
+        const m = /^(?:async )?function\s+(\w+)\s*\(([^)]*)/.exec(lines[a]);
+        if(!m) {
+            continue;
+        }
+        out.push({
+            name:   m[1],
+            line:   a + 1,
+            params: m[2],
+            body:   lines.slice(a, starts[k + 1]).join("\n"),
+        });
+    }
+    return out;
+}
+
+
+describe("every function that reads `priv` declares it", () => {
+
+    it("no bare `priv.` without `priv =` in the same function", () => {
+        const files = readdirSync(SRC)
+            .filter((f) => f.endsWith(".js") && !f.endsWith(".test.js"));
+        expect(files.length).toBeGreaterThan(10);
+
+        const offenders = [];
+        for(const f of files) {
+            const src = without_comments(readFileSync(join(SRC, f), "utf8"));
+            for(const fn of top_level_functions(src)) {
+                if(/(?<![.\w])priv(?![\w])/.test(fn.params)) {
+                    continue;   /*  it takes priv as an argument  */
+                }
+                const uses = /(?<![.\w])priv\s*\./.test(fn.body);
+                const declared = /(?<![.\w])priv\s*=[^=]/.test(fn.body);
+                if(uses && !declared) {
+                    offenders.push(`${f}:${fn.line} ${fn.name}()`);
+                }
+            }
+        }
+
+        expect(offenders).toEqual([]);
+    });
+
+    it("the checker sees a missing declaration", () => {
+        /*  The guard needs its own guard: a check that cannot fail is
+         *  a check nobody can trust.  */
+        const src = [
+            "function ac_broken(gobj, event, kw, src)",
+            "{",
+            "    if(priv.reading_files) {",
+            "        return -1;",
+            "    }",
+            "    return 0;",
+            "}",
+        ].join("\n");
+        const fns = top_level_functions(without_comments(src));
+        expect(fns.length).toBe(1);
+        expect(/(?<![.\w])priv\s*\./.test(fns[0].body)).toBe(true);
+        expect(/(?<![.\w])priv\s*=[^=]/.test(fns[0].body)).toBe(false);
+    });
+
+    it("a doc block that shows the idiom is not a use of it", () => {
+        const src = [
+            "/*  priv.theme_observer = yui_watch_theme(gobj);  */",
+            "function yui_is_dark()",
+            "{",
+            "    return yui_theme_now() === 'dark';",
+            "}",
+        ].join("\n");
+        const fns = top_level_functions(without_comments(src));
+        expect(fns.length).toBe(1);
+        expect(/(?<![.\w])priv\s*\./.test(fns[0].body)).toBe(false);
+    });
+
+    it("`gobj.priv.x` is not a bare `priv`", () => {
+        const src = [
+            "function reads_through_gobj(gobj)",
+            "{",
+            "    return gobj.priv.something;",
+            "}",
+        ].join("\n");
+        const fns = top_level_functions(without_comments(src));
+        expect(/(?<![.\w])priv\s*\./.test(fns[0].body)).toBe(false);
+    });
+});