@svgrid/enterprise 2.5.3 → 2.6.1

package/src/install.ts

@@ -1,154 +0,0 @@
-import type { RowData, TableFeatures, SvGridApi } from '@svgrid/grid'
-import {
-  exportGrid,
-  copyExportToClipboard,
-  type ExportOptions,
-  type ExportResult,
-  type ClipboardExportOptions,
-} from './export'
-import { printGrid, type PrintOptions } from './print'
-import { importData, type ImportOptions, type ImportResult } from './import'
-import { isLicenseKeySet } from './license'
-import { emitUnlicensedNudge } from './watermark'
-// AI helpers are built-in + free in @svgrid/grid now; enterprise just wires them
-// into the Pro API and registers its export engine so AI exports can write xlsx/pdf.
-import {
-  aiFilter, aiSmartFill, aiSummarize, aiClassify, aiExport, aiFindAnomalies,
-  aiChart, enableAiCharting, registerExportProvider,
-  type AIChartOptions, type AIChartPlan,
-  type AIFilterOptions, type AIFilterResult,
-  type AISmartFillOptions, type AISmartFillResult,
-  type AISummarizeOptions, type AISummary,
-  type AIClassifyOptions, type AIClassifyResult,
-  type AIExportOptions, type AIExportPlan,
-  type AIAnomalyOptions, type AIAnomalyResult,
-} from '@svgrid/grid'
-import {
-  createPivotModel,
-  type PivotConfig,
-  type PivotResult,
-} from './pivot'
-import { enableSchedulerView } from './scheduler'
-import { enableBoardView } from './board'
-import { enablePivot } from './pivot-enable'
-
-export type EnterpriseAIApi<TData extends RowData> = {
-  /** Natural-language -> filter + sort plan (and optionally apply it). */
-  filter(query: string, opts?: AIFilterOptions): Promise<AIFilterResult>
-  /** Propose values for empty cells based on a few worked examples. */
-  smartFill<TValue = unknown>(opts: AISmartFillOptions): Promise<AISmartFillResult<TValue>>
-  /** One-paragraph + bullets summary of a row, selection, group, or the whole view. */
-  summarize(opts: AISummarizeOptions): Promise<AISummary>
-  /** Classify free-text cells into one of a known set of labels. */
-  classify(opts: AIClassifyOptions): Promise<AIClassifyResult>
-  /** Natural-language export: "export EU orders from Q2 as a grouped PDF". */
-  export(query: string, opts?: AIExportOptions): Promise<AIExportPlan>
-  /** Scan a slice for anomalies / outliers, returning a structured list. */
-  findAnomalies(opts?: AIAnomalyOptions): Promise<AIAnomalyResult>
-  /** Natural-language chart: "revenue by region, stacked by product". */
-  chart(query: string, opts?: AIChartOptions): Promise<AIChartPlan>
-  // TData is referenced so the type stays bound to the row shape even
-  // though the helpers all read through `api.getData()`. Lets callers
-  // get correct inference downstream without explicit generics.
-  readonly _rowType?: TData
-}
-
-export type EnterprisePivotApi<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> = {
-  /**
-   * Build a pivot row/column model from the grid's current data. Returns
-   * `{ rows, columns }` you can feed to a separate `<SvGrid>` instance
-   * (the typical pattern - the source grid stays unmodified). Pure: no
-   * mutation, no DOM access.
-   */
-  build(config: PivotConfig<TData>): PivotResult<TFeatures>
-  /**
-   * Build a pivot from an arbitrary array (not necessarily the grid's
-   * data). Useful for previewing a designer's config against a sample
-   * before committing.
-   */
-  buildFrom<TIn extends RowData>(
-    data: ReadonlyArray<TIn>,
-    config: PivotConfig<TIn>,
-  ): PivotResult<TFeatures>
-}
-
-export type EnterpriseGridApi<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> = SvGridApi<TFeatures, TData> & {
-  /** Export the current visible rows to the chosen format. Returns the built
-   *  file ({@link ExportResult}) for the dependency-free paths (undefined for
-   *  the vendored-writer xlsx paths, which download directly). */
-  exportData(opts: ExportOptions<TData>): Promise<ExportResult | undefined>
-  /** Copy the grid (view / selection / all) to the clipboard in a native text
-   *  format (default `tsv`, pastes into Excel / Sheets as columns). */
-  copyExport(opts?: ClipboardExportOptions<TData>): Promise<void>
-  /** Open a printable view of the current visible rows in a new window. */
-  print(opts?: PrintOptions<TData>): Promise<void>
-  /** Read an Excel / CSV / TSV / JSON file (or inline text) into typed
-   *  rows. Caller decides whether to commit into the grid or preview
-   *  the parsed result first via the returned `ImportResult`. */
-  importData(opts: ImportOptions<TData>): Promise<ImportResult<TData>>
-  /** AI helpers (Pro). All calls route through a consumer-registered
-   *  AIProvider via setAIProvider(); no model client is bundled. */
-  ai: EnterpriseAIApi<TData>
-  /** Pivot table builder (Pro). Pure - returns `{ rows, columns }` you
-   *  hand to a separate `<SvGrid>` instance. */
-  pivot: EnterprisePivotApi<TFeatures, TData>
-}
-
-/**
- * Augment a SvGridApi instance with Pro methods (`exportData`, `print`,
- * `ai.*`). Mutates and returns the same object so existing references
- * keep working.
- *
- * If no license key has been set, the Pro methods still function but the
- * grid shows a small "unlicensed" watermark linking to jqwidgets.com and
- * the console emits a one-time nudge. Revoked or malformed keys throw on
- * first call.
- */
-export function installEnterprise<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(api: SvGridApi<TFeatures, TData>): EnterpriseGridApi<TFeatures, TData> {
-  const pro = api as EnterpriseGridApi<TFeatures, TData>
-  pro.exportData = (opts) => exportGrid(pro, opts)
-  pro.copyExport = (opts) => copyExportToClipboard(pro, opts)
-  pro.print = (opts) => printGrid(pro, opts)
-  pro.importData = (opts) => importData(pro, opts)
-  pro.ai = {
-    filter: (query, opts) => aiFilter(pro, query, opts),
-    smartFill: (opts) => aiSmartFill(pro, opts),
-    summarize: (opts) => aiSummarize(pro, opts),
-    classify: (opts) => aiClassify(pro, opts),
-    export: (query, opts) => aiExport(pro, query, opts),
-    findAnomalies: (opts) => aiFindAnomalies(pro, opts),
-    chart: (query, opts) => aiChart(pro, query, opts),
-  }
-  // Wire the built-in chart panel's AI button (no-op without the `charting` prop).
-  enableAiCharting(pro)
-  // Register the scheduler / calendar view (no-op without the `scheduler` prop).
-  enableSchedulerView()
-  // Register the Kanban board view (no-op without the `board` prop).
-  enableBoardView()
-  // Register the export engine so built-in AI exports (aiExport) can write the
-  // enterprise formats (xlsx / pdf / ...); free grids without it get the plan only.
-  registerExportProvider(exportGrid as never)
-  enablePivot()
-  pro.pivot = {
-    build: (config) =>
-      createPivotModel<TFeatures, TData>(pro.getData(), config),
-    buildFrom: <TIn extends RowData>(data: ReadonlyArray<TIn>, config: PivotConfig<TIn>) =>
-      // PivotConfig is variance-strict in TIn; the runtime call only needs
-      // the row shape to match config.rows / config.cols field names, which
-      // the caller-side generic enforces.
-      createPivotModel<TFeatures, TIn>(data, config),
-  }
-  // Surface the soft-gate state at install time so the watermark appears
-  // alongside the grid, not just after the user clicks Export.
-  if (!isLicenseKeySet()) emitUnlicensedNudge()
-  return pro
-}

