@svgrid/enterprise 3.1.22 → 3.1.23

package/dist/review/pending-filter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * "Only rows with changes": a condition kind of the expression language
+ * (`registerPredicateKind`) that matches rows with a pending or conflicting
+ * proposal, ANDed onto the user's own advanced filter and taken back off
+ * without touching the rest of it.
+ *
+ * The advanced filter hands its predicate the grid's rows, whose `id` is the
+ * grid's row id, which is what proposals are keyed by.
+ */
+import type { GridPredicateExpr } from '@svgrid/grid';
+export declare const PENDING_KIND = "reviewPending";
+type Source = {
+    hasPendingRow(rowId: string): boolean;
+};
+/** Make a review's rows filterable; returns the token its filter node names. */
+export declare function trackPendingSource(token: string, source: Source): void;
+/** The user's expression without any of our nodes; null when nothing is left. */
+export declare function stripPending(expr: GridPredicateExpr | null): GridPredicateExpr | null;
+/**
+ * The user's expression with our node ANDed on. `nonce` changes the node, so
+ * the grid filters again after proposals were decided.
+ */
+export declare function withPending(expr: GridPredicateExpr | null, token: string, nonce: number): GridPredicateExpr;
+/** Whether an expression holds our node. */
+export declare function hasPending(expr: GridPredicateExpr | null): boolean;
+export {};

package/dist/review/pending-filter.js

@@ -0,0 +1,71 @@
+import { enableAdvancedFilter } from '../advanced-filter-enable.js';
+import { registerPredicateKind } from '../expressions/kinds.js';
+export const PENDING_KIND = 'reviewPending';
+// Weak: the review holds its source; once the review is gone, so is the entry's target.
+const sources = new Map();
+let registered = false;
+function register() {
+    if (registered)
+        return;
+    registered = true;
+    registerPredicateKind(PENDING_KIND, {
+        compile: (payload) => {
+            const token = payload?.token ?? '';
+            const source = sources.get(token)?.deref();
+            if (!source) {
+                sources.delete(token);
+                return null;
+            }
+            return (row) => {
+                const id = row?.id;
+                return id != null && source.hasPendingRow(String(id));
+            };
+        },
+        describe: () => 'Has a proposed change',
+    });
+}
+/** Make a review's rows filterable; returns the token its filter node names. */
+export function trackPendingSource(token, source) {
+    register();
+    enableAdvancedFilter();
+    sources.set(token, new WeakRef(source));
+}
+/** The user's expression without any of our nodes; null when nothing is left. */
+export function stripPending(expr) {
+    if (!expr)
+        return null;
+    if (expr.kind === 'ext' && expr.type === PENDING_KIND)
+        return null;
+    if (expr.kind === 'and' || expr.kind === 'or') {
+        const parts = expr.parts.map(stripPending).filter((p) => p !== null);
+        if (!parts.length)
+            return null;
+        return parts.length === 1 && expr.kind === 'and' ? parts[0] : { ...expr, parts };
+    }
+    if (expr.kind === 'not') {
+        const inner = stripPending(expr.expr);
+        return inner ? { kind: 'not', expr: inner } : null;
+    }
+    return expr;
+}
+/**
+ * The user's expression with our node ANDed on. `nonce` changes the node, so
+ * the grid filters again after proposals were decided.
+ */
+export function withPending(expr, token, nonce) {
+    const node = { kind: 'ext', type: PENDING_KIND, payload: { token, nonce } };
+    const rest = stripPending(expr);
+    return rest ? { kind: 'and', parts: [rest, node] } : node;
+}
+/** Whether an expression holds our node. */
+export function hasPending(expr) {
+    if (!expr)
+        return false;
+    if (expr.kind === 'ext')
+        return expr.type === PENDING_KIND;
+    if (expr.kind === 'and' || expr.kind === 'or')
+        return expr.parts.some(hasPending);
+    if (expr.kind === 'not')
+        return hasPending(expr.expr);
+    return false;
+}

package/dist/review/rich-cells.d.ts

