@graview/core 0.1.10 → 0.1.14

package/dist/document/edit.js

@@ -3,6 +3,8 @@ import { ExprSyntaxError, parseExpr } from "./expr/parse.js";
 import { printExpr } from "./expr/print.js";
 import { error } from "./findings.js";
 import { coerce } from "./migrate.js";
+import { outsideRange, rangeWords } from "./range.js";
+import { farEnd } from "./far-end.js";
 import { ActSpec, EDGE_NAME, EdgeSpec, FIELD_NAME, FIELD_TYPES, FieldSpec, KindSpec, NAME, RuleSpec, } from "./schema.js";
 import { SHIPPED_LENSES, isShippedLens, SHIPPED_LENS_NAMES } from "../places.js";
 import { placeSlug } from "../views/types.js";
@@ -18,6 +20,7 @@ export const EDIT_OPS = [
     "rename-field",
     "retype-field",
     "set-options",
+    "set-range",
     "set-required",
     "set-default",
     "remove-field",
@@ -56,6 +59,7 @@ const SHAPES = {
     "rename-field": z.object({ op: z.literal("rename-field"), kind: kindName, field: fieldName, to: fieldName }).strict(),
     "retype-field": z.object({ op: z.literal("retype-field"), kind: kindName, field: fieldName, type: z.enum(FIELD_TYPES), options: z.array(z.string().min(1).max(80)).min(1).max(100).optional(), of: z.enum(["string", "number", "date"]).optional(), format: z.enum(["money", "percent", "duration"]).optional() }).strict(),
     "set-options": z.object({ op: z.literal("set-options"), kind: kindName, field: fieldName, add: z.array(z.string().min(1).max(80)).optional(), remove: z.array(z.string().min(1).max(80)).optional() }).strict(),
+    "set-range": z.object({ op: z.literal("set-range"), kind: kindName, field: fieldName, min: z.union([z.number(), z.null()]).optional(), max: z.union([z.number(), z.null()]).optional(), step: z.union([z.number().positive(), z.null()]).optional() }).strict(),
     "set-required": z.object({ op: z.literal("set-required"), kind: kindName, field: fieldName, required: z.boolean() }).strict(),
     "set-default": z.object({ op: z.literal("set-default"), kind: kindName, field: fieldName, default: z.unknown() }).strict(),
     "remove-field": z.object({ op: z.literal("remove-field"), kind: kindName, field: fieldName }).strict(),
@@ -66,7 +70,15 @@ const SHAPES = {
     "remove-act": z.object({ op: z.literal("remove-act"), act: actName }).strict(),
     "add-rule": z.object({ op: z.literal("add-rule"), rule: actName, replace: z.boolean().optional() }).passthrough(),
     "remove-rule": z.object({ op: z.literal("remove-rule"), rule: actName }).strict(),
-    "set-brand": z.object({ op: z.literal("set-brand"), accent: z.union([z.string(), z.null()]), name: z.string().min(1).max(60).optional() }).strict(),
+    "set-brand": z
+        .object({
+        op: z.literal("set-brand"),
+        accent: z.union([z.string(), z.null()]).optional(),
+        name: z.string().min(1).max(60).optional(),
+        currency: z.union([z.string(), z.null()]).optional(),
+        locale: z.union([z.string(), z.null()]).optional(),
+    })
+        .strict(),
     "set-label": z.object({ op: z.literal("set-label"), kind: kindName, field: fieldName.optional(), label: z.union([z.string().min(1).max(300), z.null()]) }).strict(),
     "set-describe": z.object({ op: z.literal("set-describe"), kind: kindName, describe: z.union([z.string().min(1).max(300), z.null()]) }).strict(),
     // A kind's slot; the front page (`slot: "home"`, no kind); or a blocks lens's blocks, by its title (FR-84).
@@ -148,6 +160,12 @@ function kindsOf(doc, e, ctx) {
             return kindsOf(doc, e.set, ctx);
         case "call": {
             const lit = e.args[0]?.t === "lit" && typeof e.args[0].value === "string" ? e.args[0].value : undefined;
+            // A walk from every member of a set (FR-101): its relation is its second word.
+            const walked = e.args.length === 2 && e.args[1]?.t === "lit" && typeof e.args[1].value === "string" ? e.args[1].value : undefined;
+            if (e.fn === "out" && walked)
+                return targets(doc, kindsOf(doc, e.args[0], ctx), walked);
+            if (e.fn === "in" && walked)
+                return sources(doc, walked);
             if (e.fn === "out" && lit)
                 return targets(doc, "*", lit);
             if (e.fn === "in" && lit)
@@ -212,6 +230,12 @@ function mapNames(doc, e, ctx, rename) {
                     const name = rename({ role: x.fn === "all" ? "kind" : "edge", kinds: NONE, name: literal });
                     args = name === literal ? [...x.args] : [{ ...first, value: name }];
                 }
+                else if ((x.fn === "out" || x.fn === "in") && x.args.length === 2 && x.args[1].t === "lit" && typeof x.args[1].value === "string") {
+                    // out(S, 'edge'): the set is read where the walk stands, and its relation renamed like any walk's (FR-101).
+                    const relation = x.args[1];
+                    const name = rename({ role: "edge", kinds: NONE, name: relation.value });
+                    args = [go(first, at), name === relation.value ? relation : { ...relation, value: name }];
+                }
                 else if (((x.fn === "every" || x.fn === "some") && x.args.length === 2) || (x.fn === "sort" && x.args.length >= 2)) {
                     // Read once per member, with the member as its subject: its names are the members'.
                     args = [go(x.args[0], at), go(x.args[1], kindsOf(doc, x.args[0], at)), ...x.args.slice(2).map((a) => go(a, at))];
@@ -341,8 +365,8 @@ function proseSwap(from, to) {
 }
 // ── what an act touches ──────────────────────────────────────────────────────
 const subjectKinds = (act) => (act.on ? new Set(asArray(act.on)) : NONE);
-/** The kinds each `set` in an act writes to: its subject, a record it made, or (for a `$ref` target) any kind. */
-function setTargets(act) {
+/** The kinds each `set` in an act writes to: its subject, a record it made, the other end of what it connects (FR-115), or (for a `$ref` target) any kind. */
+function setTargets(act, doc) {
     const out = [];
     const made = new Map();
     if (act.creates)
@@ -353,6 +377,11 @@ function setTargets(act) {
     });
     if (act.sets)
         out.push({ set: act.sets, kinds: subjectKinds(act), where: "sets" });
+    if (act.setsOther) {
+        const relation = act.connects ?? act.severs;
+        const end = doc && relation ? farEnd(doc.kinds, relation, asArray(act.on)) : undefined;
+        out.push({ set: act.setsOther, kinds: end && end.kinds !== "*" ? new Set(end.kinds) : "*", where: "setsOther" });
+    }
     (act.effects ?? []).forEach((e, index) => {
         if (e.create)
             out.push({ set: e.set ?? {}, kinds: new Set([e.create]), where: "create", index });
@@ -449,6 +478,8 @@ class Editor {
                 return this.retypeField(i, e);
             case "set-options":
                 return this.setOptions(i, e);
+            case "set-range":
+                return this.setRange(i, e);
             case "set-required": {
                 const f = this.field(i, e.kind, e.field);
                 if (!f)
@@ -471,6 +502,9 @@ class Editor {
                 else {
                     if (f.type === "enum" && !(f.options ?? []).includes(e.default))
                         return this.fail(i, "default", `"${String(e.default)}" is not one of ${e.field}'s options (${(f.options ?? []).join(", ")})`);
+                    const outside = outsideRange(e.default, f, e.field);
+                    if (outside)
+                        return this.fail(i, "default", outside);
                     f.default = e.default;
                     this.said.push(`${e.kind}'s ${e.field} starts as ${JSON.stringify(e.default)} on new records.`);
                 }
@@ -499,16 +533,45 @@ class Editor {
                 return;
             }
             case "set-brand": {
+                // The colours and the money (FR-100) are set apart: what an edit does not name stays as it was.
+                const brand = { ...(this.doc.brand ?? {}) };
                 if (e.accent === null) {
-                    delete this.doc.brand;
+                    delete brand["accent"];
                     this.said.push("The app goes back to Graview's colours.");
                 }
-                else {
+                else if (e.accent !== undefined) {
                     if (!/^#[0-9a-fA-F]{6}$/.test(e.accent))
                         return this.fail(i, "accent", 'an accent is a colour like "#c2577a"');
-                    this.doc.brand = { accent: e.accent, ...(e.name ? { name: e.name } : this.doc.brand?.name ? { name: this.doc.brand.name } : {}) };
+                    brand["accent"] = e.accent;
                     this.said.push(`The app's accent colour becomes ${e.accent}.`);
                 }
+                if (e.currency === null) {
+                    delete brand["currency"];
+                    this.said.push("Money is said with no currency.");
+                }
+                else if (e.currency !== undefined) {
+                    if (!/^[A-Z]{3}$/.test(e.currency))
+                        return this.fail(i, "currency", 'a currency is its three-letter code, like "USD" or "EUR"');
+                    brand["currency"] = e.currency;
+                    this.said.push(`Money is said in ${e.currency}.`);
+                }
+                if (e.locale === null)
+                    delete brand["locale"];
+                else if (e.locale !== undefined) {
+                    if (!/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/.test(e.locale))
+                        return this.fail(i, "locale", 'a locale is a language tag, like "en-US" or "de-DE"');
+                    brand["locale"] = e.locale;
+                    this.said.push(`Money is written for ${e.locale}.`);
+                }
+                if (e.name) {
+                    brand["name"] = e.name;
+                    this.said.push(`The app's wordmark says ${e.name}.`);
+                }
+                // A brand that holds only a name holds nothing to apply.
+                if (Object.keys(brand).every((key) => key === "name"))
+                    delete this.doc.brand;
+                else
+                    this.doc.brand = brand;
                 return;
             }
             case "set-label": {
@@ -699,6 +762,8 @@ class Editor {
             if (!Array.isArray(e.options?.blocks) || e.options.blocks.length === 0)
                 return this.fail(i, "options.blocks", 'a lens drawn from blocks has blocks: "options": {"blocks": [{"headline": "…"}, {"list": "all(\'<kind>\')", "as": "card"}]}');
         }
+        if (name === "columns" && !this.columnsHold(i, e.bindings))
+            return;
         if (was)
             lenses[at] = lens;
         else
@@ -721,6 +786,35 @@ class Editor {
         }
         this.said.push(retitled ? `The lens "${String(was["title"])}" is now "${e.title}"${where}${follows}.` : `The lens "${e.title}" changes${where}.`);
     }
+    /**
+     * A STATUS BOARD'S BINDINGS (FR-97), held before it is added: each kind it
+     * binds is a kind, and its `column` is a field of that kind whose values
+     * are choices — the columns. Refused at the binding's path otherwise, so a
+     * chat is told which word to change rather than shown an empty board.
+     */
+    columnsHold(i, bindings) {
+        const example = '"bindings": {"<kind>": {"column": "<a choice field, like status>"}}';
+        if (!isObject(bindings) || Object.keys(bindings).length === 0)
+            return (this.fail(i, "bindings", "a board binds a kind's choice field to its columns", example), false);
+        for (const [kind, roles] of Object.entries(bindings)) {
+            if (!isObject(this.doc.kinds[kind]))
+                return (this.fail(i, `bindings.${kind}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`), false);
+            const field = isObject(roles) ? roles["column"] : undefined;
+            const fields = this.doc.kinds[kind].fields;
+            if (typeof field !== "string")
+                return (this.fail(i, `bindings.${kind}.column`, `the board does not say which field of ${kind} its columns are`, example), false);
+            if (!(field in fields))
+                return (this.fail(i, `bindings.${kind}.column`, `${kind} has no field "${field}"; it has ${Object.keys(fields).join(", ")}`), false);
+            if (fields[field]["type"] !== "enum") {
+                const choices = Object.keys(fields).filter((one) => fields[one]["type"] === "enum");
+                return (this.fail(i, `bindings.${kind}.column`, `${kind}'s ${field} is not a choice, so it has no columns`, choices.length > 0 ? `bind one of ${choices.join(", ")}` : `give ${kind} a choice field first: add-field with "type": "enum" and its "options", in the order the columns go`), false);
+            }
+            const others = Object.keys(roles).filter((role) => role !== "column");
+            if (others.length > 0)
+                return (this.fail(i, `bindings.${kind}.${others[0]}`, `a board binds only "column"`), false);
+        }
+        return true;
+    }
     removeLens(i, e) {
         const index = this.lensIndex(i, e.title, e.on);
         if (index < 0)
@@ -1140,12 +1234,43 @@ class Editor {
             f.format = e.format;
         else if (e.type !== "number" && e.type !== "integer")
             delete f.format;
+        // A range is a number's (FR-114): a field that is no longer one lets it go.
+        if (e.type !== "number" && e.type !== "integer")
+            for (const key of ["min", "max", "step"])
+                delete f[key];
         if (f.default !== undefined && coerce(f.default, was, f) === undefined)
             delete f.default;
         else if (f.default !== undefined)
             f.default = coerce(f.default, was, f);
         this.said.push(`${e.kind}'s ${e.field} changes from ${was} to ${e.type}; values that convert are kept.`);
     }
+    /** A number's range (FR-114): a key given sets it, `null` clears it, one left out stays. */
+    setRange(i, e) {
+        const f = this.field(i, e.kind, e.field);
+        if (!f)
+            return;
+        if (f.type !== "number" && f.type !== "integer")
+            return this.fail(i, "field", `${e.field} is ${f.type === "integer" ? "an" : "a"} ${f.type}, not a number; a range belongs on a number or integer field`);
+        const next = { ...f };
+        for (const key of ["min", "max", "step"]) {
+            if (e[key] === null)
+                delete next[key];
+            else if (e[key] !== undefined)
+                next[key] = e[key];
+        }
+        if (next.min !== undefined && next.max !== undefined && next.min > next.max)
+            return this.fail(i, "max", `the most (${next.max}) is below the least (${next.min})`);
+        const outside = next.default !== undefined ? outsideRange(next.default, next, e.field) : undefined;
+        if (outside)
+            return this.fail(i, "default", `${e.field}'s default, ${outside.replace(/ is /, ", is ")}; change the default first`);
+        for (const key of ["min", "max", "step"]) {
+            if (next[key] === undefined)
+                delete f[key];
+            else
+                f[key] = next[key];
+        }
+        this.said.push(`${e.kind}'s ${e.field} takes ${rangeWords(f)}.`);
+    }
     setOptions(i, e) {
         const f = this.field(i, e.kind, e.field);
         if (!f)
@@ -1172,7 +1297,7 @@ class Editor {
         }
         // An act that sets a dropped option cannot stand.
         for (const [name, act] of Object.entries(this.doc.acts ?? {})) {
-            for (const t of setTargets(act))
+            for (const t of setTargets(act, this.doc))
                 if (hasKind(t.kinds, e.kind) && typeof t.set[e.field] === "string" && remove.includes(t.set[e.field])) {
                     this.removeActQuietly(name);
                     out.push(`the act ${name} (it set that option) is removed`);
@@ -1420,6 +1545,8 @@ class Editor {
                     act.connects = r.to;
                 if (act.severs === r.from)
                     act.severs = r.to;
+                if (Array.isArray(act.replaces))
+                    act.replaces = act.replaces.map((e) => (e === r.from ? r.to : e));
                 for (const e of act.effects ?? []) {
                     if (e.connect === r.from)
                         e.connect = r.to;
@@ -1429,7 +1556,7 @@ class Editor {
             }
             if (r.t === "field") {
                 const args = new Map();
-                for (const t of setTargets(act)) {
+                for (const t of setTargets(act, doc)) {
                     if (!hasKind(t.kinds, r.kind) || !(r.from in t.set))
                         continue;
                     if (t.kinds === "*" && Object.entries(doc.kinds).some(([k, s]) => k !== r.kind && s.fields[r.from]))
@@ -1441,6 +1568,8 @@ class Editor {
                         args.set(r.from, r.to);
                     if (t.where === "sets")
                         act.sets = renamed;
+                    else if (t.where === "setsOther")
+                        act.setsOther = renamed;
                     else
                         act.effects[t.index].set = renamed;
                 }
@@ -1469,7 +1598,7 @@ class Editor {
                 act.allowedWhen = argRename?.has(r.from) && r.t === "field" && !hasKind(on, r.kind) ? rewriteBinding(guard, r.from, r.to) : guard;
             if (act.refusal !== undefined)
                 act.refusal = tmplAt(act.refusal, on);
-            for (const t of setTargets(act))
+            for (const t of setTargets(act, doc))
                 for (const [k, v] of Object.entries(t.set))
                     if (isObject(v) && typeof v["expr"] === "string")
                         t.set[k] = { expr: exprAt(v["expr"], t.kinds === "*" ? on : t.kinds) };
@@ -1624,9 +1753,15 @@ class Editor {
             let uses = exprMentions(doc, act.allowedWhen, on, r) || templateMentions(doc, act.refusal, on, r);
             if (r.t === "edge")
                 uses ||= act.connects === r.from || act.severs === r.from || (act.effects ?? []).some((e) => e.connect === r.from || e.sever === r.from);
+            // A relation it only replaced goes from the list; one that replaced nothing else goes with it (FR-115).
+            if (r.t === "edge" && !uses && Array.isArray(act.replaces) && act.replaces.includes(r.from)) {
+                act.replaces = act.replaces.filter((e) => e !== r.from);
+                if (act.replaces.length === 0)
+                    delete act.replaces;
+            }
             if (r.t === "field" && !worked) {
                 // An act that sets other things too loses only this field; one that did nothing else goes.
-                for (const t of setTargets(act)) {
+                for (const t of setTargets(act, doc)) {
                     if (!hasKind(t.kinds, r.kind) || t.kinds === "*")
                         continue;
                     if (r.from in t.set)
@@ -1646,6 +1781,8 @@ class Editor {
                     delete act.args;
                 if (act.sets && Object.keys(act.sets).length === 0)
                     delete act.sets;
+                if (act.setsOther && Object.keys(act.setsOther).length === 0)
+                    delete act.setsOther;
                 const doesSomething = act.creates || act.writes || act.sets || act.connects || act.severs || act.removes || (act.effects ?? []).some((e) => e.create || e.connect || e.sever || e.remove || (e.set && Object.keys(e.set).length > 0));
                 if (!doesSomething)
                     uses = true;
@@ -2064,6 +2201,9 @@ function rewriteBlock(doc, b, ctx, r, kind) {
             next[key] = rewriteTemplate(doc, next[key], ctx, r);
     if (typeof next["figure"] === "string")
         next["figure"] = rewriteExpr(doc, next["figure"], ctx, r);
+    // A figure's and a meter's label is a template (FR-99); a field's is words.
+    if ((typeof next["figure"] === "string" || "progress" in next) && typeof next["label"] === "string")
+        next["label"] = rewriteTemplate(doc, next["label"], ctx, r);
     if (typeof next["list"] === "string") {
         const members = listMembers(doc, next["list"], ctx);
         next["list"] = rewriteExpr(doc, next["list"], ctx, r);
@@ -2111,6 +2251,11 @@ function pruneBlock(doc, b, ctx, r, kind) {
         for (const k of ["value", "max"])
             if (exprMentions(doc, b["progress"][k], ctx, r))
                 return null;
+    // A label that says what is gone goes; the figure or meter stays (FR-99).
+    if ((typeof b["figure"] === "string" || "progress" in b) && typeof b["label"] === "string" && templateMentions(doc, b["label"], ctx, r)) {
+        const { label: _gone, ...kept } = b;
+        return kept;
+    }
     if (typeof b["list"] === "string") {
         if (exprMentions(doc, b["list"], ctx, r))
             return null;