package/src/license-core.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { checkLicenseKey } from './license-core'
-
-describe('checkLicenseKey', () => {
-  it('unset for null / empty', () => {
-    expect(checkLicenseKey(null)).toEqual({ status: 'unset', valid: false })
-    expect(checkLicenseKey(undefined)).toEqual({ status: 'unset', valid: false })
-    expect(checkLicenseKey('')).toEqual({ status: 'unset', valid: false })
-  })
-
-  it('invalid for a wrong prefix', () => {
-    expect(checkLicenseKey('nope-123')).toEqual({ status: 'invalid', valid: false })
-  })
-
-  it('dev / eval keys are valid but flagged', () => {
-    expect(checkLicenseKey('SVENTERPRISE-DEV-abc')).toEqual({ status: 'dev', valid: true })
-    expect(checkLicenseKey('SVENTERPRISE-EVAL-acme-2026')).toEqual({ status: 'eval', valid: true })
-  })
-
-  it('any other SVENTERPRISE- key is licensed', () => {
-    expect(checkLicenseKey('SVENTERPRISE-ACME-2026-9XYZ')).toEqual({ status: 'licensed', valid: true })
-  })
-})

package/src/license-core.ts

@@ -1,107 +0,0 @@
-// Pure license classification - no DOM, no Svelte, no module state. Shared by
-// the browser gate (license.ts, via setLicenseKey) AND the Node/MCP generator
-// (which reads the key from the SVGRID_LICENSE_KEY env var). One definition of
-// "what a valid key is," so the two contexts can never drift.
-//
-// This is deliberately NOT crypto (see license.ts). It classifies a key string;
-// callers decide what to do with the result. The Studio is soft-gate only:
-// unlicensed use still works, it just nudges.
-import { REVOKED_KEYS } from './revoked.js'
-
-export const VALID_PREFIX = 'SVENTERPRISE-'
-
-export type LicenseStatus =
-  | 'unset' // no key provided
-  | 'invalid' // present but wrong prefix (usually a typo)
-  | 'revoked' // valid prefix but on the revoked list
-  | 'dev' // SVENTERPRISE-DEV... - works, not for production
-  | 'eval' // SVENTERPRISE-EVAL... - works, not for production
-  | 'licensed' // any other SVENTERPRISE-... - paid production
-
-export type LicenseInfo = {
-  status: LicenseStatus
-  /** True when the key permits use (dev / eval / licensed). */
-  valid: boolean
-  /** Expiry encoded in the key, when it carries one. Undefined otherwise. */
-  expiresAt?: Date
-  /**
-   * True once `expiresAt` has passed. Deliberately does NOT clear `valid`:
-   * an expired trial keeps working and the callers nudge instead. Turning a
-   * lapsed key into a hard stop would break a running app on a date boundary,
-   * which is exactly what a soft gate exists to avoid.
-   */
-  expired?: boolean
-}
-
-/**
- * Pull the expiry out of a key.
- *
- * Keys are `SVENTERPRISE[-KIND]-<SLUG>-<SEATS>-<DATE>-<RANDOM>`, so the date is
- * always the second-to-last segment regardless of whether a KIND is present.
- * Two widths are accepted:
- *
- *   YYYYMM   - subscription granularity; expires at the end of that month.
- *   YYYYMMDD - trial granularity; expires at the end of that day.
- *
- * The 6-digit form came first, so every key issued before day-precision trials
- * existed still parses. Anything else (including the older keys whose slug sits
- * in that position) yields null, which reads as "no expiry encoded".
- *
- * Boundaries are UTC so a key does not lapse at a different instant per
- * timezone. Kept in sync with `tools/issue-license.mjs`.
- */
-export function parseLicenseExpiry(key: string | null | undefined): Date | null {
-  if (!key) return null
-  const segments = key.split('-')
-  if (segments.length < 3) return null
-  const stamp = segments[segments.length - 2]
-  if (stamp == null) return null
-
-  if (/^\d{6}$/.test(stamp)) {
-    const year = Number(stamp.slice(0, 4))
-    const month = Number(stamp.slice(4, 6))
-    if (month < 1 || month > 12) return null
-    // Date.UTC's month is 0-based, so passing the 1-based month lands on the
-    // first of the FOLLOWING month; one millisecond earlier is the last instant
-    // of the month the key names.
-    return new Date(Date.UTC(year, month, 1) - 1)
-  }
-
-  if (/^\d{8}$/.test(stamp)) {
-    const year = Number(stamp.slice(0, 4))
-    const month = Number(stamp.slice(4, 6))
-    const day = Number(stamp.slice(6, 8))
-    if (month < 1 || month > 12 || day < 1 || day > 31) return null
-    const end = new Date(Date.UTC(year, month - 1, day, 23, 59, 59, 999))
-    // Reject a date that rolled over (e.g. 20260231), which would otherwise
-    // silently grant a few extra days.
-    if (end.getUTCMonth() !== month - 1) return null
-    return end
-  }
-
-  return null
-}
-
-/** Classify a license key string. Pure and side-effect-free.
- *  `now` is injectable so expiry behaviour is testable without faking clocks. */
-export function checkLicenseKey(
-  key: string | null | undefined,
-  now: Date = new Date(),
-): LicenseInfo {
-  if (key == null || key === '') return { status: 'unset', valid: false }
-  if (!key.startsWith(VALID_PREFIX)) return { status: 'invalid', valid: false }
-  if (REVOKED_KEYS.has(key)) return { status: 'revoked', valid: false }
-
-  const expiresAt = parseLicenseExpiry(key) ?? undefined
-  // Left undefined rather than false when the key encodes no date, so callers
-  // can tell "not expired" apart from "no expiry to check".
-  const expired = expiresAt ? now.getTime() > expiresAt.getTime() : undefined
-
-  const status: LicenseStatus = key.startsWith('SVENTERPRISE-DEV')
-    ? 'dev'
-    : key.startsWith('SVENTERPRISE-EVAL')
-      ? 'eval'
-      : 'licensed'
-
-  return { status, valid: true, expiresAt, expired }
-}