@@ -0,0 +1 @@
+export declare function registerRichCellMarks(): void;

package/dist/review/rich-cells.js

@@ -0,0 +1,36 @@
+/**
+ * The proposed value beside a cell the in-cell wrapper (`ghost.ts`) cannot
+ * take: a select, a rating, a person, a checkbox, a field type with a cell of
+ * its own. The grid's `cellDecor` slot draws a mark after the cell's own
+ * content, so the cell stays as it is and "-> Closed" follows it.
+ *
+ * Registered once, by the first review: `cellDecor` takes every cell off the
+ * grid's plain-text fast path, which an app without a review should not pay.
+ */
+import { getGridExtension, registerGridExtension } from '@svgrid/grid';
+import { cellProposalFor } from './card-marks.svelte.js';
+import { canGhost } from './ghost.js';
+import RichCellMark from './RichCellMark.svelte';
+let registered = false;
+export function registerRichCellMarks() {
+    if (registered)
+        return;
+    registered = true;
+    const before = getGridExtension()?.cellDecor;
+    registerGridExtension({
+        cellDecor: (ctrl, row, column) => {
+            const own = before?.(ctrl, row, column);
+            if (own)
+                return own;
+            const def = column?.columnDef;
+            if (!def?.field || !row || row.original === undefined)
+                return null;
+            // Cheap lookups first: this runs for every cell of every grid.
+            const p = cellProposalFor(ctrl?.props?.getRowId, row.original, String(row.id), def.field);
+            if (!p)
+                return null;
+            // The wrapper draws the proposal in cells it can wrap.
+            return canGhost(def, row.original?.[def.field]) ? null : RichCellMark;
+        },
+    });
+}

package/dist/review/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Change review types. A proposal is a write nobody typed (an AI result, an
+ * agent edit, an import, a sync) held apart from the data until a person
+ * accepts it. Pure types, so the clustering and the adapters stay free of
+ * Svelte and testable on their own.
+ */
+/** What produced a proposal. `id` keeps two runs of the same kind apart. */
+export type ProposalSource = {
+    kind: 'agent' | 'ai' | 'import' | 'bulk' | 'sync' | 'rule' | 'user';
+    id: string;
+    label: string;
+};
+export type ProposalStatus = 'pending' | 'accepted' | 'rejected' | 'stale' | 'conflict';
+export type Proposal = {
+    id: string;
+    /** Only `update` in this release; inserts and deletes come later. */
+    op: 'update';
+    /** The grid's row id (its `getRowId`), never a row index. */
+    rowId: string;
+    /** The field on the row object the value is written to. */
+    field: string;
+    /** The value when the proposal was made, which is what staleness compares with. */
+    before: unknown;
+    after: unknown;
+    source: ProposalSource;
+    /** Why, in the producer's words (an AI rationale, an import file name). */
+    reason?: string;
+    /** 0..1, when the producer has one. */
+    confidence?: number;
+    createdAt: number;
+    status: ProposalStatus;
+    /** Why a proposal is stale, skipped or in conflict, for the panel. */
+    note?: string;
+    decidedBy?: string;
+    decidedAt?: number;
+};
+/** What a producer hands over: a proposal without the fields the review fills in. */
+export type ProposalInput = Omit<Proposal, 'id' | 'op' | 'source' | 'createdAt' | 'status' | 'note' | 'decidedBy' | 'decidedAt'> & {
+    id?: string;
+    confidence?: number;
+};
+/** One batch from one producer. */
+export type ChangeSet = {
+    id: string;
+    title: string;
+    source: ProposalSource;
+    createdAt: number;
+    proposals: Proposal[];
+};
+/**
+ * How a group's members relate. The first four are rule groups: every member
+ * is proven to follow the rule. The rest are judgment groups, where a person
+ * has to look.
+ */
+export type GroupKind = 'whitespace' | 'case' | 'format' | 'scale' | 'same-mapping' | 'fill-empty' | 'constant-target' | 'unpatterned';
+export type ProposalGroup = {
+    /** Stable while the group's members do not change: source, field, kind and param. */
+    key: string;
+    kind: GroupKind;
+    /** True for the four rule kinds. */
+    rule: boolean;
+    /** What the members share, in the detector's terms ('upper', '100', a value...). */
+    param: string;
+    label: string;
+    field: string;
+    sourceId: string;
+    ids: string[];
+    count: number;
+    /** Lowest and mean confidence over the members that have one; undefined when none do. */
+    minConfidence?: number;
+    avgConfidence?: number;
+    /** Up to five ids to look at first: the least confident, then spread across the group. */
+    sample: string[];
+    /**
+     * For `constant-target` and `same-mapping`: the five most common `before`
+     * values and how many of each, then one `other` entry for the rest.
+     */
+    beforeDistribution?: Array<{
+        value: unknown;
+        count: number;
+        other?: true;
+    }>;
+};

package/dist/review/types.js

@@ -0,0 +1,7 @@
+/**
+ * Change review types. A proposal is a write nobody typed (an AI result, an
+ * agent edit, an import, a sync) held apart from the data until a person
+ * accepts it. Pure types, so the clustering and the adapters stay free of
+ * Svelte and testable on their own.
+ */
+export {};

package/dist/upgrade-prompt.d.ts

@@ -1,5 +1,5 @@
 /** Human-readable labels for the Enterprise surfaces that gate behind a license. */
-export type EnterpriseFeatureLabel = 'Export' | 'Import' | 'Print' | 'AI assistant' | 'Pivot' | 'Server-side row model' | 'Spreadsheet' | 'SvGrid Base' | 'Studio';
+export type EnterpriseFeatureLabel = 'Export' | 'Import' | 'Print' | 'AI assistant' | 'Pivot' | 'Server-side row model' | 'Spreadsheet' | 'SvGrid Base' | 'Studio' | 'Change review';
 /**
  * Show the contextual upgrade prompt for `feature`. No-ops if one has already
  * been shown this session, a card is already up, or we're on the server. Safe

package/dist/version.d.ts

@@ -10,7 +10,7 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export declare const SVGRID_VERSION = "3.1.22";
+export declare const SVGRID_VERSION = "3.1.23";
 /**
  * The version of `@svgrid/grid`, which releases on its own line: enterprise is
  * on 3.1.x while the grid is on 3.0.x.
@@ -23,4 +23,4 @@ export declare const SVGRID_VERSION = "3.1.22";
  *
  * `version.test.ts` asserts this matches packages/grid/package.json.
  */
-export declare const GRID_VERSION = "3.0.21";
+export declare const GRID_VERSION = "3.0.22";

package/dist/version.js

@@ -10,7 +10,7 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export const SVGRID_VERSION = '3.1.22';
+export const SVGRID_VERSION = '3.1.23';
 /**
  * The version of `@svgrid/grid`, which releases on its own line: enterprise is
  * on 3.1.x while the grid is on 3.0.x.
@@ -23,4 +23,4 @@ export const SVGRID_VERSION = '3.1.22';
  *
  * `version.test.ts` asserts this matches packages/grid/package.json.
  */
-export const GRID_VERSION = '3.0.21';
+export const GRID_VERSION = '3.0.22';

package/dist/wc/merges-DQTOlMWM.js

@@ -0,0 +1,109 @@
+//#region ../grid/dist/merges.js
+var e = (e, t) => `${e}:${t}`;
+function t(t) {
+	if (!t || t.length === 0) return null;
+	let n = /* @__PURE__ */ new Map(), r = [];
+	for (let i of t) {
+		let t = Math.max(1, Math.floor(i.rowSpan)), a = Math.max(1, Math.floor(i.colSpan));
+		if (t === 1 && a === 1) continue;
+		let o = {
+			rowIndex: i.rowIndex,
+			colIndex: i.colIndex,
+			rowSpan: t,
+			colSpan: a
+		};
+		r.push(o);
+		for (let r = o.rowIndex; r < o.rowIndex + t; r += 1) for (let t = o.colIndex; t < o.colIndex + a; t += 1) n.set(e(r, t), o);
+	}
+	return r.length ? {
+		list: r,
+		byCell: n
+	} : null;
+}
+function n(t, n, r) {
+	return t?.byCell.get(e(n, r));
+}
+function r(e, t, r) {
+	let i = n(e, t, r);
+	return !!i && (i.rowIndex !== t || i.colIndex !== r);
+}
+function i(e, t, r) {
+	let i = n(e, t, r);
+	return i ? {
+		rowIndex: i.rowIndex,
+		colIndex: i.colIndex
+	} : {
+		rowIndex: t,
+		colIndex: r
+	};
+}
+function a(e, t, r) {
+	let i = n(e, t, r);
+	return i ? {
+		rowIndex: i.rowIndex + i.rowSpan - 1,
+		colIndex: i.colIndex + i.colSpan - 1
+	} : {
+		rowIndex: t,
+		colIndex: r
+	};
+}
+function o(e, t) {
+	if (!e) return t;
+	let { minRow: n, maxRow: r, minCol: i, maxCol: a } = t;
+	for (let t = 0; t < 64; t += 1) {
+		let t = !1;
+		for (let o of e.list) {
+			let e = o.rowIndex + o.rowSpan - 1, s = o.colIndex + o.colSpan - 1;
+			o.rowIndex <= r && e >= n && o.colIndex <= a && s >= i && (o.rowIndex < n && (n = o.rowIndex, t = !0), e > r && (r = e, t = !0), o.colIndex < i && (i = o.colIndex, t = !0), s > a && (a = s, t = !0));
+		}
+		if (!t) break;
+	}
+	return n === t.minRow && r === t.maxRow && i === t.minCol && a === t.maxCol ? t : {
+		minRow: n,
+		maxRow: r,
+		minCol: i,
+		maxCol: a
+	};
+}
+function s(e, t, r, i) {
+	if (!e) return r;
+	let a = n(e, r.rowIndex, r.colIndex);
+	if (!a) return r;
+	if (n(e, t.rowIndex, t.colIndex) !== a) return {
+		rowIndex: a.rowIndex,
+		colIndex: a.colIndex
+	};
+	let o = Math.sign(r.rowIndex - t.rowIndex), s = Math.sign(r.colIndex - t.colIndex);
+	if (o === 0 && s === 0) return {
+		rowIndex: a.rowIndex,
+		colIndex: a.colIndex
+	};
+	let c = r.rowIndex, l = r.colIndex;
+	if (o > 0 ? c = a.rowIndex + a.rowSpan : o < 0 && (c = a.rowIndex - 1), s > 0 ? l = a.colIndex + a.colSpan : s < 0 && (l = a.colIndex - 1), c < 0 || c > i.maxRow || l < 0 || l > i.maxCol) return {
+		rowIndex: a.rowIndex,
+		colIndex: a.colIndex
+	};
+	let u = n(e, c, l);
+	return u ? {
+		rowIndex: u.rowIndex,
+		colIndex: u.colIndex
+	} : {
+		rowIndex: c,
+		colIndex: l
+	};
+}
+function c(e, t, r, i) {
+	let a = n(e, t, r);
+	if (!a) return null;
+	let o = Math.max(a.rowIndex, i.firstRow), s = Math.max(a.colIndex, i.firstCol);
+	if (t !== o || r !== s) return { kind: "skip" };
+	let c = o === a.rowIndex && s === a.colIndex, l = Math.max(1, Math.min(a.rowIndex + a.rowSpan - t, i.lastRow - t + 1)), u = Math.max(1, Math.min(a.colIndex + a.colSpan - r, i.lastCol - r + 1));
+	return {
+		kind: c ? "origin" : "continuation",
+		merge: a,
+		rowSpan: l,
+		colSpan: u
+	};
+}
+//#endregion
+export { t as buildMergeIndex, a as endOf, o as expandRectToMerges, r as isCovered, n as mergeAt, c as mergeDrawAt, i as originOf, s as stepPastMerge };