@graview/core 0.1.12 → 0.1.15

package/dist/document/edit.js

@@ -3,11 +3,13 @@ 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";
 import { computedOf, validateComputed } from "./computed.js";
-import { parseTemplate, templateBraces, TemplateError } from "./template.js";
+import { parseTemplate, templateBraces, TemplateError } from "./template-parse.js";
 import { validateViews, VIEW_SLOTS } from "./views.js";
 /** The ops, for tool schemas and the guide. */
 export const EDIT_OPS = [
@@ -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(),
@@ -361,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)
@@ -373,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 });
@@ -469,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)
@@ -491,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.`);
                 }
@@ -1220,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)
@@ -1252,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`);
@@ -1500,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;
@@ -1509,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]))
@@ -1521,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;
                 }
@@ -1549,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) };
@@ -1704,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)
@@ -1726,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;