logisheets-core 1.1.0

package/dist/craft-interactions/index.d.ts

@@ -0,0 +1,140 @@
+export interface RadioBinding {
+    type: 'radio';
+    groupId: string;
+    sheetIdx: number;
+    blockId: number;
+    row: number;
+    col: number;
+    value: string;
+}
+export declare function subscribeRadioBindings(listener: () => void): () => void;
+export declare function registerRadioBinding(binding: RadioBinding): void;
+export declare function unregisterRadioBinding(binding: Pick<RadioBinding, 'groupId' | 'blockId' | 'row' | 'col'>): void;
+export declare function clearRadioBindings(groupId?: string): void;
+export declare function getRadioBindings(): readonly RadioBinding[];
+export declare function getRadioSelection(groupId: string): string | undefined;
+export declare function setRadioSelection(groupId: string, value: string): void;
+export interface MultiSelectBinding {
+    type: 'multiSelect';
+    groupId: string;
+    sheetIdx: number;
+    blockId: number;
+    row: number;
+    col: number;
+    value: string;
+}
+export declare function registerMultiSelectBinding(binding: MultiSelectBinding): void;
+export declare function unregisterMultiSelectBinding(binding: Pick<MultiSelectBinding, 'groupId' | 'blockId' | 'row' | 'col'>): void;
+export declare function clearMultiSelectBindings(groupId?: string): void;
+export declare function getMultiSelectBindings(): readonly MultiSelectBinding[];
+export declare function setMultiSelectMax(groupId: string, max: number): void;
+export declare function getMultiSelectMax(groupId: string): number;
+export declare function getMultiSelectSelections(groupId: string): string[];
+export declare function toggleMultiSelectValue(groupId: string, value: string): void;
+export interface PointAllocatorBinding {
+    type: 'pointAllocator';
+    groupId: string;
+    sheetIdx: number;
+    blockId: number;
+    row: number;
+    col: number;
+}
+export interface PointAllocation {
+    blockId: number;
+    row: number;
+    col: number;
+    points: number;
+}
+export declare function registerPointAllocator(binding: PointAllocatorBinding): void;
+export declare function unregisterPointAllocator(binding: Pick<PointAllocatorBinding, 'groupId' | 'blockId' | 'row' | 'col'>): void;
+export declare function clearPointAllocators(groupId?: string): void;
+export declare function getPointAllocatorBindings(): readonly PointAllocatorBinding[];
+export declare function setPointPool(groupId: string, total: number): void;
+export declare function getPointPool(groupId: string): {
+    total: number;
+    used: number;
+    remaining: number;
+};
+export declare function getPointAllocation(binding: Pick<PointAllocatorBinding, 'groupId' | 'blockId' | 'row' | 'col'>): number;
+export declare function getPointAllocations(groupId: string): PointAllocation[];
+export interface NumberSliderBinding {
+    type: 'numberSlider';
+    groupId: string;
+    sheetIdx: number;
+    blockId: number;
+    row: number;
+    col: number;
+    min: number;
+    max: number;
+    step?: number;
+    initialValue?: number;
+}
+export declare function registerNumberSlider(binding: NumberSliderBinding): void;
+export declare function unregisterNumberSlider(binding: Pick<NumberSliderBinding, 'groupId' | 'blockId' | 'row' | 'col'>): void;
+export declare function clearNumberSliders(groupId?: string): void;
+export declare function getNumberSliderBindings(): readonly NumberSliderBinding[];
+export declare function adjustPointAllocation(binding: Pick<PointAllocatorBinding, 'groupId' | 'blockId' | 'row' | 'col'>, delta: number): void;
+export interface PercentAllocatorBinding {
+    type: 'percentAllocator';
+    groupId: string;
+    sheetIdx: number;
+    blockId: number;
+    row: number;
+    col: number;
+}
+export declare function registerPercentAllocator(binding: PercentAllocatorBinding): void;
+export declare function unregisterPercentAllocator(binding: Pick<PercentAllocatorBinding, 'groupId' | 'blockId' | 'row' | 'col'>): void;
+export declare function clearPercentAllocators(groupId?: string): void;
+export declare function getPercentAllocatorBindings(): readonly PercentAllocatorBinding[];
+/**
+ * Pure helper: apply `deltaPct` percentage points to the `targetIdx`
+ * slot of a group and rebalance the others so the group sum is always
+ * exactly 1 (100%) after the call.
+ *
+ * Semantics:
+ *  - **First-touch (group sum ≈ 0)**: auto-seed an even 1/n split as
+ *    the conceptual starting point, *then* apply the delta. So
+ *    `[0,0] +1 on idx 0` reads as "starting from 50/50, give idx 0
+ *    +1%" → `[0.51, 0.49]`. This is what we want when a craft has
+ *    bound a pair but hasn't written initial values yet — the first
+ *    click both initializes and adjusts in one step.
+ *  - **Any positive delta** (`+k`): bump target by k% (clamped to
+ *    [0,1]), take the same total off the other slots proportionally
+ *    to their pre-click share.
+ *  - **Any negative delta** (`-k`): lower target by k% (clamped),
+ *    give the same total back to the other slots proportionally.
+ *  - **Already-at-bound clicks** (e.g. +1 on a slot at 100%): no-op.
+ *  - **Manually under- or over-allocated input** (sum != 1): every
+ *    click renormalizes the group back to 1.
+ *
+ * Examples (n=2):
+ *
+ *   [0, 0]      +1 on idx 0   → [0.51, 0.49]   (auto-seed + +1)
+ *   [0.5, 0.5]  +1 on idx 0   → [0.51, 0.49]
+ *   [0.5, 0.5]  -1 on idx 0   → [0.49, 0.51]
+ *   [1.0, 0]    +1 on idx 0   → [1.0, 0]        (clamped)
+ *   [1.0, 0]    +1 on idx 1   → [0.99, 0.01]
+ *
+ * Earlier versions had a sticky-after-first-click bug: when the group
+ * was [0.01, 0], adding to idx 0 saw "others total = 0" and either
+ * reverted the bump (preserve-sum branch) or just let it climb
+ * (overflow-only branch) — neither was what the user wanted. Auto-
+ * seeding at sum≈0 makes every subsequent click see a well-formed
+ * group, so the renormalization branch always has weight to work with.
+ */
+export declare function redistributePercent(current: readonly number[], targetIdx: number, deltaPct: number): number[];
+interface PersistedShape {
+    radioBindings: RadioBinding[];
+    radioSelections: Record<string, string>;
+    multiSelectBindings: MultiSelectBinding[];
+    multiSelectMax: Record<string, number>;
+    multiSelectSelections: Record<string, string[]>;
+    pointBindings: PointAllocatorBinding[];
+    pointPoolTotals: Record<string, number>;
+    pointAllocations: Record<string, PointAllocation[]>;
+    numberSliderBindings: NumberSliderBinding[];
+    percentBindings: PercentAllocatorBinding[];
+}
+export declare function getPersistentInteractions(): PersistedShape;
+export declare function loadPersistentInteractions(data: unknown): void;
+export {};

