@svgrid/enterprise 2.5.2 → 2.6.0

package/src/ai-export-xlsx.dom.test.ts

@@ -1,90 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Real exportGrid runs (NOT mocked). Capture the xlsx parts / avoid the DOM.
-const captured: { parts: Record<string, string> } = { parts: {} }
-vi.mock('jszip', () => ({
-  default: class {
-    file(p: string, d: string) {
-      captured.parts[p] = d
-    }
-    async generateAsync() {
-      return new Blob([])
-    }
-  },
-}))
-vi.mock('./export-serialize', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>
-  return { ...actual, downloadBlobFile: () => {}, downloadTextFile: () => {} }
-})
-
-import { aiExport, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
-import { exportGrid } from './export'
-import { setLicenseKey } from './license'
-
-// Mirrors the real makeOrders shape - crucially includes `inStock` (boolean)
-// and `quantity`/`index` (numbers that never exceed 300), so the mock must
-// target `price` for "$300", not a boolean or a count.
-type Order = {
-  id: string
-  index: number
-  country: string
-  company: string
-  product: string
-  inStock: boolean
-  quantity: number
-  price: number
-}
-const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
-  id: `o${i}`,
-  index: i + 1,
-  country: ['USA', 'UK', 'Germany'][i % 3]!,
-  company: `Co${i}`,
-  product: 'Widget',
-  inStock: i % 3 !== 0,
-  quantity: 5 + (i % 50), // max 54 - never > 300
-  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
-}))
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'country', field: 'country', header: 'Country', visible: true },
-      { id: 'company', field: 'company', header: 'Company', visible: true },
-      { id: 'product', field: 'product', header: 'Product', visible: true },
-      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
-      { id: 'price', field: 'price', header: 'Price', visible: true, format: { type: 'currency', currency: 'USD' } },
-    ],
-    getState: () => ({ grouping: [] }),
-    getColumnPinning: () => ({ left: [], right: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-    setGroupBy: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  captured.parts = {}
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-  // aiExport is free (grid) and delegates the real write to enterprise's engine.
-  registerExportProvider(exportGrid as never)
-})
-
-describe('aiExport - "export orders over $300" (xlsx default)', () => {
-  it('produces a non-empty xlsx via the real export path', async () => {
-    const plan = await aiExport(makeApi(), 'export orders over $300')
-    expect(plan.format).toBe('xlsx')
-    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
-
-    const sheet = captured.parts['xl/worksheets/sheet1.xml']
-    expect(sheet).toBeTruthy()
-    // header row + at least one data row
-    const rowCount = (sheet!.match(/<row /g) ?? []).length
-    expect(rowCount).toBeGreaterThan(1)
-  })
-})

package/src/ai-export.dom.test.ts

