@svgrid/enterprise 2.2.1 → 2.3.1

package/src/index.ts

@@ -54,6 +54,82 @@ export { installEnterprise, type EnterpriseGridApi, type EnterpriseAIApi, type E
 // renderer so `<SvGrid scheduler={...}>` shows a Month/Week/Day/Agenda calendar.
 // The pure model helpers + config types live in @svgrid/grid; import them from there.
 export { enableSchedulerView, SvGridScheduler } from './scheduler'
+// Kanban board view (Pro). `enableBoardView()` registers the renderer so
+// `<SvGrid board={...}>` shows lanes of cards. Config types live in @svgrid/grid.
+export { enableBoardView, SvGridBoard } from './board'
+// In-grid pivot mode (Pro). `enablePivot()` registers the pivot engine so
+// `<SvGrid pivot={...}>` renders a pivot table in place of the flat table.
+export { enablePivot } from './pivot-enable'
+// Scheduler Pro feature surface (dependencies, multi-assignment + summaries,
+// axis collapse + zoom). Config type extends the free grid's SchedulerConfig;
+// the pure models are unit-tested framework-free helpers the renderer consumes.
+export type { SchedulerProConfig } from './scheduler-config'
+export {
+  buildDependencyGraph,
+  topoOrder,
+  hasCycle,
+  requiredStart,
+  cascade,
+  violations,
+  type DependencyType,
+  type SchedulerDependency,
+  type EventTimes,
+  type DependencyGraph,
+  type CascadeOptions,
+} from './scheduler-dependencies'
+export {
+  expandAssignments,
+  resourceLoad,
+  overallocations,
+  assignedMinutes,
+  type SchedulerAssignment,
+  type Allocation,
+  type Overallocation,
+} from './scheduler-assignments'
+export {
+  columnSummaries,
+  sumReducer,
+  countReducer,
+  busyMinutesReducer,
+  type ColumnReducer,
+  type SummaryItem,
+} from './scheduler-summary'
+export {
+  buildAxis,
+  timeToX,
+  xToTime,
+  resolveZoom,
+  zoomPresets,
+  type Axis,
+  type AxisSegment,
+  type AxisSegmentKind,
+  type BuildAxisOptions,
+  type ZoomLevel,
+  type ZoomMajorUnit,
+} from './scheduler-axis'
+export {
+  buildResourceRows,
+  visibleResourceIds,
+  type SchedulerResourceGroup,
+  type ResourceRow,
+} from './scheduler-resource-tree'
+export { heatCells, heatPeak, type HeatCell } from './scheduler-heatmap'
+export {
+  respectsBuffer,
+  withinDurationBounds,
+  afterLead,
+  type BusyEvent,
+  type GapMin,
+} from './scheduler-booking'
+export {
+  availableSlots,
+  mergeIntervals,
+  subtractIntervals,
+  type Interval,
+  type Slot,
+  type SlotOptions,
+} from './scheduler-slots'
+export { mergeBusy, commonFree } from './scheduler-freebusy'
 export {
   createStagedEditing,
   type StagedChange,
@@ -125,6 +201,7 @@ export {
   type PlanOp,
   type KitDataSourceOptions,
   type KitHandlerOptions,
+  type KitScope,
   type KitHandlers,
   type KitMessage,
   type SqlDialect,
@@ -141,6 +218,7 @@ export {
   dummyJsonAdapter,
   jsonServerAdapter,
   introspectSupabaseTable,
+  listSupabaseTables,
   createSupabaseRealtime,
   createRelationLookup,
   createSupabaseAuth,
@@ -240,9 +318,21 @@ export {
   emitStudioApp,
   sampleApps,
   getSampleApp,
+  starterProject,
   liveDataSamples,
   getLiveDataSample,
   type SampleApp,
+  starterDatasets,
+  getStarterDataset,
+  type StarterDataset,
+  crudSuiteScreens,
+  addCrudSuite,
+  crudAppFromSchemas,
+  type CrudScreenKind,
+  type CrudEditingMode,
+  type CrudSuiteOptions,
+  type CrudAppOptions,
+  introspectJson,
   sanitizeStudioProject,
   buildStudioBugReport,
   type BugReport,
@@ -360,50 +450,106 @@ export {
   type Well,
 } from './pivot-designer'
 
-export {
-  // Provider plumbing
-  setAIProvider,
-  getAIProvider,
-  hasAIProvider,
-  mockAIProvider,
-  type AIProvider,
-  type AIRequest,
-  type AITask,
-  // Filter
-  aiFilter,
-  type AIFilterOptions,
-  type AIFilterResult,
-  type AIFilterClause,
-  type AISortClause,
-  // Smart fill
-  aiSmartFill,
-  type AISmartFillOptions,
-  type AISmartFillResult,
-  type AISmartFillExample,
-  // Summarize
-  aiSummarize,
-  type AISummarizeOptions,
-  type AISummarizeTarget,
-  type AISummary,
-  // Classify
-  aiClassify,
-  type AIClassifyOptions,
-  type AIClassifyResult,
-  // Natural-language export
-  aiExport,
-  type AIExportOptions,
-  type AIExportPlan,
-  // Anomaly detection
-  aiFindAnomalies,
-  type AIAnomaly,
-  type AIAnomalyOptions,
-  type AIAnomalyResult,
-  // Natural-language chart ("chart this")
-  aiChart,
-  enableAiCharting,
-  disableAiCharting,
-  type AIChartOptions,
-  type AIChartPlan,
-  type AIChartType,
-} from './ai'
+// The AI helpers (setAIProvider, aiFilter, aiSmartFill, aiSummarize, aiClassify,
+// aiExport, aiFindAnomalies, aiChart, enableAiCharting, ...) are now BUILT-IN and
+// FREE in @svgrid/grid - import them from there. Enterprise only registers its
+// export engine so AI-planned Excel/PDF exports can run (see install.ts).
 export { pivotToChartSpec, type PivotChartOptions } from './pivot-chart'
+
+// Expression / query language (Pro). One predicate/scalar/change model that
+// powers alerts (and, in time, styled + calculated columns). Leaf comparisons
+// reuse the grid's own `applyExcelFilter`, so operators match the filter row.
+export {
+  evaluatePredicate,
+  evaluateScalar,
+  evaluateChange,
+  BUILTIN_FUNCTION_NAMES,
+  isBuiltinFunction,
+} from './expressions/evaluate'
+export {
+  parsePredicate,
+  stringifyPredicate,
+  stringifyScalar,
+  validateExpression,
+  collectColumnRefs,
+  ExpressionParseError,
+} from './expressions/parse'
+export {
+  OPERATORS,
+  operatorMeta,
+  operatorsForType,
+  isValueless,
+  isSetOperator,
+  isRangeOperator,
+  columnById,
+  resolveColumnRef,
+  columnLabel,
+  columnRefText,
+  type ExprColumn,
+  type ExprColumnType,
+  type OperatorMeta,
+} from './expressions/expression-columns'
+export type {
+  ScalarExpr,
+  PredicateExpr,
+  ChangeExpr,
+  ComparisonOp,
+  ArithmeticOp,
+  AggFn,
+  EvalContext,
+  ExprRow,
+} from './expressions/expression-types'
+export { default as SvExpressionEditor } from './SvExpressionEditor.svelte'
+
+// Alert Rules engine (Pro). Declarative "when this holds / this moves -> toast /
+// badge / highlight / flash / prevent-edit / log". Authored at runtime,
+// persisted, shareable. Surfacing reuses the grid's toast + conditional-format
+// engines; `<SvGridAlerts>` is the runtime overlay the consumer mounts.
+export { enableAlerts } from './alerts'
+export {
+  createAlertEngine,
+  renderTemplate,
+  type AlertEngine,
+  type AlertEngineOptions,
+  type ValidateEditResult,
+} from './alerts/alert-engine'
+export {
+  attachAlertEngine,
+  applyAlertEvents,
+  type AlertAttachment,
+  type AttachAlertOptions,
+  type FlashTarget,
+} from './alerts/alert-engine-attach'
+export {
+  memoryAlertRules,
+  localStorageAlertRules,
+  createAlertRules,
+  type AlertRulesStorage,
+  type AlertRulesManager,
+} from './alerts/alert-storage'
+export {
+  createAlertObserver,
+  type AlertObserver,
+  type AlertObserverOptions,
+} from './alerts/alert-observer'
+export {
+  createAlertScheduler,
+  type AlertScheduler,
+  type AlertSchedulerMode,
+} from './alerts/alert-scheduler'
+export { toConditionalFormats, rulesToConditionalFormats, type StylingContext } from './alerts/alert-formats'
+export { alertStore } from './alerts/alert-store.svelte'
+export type {
+  AlertRule,
+  AlertEvent,
+  AlertTrigger,
+  AlertAction,
+  AlertActionKind,
+  AlertActionStyle,
+  AlertScope,
+  AlertSeverity,
+} from './alerts/alert-types'
+export { default as SvGridAlerts } from './SvGridAlerts.svelte'
+export { default as SvAlertRuleEditor } from './SvAlertRuleEditor.svelte'
+export { default as SvAlertsManager } from './SvAlertsManager.svelte'
+export { default as SvAlertsPanel } from './SvAlertsPanel.svelte'

package/src/install.ts

@@ -10,9 +10,11 @@ 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,
+  aiChart, enableAiCharting, registerExportProvider,
   type AIChartOptions, type AIChartPlan,
   type AIFilterOptions, type AIFilterResult,
   type AISmartFillOptions, type AISmartFillResult,
@@ -20,13 +22,15 @@ import {
   type AIClassifyOptions, type AIClassifyResult,
   type AIExportOptions, type AIExportPlan,
   type AIAnomalyOptions, type AIAnomalyResult,
-} from './ai'
+} 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). */
@@ -128,6 +132,12 @@ export function installEnterprise<
   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),

package/src/pivot-enable.ts

@@ -0,0 +1,44 @@
+/**
+ * In-grid pivot (Pro). `enablePivot()` registers the pivot ENGINE with the grid
+ * so `<SvGrid pivot={...}>` renders a pivot table in place of the flat table -
+ * the same grid, aggregated with nested column headers. The engine (which turns
+ * rows into a pivot result) is `createPivotModel`; the grid ships the `pivot`
+ * prop + config types for free and looks the engine up through the
+ * `registerPivotEngine` seam.
+ *
+ * Soft-gated like the rest of Enterprise: it works without a license key but the
+ * grid shows the unlicensed watermark + a one-time console nudge.
+ *
+ * ```ts
+ * import { setLicenseKey, enablePivot } from '@svgrid/enterprise'
+ * setLicenseKey('YOUR-KEY')
+ * enablePivot()
+ * // then: <SvGrid {data} {columns} pivot={{ rows: ['region'], cols: ['quarter'], values: [{ field: 'sales', agg: 'sum' }] }} />
+ * ```
+ */
+import { registerPivotEngine, type PivotEngine } from '@svgrid/grid'
+import { isLicenseKeySet } from './license'
+import { emitUnlicensedNudge } from './watermark'
+import { createPivotModel, type PivotConfig } from './pivot'
+
+let enabled = false
+
+// The grid's `PivotEngine` seam is generic over row type; `createPivotModel` is
+// the concrete implementation. Bridge them with a single boundary cast.
+const pivotEngine: PivotEngine = (data, config) =>
+  createPivotModel(
+    data as ReadonlyArray<Record<string, unknown>>,
+    config as unknown as PivotConfig<Record<string, unknown>>,
+  ) as never
+
+/**
+ * Register the Enterprise pivot engine. Idempotent - safe to call from every
+ * component that uses `pivot`, or once at app start. Also invoked by
+ * {@link installEnterprise} so wiring the Pro API turns pivot on too.
+ */
+export function enablePivot(): void {
+  if (enabled) return
+  enabled = true
+  registerPivotEngine(pivotEngine)
+  if (!isLicenseKeySet()) emitUnlicensedNudge()
+}

package/src/pivot.test.ts

@@ -8,7 +8,6 @@ import {
   filterCollapsedPivotRows,
   pivotAggregators,
   type PivotConfig,
-  type PivotRow,
 } from './pivot'
 
 type Sale = {

package/src/scheduler-assignments.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest'
+import {
+  assignedMinutes,
+  expandAssignments,
+  overallocations,
+  resourceLoad,
+  type SchedulerAssignment,
+} from './scheduler-assignments'
+
+type Ev = { key: string; start: Date; end: Date; resource?: string }
+const D = (h: number) => new Date(2026, 0, 5, h, 0, 0, 0)
+const ev = (key: string, s: number, e: number, resource?: string): Ev => ({ key, start: D(s), end: D(e), resource })
+
+const opts = {
+  keyOf: (e: Ev) => e.key,
+  startOf: (e: Ev) => e.start,
+  endOf: (e: Ev) => e.end,
+  resourceOf: (e: Ev) => e.resource,
+}
+
+describe('expandAssignments', () => {
+  it('renders one event once per assigned resource', () => {
+    const events = [ev('e1', 9, 11)]
+    const assigns: SchedulerAssignment[] = [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
+      { id: 'a2', eventId: 'e1', resourceId: 'r2' },
+    ]
+    const out = expandAssignments(events, assigns, opts)
+    expect(out.map((a) => a.resourceId).sort()).toEqual(['r1', 'r2'])
+    expect(out.every((a) => a.units === 1)).toBe(true)
+  })
+
+  it('dedupes duplicate resource assignments to the max units', () => {
+    const out = expandAssignments([ev('e1', 9, 11)], [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 0.5 },
+      { id: 'a2', eventId: 'e1', resourceId: 'r1', units: 0.8 },
+    ], opts)
+    expect(out).toHaveLength(1)
+    expect(out[0]!.units).toBe(0.8)
+  })
+
+  it('falls back to resourceOf when the event has no assignment', () => {
+    const out = expandAssignments([ev('e1', 9, 11, 'rX')], [], opts)
+    expect(out).toEqual([expect.objectContaining({ resourceId: 'rX', units: 1 })])
+  })
+
+  it('drops an event with neither assignment nor resource', () => {
+    const out = expandAssignments([ev('e1', 9, 11)], [], opts)
+    expect(out).toHaveLength(0)
+  })
+})
+
+describe('resourceLoad', () => {
+  it('sums units of overlapping allocations on the resource', () => {
+    const events = [ev('e1', 9, 11), ev('e2', 10, 12)]
+    const allocs = expandAssignments(events, [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 1 },
+      { id: 'a2', eventId: 'e2', resourceId: 'r1', units: 0.5 },
+    ], opts)
+    expect(resourceLoad(allocs, 'r1', D(10), D(11))).toBe(1.5) // both overlap 10-11
+    expect(resourceLoad(allocs, 'r1', D(9), D(10))).toBe(1) // only e1
+    expect(resourceLoad(allocs, 'r2', D(9), D(12))).toBe(0)
+  })
+})
+
+describe('overallocations', () => {
+  it('flags buckets where load exceeds capacity', () => {
+    const events = [ev('e1', 9, 12), ev('e2', 9, 12)]
+    const allocs = expandAssignments(events, [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
+      { id: 'a2', eventId: 'e2', resourceId: 'r1' },
+    ], opts)
+    const buckets = [{ start: D(9), end: D(10) }, { start: D(10), end: D(11) }]
+    const over = overallocations(allocs, ['r1'], buckets, 1)
+    expect(over).toHaveLength(2) // 2 concurrent > capacity 1, in both buckets
+    expect(over[0]).toMatchObject({ resourceId: 'r1', load: 2, capacity: 1 })
+  })
+
+  it('respects a per-resource capacity function', () => {
+    const events = [ev('e1', 9, 12), ev('e2', 9, 12)]
+    const allocs = expandAssignments(events, [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
+      { id: 'a2', eventId: 'e2', resourceId: 'r1' },
+    ], opts)
+    const over = overallocations(allocs, ['r1'], [{ start: D(9), end: D(10) }], () => 2)
+    expect(over).toHaveLength(0) // capacity 2 absorbs 2 concurrent
+  })
+})
+
+describe('assignedMinutes', () => {
+  it('totals weighted minutes across allocations', () => {
+    const allocs = expandAssignments([ev('e1', 9, 11)], [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 0.5 },
+    ], opts)
+    expect(assignedMinutes(allocs, 'r1')).toBe(60) // 120 min * 0.5
+  })
+})