package/dist/craft-interactions/index.js

@@ -0,0 +1,462 @@
+const radioBindings = new Map();
+const groupSelections = new Map();
+const storeListeners = new Set();
+function bindingKey(b) {
+    return `${b.groupId}-${b.blockId}-${b.row}-${b.col}`;
+}
+function notifyStore() {
+    for (const l of storeListeners)
+        l();
+}
+export function subscribeRadioBindings(listener) {
+    storeListeners.add(listener);
+    return () => {
+        storeListeners.delete(listener);
+    };
+}
+export function registerRadioBinding(binding) {
+    radioBindings.set(bindingKey(binding), binding);
+    notifyStore();
+}
+export function unregisterRadioBinding(binding) {
+    radioBindings.delete(bindingKey(binding));
+    notifyStore();
+}
+export function clearRadioBindings(groupId) {
+    if (groupId === undefined) {
+        radioBindings.clear();
+        groupSelections.clear();
+    }
+    else {
+        for (const [key, b] of radioBindings) {
+            if (b.groupId === groupId)
+                radioBindings.delete(key);
+        }
+        groupSelections.delete(groupId);
+    }
+    notifyStore();
+}
+export function getRadioBindings() {
+    return Array.from(radioBindings.values());
+}
+export function getRadioSelection(groupId) {
+    return groupSelections.get(groupId);
+}
+export function setRadioSelection(groupId, value) {
+    groupSelections.set(groupId, value);
+    notifyStore();
+}
+const multiSelectBindings = new Map();
+const multiSelectMax = new Map();
+const multiSelectSelections = new Map();
+function multiSelectKey(b) {
+    return `${b.groupId}-${b.blockId}-${b.row}-${b.col}`;
+}
+export function registerMultiSelectBinding(binding) {
+    multiSelectBindings.set(multiSelectKey(binding), binding);
+    notifyStore();
+}
+export function unregisterMultiSelectBinding(binding) {
+    multiSelectBindings.delete(multiSelectKey(binding));
+    notifyStore();
+}
+export function clearMultiSelectBindings(groupId) {
+    if (groupId === undefined) {
+        multiSelectBindings.clear();
+        multiSelectMax.clear();
+        multiSelectSelections.clear();
+    }
+    else {
+        for (const [k, b] of multiSelectBindings) {
+            if (b.groupId === groupId)
+                multiSelectBindings.delete(k);
+        }
+        multiSelectMax.delete(groupId);
+        multiSelectSelections.delete(groupId);
+    }
+    notifyStore();
+}
+export function getMultiSelectBindings() {
+    return Array.from(multiSelectBindings.values());
+}
+export function setMultiSelectMax(groupId, max) {
+    multiSelectMax.set(groupId, Math.max(0, max));
+    notifyStore();
+}
+export function getMultiSelectMax(groupId) {
+    return multiSelectMax.get(groupId) ?? 0;
+}
+export function getMultiSelectSelections(groupId) {
+    return Array.from(multiSelectSelections.get(groupId) ?? []);
+}
+export function toggleMultiSelectValue(groupId, value) {
+    let set = multiSelectSelections.get(groupId);
+    if (!set) {
+        set = new Set();
+        multiSelectSelections.set(groupId, set);
+    }
+    if (set.has(value)) {
+        set.delete(value);
+    }
+    else {
+        const max = multiSelectMax.get(groupId) ?? Infinity;
+        if (set.size >= max)
+            return;
+        set.add(value);
+    }
+    notifyStore();
+}
+const pointBindings = new Map();
+const pointPoolTotals = new Map();
+const pointAllocations = new Map();
+function pointBindingKey(b) {
+    return `${b.groupId}-${b.blockId}-${b.row}-${b.col}`;
+}
+function cellKey(blockId, row, col) {
+    return `${blockId}-${row}-${col}`;
+}
+function groupTotalUsed(groupId) {
+    const m = pointAllocations.get(groupId);
+    if (!m)
+        return 0;
+    let s = 0;
+    for (const v of m.values())
+        s += v;
+    return s;
+}
+export function registerPointAllocator(binding) {
+    pointBindings.set(pointBindingKey(binding), binding);
+    notifyStore();
+}
+export function unregisterPointAllocator(binding) {
+    pointBindings.delete(pointBindingKey(binding));
+    notifyStore();
+}
+export function clearPointAllocators(groupId) {
+    if (groupId === undefined) {
+        pointBindings.clear();
+        pointPoolTotals.clear();
+        pointAllocations.clear();
+    }
+    else {
+        for (const [key, b] of pointBindings) {
+            if (b.groupId === groupId)
+                pointBindings.delete(key);
+        }
+        pointPoolTotals.delete(groupId);
+        pointAllocations.delete(groupId);
+    }
+    notifyStore();
+}
+export function getPointAllocatorBindings() {
+    return Array.from(pointBindings.values());
+}
+export function setPointPool(groupId, total) {
+    pointPoolTotals.set(groupId, Math.max(0, total));
+    notifyStore();
+}
+export function getPointPool(groupId) {
+    const total = pointPoolTotals.get(groupId) ?? 0;
+    const used = groupTotalUsed(groupId);
+    return { total, used, remaining: total - used };
+}
+export function getPointAllocation(binding) {
+    return (pointAllocations
+        .get(binding.groupId)
+        ?.get(cellKey(binding.blockId, binding.row, binding.col)) ?? 0);
+}
+export function getPointAllocations(groupId) {
+    const m = pointAllocations.get(groupId);
+    if (!m)
+        return [];
+    const out = [];
+    for (const [key, points] of m) {
+        const [blockId, row, col] = key.split('-').map(Number);
+        out.push({ blockId, row, col, points });
+    }
+    return out;
+}
+const numberSliderBindings = new Map();
+function numberSliderKey(b) {
+    return `${b.groupId}-${b.blockId}-${b.row}-${b.col}`;
+}
+export function registerNumberSlider(binding) {
+    numberSliderBindings.set(numberSliderKey(binding), binding);
+    notifyStore();
+}
+export function unregisterNumberSlider(binding) {
+    numberSliderBindings.delete(numberSliderKey(binding));
+    notifyStore();
+}
+export function clearNumberSliders(groupId) {
+    if (groupId === undefined) {
+        numberSliderBindings.clear();
+    }
+    else {
+        for (const [k, b] of numberSliderBindings) {
+            if (b.groupId === groupId)
+                numberSliderBindings.delete(k);
+        }
+    }
+    notifyStore();
+}
+export function getNumberSliderBindings() {
+    return Array.from(numberSliderBindings.values());
+}
+export function adjustPointAllocation(binding, delta) {
+    const { groupId, blockId, row, col } = binding;
+    let m = pointAllocations.get(groupId);
+    if (!m) {
+        m = new Map();
+        pointAllocations.set(groupId, m);
+    }
+    const key = cellKey(blockId, row, col);
+    const current = m.get(key) ?? 0;
+    const total = pointPoolTotals.get(groupId) ?? 0;
+    const used = groupTotalUsed(groupId);
+    const remaining = total - used;
+    const applied = delta > 0 ? Math.min(delta, remaining) : Math.max(delta, -current);
+    const next = current + applied;
+    if (next <= 0)
+        m.delete(key);
+    else
+        m.set(key, next);
+    notifyStore();
+}
+const percentBindings = new Map();
+function percentBindingKey(b) {
+    return `${b.groupId}-${b.blockId}-${b.row}-${b.col}`;
+}
+export function registerPercentAllocator(binding) {
+    percentBindings.set(percentBindingKey(binding), binding);
+    notifyStore();
+}
+export function unregisterPercentAllocator(binding) {
+    percentBindings.delete(percentBindingKey(binding));
+    notifyStore();
+}
+export function clearPercentAllocators(groupId) {
+    if (groupId === undefined) {
+        percentBindings.clear();
+    }
+    else {
+        for (const [k, b] of percentBindings) {
+            if (b.groupId === groupId)
+                percentBindings.delete(k);
+        }
+    }
+    notifyStore();
+}
+export function getPercentAllocatorBindings() {
+    return Array.from(percentBindings.values());
+}
+/**
+ * Pure helper: apply `deltaPct` percentage points to the `targetIdx`
+ * slot of a group and rebalance the others so the group sum is always
+ * exactly 1 (100%) after the call.
+ *
+ * Semantics:
+ *  - **First-touch (group sum ≈ 0)**: auto-seed an even 1/n split as
+ *    the conceptual starting point, *then* apply the delta. So
+ *    `[0,0] +1 on idx 0` reads as "starting from 50/50, give idx 0
+ *    +1%" → `[0.51, 0.49]`. This is what we want when a craft has
+ *    bound a pair but hasn't written initial values yet — the first
+ *    click both initializes and adjusts in one step.
+ *  - **Any positive delta** (`+k`): bump target by k% (clamped to
+ *    [0,1]), take the same total off the other slots proportionally
+ *    to their pre-click share.
+ *  - **Any negative delta** (`-k`): lower target by k% (clamped),
+ *    give the same total back to the other slots proportionally.
+ *  - **Already-at-bound clicks** (e.g. +1 on a slot at 100%): no-op.
+ *  - **Manually under- or over-allocated input** (sum != 1): every
+ *    click renormalizes the group back to 1.
+ *
+ * Examples (n=2):
+ *
+ *   [0, 0]      +1 on idx 0   → [0.51, 0.49]   (auto-seed + +1)
+ *   [0.5, 0.5]  +1 on idx 0   → [0.51, 0.49]
+ *   [0.5, 0.5]  -1 on idx 0   → [0.49, 0.51]
+ *   [1.0, 0]    +1 on idx 0   → [1.0, 0]        (clamped)
+ *   [1.0, 0]    +1 on idx 1   → [0.99, 0.01]
+ *
+ * Earlier versions had a sticky-after-first-click bug: when the group
+ * was [0.01, 0], adding to idx 0 saw "others total = 0" and either
+ * reverted the bump (preserve-sum branch) or just let it climb
+ * (overflow-only branch) — neither was what the user wanted. Auto-
+ * seeding at sum≈0 makes every subsequent click see a well-formed
+ * group, so the renormalization branch always has weight to work with.
+ */
+export function redistributePercent(current, targetIdx, deltaPct) {
+    const n = current.length;
+    if (n === 0)
+        return [];
+    if (n === 1)
+        return [Math.max(0, Math.min(1, current[0] + deltaPct / 100))];
+    const deltaFrac = deltaPct / 100;
+    const preSum = current.reduce((s, v) => s + v, 0);
+    // First-touch: an uninitialized group conceptually starts as an
+    // even split. Build that virtual base, then proceed normally.
+    const base = preSum > 1e-9 ? current.slice() : new Array(n).fill(1 / n);
+    // Apply delta to target (clamped). If nothing actually changed,
+    // bail out — `base` is already at sum=1 (or whatever the user
+    // had); no-op clicks shouldn't trigger renormalization.
+    const targetNew = Math.max(0, Math.min(1, base[targetIdx] + deltaFrac));
+    if (targetNew === base[targetIdx] && preSum > 1e-9)
+        return current.slice();
+    const next = base.slice();
+    next[targetIdx] = targetNew;
+    // Renormalize the others by the same total delta — taking from
+    // them on a positive click, giving back on a negative click. Share
+    // is proportional to each slot's pre-click value; falls back to
+    // an even split when the others are all 0.
+    const targetDelta = targetNew - base[targetIdx];
+    const adjust = -targetDelta; // how much the others must absorb in aggregate
+    if (Math.abs(adjust) > 1e-12) {
+        const othersWeight = base.reduce((s, v, i) => (i === targetIdx ? s : s + v), 0);
+        for (let i = 0; i < n; i++) {
+            if (i === targetIdx)
+                continue;
+            const share = othersWeight > 0 ? base[i] / othersWeight : 1 / (n - 1);
+            next[i] = Math.max(0, Math.min(1, base[i] + adjust * share));
+        }
+    }
+    // Float drift correction so sum lands on exactly 1.
+    const finalTotal = next.reduce((s, v) => s + v, 0);
+    if (finalTotal > 0 && Math.abs(finalTotal - 1) > 1e-9) {
+        for (let i = 0; i < n; i++)
+            next[i] = next[i] / finalTotal;
+    }
+    return next;
+}
+export function getPersistentInteractions() {
+    const out = {
+        radioBindings: Array.from(radioBindings.values()),
+        radioSelections: {},
+        multiSelectBindings: Array.from(multiSelectBindings.values()),
+        multiSelectMax: {},
+        multiSelectSelections: {},
+        pointBindings: Array.from(pointBindings.values()),
+        pointPoolTotals: {},
+        pointAllocations: {},
+        numberSliderBindings: Array.from(numberSliderBindings.values()),
+        percentBindings: Array.from(percentBindings.values()),
+    };
+    for (const [groupId, value] of groupSelections) {
+        out.radioSelections[groupId] = value;
+    }
+    for (const [groupId, max] of multiSelectMax) {
+        out.multiSelectMax[groupId] = max;
+    }
+    for (const [groupId, set] of multiSelectSelections) {
+        if (set.size > 0)
+            out.multiSelectSelections[groupId] = Array.from(set);
+    }
+    for (const [groupId, total] of pointPoolTotals) {
+        out.pointPoolTotals[groupId] = total;
+    }
+    for (const groupId of pointAllocations.keys()) {
+        const list = getPointAllocations(groupId);
+        if (list.length > 0)
+            out.pointAllocations[groupId] = list;
+    }
+    return out;
+}
+export function loadPersistentInteractions(data) {
+    if (!data || typeof data !== 'object')
+        return;
+    const d = data;
+    // Radio
+    radioBindings.clear();
+    if (Array.isArray(d.radioBindings)) {
+        for (const b of d.radioBindings) {
+            if (b && typeof b === 'object') {
+                radioBindings.set(bindingKey(b), b);
+            }
+        }
+    }
+    groupSelections.clear();
+    if (d.radioSelections) {
+        for (const [groupId, value] of Object.entries(d.radioSelections)) {
+            if (typeof value === 'string')
+                groupSelections.set(groupId, value);
+        }
+    }
+    // Multi-select
+    multiSelectBindings.clear();
+    if (Array.isArray(d.multiSelectBindings)) {
+        for (const b of d.multiSelectBindings) {
+            if (b && typeof b === 'object') {
+                multiSelectBindings.set(multiSelectKey(b), b);
+            }
+        }
+    }
+    multiSelectMax.clear();
+    if (d.multiSelectMax) {
+        for (const [groupId, max] of Object.entries(d.multiSelectMax)) {
+            if (typeof max === 'number')
+                multiSelectMax.set(groupId, max);
+        }
+    }
+    multiSelectSelections.clear();
+    if (d.multiSelectSelections) {
+        for (const [groupId, values] of Object.entries(d.multiSelectSelections)) {
+            if (Array.isArray(values)) {
+                multiSelectSelections.set(groupId, new Set(values.filter((v) => typeof v === 'string')));
+            }
+        }
+    }
+    // Point allocator
+    pointBindings.clear();
+    if (Array.isArray(d.pointBindings)) {
+        for (const b of d.pointBindings) {
+            if (b && typeof b === 'object') {
+                pointBindings.set(pointBindingKey(b), b);
+            }
+        }
+    }
+    pointPoolTotals.clear();
+    if (d.pointPoolTotals) {
+        for (const [groupId, total] of Object.entries(d.pointPoolTotals)) {
+            if (typeof total === 'number')
+                pointPoolTotals.set(groupId, total);
+        }
+    }
+    pointAllocations.clear();
+    if (d.pointAllocations) {
+        for (const [groupId, list] of Object.entries(d.pointAllocations)) {
+            if (!Array.isArray(list))
+                continue;
+            const m = new Map();
+            for (const a of list) {
+                if (typeof a?.blockId === 'number' &&
+                    typeof a?.row === 'number' &&
+                    typeof a?.col === 'number' &&
+                    typeof a?.points === 'number' &&
+                    a.points > 0) {
+                    m.set(cellKey(a.blockId, a.row, a.col), a.points);
+                }
+            }
+            if (m.size > 0)
+                pointAllocations.set(groupId, m);
+        }
+    }
+    // Number slider (bindings only — values live in cells)
+    numberSliderBindings.clear();
+    if (Array.isArray(d.numberSliderBindings)) {
+        for (const b of d.numberSliderBindings) {
+            if (b && typeof b === 'object') {
+                numberSliderBindings.set(numberSliderKey(b), b);
+            }
+        }
+    }
+    // Percent allocator (bindings only — values live in cells)
+    percentBindings.clear();
+    if (Array.isArray(d.percentBindings)) {
+        for (const b of d.percentBindings) {
+            if (b && typeof b === 'object') {
+                percentBindings.set(percentBindingKey(b), b);
+            }
+        }
+    }
+    notifyStore();
+}