@@ -1,114 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Capture downloads instead of touching the DOM (aiExport -> exportGrid).
-const downloads: Array<{ text: string; filename: string }> = []
-vi.mock('./export-serialize', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>
-  return {
-    ...actual,
-    downloadTextFile: (text: string, filename: string) => {
-      downloads.push({ text, filename })
-    },
-  }
-})
-
-import { aiExport, aiFindAnomalies, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
-import { exportGrid } from './export'
-import { setLicenseKey } from './license'
-
-type Row = { region: string; amount: number; name: string }
-const rows: Row[] = [
-  { region: 'EMEA', amount: 100, name: 'A' },
-  { region: 'NA', amount: 2000, name: 'B' },
-  { region: 'EMEA', amount: 50, name: 'C' },
-]
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'region', field: 'region', header: 'Region', visible: true },
-      { id: 'amount', field: 'amount', header: 'Amount', visible: true },
-      { id: 'name', field: 'name', header: 'Name', visible: true },
-    ],
-    getState: () => ({ grouping: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  downloads.length = 0
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-  // aiExport is free (grid) and delegates the WRITE to the registered engine;
-  // register enterprise's exportGrid so the download path actually runs.
-  registerExportProvider(exportGrid as never)
-})
-afterEach(() => setAIProvider(null))
-
-describe('aiExport', () => {
-  it('parses format + groupBy + filters; applies to the grid only when asked', async () => {
-    const api = makeApi()
-    const plan = await aiExport(api, 'export deals over 500 grouped by region as a pdf', {
-      run: false,
-      apply: true,
-    })
-    expect(plan.format).toBe('pdf')
-    expect(plan.groupBy).toEqual(['region'])
-    expect(plan.filters).toContainEqual({ field: 'amount', operator: 'greaterThan', value: '500' })
-    // apply: true -> the grid is mutated
-    expect(api.clearAllFilters).toHaveBeenCalled()
-    expect(api.setFilter).toHaveBeenCalledWith('amount', { operator: 'greaterThan', value: '500' })
-    // run:false -> nothing downloaded
-    expect(downloads).toHaveLength(0)
-  })
-
-  it('defaults to xlsx and does NOT touch the grid (apply defaults off)', async () => {
-    const api = makeApi()
-    const plan = await aiExport(api, 'just export everything', { run: false })
-    expect(plan.format).toBe('xlsx')
-    expect(api.clearAllFilters).not.toHaveBeenCalled()
-    expect(api.setFilter).not.toHaveBeenCalled()
-  })
-
-  it('runs the export (downloads) when run is not false', async () => {
-    const api = makeApi()
-    await aiExport(api, 'export as csv', { filename: 'report' })
-    expect(downloads).toHaveLength(1)
-    expect(downloads[0]!.filename).toBe('report.csv')
-  })
-
-  it('exports the plan-filtered rows directly (not the grid displayed rows)', async () => {
-    // getDisplayedRows returns EVERYTHING (as if the grid hadn't re-filtered);
-    // the export must still contain only rows matching the plan's filter.
-    const api = makeApi()
-    await aiExport(api, 'export deals over 500 as csv', { filename: 'big' })
-    const { text } = downloads[0]!
-    expect(text).toContain('2000') // amount 2000 > 500 kept
-    expect(text).not.toContain('100') // amount 100 filtered out
-    expect(text).not.toContain('50') // amount 50 filtered out
-  })
-})
-
-describe('aiFindAnomalies', () => {
-  it('flags a numeric outlier over the scanned rows', async () => {
-    const api = makeApi()
-    const result = await aiFindAnomalies(api, {})
-    expect(result.anomalies.length).toBeGreaterThan(0)
-    const amountAnomaly = result.anomalies.find((a) => a.field === 'amount')
-    expect(amountAnomaly?.value).toBe(2000) // the max in the sample
-    expect(amountAnomaly?.severity).toBe('medium')
-    expect(result.summary).toBeTruthy()
-  })
-
-  it('returns empty for an empty selection', async () => {
-    const api = makeApi()
-    const result = await aiFindAnomalies(api, { target: { kind: 'selection', rowIndices: [] } })
-    expect(result.anomalies).toEqual([])
-  })
-})

package/src/alerts/alert-engine-attach.ts

