@getaster/data 0.3.5 → 0.4.0

package/dist/edit/edit-model.d.ts

@@ -15,6 +15,24 @@ export type Rule = (values: Entity) => Readonly<Record<string, string | undefine
 export interface EditOptions {
     readonly rules?: readonly Rule[];
 }
+/** Static defaults for one field. A page rule that names an effect overrides it. */
+export interface EditFieldPolicy {
+    readonly readOnly?: boolean;
+    readonly disabled?: boolean;
+    readonly required?: boolean;
+}
+/**
+ * Static edit defaults, applied through [[method:EditModel.applyPolicy]].
+ * They are defaults, not a second rule system: an effect a page rule sets
+ * wins, and the metadata's ceilings (computed, immutable, non-nullable)
+ * still apply. A form's presentation configuration carries them.
+ */
+export interface EditPolicy {
+    readonly readOnly?: boolean;
+    readonly disabled?: boolean;
+    /** Per-field defaults, merged over the form-wide entries. */
+    readonly fields?: Readonly<Record<string, EditFieldPolicy>>;
+}
 /**
  * A field's page rules. With `clearWhenHidden`, hiding a shown field clears
  * its value. `derived` gives the field a value from the page: cases for
@@ -114,6 +132,20 @@ export declare class EditModel {
      * `explain`. Call once, before the fields are shown.
      */
     applyRules(scope: PageScope, target: string, rules: Readonly<Record<string, FieldRules>>): void;
+    /**
+     * Static edit defaults, such as a form that is locked for viewing. They
+     * are defaults: a page rule that names an effect overrides it, and the
+     * metadata still refuses edits to computed or immutable fields. Passing
+     * `{}` clears them. Call it before or after `applyRules`; the state is
+     * recomputed for whoever reads it.
+     */
+    applyPolicy(policy: EditPolicy): void;
+    /**
+     * Checks one field and shows or clears its error, leaving the other
+     * fields' errors alone. This is the per-field validation behind
+     * `validateOn: "change"` and `"exit"`; `validate()` checks everything.
+     */
+    validateField(name: string): boolean;
     /**
      * Whether the field holds its derived value: suggested or replaced, not
      * typed over. False for a field without one.
@@ -122,9 +154,10 @@ export declare class EditModel {
     /** The page rules behind a field's state, with what they read now. */
     explain(name: string): Explanation[];
     /**
-     * A field's state: its page rules, then what the metadata and the record
-     * say. Computed fields are read-only, immutable ones once saved, and every
-     * field of a deleted record; a non-nullable field is required.
+     * A field's state: static policy for effects no page rule names, then the
+     * page rules, then what the metadata and the record say. Computed fields
+     * are read-only, immutable ones once saved, and every field of a deleted
+     * record; a non-nullable field is required.
      */
     state(name: string): ReadonlySignal<FieldState>;
     pending(name: string): ReadonlySignal<boolean>;

package/dist/edit/edit-model.js

@@ -6,6 +6,8 @@ import { DEFAULT_STATE } from "../scope/scope.js";
 import { keyFromText } from "../store/keys.js";
 import { validateEntity } from "../validate/validate.js";
 const NONE = new Set();
+const NO_EFFECTS = new Set();
+const EFFECTS = ["visible", "enabled", "readOnly", "required"];
 /**
  * Uncommitted values for one record, apart from the stored record.
  *
@@ -42,6 +44,9 @@ export class EditModel {
     #writes = [];
     #pending = new Map();
     #ruled = signal(new Map());
+    /** The effects each field's page rules name; an unnamed effect yields to static policy. */
+    #effects = new Map();
+    #policy = signal({});
     #states = new Map();
     #disposers = [];
     /** A past change shown over its old values: read-only, never saved. */
@@ -194,6 +199,10 @@ export class EditModel {
             this.#errors.value = { ...this.#errors.peek(), [name]: [state.reasons.readOnly ?? `${this.#title(name)} is read-only.`] };
             return;
         }
