@svgrid/enterprise 2.5.2 → 2.6.0

package/src/SvGridEditPanel.dom.test.ts

@@ -1,320 +0,0 @@
-/**
- * The repo's first runtime (DOM) test: mount SvGridEditPanel in jsdom and assert
- * it renders the *rich* editor suite (not bare native inputs) and round-trips a
- * row's values - the path that was previously only compile-checked. Enabled by
- * the svelte plugin in vite.config.ts.
- */
-import { describe, it, expect, afterEach, vi } from 'vitest'
-import { mount, unmount, flushSync } from 'svelte'
-import SvGridEditPanel from './SvGridEditPanel.svelte'
-import type { EntitySchema } from './schema'
-import { getSampleApp } from './studio/samples/index'
-
-type Customer = { id: string; name: string; mrr: number; active: boolean; tier: string }
-
-const schema: EntitySchema<Customer> = {
-  name: 'customers',
-  idField: 'id',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true, readonly: true },
-    { field: 'name', type: 'text', required: true },
-    { field: 'mrr', type: 'number' },
-    { field: 'active', type: 'boolean' },
-    { field: 'tier', type: 'enum', options: [{ value: 'free', label: 'Free' }, { value: 'pro', label: 'Pro' }] },
-  ],
-}
-
-let host: HTMLElement | null = null
-let comp: ReturnType<typeof mount> | null = null
-
-afterEach(() => {
-  if (comp) { unmount(comp); comp = null }
-  if (host) { host.remove(); host = null }
-})
-
-function render(props: Record<string, unknown>): HTMLElement {
-  // Tear down a previous mount first: a test that renders more than once used to
-  // leak every panel but the last, leaving live components (and duplicate field
-  // ids) in the document for whatever ran next.
-  if (comp) { unmount(comp); comp = null }
-  if (host) { host.remove(); host = null }
-  host = document.createElement('div')
-  document.body.appendChild(host)
-  comp = mount(SvGridEditPanel, { target: host, props })
-  flushSync()
-  return host
-}
-
-describe('SvGridEditPanel (DOM)', () => {
-  it('mounts and renders each field with its rich editor, seeded from the row', () => {
-    const el = render({
-      schema,
-      row: { id: '1', name: 'Ada', mrr: 1200, active: true, tier: 'pro' },
-      presentation: 'inline',
-      onSubmit: vi.fn(),
-      onCancel: vi.fn(),
-    })
-
-    // Field labels are present.
-    expect(el.textContent).toContain('Name')
-    expect(el.textContent).toContain('Mrr')
-
-    // number -> SvNumberInput (its .sv-num__input), not a bare <input type="number">.
-    const numInput = el.querySelector<HTMLInputElement>('.sv-num__input')
-    expect(numInput).toBeTruthy()
-    expect(numInput!.value).toBe('1200') // seeded from the row
-
-    // boolean -> SvSwitchButton, on because active === true.
-    const sw = el.querySelector('.sv-switch')
-    expect(sw).toBeTruthy()
-    expect(sw!.classList.contains('is-on')).toBe(true)
-
-    // The primary action reads "Save" in edit mode.
-    const submit = el.querySelector<HTMLButtonElement>('button[type="submit"]')
-    expect(submit?.textContent?.trim()).toBe('Save')
-  })
-
-  it('is in create mode with no row (empty number, switch off, "Create" button)', () => {
-    const el = render({ schema, presentation: 'inline', onSubmit: vi.fn(), onCancel: vi.fn() })
-    expect(el.querySelector<HTMLInputElement>('.sv-num__input')!.value).toBe('') // empty, not "0"
-    expect(el.querySelector('.sv-switch')!.classList.contains('is-on')).toBe(false)
-    expect(el.querySelector('button[type="submit"]')?.textContent?.trim()).toBe('Create')
-  })
-
-  it('routes each editorType to its rich editor from the suite', () => {
-    const rich: EntitySchema = {
-      name: 'assets',
-      idField: 'id',
-      fields: [
-        { field: 'id', type: 'text', primaryKey: true, readonly: true },
-        { field: 'brand', type: 'text', input: { editorType: 'color' } },
-        { field: 'secret', type: 'text', input: { editorType: 'password' } },
-        { field: 'labels', type: 'text', input: { editorType: 'chips' } },
-        { field: 'due', type: 'date' },
-        { field: 'phone', type: 'text', input: { editorType: 'phone' } },
-        { field: 'score', type: 'number', input: { editorType: 'slider' }, min: 0, max: 10 },
-      ],
-    }
-    const el = render({
-      schema: rich,
-      row: { id: '1', brand: '#ff0000', secret: 'pw', labels: 'a,b', due: '2024-01-02', phone: '+14155550100', score: 7 },
-      presentation: 'inline',
-      onSubmit: vi.fn(),
-      onCancel: vi.fn(),
-    })
-    expect(el.querySelector('.sv-color')).toBeTruthy()  // color -> SvColorInput
-    expect(el.querySelector('.sv-pw')).toBeTruthy()     // password -> SvPasswordInput
-    expect(el.querySelector('.sv-tags')).toBeTruthy()   // chips -> SvTagsInput
-    expect(el.querySelector('.sv-dtp')).toBeTruthy()    // date -> SvDateTimePicker
-    expect(el.querySelector('.sv-phone')).toBeTruthy()  // phone -> SvPhoneInput
-    expect(el.querySelector('.sv-slider')).toBeTruthy() // slider -> SvSlider
-  })
-
-  it('renders the enriched CRM sample forms with real editors (samples <-> edit panel)', () => {
-    const proj = getSampleApp('crm')!.build()
-    const entity = (name: string) => proj.entities.find((e) => e.name === name)!
-    const firstRow = (name: string) => (proj.dataSources?.[name] as { seed?: Record<string, unknown>[] }).seed![0]!
-
-    // Contacts: phone -> SvPhoneInput, segments (chips) -> SvTagsInput.
-    const contacts = render({ schema: entity('contacts'), row: firstRow('contacts'), presentation: 'inline', onSubmit: vi.fn(), onCancel: vi.fn() })
-    expect(contacts.querySelector('.sv-phone')).toBeTruthy()
-    expect(contacts.querySelector('.sv-tags')).toBeTruthy()
-
-    // Deals: probability -> SvSlider (rendered for slider editorType).
-    const deals = render({ schema: entity('deals'), row: firstRow('deals'), presentation: 'inline', onSubmit: vi.fn(), onCancel: vi.fn() })
-    expect(deals.querySelector('.sv-slider')).toBeTruthy()
-
-    // Companies: country -> SvCountryInput, health (rating) -> SvSlider.
-    const companies = render({ schema: entity('companies'), row: firstRow('companies'), presentation: 'inline', onSubmit: vi.fn(), onCancel: vi.fn() })
-    expect(companies.querySelector('.sv-country')).toBeTruthy()
-    expect(companies.querySelector('.sv-slider')).toBeTruthy()
-  })
-
-  it('submits the row values (edit mode, readonly id omitted)', async () => {
-    const onSubmit = vi.fn()
-    const el = render({
-      schema,
-      row: { id: '1', name: 'Ada', mrr: 1200, active: true, tier: 'pro' },
-      presentation: 'inline',
-      onSubmit,
-      onCancel: vi.fn(),
-    })
-    el.querySelector<HTMLButtonElement>('button[type="submit"]')!.click()
-    // Submit validates asynchronously before calling onSubmit.
-    await vi.waitFor(() => expect(onSubmit).toHaveBeenCalledTimes(1))
-    const payload = onSubmit.mock.calls[0]![0] as { mode: string; id: string | null; values: Record<string, unknown> }
-    expect(payload.mode).toBe('edit')
-    expect(payload.id).toBe('1')
-    expect(payload.values).toMatchObject({ name: 'Ada', mrr: 1200, active: true, tier: 'pro' })
-    expect(payload.values).not.toHaveProperty('id') // readonly PK is never submitted
-  })
-
-  it('lays the form out from the schema, so a built form travels with the entity', () => {
-    const laidOut: EntitySchema = {
-      name: 'people',
-      idField: 'id',
-      fields: [
-        { field: 'id', type: 'text', primaryKey: true, readonly: true },
-        { field: 'name', type: 'text' },
-        { field: 'email', type: 'text' },
-        { field: 'street', type: 'text' },
-        { field: 'city', type: 'text' },
-      ],
-      form: {
-        columns: 2,
-        sections: [
-          { title: 'Who', description: 'How we reach them.', fields: ['name', 'email'] },
-          { title: 'Where', columns: 1, fields: ['street', 'city'] },
-        ],
-      },
-    }
-    const el = render({ schema: laidOut, presentation: 'inline', onSubmit: vi.fn() })
-
-    const titles = [...el.querySelectorAll('.sv-ep__section-title')].map((n) => n.textContent)
-    expect(titles).toEqual(['Who', 'Where'])
-    expect(el.querySelector('.sv-ep__section-desc')?.textContent).toBe('How we reach them.')
-
-    // Per-section column count wins over the form's.
-    const bodies = [...el.querySelectorAll<HTMLElement>('.sv-ep__body')]
-    expect(bodies[0]!.style.getPropertyValue('--sv-ep-cols')).toBe('2')
-    expect(bodies[1]!.style.getPropertyValue('--sv-ep-cols')).toBe('1')
-
-    // The unassigned id field is not dropped - it lands in a trailing group.
-    expect(el.querySelector('#sv-ef-id')).toBeTruthy()
-  })
-
-  it('waits until you leave a field before complaining, then clears as you fix it', async () => {
-    const required: EntitySchema = {
-      name: 'people',
-      idField: 'id',
-      fields: [
-        { field: 'id', type: 'text', primaryKey: true, readonly: true },
-        { field: 'email', type: 'text', required: true, format: 'email' },
-      ],
-    }
-    const el = render({ schema: required, presentation: 'inline', onSubmit: vi.fn() })
-    const input = el.querySelector<HTMLInputElement>('#sv-ef-email')!
-
-    // Typing something invalid says nothing yet - the user is mid-thought.
-    input.value = 'nope'
-    input.dispatchEvent(new Event('input', { bubbles: true }))
-    flushSync()
-    expect(el.querySelector('.sv-ep-field__err')).toBeNull()
-    expect(input.getAttribute('aria-invalid')).toBe('false')
-
-    // Leaving it is the moment to speak up.
-    input.dispatchEvent(new FocusEvent('focusout', { bubbles: true }))
-    await vi.waitFor(() => expect(el.querySelector('.sv-ep-field__err')?.textContent).toMatch(/valid email/))
-    expect(input.getAttribute('aria-invalid')).toBe('true')
-    // The message is wired to the input for screen readers.
-    expect(input.getAttribute('aria-describedby')).toBe('sv-ee-email')
-    expect(el.querySelector('#sv-ee-email')).toBeTruthy()
-
-    // Correcting it clears the message without another submit.
-    input.value = 'ada@example.com'
-    input.dispatchEvent(new Event('input', { bubbles: true }))
-    await vi.waitFor(() => expect(el.querySelector('.sv-ep-field__err')).toBeNull())
-    expect(input.getAttribute('aria-invalid')).toBe('false')
-  })
-
-  it('summarises a failed submit and focuses the first field that needs fixing', async () => {
-    const required: EntitySchema = {
-      name: 'people',
-      idField: 'id',
-      fields: [
-        { field: 'id', type: 'text', primaryKey: true, readonly: true },
-        { field: 'name', type: 'text', required: true },
-        { field: 'email', type: 'text', required: true },
-      ],
-    }
-    const onSubmit = vi.fn()
-    const el = render({ schema: required, presentation: 'inline', onSubmit })
-
-    el.querySelector<HTMLButtonElement>('button[type="submit"]')!.click()
-
-    await vi.waitFor(() => expect(el.querySelector('.sv-ep__summary')).toBeTruthy())
-    expect(onSubmit).not.toHaveBeenCalled()
-    const summary = el.querySelector('.sv-ep__summary')!
-    expect(summary.getAttribute('role')).toBe('alert')
-    expect(summary.textContent).toContain('Name')
-    expect(summary.textContent).toContain('Email')
-    // Focus lands on the first problem, so fixing can start immediately.
-    expect(document.activeElement?.id).toBe('sv-ef-name')
-  })
-
-  it('asks before throwing away edits, and closes straight away when there are none', () => {
-    const onCancel = vi.fn()
-    const el = render({
-      schema,
-      row: { id: '1', name: 'Ada', mrr: 1200, active: true, tier: 'pro' },
-      presentation: 'inline',
-      onSubmit: vi.fn(),
-      onCancel,
-    })
-    const cancel = () => [...el.querySelectorAll<HTMLButtonElement>('button')].find((b) => b.textContent?.trim() === 'Cancel')!
-
-    // Untouched: cancelling just closes.
-    cancel().click()
-    flushSync()
-    expect(onCancel).toHaveBeenCalledTimes(1)
-
-    // Now dirty the form; cancelling asks instead of discarding.
-    const name = el.querySelector<HTMLInputElement>('#sv-ef-name')!
-    name.value = 'Grace'
-    name.dispatchEvent(new Event('input', { bubbles: true }))
-    flushSync()
-    cancel().click()
-    flushSync()
-    expect(onCancel).toHaveBeenCalledTimes(1) // still not closed
-    expect(el.textContent).toContain('Discard your changes?')
-
-    // "Keep editing" puts you back in the form with the edit intact.
-    ;[...el.querySelectorAll<HTMLButtonElement>('button')].find((b) => b.textContent?.trim() === 'Keep editing')!.click()
-    flushSync()
-    expect(el.textContent).not.toContain('Discard your changes?')
-    expect(el.querySelector<HTMLInputElement>('#sv-ef-name')!.value).toBe('Grace')
-
-    // Confirming discards.
-    cancel().click()
-    flushSync()
-    ;[...el.querySelectorAll<HTMLButtonElement>('button')].find((b) => b.textContent?.trim() === 'Discard')!.click()
-    flushSync()
-    expect(onCancel).toHaveBeenCalledTimes(2)
-  })
-
-  it('reveals and locks fields live as the answers change', async () => {
-    // One answer drives two others: choosing "refund" asks for a justification
-    // and unlocks the approver, both without a remount.
-    const cmp = (column: string, op: string, value: unknown) => ({ kind: 'cmp', column, op, value })
-    const returns = {
-      name: 'returns',
-      idField: 'id',
-      fields: [
-        { field: 'id', type: 'text', primaryKey: true, readonly: true },
-        { field: 'mode', type: 'text' },
-        { field: 'justification', type: 'text', label: 'Justification', when: { visible: cmp('mode', 'equals', 'refund') } },
-        { field: 'approver', type: 'text', when: { disabled: cmp('mode', 'notEquals', 'refund') } },
-      ],
-    } as unknown as EntitySchema<Record<string, unknown>>
-
-    const el = render({
-      schema: returns,
-      row: { id: '1', mode: 'exchange', justification: '', approver: '' },
-      presentation: 'inline',
-      onSubmit: vi.fn(),
-    })
-
-    // An exchange: no justification asked for, and the approver is locked.
-    expect(el.textContent).not.toContain('Justification')
-    expect(el.querySelector('#sv-ef-approver')!.hasAttribute('disabled')).toBe(true)
-
-    // Switch to a refund; both fields react to the new value.
-    const mode = el.querySelector<HTMLInputElement>('#sv-ef-mode')!
-    mode.value = 'refund'
-    mode.dispatchEvent(new Event('input', { bubbles: true }))
-    flushSync()
-
-    expect(el.textContent).toContain('Justification')
-    expect(el.querySelector('#sv-ef-approver')!.hasAttribute('disabled')).toBe(false)
-  })
-})