package/src/license-expiry.test.ts

@@ -1,144 +0,0 @@
-// @vitest-environment jsdom
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { checkLicenseKey, parseLicenseExpiry } from './license-core'
-import {
-  assertEnterpriseLicensed,
-  clearLicenseKey,
-  getLicenseExpiry,
-  isLicenseExpired,
-  setLicenseKey,
-} from './license'
-import { dismissUpgradePrompt } from './upgrade-prompt'
-import { emitUnlicensedNudge } from './watermark'
-
-// Keep everything else in the module real; only the watermark emitter is spied.
-vi.mock('./watermark', async (importOriginal) => ({
-  ...(await importOriginal()),
-  emitUnlicensedNudge: vi.fn(),
-}))
-
-const KEY = 'SVENTERPRISE-EVAL-GUNEI-5-20260904-RGY2TN'
-const CARD = '[data-svgrid-enterprise-upgrade]'
-
-/** Calls to emitUnlicensedNudge() since the last reset.
- *
- *  Spied rather than counted in the DOM: the real function attaches its badge
- *  to grid elements on a microtask, so in a document with no grid it renders
- *  nothing and a node count would read 0 for every case - passing even if the
- *  watermark were wired up wrongly. The call is the contract under test. */
-const watermarkCalls = () => vi.mocked(emitUnlicensedNudge).mock.calls.length
-
-describe('trial key expiry parsing', () => {
-  it('unlocks Enterprise today', () => {
-    const info = checkLicenseKey(KEY, new Date('2026-08-21T12:00:00Z'))
-    expect(info).toMatchObject({ status: 'eval', valid: true, expired: false })
-  })
-
-  it('expires end of 2026-09-04, not end of September', () => {
-    expect(parseLicenseExpiry(KEY)?.toISOString()).toBe('2026-09-04T23:59:59.999Z')
-  })
-
-  it('still valid on the final day', () => {
-    expect(checkLicenseKey(KEY, new Date('2026-09-04T23:00:00Z')).expired).toBe(false)
-  })
-
-  it('expired the next day, but still permitted', () => {
-    const info = checkLicenseKey(KEY, new Date('2026-09-05T00:30:00Z'))
-    expect(info.expired).toBe(true)
-    expect(info.valid).toBe(true)
-  })
-
-  it('keeps parsing month-granularity keys issued before day precision', () => {
-    expect(parseLicenseExpiry('SVENTERPRISE-ACME-5-202705-ABC123')?.toISOString()).toBe(
-      '2027-05-31T23:59:59.999Z',
-    )
-  })
-
-  it('a key with no encoded date has no expiry', () => {
-    const info = checkLicenseKey('SVENTERPRISE-EVAL-acme-2026')
-    expect(info.expiresAt).toBeUndefined()
-    expect(info.expired).toBeUndefined()
-  })
-})
-
-describe('what happens after the trial ends', () => {
-  beforeEach(() => {
-    vi.useRealTimers()
-    clearLicenseKey()
-    dismissUpgradePrompt()
-    vi.mocked(emitUnlicensedNudge).mockClear()
-    document.body.innerHTML = ''
-  })
-
-  it('during the trial: no card, and nothing thrown', () => {
-    vi.useFakeTimers({ now: new Date('2026-08-25T10:00:00Z') })
-    setLicenseKey(KEY)
-    expect(isLicenseExpired()).toBe(false)
-    expect(() => assertEnterpriseLicensed('Export')).not.toThrow()
-    expect(document.querySelector(CARD)).toBeNull()
-  })
-
-  it('after the trial: pops the message, and STILL does not throw', () => {
-    vi.useFakeTimers({ now: new Date('2026-09-20T10:00:00Z') })
-    setLicenseKey(KEY)
-    expect(isLicenseExpired()).toBe(true)
-
-    expect(() => assertEnterpriseLicensed('Export')).not.toThrow()
-
-    const card = document.querySelector(CARD)
-    expect(card).not.toBeNull()
-    expect(card!.textContent).toContain('Your trial has ended')
-    expect(card!.textContent).toContain('everything still works')
-  })
-
-  it('exposes the expiry date so a host can render its own banner', () => {
-    vi.useFakeTimers({ now: new Date('2026-09-20T10:00:00Z') })
-    setLicenseKey(KEY)
-    expect(getLicenseExpiry()?.toISOString()).toBe('2026-09-04T23:59:59.999Z')
-  })
-
-  it('a lapsed trial gets the watermark, the console notice AND the card', () => {
-    vi.useFakeTimers({ now: new Date('2026-09-20T10:00:00Z') })
-    const info = vi.spyOn(console, 'info').mockImplementation(() => {})
-    setLicenseKey(KEY)
-    assertEnterpriseLicensed('Export')
-
-    // The evaluation is over, so the app stops looking licensed on every
-    // surface - it just keeps working.
-    expect(document.querySelector(CARD)).not.toBeNull()
-    expect(watermarkCalls()).toBeGreaterThan(0)
-    expect(info.mock.calls.flat().join(' ')).toMatch(/evaluation license expired on 2026-09-04/)
-    info.mockRestore()
-  })
-
-  it('the expiry console notice fires once, not on every Pro call', () => {
-    vi.useFakeTimers({ now: new Date('2026-09-20T10:00:00Z') })
-    const info = vi.spyOn(console, 'info').mockImplementation(() => {})
-    setLicenseKey(KEY)
-    assertEnterpriseLicensed('Export')
-    assertEnterpriseLicensed('Export')
-    assertEnterpriseLicensed('Print')
-
-    const expiryNotices = info.mock.calls
-      .flat()
-      .filter((m) => typeof m === 'string' && m.includes('evaluation license expired'))
-    expect(expiryNotices).toHaveLength(1)
-    info.mockRestore()
-  })
-
-  it('an app with no key at all still gets the watermark', () => {
-    clearLicenseKey()
-    assertEnterpriseLicensed('Export')
-
-    expect(document.querySelector(CARD)).not.toBeNull()
-    expect(watermarkCalls()).toBeGreaterThan(0)
-  })
-
-  it('a paid key never shows the card', () => {
-    vi.useFakeTimers({ now: new Date('2026-09-20T10:00:00Z') })
-    setLicenseKey('SVENTERPRISE-ACME-5-202705-ABC123')
-    expect(isLicenseExpired()).toBe(false)
-    assertEnterpriseLicensed('Export')
-    expect(document.querySelector(CARD)).toBeNull()
-  })
-})

package/src/license.ts

@@ -1,157 +0,0 @@
-// Polite license gate. Not crypto - anyone with devtools can extract the key
-// from a deployed bundle. The point is to make commercial use require a
-// transaction, not to defeat reverse engineering.
-//
-// Behavior matrix:
-//
-//   currentKey state                  -> result
-//   ────────────────────────────────────────────────────────────────────
-//   null (no key set)                 -> soft-gate: watermark + console.log,
-//                                        feature still runs
-//   does not start with "SVENTERPRISE-"      -> throws (programmer error)
-//   in REVOKED_KEYS                   -> throws (revoked / leaked / expired)
-//   starts with "SVENTERPRISE-DEV" or
-//     "SVENTERPRISE-EVAL"                    -> works; one-time console.info notice
-//   an EXPIRED dev/eval key            -> still works, but stops looking
-//                                        licensed: watermark + a one-time
-//                                        console notice naming the expiry date
-//                                        + the upgrade card. Stays a soft gate
-//                                        so a trial ending cannot break a build.
-//   any other "SVENTERPRISE-..."             -> works silently (paid production)
-
-import { checkLicenseKey, VALID_PREFIX, type LicenseInfo } from './license-core'
-import { emitUnlicensedNudge } from './watermark'
-import { showUpgradePrompt, type EnterpriseFeatureLabel } from './upgrade-prompt'
-
-export { checkLicenseKey, type LicenseInfo, type LicenseStatus } from './license-core'
-
-let currentKey: string | null = null
-let noticedDev = false
-let noticedExpired = false
-
-/** One-time console notice for a trial that has run out. Separate from the
- *  dev/eval notice: that one says "not for production", this one says the
- *  evaluation is over and names the date, which is the actionable part. */
-function noticeExpired(info: LicenseInfo): void {
-  if (noticedExpired) return
-  noticedExpired = true
-  const on = info.expiresAt ? ` on ${info.expiresAt.toISOString().slice(0, 10)}` : ''
-  // eslint-disable-next-line no-console
-  console.info(
-    `@svgrid/enterprise: your evaluation license expired${on}. Everything still ` +
-      'works, but the watermark and upgrade notice stay until a license key is set. ' +
-      'Contact sales@jqwidgets.com or see https://svgrid.com/pricing',
-  )
-}
-
-export function setLicenseKey(key: string): void {
-  if (typeof key !== 'string' || key.length === 0) {
-    throw new Error('@svgrid/enterprise: setLicenseKey() requires a non-empty string')
-  }
-  currentKey = key
-  noticedDev = false
-  noticedExpired = false
-}
-
-export function clearLicenseKey(): void {
-  currentKey = null
-  noticedDev = false
-  noticedExpired = false
-}
-
-export function getLicenseKey(): string | null {
-  return currentKey
-}
-
-/** True if a key is set at all (regardless of validity). */
-export function isLicenseKeySet(): boolean {
-  return currentKey != null
-}
-
-/**
- * True if the current key passes every check: present, valid prefix, not
- * revoked. Use this from callers that want to branch on license status
- * (e.g. UI that hides Pro-only options when unlicensed).
- */
-export function hasValidLicense(): boolean {
-  return checkLicenseKey(currentKey).valid
-}
-
-/**
- * True when the current key encoded an expiry that has passed. The feature set
- * still runs - this exists so a host can show its own banner rather than rely
- * on the built-in card. Returns false when the key carries no expiry.
- */
-export function isLicenseExpired(): boolean {
-  return checkLicenseKey(currentKey).expired === true
-}
-
-/** When the current key lapses, or null if it encodes no expiry. */
-export function getLicenseExpiry(): Date | null {
-  return checkLicenseKey(currentKey).expiresAt ?? null
-}
-
-/**
- * Soft-gate a Pro surface: if the current key isn't valid, nudge (watermark +
- * one-time console log + a moment-of-intent upgrade card naming `feature`) and
- * return. NEVER throws and NEVER blocks - the feature always runs. This is the
- * gate the Studio uses, and it's safe to call on the server (the nudges no-op
- * without a DOM). Idempotent/self-throttling, so call it freely at chokepoints.
- */
-export function nudgeEnterprise(feature?: EnterpriseFeatureLabel): void {
-  const info = checkLicenseKey(currentKey)
-  // `valid` stays true past a trial's expiry (the feature keeps running), so
-  // checking it alone would let a lapsed trial through silently forever.
-  if (info.valid && !info.expired) return
-  const lapsedTrial = info.valid && info.expired === true
-  // A lapsed trial gets the same treatment as an unlicensed app - watermark,
-  // console notice and card. The evaluation is over; the app keeps running,
-  // but it stops looking licensed.
-  emitUnlicensedNudge()
-  if (lapsedTrial) noticeExpired(info)
-  showUpgradePrompt(feature, { expired: lapsedTrial })
-}
-
-export function assertEnterpriseLicensed(feature?: EnterpriseFeatureLabel): void {
-  const info: LicenseInfo = checkLicenseKey(currentKey)
-  switch (info.status) {
-    case 'unset':
-      // Soft-gate: the feature still runs, but the user gets a watermark +
-      // a one-time console.log nudge directing them to pricing, plus a
-      // contextual moment-of-intent upgrade card naming the feature they
-      // just reached for.
-      emitUnlicensedNudge()
-      showUpgradePrompt(feature)
-      return
-    case 'invalid':
-      throw new Error(
-        `@svgrid/enterprise: invalid license key format (expected "${VALID_PREFIX}..." prefix).`,
-      )
-    case 'revoked':
-      throw new Error(
-        '@svgrid/enterprise: this license key has been revoked. ' +
-          'Contact sales@jqwidgets.com for a replacement.',
-      )
-    case 'dev':
-    case 'eval':
-      if (info.expired) {
-        // The trial is over. Deliberately NOT a throw: the app keeps working,
-        // so the developer sees the nudges without their users hitting a broken
-        // build. Watermark + console notice + card, same as an unlicensed app.
-        emitUnlicensedNudge()
-        noticeExpired(info)
-        showUpgradePrompt(feature, { expired: true })
-        return
-      }
-      if (!noticedDev) {
-        // eslint-disable-next-line no-console
-        console.info(
-          '@svgrid/enterprise: using a development / evaluation license. Not for production use.',
-        )
-        noticedDev = true
-      }
-      return
-    case 'licensed':
-      return
-  }
-}

