logisheets-core 1.13.0 → 1.14.1

package/dist/ops/index.d.ts

@@ -17,6 +17,16 @@ export interface FormBlockField {
     renderId: string;
     /** Per-field value-formula template (#FIELD("X") / #KEY); '' if free-form. */
     valueFormula?: string;
+    /**
+     * Per-field validation template (#PLACEHOLDER for the value under test,
+     * #FIELD("X") for a same-row sibling); '' when the field has no rule.
+     *
+     * This goes into the schema rather than staying host-side so the engine
+     * installs the per-record shadow itself — on bind AND on every row added
+     * later — and so one answer serves every reader: the warning marker, the
+     * `overrideValidation` write gate, and any other host.
+     */
+    validationFormula?: string;
     /** Whether the field renders via a host-drawn (DIY) overlay. */
     diyRender: boolean;
     /** Number format applied to the field's render info. */
@@ -188,6 +198,23 @@ export declare class WorkbookOps {
         keyIdx: number;
         fields: readonly FormBlockField[];
     }): Promise<void>;
+    /**
+     * Rewrite ONE kind of per-field rule on a block, leaving the others alone.
+     *
+     * `formulas` is one entry per field, in the schema's field order — a rule
+     * or `''` for none. The other two rule kinds are sent empty, which the
+     * engine reads as "don't touch these", so editing a validation rule cannot
+     * clear the value formulas standing next to it.
+     *
+     * Every existing row is re-materialized from the new rule, so this is also
+     * how a rule is removed: pass `''` for that field.
+     */
+    setFieldRules(opts: {
+        sheetIdx: number;
+        blockId: number;
+        kind: 'value' | 'validation' | 'editability';
+        formulas: readonly string[];
+    }): Promise<void>;
     /**
      * Apply a caller-built payload list as one transaction (at the host's
      * temp-mode). Escape hatch for operations whose payload construction still

package/dist/ops/index.js

@@ -262,7 +262,7 @@ export class WorkbookOps {
                     fields: fields.map((f) => f.name),
                     renderIds: fields.map((f) => f.renderId),
                     fieldFormulas: fields.map((f) => f.valueFormula ?? ''),
-                    validationFormulas: [],
+                    validationFormulas: fields.map((f) => f.validationFormula ?? ''),
                     editabilityFormulas: [],
                 },
             },
@@ -309,7 +309,7 @@ export class WorkbookOps {
                     fields: fields.map((f) => f.name),
                     renderIds: fields.map((f) => f.renderId),
                     fieldFormulas: fields.map((f) => f.valueFormula ?? ''),
-                    validationFormulas: [],
+                    validationFormulas: fields.map((f) => f.validationFormula ?? ''),
                     editabilityFormulas: [],
                 },
             },
@@ -375,7 +375,7 @@ export class WorkbookOps {
                 fields: fields.map((f) => f.name),
                 renderIds: fields.map((f) => f.renderId),
                 fieldFormulas: fields.map((f) => f.valueFormula ?? ''),
-                validationFormulas: [],
+                validationFormulas: fields.map((f) => f.validationFormula ?? ''),
                 editabilityFormulas: [],
             },
         });
@@ -389,6 +389,33 @@ export class WorkbookOps {
         })));
         await this.apply(payloads, true);
     }
+    /**
+     * Rewrite ONE kind of per-field rule on a block, leaving the others alone.
+     *
+     * `formulas` is one entry per field, in the schema's field order — a rule
+     * or `''` for none. The other two rule kinds are sent empty, which the
+     * engine reads as "don't touch these", so editing a validation rule cannot
+     * clear the value formulas standing next to it.
+     *
+     * Every existing row is re-materialized from the new rule, so this is also
+     * how a rule is removed: pass `''` for that field.
+     */
+    async setFieldRules(opts) {
+        const { sheetIdx, blockId, kind, formulas } = opts;
+        const forKind = (k) => kind === k ? formulas.map((f) => f ?? '') : [];
+        await this.apply([
+            {
+                type: 'upsertFieldFormulas',
+                value: {
+                    sheetIdx,
+                    blockId,
+                    fieldFormulas: forKind('value'),
+                    validationFormulas: forKind('validation'),
+                    editabilityFormulas: forKind('editability'),
+                },
+            },
+        ], true);
+    }
     // ---- generic / temp-branch -----------------------------------------
     /**
      * Apply a caller-built payload list as one transaction (at the host's

package/dist/permissions/index.d.ts

@@ -5,6 +5,22 @@ declare class CallerRegistry {
     getUserUuid(): string;
     getCraftUuid(craftId: string): string;
     isUser(uuid: string | undefined): boolean;
+    /**
+     * The engine-side identity a caller uuid stands for: `'user'`, or the
+     * craft named by the id it registered under.
+     *
+     * The uuids here are session-scoped, while a block's `owner` is a craft id
+     * saved in the file — so asking the engine whether a caller may touch a
+     * block means translating back first. `undefined` for a uuid this registry
+     * never issued, which the caller should treat as unidentified rather than
+     * as the user.
+     */
+    resolveActor(uuid: string | undefined): {
+        type: 'user';
+    } | {
+        type: 'craft';
+        craftId: string;
+    } | undefined;
     registerBlockOwner(sheetIdx: number, blockId: number, callerUuid: string): void;
     getBlockOwner(sheetIdx: number, blockId: number): string | undefined;
     /**

package/dist/permissions/index.js

@@ -33,6 +33,28 @@ class CallerRegistry {
     isUser(uuid) {
         return uuid === this._entries.get(USER_KEY);
     }
+    /**
+     * The engine-side identity a caller uuid stands for: `'user'`, or the
+     * craft named by the id it registered under.
+     *
+     * The uuids here are session-scoped, while a block's `owner` is a craft id
+     * saved in the file — so asking the engine whether a caller may touch a
+     * block means translating back first. `undefined` for a uuid this registry
+     * never issued, which the caller should treat as unidentified rather than
+     * as the user.
+     */
+    resolveActor(uuid) {
+        if (uuid === undefined)
+            return undefined;
+        for (const [key, value] of this._entries) {
+            if (value !== uuid)
+                continue;
+            return key === USER_KEY
+                ? { type: 'user' }
+                : { type: 'craft', craftId: key };
+        }
+        return undefined;
+    }
     registerBlockOwner(sheetIdx, blockId, callerUuid) {
         this._blockOwners.set(`${sheetIdx}-${blockId}`, callerUuid);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "logisheets-core",
-    "version": "1.13.0",
+    "version": "1.14.1",
     "description": "UI-free LogiSheets logic — runs in the browser or on Node. Depends on logisheets-web only for types; the engine Client is injected by the host.",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
@@ -63,7 +63,7 @@
     },
     "homepage": "https://github.com/logisky/LogiSheets",
     "peerDependencies": {
-        "logisheets-web": "^1.13.0"
+        "logisheets-web": "^1.14.1"
     },
     "devDependencies": {
         "@types/node": "^18",