package/src/SvRecordDetail.dom.test.ts

@@ -1,137 +0,0 @@
-/**
- * DOM test: SvRecordDetail renders a record header (title + status pill + metric
- * tiles), a tabbed Overview of field groups, and a related-collection timeline
- * filtered by the foreign key. Also mounts against the real CRM deals + activities
- * sample so the detail <-> sample path is covered.
- */
-import { describe, it, expect, afterEach } from 'vitest'
-import { mount, unmount, flushSync } from 'svelte'
-import SvRecordDetail from './SvRecordDetail.svelte'
-import { getSampleApp } from './studio/samples/index'
-import type { EntitySchema } from './schema'
-
-const dealsSchema: EntitySchema = {
-  name: 'deals',
-  idField: 'id',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true, readonly: true },
-    { field: 'title', type: 'text' },
-    { field: 'owner', type: 'text', label: 'Owner' },
-    { field: 'value', type: 'number', label: 'Value ($)' },
-    { field: 'probability', type: 'number', label: 'Probability (%)' },
-    { field: 'stage', type: 'enum', options: [
-      { value: 'lead', label: 'Lead', color: '#94a3b8' },
-      { value: 'won', label: 'Won', color: '#10b981' },
-    ] },
-  ],
-}
-const actsSchema: EntitySchema = {
-  name: 'activities',
-  idField: 'id',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true },
-    { field: 'subject', type: 'text' },
-    { field: 'dealId', type: 'relation', relation: { entity: 'deals', foreignKey: 'dealId', labelField: 'title' } },
-    { field: 'dueDate', type: 'date' },
-  ],
-}
-
-let host: HTMLElement | null = null
-let comp: ReturnType<typeof mount> | null = null
-afterEach(() => { if (comp) { unmount(comp); comp = null } if (host) { host.remove(); host = null } })
-
-function render(props: Record<string, unknown>): HTMLElement {
-  host = document.createElement('div')
-  document.body.appendChild(host)
-  comp = mount(SvRecordDetail, { target: host, props })
-  flushSync()
-  return host
-}
-
-describe('SvRecordDetail (DOM)', () => {
-  it('renders header title, status pill, and metric tiles', () => {
-    const rows = [{ id: 'd1', title: 'Alpha deal', owner: 'Sam', value: 1000, probability: 60, stage: 'won' }]
-    const el = render({ schema: dealsSchema, rows, titleField: 'title', subtitleField: 'owner', statusField: 'stage', metricFields: ['value', 'probability'] })
-    expect(el.querySelector('.sv-detail__title')?.textContent).toBe('Alpha deal')
-    expect(el.querySelector('.sv-detail__status')?.textContent).toBe('Won')
-    const metrics = [...el.querySelectorAll('.sv-detail__metric-value')].map((n) => n.textContent)
-    expect(metrics).toContain('$1,000') // money-formatted from the "Value ($)" label
-    expect(metrics).toContain('60')
-  })
-
-  it('auto-builds an Overview of the remaining fields when no sections given', () => {
-    const rows = [{ id: 'd1', title: 'Alpha', owner: 'Sam', value: 1000, probability: 60, stage: 'won' }]
-    const el = render({ schema: dealsSchema, rows, titleField: 'title', statusField: 'stage', metricFields: ['value'] })
-    const labels = [...el.querySelectorAll('.sv-detail__field dt')].map((n) => n.textContent)
-    // title/stage/value are surfaced in the header, so the auto group shows the rest.
-    expect(labels).toContain('Owner')
-    expect(labels).toContain('Probability (%)')
-    expect(labels).not.toContain('Value ($)') // in the header metrics, not the Overview
-  })
-
-  it('shows a related timeline filtered by the foreign key', () => {
-    const rows = [{ id: 'd1', title: 'Alpha', stage: 'won' }, { id: 'd2', title: 'Beta', stage: 'lead' }]
-    const acts = [
-      { id: 'a1', subject: 'Call', dealId: 'd1', dueDate: '2026-03-01' },
-      { id: 'a2', subject: 'Email', dealId: 'd1', dueDate: '2026-03-05' },
-      { id: 'a3', subject: 'Other', dealId: 'd2', dueDate: '2026-03-02' },
-    ]
-    const el = render({
-      schema: dealsSchema, rows, titleField: 'title', statusField: 'stage',
-      related: [{ label: 'Activities', schema: actsSchema, rows: acts, foreignKey: 'dealId', titleField: 'subject', dateField: 'dueDate' }],
-    })
-    // Two tabs: Overview + Activities.
-    const tabs = [...el.querySelectorAll('.sv-detail__tab')].map((n) => n.textContent)
-    expect(tabs).toEqual(['Overview', 'Activities'])
-    // Switch to the Activities tab.
-    const actTab = [...el.querySelectorAll<HTMLButtonElement>('.sv-detail__tab')].find((b) => b.textContent === 'Activities')!
-    actTab.click()
-    flushSync()
-    const events = [...el.querySelectorAll('.sv-detail__event-title')].map((n) => n.textContent)
-    expect(events).toEqual(['Email', 'Call']) // only d1's activities, newest date first
-  })
-
-  it('mounts against the real CRM deals + activities sample', () => {
-    const proj = getSampleApp('crm')!.build()
-    const deals = proj.entities.find((e) => e.name === 'deals')
-    const activities = proj.entities.find((e) => e.name === 'activities')
-    const dealRows = (proj.dataSources!.deals as { seed?: Record<string, unknown>[] }).seed!
-    const actRows = (proj.dataSources!.activities as { seed?: Record<string, unknown>[] }).seed!
-    const el = render({
-      schema: deals, rows: dealRows, titleField: 'title', subtitleField: 'companyId', statusField: 'stage', metricFields: ['value', 'probability'],
-      related: [{ label: 'Activities', schema: activities, rows: actRows, foreignKey: 'dealId', titleField: 'subject', dateField: 'dueDate', statusField: 'priority' }],
-    })
-    expect(el.querySelector('.sv-detail__title')?.textContent).toBeTruthy()
-    expect(el.querySelectorAll('.sv-detail__metric').length).toBe(2)
-    expect([...el.querySelectorAll('.sv-detail__tab')].map((n) => n.textContent)).toEqual(['Overview', 'Activities'])
-  })
-
-  it('matches a related timeline by parentField when the child has no FK id (denormalized view)', () => {
-    const productsSchema: EntitySchema = {
-      name: 'products', idField: 'id',
-      fields: [{ field: 'id', type: 'number', primaryKey: true }, { field: 'name', type: 'text' }],
-    }
-    const linesSchema: EntitySchema = {
-      name: 'order_lines', idField: 'id',
-      fields: [{ field: 'id', type: 'number', primaryKey: true }, { field: 'product', type: 'text' }, { field: 'customer', type: 'text' }, { field: 'line_total', type: 'number', label: 'Total ($)' }],
-    }
-    const rows = [{ id: 1, name: 'Chai' }, { id: 2, name: 'Chang' }]
-    // The view carries the product NAME (not its id), so the timeline matches name.
-    const lines = [
-      { id: 10, product: 'Chai', customer: 'Alfreds', line_total: 90 },
-      { id: 11, product: 'Chang', customer: 'Berglunds', line_total: 40 },
-      { id: 12, product: 'Chai', customer: "B's", line_total: 54 },
-    ]
-    const el = render({
-      schema: productsSchema, rows, titleField: 'name',
-      related: [{ label: 'Orders', schema: linesSchema, rows: lines, foreignKey: 'product', parentField: 'name', titleField: 'customer', subtitleField: 'line_total' }],
-    })
-    const ordersTab = [...el.querySelectorAll<HTMLButtonElement>('.sv-detail__tab')].find((b) => b.textContent === 'Orders')!
-    ordersTab.click()
-    flushSync()
-    // Opens on Chai -> its two lines (matched by name, not id), $ money-formatted.
-    const events = [...el.querySelectorAll('.sv-detail__event-title')].map((n) => n.textContent)
-    expect(events.sort()).toEqual(['Alfreds', "B's"])
-    expect(el.textContent).toContain('$90')
-  })
-})