+        if (!state.enabled) {
+            this.#errors.value = { ...this.#errors.peek(), [name]: [state.reasons.enabled ?? `${this.#title(name)} is disabled.`] };
+            return;
+        }
         batch(() => {
             this.#values.value = { ...this.#values.peek(), [name]: value };
             if (this.#derived.has(name) && !this.#typed.peek().has(name))
@@ -214,6 +223,11 @@ export class EditModel {
         const ruled = new Map(this.#ruled.peek());
         for (const [name, { clearWhenHidden: _, derived, ...state }] of Object.entries(rules)) {
             const field = this.#field(name);
+            const effects = new Set();
+            for (const effect of EFFECTS)
+                if (rules[name][effect] !== undefined)
+                    effects.add(effect);
+            this.#effects.set(name, effects);
             ruled.set(name, scope.state(`${target}.${name}`, state));
             if (derived === undefined)
                 continue;
@@ -251,6 +265,32 @@ export class EditModel {
             }));
         }
     }
+    /**
+     * Static edit defaults, such as a form that is locked for viewing. They
+     * are defaults: a page rule that names an effect overrides it, and the
+     * metadata still refuses edits to computed or immutable fields. Passing
+     * `{}` clears them. Call it before or after `applyRules`; the state is
+     * recomputed for whoever reads it.
+     */
+    applyPolicy(policy) {
+        this.#policy.value = policy;
+    }
+    /**
+     * Checks one field and shows or clears its error, leaving the other
+     * fields' errors alone. This is the per-field validation behind
+     * `validateOn: "change"` and `"exit"`; `validate()` checks everything.
+     */
+    validateField(name) {
+        this.#field(name);
+        const now = this.#check(this.#values.peek())[name];
+        const rest = { ...this.#errors.peek() };
+        if (now === undefined)
+            delete rest[name];
+        else
+            rest[name] = now;
+        this.#errors.value = rest;
+        return now === undefined;
+    }
     /**
      * Whether the field holds its derived value: suggested or replaced, not
      * typed over. False for a field without one.
@@ -325,9 +365,10 @@ export class EditModel {
         return rules.map((r) => r.effect === "derived" ? { ...r, overridden: this.#typed.peek().has(name), current: this.#values.peek()[name] } : r);
     }
     /**
-     * A field's state: its page rules, then what the metadata and the record
-     * say. Computed fields are read-only, immutable ones once saved, and every
-     * field of a deleted record; a non-nullable field is required.
+     * A field's state: static policy for effects no page rule names, then the
+     * page rules, then what the metadata and the record say. Computed fields
+     * are read-only, immutable ones once saved, and every field of a deleted
+     * record; a non-nullable field is required.
      */
     state(name) {
         let state = this.#states.get(name);
@@ -335,8 +376,15 @@ export class EditModel {
             const field = this.#field(name);
             state = computed(() => {
                 const ruled = this.#ruled.value.get(name)?.value ?? DEFAULT_STATE;
+                const owned = this.#effects.get(name) ?? NO_EFFECTS;
+                const policy = this.#policy.value;
+                const own = policy.fields?.[name];
                 const reasons = { ...ruled.reasons };
-                let readOnly = ruled.readOnly;
+                const policyReadOnly = own?.readOnly ?? policy.readOnly ?? false;
+                const policyDisabled = own?.disabled ?? policy.disabled ?? false;
+                const policyRequired = own?.required ?? false;
+                let readOnly = owned.has("readOnly") ? ruled.readOnly : policyReadOnly;
+                let enabled = owned.has("enabled") ? ruled.enabled : !policyDisabled;
                 if (this.#replay) {
                     readOnly = true;
                     reasons.readOnly = "This is a past change.";
@@ -355,8 +403,12 @@ export class EditModel {
                         ? `${this.#title(name)} is set by the server.`
                         : `${this.#title(name)} can't be changed once it's set.`;
                 }
-                const required = ruled.required || (!field.nullable && !field.computed);
-                return Object.freeze({ ...ruled, readOnly, required, reasons: Object.freeze(reasons) });
+                if (!owned.has("readOnly") && policyReadOnly)
+                    reasons.readOnly ??= "Read-only.";
+                if (!owned.has("enabled") && policyDisabled)
+                    reasons.enabled ??= "Disabled.";
+                const required = (owned.has("required") ? ruled.required : policyRequired) || (!field.nullable && !field.computed);
+                return Object.freeze({ ...ruled, readOnly, enabled, required, reasons: Object.freeze(reasons) });
             });
             this.#states.set(name, state);
         }
@@ -414,11 +466,14 @@ export class EditModel {
         const mode = untracked(() => this.isNew.value) ? "create" : "update";
         const changed = mode === "create" ? values : this.#changed(values);
         const errors = { ...validateEntity(this.type, changed, mode) };
-        for (const name of this.#ruled.value.keys()) {
-            const state = this.state(name).value;
-            if (state.required && (values[name] ?? null) === null && !errors[name] && !this.#hidden.value.has(name)) {
+        for (const field of this.type.fields) {
+            const name = field.name;
+            if (field.computed || this.#hidden.value.has(name))
+                continue;
+            if ((values[name] ?? null) !== null || errors[name])
+                continue;
+            if (this.state(name).value.required)
                 errors[name] = [`${this.#title(name)} is required.`];
-            }
         }
         const ruled = new Set();
         for (const rule of this.#rules) {

package/dist/index.d.ts

@@ -21,7 +21,7 @@ export { Collection, type CollectionOptions, type CollectionStatus } from "./col
 export { aggregate, countBy, countWhere, subtractExact, sum, sumValues } from "./collection/aggregate.ts";
 export { apply, creatable, diff, invert, merge, writable, type ChangeSet, type FieldChange, type OwnedChanges } from "./changes/changeset.ts";
 export { validateEntity, validateField, type FieldErrors } from "./validate/validate.ts";
-export { EditModel, type Conflict, type EditDraft, type EditOptions, type FieldRules, type Rule } from "./edit/edit-model.ts";
+export { EditModel, type Conflict, type EditDraft, type EditFieldPolicy, type EditOptions, type EditPolicy, type FieldRules, type Rule } from "./edit/edit-model.ts";
 export { DataContext, type Saved } from "./context.ts";
 export { Selection, selectionOptionsError, type SelectionOptions } from "./selection/selection.ts";
 export { PageScope, toCriteria, DEFAULT_STATE, MAX_HOPS, type Case, type Condition, type Effect, type Explanation, type FieldState, type Publication, type Ruled, type ScopeName, type ScopeSchema, type SelectedValue, type StateRules, } from "./scope/scope.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getaster/data",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {