@svgrid/enterprise 2.5.3 → 2.6.1

package/dist/alerts/alert-storage.js

@@ -0,0 +1,92 @@
+/** In-memory storage (default). State lives only as long as the manager. */
+export function memoryAlertRules(initial = []) {
+    let rules = [...initial];
+    return {
+        read: () => rules,
+        write: (next) => {
+            rules = next;
+        },
+    };
+}
+/** localStorage-backed storage. Safe to construct under SSR (no-ops there). */
+export function localStorageAlertRules(key) {
+    const available = typeof localStorage !== 'undefined';
+    return {
+        read() {
+            if (!available)
+                return [];
+            try {
+                const raw = localStorage.getItem(key);
+                const parsed = raw ? JSON.parse(raw) : [];
+                return Array.isArray(parsed) ? parsed : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        write(rules) {
+            if (!available)
+                return;
+            try {
+                localStorage.setItem(key, JSON.stringify(rules));
+            }
+            catch {
+                // quota / private-mode - persistence is best-effort
+            }
+        },
+    };
+}
+/** CRUD manager over a storage adapter (defaults to in-memory). */
+export function createAlertRules(storage = memoryAlertRules()) {
+    const load = () => storage.read();
+    const commit = (rules) => storage.write(rules);
+    return {
+        list: () => load(),
+        get: (id) => load().find((r) => r.id === id),
+        save(rule) {
+            const rules = load();
+            const i = rules.findIndex((r) => r.id === rule.id);
+            if (i >= 0)
+                rules[i] = rule;
+            else
+                rules.push(rule);
+            commit(rules);
+            return rule;
+        },
+        remove(id) {
+            const rules = load();
+            const next = rules.filter((r) => r.id !== id);
+            if (next.length === rules.length)
+                return false;
+            commit(next);
+            return true;
+        },
+        rename(id, name) {
+            const rules = load();
+            const rule = rules.find((r) => r.id === id);
+            if (!rule)
+                return false;
+            rule.name = name;
+            commit(rules);
+            return true;
+        },
+        toggle(id) {
+            const rules = load();
+            const rule = rules.find((r) => r.id === id);
+            if (!rule)
+                return undefined;
+            rule.enabled = !rule.enabled;
+            commit(rules);
+            return rule.enabled;
+        },
+        export() {
+            return JSON.stringify(load(), null, 2);
+        },
+        import(json) {
+            const parsed = JSON.parse(json);
+            const rules = Array.isArray(parsed) ? parsed : [];
+            commit(rules);
+            return rules;
+        },
+    };
+}

package/dist/alerts/alert-store.svelte.d.ts

@@ -0,0 +1,24 @@
+/**
+ * alert-store - the reactive log behind the alerts badge + panel. A singleton
+ * queue of fired `AlertEvent`s (newest first) with an unacknowledged count,
+ * mirroring the grid's `toast-store` shape. The observer pushes events here; the
+ * badge reads `activeCount`; the panel lists, acknowledges, and clears them.
+ *
+ * Perf: a burst of events from one evaluation is written in ONE array update via
+ * `pushMany` (not one reassignment per event), and `activeCount` is a maintained
+ * counter - not an O(n) reduce recomputed on every render.
+ */
+import type { AlertEvent } from './alert-types';
+/** The shared alerts log. Read `.events` / `.activeCount` inside a component. */
+export declare const alertStore: {
+    readonly events: AlertEvent[];
+    /** Number of unacknowledged events (what the badge shows). */
+    readonly activeCount: number;
+    /** Append one event (kept for API compatibility; prefer `pushMany`). */
+    push(event: AlertEvent): void;
+    /** Append a batch of events in a single reactive update (newest first). */
+    pushMany(batch: ReadonlyArray<AlertEvent>): void;
+    acknowledge(index: number): void;
+    acknowledgeAll(): void;
+    clear(): void;
+};

package/dist/alerts/alert-store.svelte.js

@@ -0,0 +1,69 @@
+const MAX = 500;
+function createAlertStore() {
+    let events = $state([]);
+    let active = $state(0);
+    let seq = 0;
+    /** Recompute the unacknowledged counter after a trim/clear/ack. */
+    function recount(list) {
+        let n = 0;
+        for (const e of list)
+            if (!e.acknowledged)
+                n++;
+        return n;
+    }
+    return {
+        get events() {
+            return events;
+        },
+        /** Number of unacknowledged events (what the badge shows). */
+        get activeCount() {
+            return active;
+        },
+        /** Append one event (kept for API compatibility; prefer `pushMany`). */
+        push(event) {
+            this.pushMany([event]);
+        },
+        /** Append a batch of events in a single reactive update (newest first). */
+        pushMany(batch) {
+            if (batch.length === 0)
+                return;
+            const tagged = [];
+            let added = 0;
+            // Newest first: reverse so the last event in the batch ends up on top.
+            for (let i = batch.length - 1; i >= 0; i--) {
+                tagged.push({ ...batch[i], _id: ++seq });
+                if (!batch[i].acknowledged)
+                    added++;
+            }
+            let next = [...tagged, ...events];
+            if (next.length > MAX) {
+                next = next.slice(0, MAX);
+                // A trim can drop unacknowledged events - recount to stay exact.
+                active = recount(next);
+            }
+            else {
+                active += added;
+            }
+            events = next;
+        },
+        acknowledge(index) {
+            const next = events.slice();
+            const cur = next[index];
+            if (cur && !cur.acknowledged) {
+                next[index] = { ...cur, acknowledged: true };
+                active = Math.max(0, active - 1);
+                events = next;
+            }
+        },
+        acknowledgeAll() {
+            events = events.map((e) => (e.acknowledged ? e : { ...e, acknowledged: true }));
+            active = 0;
+        },
+        clear() {
+            events = [];
+            active = 0;
+        },
+    };
+}
+/** The shared alerts log. Read `.events` / `.activeCount` inside a component. */
+export const alertStore = createAlertStore();

package/dist/alerts/alert-types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Alert Rules engine - the model layer.
+ *
+ * An alert rule is a declarative "when this predicate holds (or this value
+ * moves), do these things": raise a toast, paint a badge/highlight, flash the
+ * cell, veto the edit, or log it. Rules are authored by end users at runtime,
+ * persisted, and shareable - the AdapTable-style alerting surface, built on the
+ * grid's own filter/conditional-format engines.
+ *
+ * Predicates and change tests come from the expression layer (`../expressions`).
+ */
+import type { ChangeExpr, PredicateExpr } from '../expressions/expression-types';
+import type { Schedule } from '../scheduling';
+/** Maps onto the toast variants + conditional-format intent. */
+export type AlertSeverity = 'info' | 'success' | 'warning' | 'error';
+/** What the rule watches over. */
+export type AlertScope = 'row' | 'cell' | 'aggregate';
+/**
+ * When a rule fires:
+ * - `dataChange`   - a row newly satisfies `predicate` after an edit/update.
+ * - `relativeChange` - a value moved (delta / percent / crossed a threshold).
+ * - `validation`   - evaluated on edit; may veto the change (`preventEdit`).
+ * - `scheduled`    - re-checked on a cron/one-off schedule (reuses the enterprise
+ *                    scheduler); surfaces rows currently matching `predicate`.
+ */
+export type AlertTrigger = {
+    type: 'dataChange';
+} | {
+    type: 'relativeChange';
+    expr: ChangeExpr;
+} | {
+    type: 'validation';
+} | {
+    type: 'scheduled';
+    schedule: Schedule;
+};
+/** A thing the rule does when it fires. */
+export type AlertActionKind = 'toast' | 'badge' | 'cellFlash' | 'highlight' | 'preventEdit' | 'log';
+/** Visual styling for `badge` / `highlight` actions. */
+export type AlertActionStyle = {
+    background?: string;
+    color?: string;
+    /** A short glyph/emoji shown as a badge. */
+    icon?: string;
+};
+export type AlertAction = {
+    kind: AlertActionKind;
+    /**
+     * Message template. Tokens: `{rule}`, `{severity}`, `{column}`, `{value}`,
+     * and `{field}` / `{row.field}` for any row field.
+     */
+    message?: string;
+    style?: AlertActionStyle;
+    /** Columns the badge/highlight/flash targets (defaults to the rule's). */
+    columns?: string[];
+};
+export type AlertRule = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    severity: AlertSeverity;
+    scope: AlertScope;
+    predicate: PredicateExpr;
+    trigger: AlertTrigger;
+    actions: AlertAction[];
+    /** Columns in scope for cell-level styling (badge/highlight/flash). */
+    columns?: string[];
+    createdAt: number;
+};
+/** A single firing of a rule. */
+export type AlertEvent = {
+    ruleId: string;
+    ruleName: string;
+    severity: AlertSeverity;
+    scope: AlertScope;
+    triggerType: AlertTrigger['type'];
+    /** The row that matched (absent for aggregate-scope events). */
+    rowId?: string;
+    /** The column that triggered/targets the event, when applicable. */
+    columnId?: string;
+    value?: unknown;
+    message: string;
+    actions: AlertAction[];
+    firedAt: number;
+    acknowledged?: boolean;
+};