package/dist/field/index.d.ts

@@ -0,0 +1,51 @@
+import type { Value } from 'logisheets-web';
+import type { Violation } from '../validation/index.js';
+export type FieldTypeEnum = 'enum' | 'multiSelect' | 'datetime' | 'boolean' | 'string' | 'number' | 'image' | 'fieldRef' | 'multiSelectRef';
+export interface EnumValue {
+    id: string;
+    label: string;
+    description: string;
+    color: string;
+}
+export interface FieldSetting {
+    id: string;
+    name: string;
+    type: FieldTypeEnum;
+    description?: string;
+    required: boolean;
+    primary: boolean;
+    enumId?: string;
+    defaultValue?: string;
+    format?: string;
+    validation?: string;
+    unique?: boolean;
+    valueFormula?: string;
+    refSelf?: boolean;
+    refSheetId?: number;
+    refBlockId?: number;
+    refFieldName?: string;
+}
+export interface CellRef {
+    sheetIdx: number;
+    row: number;
+    col: number;
+}
+/** A field column: its constraints plus the data cells that belong to it. */
+export interface FieldColumn {
+    field: Pick<FieldSetting, 'name' | 'required' | 'unique'>;
+    cells: readonly CellRef[];
+    /**
+     * Allowed values for membership-constrained fields (enum / multiSelect /
+     * fieldRef / multiSelectRef). When provided, every non-empty cell value
+     * must appear here. The caller resolves the candidate set — for enums it
+     * is the enum labels; for fieldRef it is the referenced field's values.
+     * Leave undefined for fields with no membership constraint.
+     */
+    allowed?: readonly string[];
+}
+/**
+ * Check `required` and `unique` across every field column and return all
+ * violating cells. Pure: the caller supplies `getValue` (WorkbookOps wraps the
+ * engine), so this runs identically in the browser and on Node.
+ */
+export declare function checkFieldConstraints(columns: readonly FieldColumn[], getValue: (sheetIdx: number, row: number, col: number) => Value): Violation[];