package/src/scheduler-assignments.ts

@@ -0,0 +1,134 @@
+/**
+ * scheduler-assignments - the pure core behind Scheduler Pro *multi-assignment*
+ * (one event assigned to several resources) and the *resource utilization
+ * histogram*. No Svelte, no DOM. Generic over the event shape via accessor
+ * callbacks so it needs no dependency on the grid's ResolvedEvent.
+ */
+
+/** A many-to-many event <-> resource link, with an optional allocation (0..1). */
+export type SchedulerAssignment = {
+  id: string
+  eventId: string
+  resourceId: string
+  /** Allocation fraction, default 1 (full). Summed for histogram / overallocation. */
+  units?: number
+}
+
+/** One event placed on one resource (the flattened render unit). */
+export type Allocation<E = unknown> = {
+  event: E
+  key: string
+  resourceId: string
+  units: number
+  start: Date
+  end: Date
+}
+
+export type ExpandOptions<E> = {
+  keyOf: (e: E) => string
+  startOf: (e: E) => Date
+  endOf: (e: E) => Date
+  /** Single-resource fallback when an event has no assignment. */
+  resourceOf?: (e: E) => string | undefined
+}
+
+const MS_MIN = 60_000
+
+/**
+ * Flatten events into per-resource allocations. An event with assignments renders
+ * once per assigned resource (deduped by eventId+resourceId, keeping the max
+ * units); an event with none falls back to its single `resourceOf` (units 1), or
+ * is dropped when it has neither. The result drives the resource-column bucketing.
+ */
+export function expandAssignments<E>(
+  events: ReadonlyArray<E>,
+  assignments: ReadonlyArray<SchedulerAssignment>,
+  opts: ExpandOptions<E>,
+): Allocation<E>[] {
+  // Group assignments by eventId, collapsing duplicate resources to the max units.
+  const byEvent = new Map<string, Map<string, number>>()
+  for (const a of assignments) {
+    if (!a || !a.eventId || !a.resourceId) continue
+    let m = byEvent.get(a.eventId)
+    if (!m) byEvent.set(a.eventId, (m = new Map()))
+    const units = a.units == null ? 1 : a.units
+    m.set(a.resourceId, Math.max(m.get(a.resourceId) ?? 0, units))
+  }
+
+  const out: Allocation<E>[] = []
+  for (const e of events) {
+    const key = opts.keyOf(e)
+    const start = opts.startOf(e)
+    const end = opts.endOf(e)
+    const m = byEvent.get(key)
+    if (m && m.size) {
+      for (const [resourceId, units] of m) out.push({ event: e, key, resourceId, units, start, end })
+    } else {
+      const resourceId = opts.resourceOf?.(e)
+      if (resourceId != null) out.push({ event: e, key, resourceId, units: 1, start, end })
+    }
+  }
+  return out
+}
+
+/** True when `[aStart,aEnd)` overlaps `[bStart,bEnd)`. */
+function overlaps(aStart: Date, aEnd: Date, bStart: Date, bEnd: Date): boolean {
+  return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime()
+}
+
+/**
+ * Summed allocation units on `resourceId` overlapping the bucket
+ * `[bucketStart, bucketEnd)` - the height of one histogram bar.
+ */
+export function resourceLoad<E>(
+  allocs: ReadonlyArray<Allocation<E>>,
+  resourceId: string,
+  bucketStart: Date,
+  bucketEnd: Date,
+): number {
+  let load = 0
+  for (const a of allocs) {
+    if (a.resourceId !== resourceId) continue
+    if (overlaps(a.start, a.end, bucketStart, bucketEnd)) load += a.units
+  }
+  return load
+}
+
+/** One over-capacity bucket (summed load exceeds the resource capacity). */
+export type Overallocation = { resourceId: string; start: Date; end: Date; load: number; capacity: number }
+
+/**
+ * Buckets where a resource's summed load exceeds its capacity. `buckets` are the
+ * axis intervals to test; `capacity` is a flat number or a per-resource function
+ * (default 1). Used to tint histogram bars / flag conflicts.
+ */
+export function overallocations<E>(
+  allocs: ReadonlyArray<Allocation<E>>,
+  resourceIds: ReadonlyArray<string>,
+  buckets: ReadonlyArray<{ start: Date; end: Date }>,
+  capacity: number | ((resourceId: string) => number) = 1,
+): Overallocation[] {
+  const capOf = typeof capacity === 'function' ? capacity : () => capacity
+  const out: Overallocation[] = []
+  for (const resourceId of resourceIds) {
+    const cap = capOf(resourceId)
+    for (const b of buckets) {
+      const load = resourceLoad(allocs, resourceId, b.start, b.end)
+      if (load > cap + 1e-9) out.push({ resourceId, start: b.start, end: b.end, load, capacity: cap })
+    }
+  }
+  return out
+}
+
+/**
+ * Total assigned minutes per resource across `allocs` (a simple utilization
+ * roll-up for a legend / header, independent of buckets).
+ */
+export function assignedMinutes<E>(allocs: ReadonlyArray<Allocation<E>>, resourceId: string): number {
+  let mins = 0
+  for (const a of allocs) {
+    if (a.resourceId !== resourceId) continue
+    mins += ((a.end.getTime() - a.start.getTime()) / MS_MIN) * a.units
+  }
+  return mins
+}