package/dist/alerts/alert-types.js

@@ -0,0 +1 @@
+export {};

package/dist/alerts.d.ts

@@ -0,0 +1,2 @@
+/** Turn on the alerts feature (soft-gated). Idempotent. */
+export declare function enableAlerts(): void;

package/{src/alerts.ts → dist/alerts.js}

@@ -15,14 +15,14 @@
  * // spread `formats` into <SvGrid conditionalFormats={[...base, ...formats]} />
  * ```
  */
-import { isLicenseKeySet } from './license'
-import { emitUnlicensedNudge } from './watermark'
-
-let enabled = false
-
+import { isLicenseKeySet } from './license';
+import { emitUnlicensedNudge } from './watermark';
+let enabled = false;
 /** Turn on the alerts feature (soft-gated). Idempotent. */
-export function enableAlerts(): void {
-  if (enabled) return
-  enabled = true
-  if (!isLicenseKeySet()) emitUnlicensedNudge()
+export function enableAlerts() {
+    if (enabled)
+        return;
+    enabled = true;
+    if (!isLicenseKeySet())
+        emitUnlicensedNudge();
 }

package/dist/board.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Register the Enterprise Kanban board view. Idempotent - safe to call from every
+ * component that uses `board`, or once at app start. Also invoked by
+ * {@link installEnterprise} so wiring the Pro API turns the view on too.
+ */
+export declare function enableBoardView(): void;
+export { default as SvGridBoard } from './SvGridBoard.svelte';

package/{src/board.ts → dist/board.js}

@@ -14,23 +14,22 @@
  * // then: <SvGrid {data} {columns} board={{ groupBy: 'status' }} />
  * ```
  */
-import { registerBoardView } from '@svgrid/grid'
-import { isLicenseKeySet } from './license'
-import { emitUnlicensedNudge } from './watermark'
-import SvGridBoard from './SvGridBoard.svelte'
-
-let enabled = false
-
+import { registerBoardView } from '@svgrid/grid';
+import { isLicenseKeySet } from './license';
+import { emitUnlicensedNudge } from './watermark';
+import SvGridBoard from './SvGridBoard.svelte';
+let enabled = false;
 /**
  * Register the Enterprise Kanban board view. Idempotent - safe to call from every
  * component that uses `board`, or once at app start. Also invoked by
  * {@link installEnterprise} so wiring the Pro API turns the view on too.
  */
-export function enableBoardView(): void {
-  if (enabled) return
-  enabled = true
-  registerBoardView(SvGridBoard as never)
-  if (!isLicenseKeySet()) emitUnlicensedNudge()
+export function enableBoardView() {
+    if (enabled)
+        return;
+    enabled = true;
+    registerBoardView(SvGridBoard);
+    if (!isLicenseKeySet())
+        emitUnlicensedNudge();
 }
-
-export { default as SvGridBoard } from './SvGridBoard.svelte'
+export { default as SvGridBoard } from './SvGridBoard.svelte';