package/src/SvSchedule.dom.test.ts

@@ -1,57 +0,0 @@
-/**
- * DOM test: SvSchedule renders a month grid anchored to the earliest event, places
- * each dated row as an event chip on its day, and paginates months.
- */
-import { describe, it, expect, afterEach } from 'vitest'
-import { mount, unmount, flushSync } from 'svelte'
-import SvSchedule from './SvSchedule.svelte'
-import type { EntitySchema } from './schema'
-
-const schema: EntitySchema = {
-  name: 'events',
-  idField: 'id',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true, readonly: true },
-    { field: 'name', type: 'text' },
-    { field: 'startAt', type: 'datetime' },
-    { field: 'category', type: 'enum', options: [
-      { value: 'conf', label: 'Conference', color: '#6366f1' },
-      { value: 'workshop', label: 'Workshop', color: '#10b981' },
-    ] },
-  ],
-}
-
-let host: HTMLElement | null = null
-let comp: ReturnType<typeof mount> | null = null
-afterEach(() => { if (comp) { unmount(comp); comp = null } if (host) { host.remove(); host = null } })
-function render(props: Record<string, unknown>): HTMLElement {
-  host = document.createElement('div')
-  document.body.appendChild(host)
-  comp = mount(SvSchedule, { target: host, props })
-  flushSync()
-  return host
-}
-
-describe('SvSchedule (DOM)', () => {
-  const rows = [
-    { id: 'e1', name: 'Svelte Summit', startAt: '2026-09-12T09:00:00Z', category: 'conf' },
-    { id: 'e2', name: 'A11y Workshop', startAt: '2026-09-20T10:00:00Z', category: 'workshop' },
-  ]
-
-  it('anchors to the earliest event month and renders its events', () => {
-    const el = render({ schema, rows, dateField: 'startAt', titleField: 'name', colorField: 'category' })
-    expect(el.querySelector('.sv-sched__month')?.textContent).toContain('September 2026')
-    expect(el.querySelectorAll('.sv-sched__cell').length).toBe(42) // 6 weeks
-    const evs = [...el.querySelectorAll('.sv-sched__ev')].map((n) => n.textContent?.trim())
-    expect(evs).toContain('Svelte Summit')
-    expect(evs).toContain('A11y Workshop')
-  })
-
-  it('paginates to the next month (events drop off)', () => {
-    const el = render({ schema, rows, dateField: 'startAt', titleField: 'name' })
-    el.querySelector<HTMLButtonElement>('[aria-label="Next month"]')!.click()
-    flushSync()
-    expect(el.querySelector('.sv-sched__month')?.textContent).toContain('October 2026')
-    expect(el.querySelectorAll('.sv-sched__ev').length).toBe(0)
-  })
-})

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