@@ -1,165 +0,0 @@
-/**
- * Headless glue between the pure engine and the running grid.
- *
- * The grid's `onCellValueChange` fires only for edits made through the grid, not
- * for streaming feeds / server pushes / a programmatic `data = ...`. Alerts must
- * react to all of those, so we observe changes by diffing snapshots (the same
- * approach the grid's `attachAutoSavedView` uses for state). `applyAlertEvents`
- * routes fired events
- * to their side effects (toast, log) and returns the visual bits (conditional
- * formats + cells to flash) for the caller to paint. The `<SvGridAlerts>`
- * overlay drives this reactively via `$effect`; `attachAlertEngine` offers the
- * same as a plain-JS interval poll for non-Svelte hosts.
- */
-import type { ConditionalFormat } from '@svgrid/grid/format'
-import { toast } from '@svgrid/grid'
-import { alertStore } from './alert-store.svelte'
-import { toConditionalFormats } from './alert-formats'
-import { createAlertEngine, type AlertEngine } from './alert-engine'
-import type { AlertEvent, AlertRule } from './alert-types'
-
-export type FlashTarget = { rowId: string; columnId?: string }
-
-export type ApplyAlertOptions = {
-  /**
-   * Gate which fired events actually raise a toast. Every event is still logged
-   * (the badge/panel stay accurate) - this only suppresses the visible toast, so
-   * a busy live feed does not become a toast storm. Return `false` to skip the
-   * toast. Defaults to always-toast.
-   */
-  shouldToast?: (event: AlertEvent) => boolean
-}
-
-/**
- * Perform the side effects of a batch of fired events and return the visual
- * output: every event is recorded in the log (so the badge/panel stay accurate),
- * `toast` actions raise a toast (subject to `shouldToast`), and
- * `badge`/`highlight`/`cellFlash` actions yield formats + flash targets for the
- * caller to apply to the grid.
- *
- * The whole batch lands in the log in ONE reactive write (`pushMany`) so a burst
- * of firings from a single evaluation does not thrash the store.
- */
-export function applyAlertEvents<TData = Record<string, unknown>>(
-  events: ReadonlyArray<AlertEvent>,
-  getRowId: (row: TData) => string,
-  options: ApplyAlertOptions = {},
-): { formats: ConditionalFormat<TData>[]; flashes: FlashTarget[] } {
-  if (events.length === 0) return { formats: [], flashes: [] }
-  alertStore.pushMany(events)
-  const allow = options.shouldToast
-  for (const event of events) {
-    if (event.actions.some((a) => a.kind === 'toast') && (!allow || allow(event))) {
-      toast[event.severity](event.message)
-    }
-  }
-  const flashes: FlashTarget[] = []
-  for (const event of events) {
-    if (event.rowId && event.actions.some((a) => a.kind === 'cellFlash')) {
-      flashes.push({ rowId: event.rowId, columnId: event.columnId })
-    }
-  }
-  return { formats: toConditionalFormats(events, getRowId), flashes }
-}
-
-export type AttachAlertOptions<TData> = {
-  rules: AlertRule[]
-  getRowId: (row: TData) => string
-  /** Read the grid's current rows. */
-  getData: () => ReadonlyArray<TData>
-  getValue?: (row: TData, columnId: string) => unknown
-  locale?: string | ReadonlyArray<string>
-  /** Merge alert-driven conditional formats into the grid. */
-  applyFormats?: (formats: ConditionalFormat<TData>[]) => void
-  /** Flash a cell (e.g. call `api.flashCells`). */
-  flashCell?: (target: FlashTarget) => void
-  /** Poll interval in ms (`0` disables polling - drive `tick()` yourself). */
-  intervalMs?: number
-}
-
-export type AlertAttachment<TData> = {
-  engine: AlertEngine<TData>
-  /** Run one evaluation pass against the latest data. */
-  tick(): void
-  /** Push new rules into the engine (e.g. after the user edits a rule). */
-  setRules(rules: AlertRule[]): void
-  detach(): void
-}
-
-/**
- * Wire the engine to a data source. On the first pass it seeds edges silently
- * from the current snapshot (so pre-existing matches do not fire); thereafter
- * each pass fires newly-matching rows.
- *
- * Perf: cloning a previous snapshot is gated on `engine.needsPrev()`. For a rule
- * set that is purely `dataChange`/aggregate (the common case) NO clone is taken -
- * `engine.evaluate` re-checks the current rows and its edge memory (the `active`
- * set) fires each row exactly once when it starts matching. Only `relativeChange`
- * rules, which compare prev -> next, pay for a snapshot. This is the non-Svelte
- * poll host; for the reactive overlay, `createAlertObserver` adds a scheduler and
- * an O(changed) push path. Returns `detach()` to stop.
- */
-export function attachAlertEngine<TData = Record<string, unknown>>(
-  opts: AttachAlertOptions<TData>,
-): AlertAttachment<TData> {
-  const engine = createAlertEngine<TData>({
-    rules: opts.rules,
-    getRowId: opts.getRowId,
-    getValue: opts.getValue,
-    locale: opts.locale,
-  })
-
-  let prev: TData[] | null = null
-  let seeded = false
-
-  const snapshot = (rows: ReadonlyArray<TData>): TData[] =>
-    rows.map((r) => (r && typeof r === 'object' ? ({ ...r } as TData) : r))
-
-  const flush = (events: AlertEvent[]) => {
-    if (events.length === 0) return
-    const { formats, flashes } = applyAlertEvents(events, opts.getRowId)
-    if (formats.length && opts.applyFormats) opts.applyFormats(formats)
-    if (opts.flashCell) flashes.forEach((f) => opts.flashCell?.(f))
-  }
-
-  const tick = () => {
-    const rows = opts.getData()
-    const needsPrev = engine.needsPrev()
-    let events: AlertEvent[]
-    if (!seeded) {
-      // Silent seed: arm edges from the current set, fire nothing.
-      engine.evaluate(rows)
-      events = []
-      seeded = true
-    } else if (needsPrev) {
-      events = engine.evaluateTransition(prev ?? [], rows)
-    } else {
-      // No rule reads prev - the edge set dedups, so no clone/diff is needed.
-      events = engine.evaluate(rows)
-    }
-    prev = needsPrev ? snapshot(rows) : null
-    flush(events)
-  }
-
-  const interval = opts.intervalMs ?? 400
-  let timer: ReturnType<typeof setInterval> | null = null
-  if (interval > 0) {
-    tick()
-    timer = setInterval(tick, interval)
-  }
-
-  return {
-    engine,
-    tick,
-    setRules(rules) {
-      engine.setRules(rules)
-      engine.reset()
-      prev = null
-      seeded = false
-    },
-    detach() {
-      if (timer) clearInterval(timer)
-      timer = null
-    },
-  }
-}