package/src/master-detail.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { buildDisplayRows, isDetailRow, toggleExpanded } from './master-detail'
-
-type Order = { id: string; customer: string }
-const orders: Order[] = [
-  { id: 'o1', customer: 'Ann' },
-  { id: 'o2', customer: 'Bob' },
-  { id: 'o3', customer: 'Cara' },
-]
-const idOf = (o: Order) => o.id
-
-describe('toggleExpanded', () => {
-  it('adds then removes an id, immutably', () => {
-    const a = toggleExpanded(new Set(), 'o1')
-    expect([...a]).toEqual(['o1'])
-    const b = toggleExpanded(a, 'o1')
-    expect([...b]).toEqual([])
-    expect([...a]).toEqual(['o1']) // original untouched
-  })
-})
-
-describe('isDetailRow', () => {
-  it('distinguishes detail markers from plain rows', () => {
-    expect(isDetailRow({ __svgridDetail: true, parent: {}, parentId: 'x' })).toBe(true)
-    expect(isDetailRow({ id: 'o1' })).toBe(false)
-    expect(isDetailRow(null)).toBe(false)
-  })
-})
-
-describe('buildDisplayRows', () => {
-  it('returns just the parents when nothing is expanded', () => {
-    const rows = buildDisplayRows(orders, new Set(), idOf)
-    expect(rows).toHaveLength(3)
-    expect(rows.every((r) => !isDetailRow(r))).toBe(true)
-  })
-
-  it('inserts a detail row right after each expanded parent, preserving order', () => {
-    const rows = buildDisplayRows(orders, new Set(['o2']), idOf)
-    expect(rows).toHaveLength(4)
-    expect(isDetailRow(rows[2])).toBe(true) // after o2
-    const detail = rows[2]
-    if (isDetailRow(detail)) {
-      expect(detail.parentId).toBe('o2')
-      expect((detail.parent as Order).customer).toBe('Bob')
-    }
-    // surrounding parents intact
-    expect((rows[1] as Order).id).toBe('o2')
-    expect((rows[3] as Order).id).toBe('o3')
-  })
-
-  it('handles multiple expanded parents', () => {
-    const rows = buildDisplayRows(orders, new Set(['o1', 'o3']), idOf)
-    expect(rows.map((r) => (isDetailRow(r) ? 'detail' : (r as Order).id))).toEqual([
-      'o1',
-      'detail',
-      'o2',
-      'o3',
-      'detail',
-    ])
-  })
-})