@@ -1,77 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Capture exactly what exportGrid receives (so we don't need pdfmake / the DOM).
-const calls: Array<{ format: string; rows?: unknown[]; groupBy?: string[] }> = []
-vi.mock('./export', () => ({
-  exportGrid: async (_api: unknown, opts: { format: string; rows?: unknown[]; groupBy?: string[] }) => {
-    calls.push({ format: opts.format, rows: opts.rows as unknown[], groupBy: opts.groupBy })
-  },
-}))
-
-import { aiExport, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
-import { exportGrid } from './export'
-import { setLicenseKey } from './license'
-
-type Order = { country: string; company: string; product: string; quantity: number; price: number }
-const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
-  country: ['USA', 'UK', 'Germany'][i % 3]!,
-  company: `Co${i}`,
-  product: 'Widget',
-  quantity: 5 + (i % 50),
-  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
-}))
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    // Simulate the grid returning EVERYTHING (the reactive-filter bug we route around).
-    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 },
-    ],
-    getState: () => ({ grouping: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-    setGroupBy: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  calls.length = 0
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-  // aiExport delegates to the registered engine - here the mocked exportGrid.
-  registerExportProvider(exportGrid as never)
-})
-
-describe('aiExport - the demo 203 "grouped PDF" query', () => {
-  it('parses the plan and exports non-empty, filtered, grouped rows', async () => {
-    const plan = await aiExport(makeApi(), 'export orders over $300 as a grouped PDF by country')
-
-    expect(plan.format).toBe('pdf')
-    expect(plan.groupBy).toEqual(['country'])
-    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
-
-    // exportGrid was called with real, filtered rows (not the empty grid view).
-    expect(calls).toHaveLength(1)
-    expect(calls[0]!.format).toBe('pdf')
-    expect(calls[0]!.groupBy).toEqual(['country'])
-    const exported = calls[0]!.rows as Order[]
-    expect(exported.length).toBeGreaterThan(0)
-    expect(exported.every((r) => r.price > 300)).toBe(true)
-    // Rows are contiguous by country (group order preserved).
-    const countries = exported.map((r) => r.country)
-    const firstSeen = [...new Set(countries)]
-    const contiguous = countries.join('|')
-    for (const c of firstSeen) {
-      expect(contiguous).toMatch(new RegExp(`(?:^|\\|)${c}(?:\\|${c})*(?:\\||$)`))
-    }
-  })
-})