package/src/alerts/alert-engine.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { createAlertEngine, renderTemplate } from './alert-engine'
-import type { AlertRule } from './alert-types'
-
-type Row = { id: string; price: number; region: string; status: string }
-
-const rows = (over: Partial<Row>[] = []): Row[] =>
-  [
-    { id: 'a', price: 120, region: 'EU', status: 'open' },
-    { id: 'b', price: 80, region: 'US', status: 'open' },
-  ].map((r, i) => ({ ...r, ...(over[i] ?? {}) }))
-
-const getRowId = (r: Row) => r.id
-
-const rule = (over: Partial<AlertRule> = {}): AlertRule => ({
-  id: 'r1',
-  name: 'High price',
-  enabled: true,
-  severity: 'warning',
-  scope: 'row',
-  predicate: { kind: 'cmp', column: 'price', op: 'greaterThan', value: 100 },
-  trigger: { type: 'dataChange' },
-  actions: [{ kind: 'toast', message: '{region} price is {value}' }],
-  createdAt: 0,
-  ...over,
-})
-
-const engine = (r: AlertRule[]) => createAlertEngine<Row>({ rules: r, getRowId, now: () => 1000 })
-
-describe('dataChange edge firing', () => {
-  it('fires once when a row starts matching, not on every pass', () => {
-    const e = engine([rule()])
-    const first = e.evaluate(rows())
-    expect(first).toHaveLength(1)
-    expect(first[0]!.rowId).toBe('a')
-    // Re-evaluating the same data must not re-fire.
-    expect(e.evaluate(rows())).toHaveLength(0)
-  })
-
-  it('re-arms after a row stops matching', () => {
-    const e = engine([rule()])
-    e.evaluate(rows())
-    // 'a' drops below threshold -> no fire, edge memory cleared.
-    expect(e.evaluate(rows([{ price: 90 }]))).toHaveLength(0)
-    // 'a' climbs back over -> fires again.
-    expect(e.evaluate(rows([{ price: 130 }]))).toHaveLength(1)
-  })
-
-  it('fires on transition when a row newly matches after an edit', () => {
-    const e = engine([rule()])
-    const prev = rows([{ price: 90 }]) // 'a' below threshold
-    e.evaluate(prev)
-    const events = e.evaluateTransition(prev, rows([{ price: 130 }]))
-    expect(events).toHaveLength(1)
-    expect(events[0]!.rowId).toBe('a')
-  })
-
-  it('respects disabled rules', () => {
-    const e = engine([rule({ enabled: false })])
-    expect(e.evaluate(rows())).toHaveLength(0)
-  })
-})
-
-describe('relativeChange firing', () => {
-  it('fires when a value jumps by more than the threshold', () => {
-    const r = rule({
-      id: 'r2',
-      trigger: { type: 'relativeChange', expr: { kind: 'percentChange', column: 'price', op: '>', value: 5, abs: true } },
-      predicate: { kind: 'const', value: true },
-    })
-    const e = engine([r])
-    const prev = rows()
-    e.evaluate(prev)
-    const events = e.evaluateTransition(prev, rows([{ price: 140 }])) // +16%
-    expect(events).toHaveLength(1)
-    expect(events[0]!.columnId).toBe('price')
-  })
-
-  it('gates relativeChange on the predicate', () => {
-    const r = rule({
-      id: 'r3',
-      trigger: { type: 'relativeChange', expr: { kind: 'changed', column: 'status' } },
-      predicate: { kind: 'cmp', column: 'status', op: 'equals', value: 'closed' },
-    })
-    const e = engine([r])
-    const prev = rows()
-    // status changes open -> pending: predicate (== closed) fails -> no fire.
-    expect(e.evaluateTransition(prev, rows([{ status: 'pending' }]))).toHaveLength(0)
-    // status changes open -> closed: fires.
-    expect(e.evaluateTransition(prev, rows([{ status: 'closed' }]))).toHaveLength(1)
-  })
-})
-
-describe('aggregate scope', () => {
-  it('fires one edge event when the whole-set predicate flips true', () => {
-    const r = rule({
-      id: 'agg',
-      scope: 'aggregate',
-      predicate: { kind: 'scalarCmp', left: { kind: 'agg', fn: 'sum', column: 'price' }, op: '>', right: { kind: 'lit', value: 250 } },
-    })
-    const e = engine([r])
-    expect(e.evaluate(rows())).toHaveLength(0) // 120+80 = 200
-    const fired = e.evaluate(rows([{ price: 200 }])) // 200+80 = 280
-    expect(fired).toHaveLength(1)
-    expect(fired[0]!.rowId).toBeUndefined()
-  })
-})
-
-describe('validateEdit', () => {
-  it('vetoes an edit that trips a preventEdit validation rule', () => {
-    const r = rule({
-      id: 'v',
-      trigger: { type: 'validation' },
-      predicate: { kind: 'cmp', column: 'price', op: 'lessThan', value: 0 },
-      actions: [{ kind: 'preventEdit', message: 'Price cannot be negative' }],
-    })
-    const e = engine([r])
-    const target = rows()[0]!
-    expect(e.validateEdit(target, 'price', -5).vetoed).toBe(true)
-    expect(e.validateEdit(target, 'price', 50).vetoed).toBe(false)
-  })
-})
-
-describe('renderTemplate', () => {
-  it('fills tokens from the firing context', () => {
-    expect(
-      renderTemplate('{rule}: {region} = {value}', {
-        rule: rule(),
-        row: { region: 'EU' },
-        columnId: 'price',
-        value: 120,
-      }),
-    ).toBe('High price: EU = 120')
-  })
-})