@open-mercato/shared 0.4.5-develop-03023b2707 → 0.4.5-develop-0c30cb4b11

package/src/modules/widgets/injection-loader.ts

@@ -1,5 +1,7 @@
 import type { ModuleInjectionWidgetEntry } from '../registry'
 import type {
+  InjectionAnyWidgetModule,
+  InjectionDataWidgetModule,
   InjectionWidgetMetadata,
   InjectionWidgetModule,
   InjectionSpotId,
@@ -9,6 +11,8 @@ import type {
 } from './injection'
 
 type LoadedWidgetModule = InjectionWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }
+type LoadedDataWidgetModule = InjectionDataWidgetModule & { metadata: InjectionWidgetMetadata }
+
 export type LoadedInjectionWidget = LoadedWidgetModule & {
   moduleId: string
   key: string
@@ -22,6 +26,19 @@ export type LoadedInjectionWidget = LoadedWidgetModule & {
   }
 }
 
+export type LoadedInjectionDataWidget = LoadedDataWidgetModule & {
+  moduleId: string
+  key: string
+  placement?: {
+    groupId?: string
+    groupLabel?: string
+    groupDescription?: string
+    column?: 1 | 2
+    kind?: 'tab' | 'group' | 'stack'
+    [k: string]: unknown
+  }
+}
+
 type WidgetEntry = ModuleInjectionWidgetEntry & { moduleId: string }
 
 // Registration pattern for publishable packages
@@ -142,7 +159,6 @@ async function loadWidgetEntries(): Promise<WidgetEntry[]> {
       }))
     )
     widgetEntriesPromise = promise.catch((err) => {
-      // Clear cache on error so next call can retry after registration
       if (widgetEntriesPromise === promise) {
         widgetEntriesPromise = null
       }
@@ -190,7 +206,6 @@ async function loadInjectionTable(): Promise<Map<InjectionSpotId, TableEntry[]>>
       return table
     })
     injectionTablePromise = promise.catch((err) => {
-      // Clear cache on error so next call can retry after registration
       if (injectionTablePromise === promise) {
         injectionTablePromise = null
       }
@@ -200,49 +215,115 @@ async function loadInjectionTable(): Promise<Map<InjectionSpotId, TableEntry[]>>
   return injectionTablePromise
 }
 
-const widgetCache = new Map<string, Promise<LoadedWidgetModule>>()
+const widgetCache = new Map<string, Promise<InjectionAnyWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }>>()
+
+function isDataWidgetModule(widget: Record<string, unknown>): widget is LoadedDataWidgetModule {
+  const keys = [
+    'columns',
+    'rowActions',
+    'bulkActions',
+    'filters',
+    'fields',
+    'steps',
+    'badge',
+    'menuItems',
+  ]
+  return keys.some((key) => key in widget)
+}
 
-function ensureValidWidgetModule(mod: any, key: string, moduleId: string): LoadedWidgetModule {
+function ensureValidInjectionModule(mod: unknown, key: string, moduleId: string): (InjectionAnyWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }) {
   if (!mod || typeof mod !== 'object') {
     throw new Error(`Invalid injection widget module "${key}" from "${moduleId}" (expected object export)`)
   }
-  const widget = (mod.default ?? mod) as InjectionWidgetModule<any, any>
+  const widget = (mod as { default?: InjectionAnyWidgetModule<any, any> }).default ?? (mod as InjectionAnyWidgetModule<any, any>)
   if (!widget || typeof widget !== 'object') {
-    throw new Error(`Invalid injection widget export "${key}" from "${moduleId}" (missing default export)`)
+    throw new Error(`Invalid injection widget export "${key}" from "${moduleId}" (missing default export)`) 
   }
-  if (!widget.metadata || typeof widget.metadata !== 'object') {
+  if (!('metadata' in widget) || !widget.metadata || typeof widget.metadata !== 'object') {
     throw new Error(`Injection widget "${key}" from "${moduleId}" is missing metadata`)
   }
-  const { metadata } = widget
+  const metadata = widget.metadata
   if (typeof metadata.id !== 'string' || metadata.id.length === 0) {
     throw new Error(`Injection widget "${key}" from "${moduleId}" metadata.id must be a non-empty string`)
   }
-  if (typeof metadata.title !== 'string' || metadata.title.length === 0) {
-    throw new Error(`Injection widget "${metadata.id}" from "${moduleId}" must have a title`)
-  }
-  return {
+  const normalized = {
     ...widget,
     metadata,
   }
+
+  if ('Widget' in normalized && typeof normalized.Widget === 'function') {
+    if (typeof metadata.title !== 'string' || metadata.title.length === 0) {
+      throw new Error(`Injection widget "${metadata.id}" from "${moduleId}" must have a title`)
+    }
+    return normalized
+  }
+
+  if (!isDataWidgetModule(normalized as Record<string, unknown>)) {
+    throw new Error(
+      `Injection widget "${metadata.id}" from "${moduleId}" must export either Widget component or a declarative data payload`
+    )
+  }
+
+  return normalized
 }
 
-async function loadEntry(entry: WidgetEntry): Promise<LoadedWidgetModule> {
+function isLoadedInjectionWidget(
+  module: InjectionAnyWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }
+): module is LoadedWidgetModule {
+  return 'Widget' in module && typeof module.Widget === 'function'
+}
+
+function isLoadedInjectionDataWidget(
+  module: InjectionAnyWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }
+): module is LoadedDataWidgetModule {
+  return !isLoadedInjectionWidget(module)
+}
+
+async function loadEntry(entry: WidgetEntry): Promise<InjectionAnyWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }> {
   if (!widgetCache.has(entry.key)) {
-    const promise = entry.loader()
-      .then((mod) => ensureValidWidgetModule(mod, entry.key, entry.moduleId))
+    const promise = entry.loader().then((mod) => ensureValidInjectionModule(mod, entry.key, entry.moduleId))
     widgetCache.set(entry.key, promise)
   }
   return widgetCache.get(entry.key)!
 }
 
+async function getResolvedEntriesForSpot(spotId: InjectionSpotId): Promise<TableEntry[]> {
+  const table = await loadInjectionTable()
+  const exactEntries = table.get(spotId) ?? []
+  const wildcardEntries: TableEntry[] = []
+
+  for (const [candidateSpotId, candidateEntries] of table.entries()) {
+    if (candidateSpotId === spotId) continue
+    if (!candidateSpotId.includes('*')) continue
+    const pattern = new RegExp(`^${candidateSpotId.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`)
+    if (!pattern.test(spotId)) continue
+    wildcardEntries.push(...candidateEntries)
+  }
+
+  const dedupedEntries = new Map<string, TableEntry>()
+  for (const entry of [...exactEntries, ...wildcardEntries]) {
+    const cacheKey = `${entry.moduleId}:${entry.widgetId}`
+    const previous = dedupedEntries.get(cacheKey)
+    if (!previous || (entry.priority ?? 0) > (previous.priority ?? 0)) {
+      dedupedEntries.set(cacheKey, entry)
+    }
+  }
+
+  return Array.from(dedupedEntries.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))
+}
+
 export async function loadAllInjectionWidgets(): Promise<LoadedInjectionWidget[]> {
   const widgetEntries = await loadWidgetEntries()
-  const loaded = await Promise.all(widgetEntries.map(async (entry) => {
-    const widget = await loadEntry(entry)
-    return { ...widget, moduleId: entry.moduleId, key: entry.key }
-  }))
-  const byId = new Map<string, LoadedWidgetModule & { moduleId: string; key: string }>()
+  const loaded = await Promise.all(
+    widgetEntries.map(async (entry) => {
+      const module = await loadEntry(entry)
+      if (!isLoadedInjectionWidget(module)) return null
+      return { ...module, moduleId: entry.moduleId, key: entry.key }
+    })
+  )
+  const byId = new Map<string, LoadedInjectionWidget>()
   for (const widget of loaded) {
+    if (!widget) continue
     if (!byId.has(widget.metadata.id)) {
       byId.set(widget.metadata.id, widget)
     }
@@ -253,42 +334,51 @@ export async function loadAllInjectionWidgets(): Promise<LoadedInjectionWidget[]
 export async function loadInjectionWidgetById(widgetId: string): Promise<LoadedInjectionWidget | null> {
   const widgetEntries = await loadWidgetEntries()
   for (const entry of widgetEntries) {
-    const widget = await loadEntry(entry)
-    if (widget.metadata.id === widgetId) {
-      return { ...widget, moduleId: entry.moduleId, key: entry.key }
+    const module = await loadEntry(entry)
+    if (!isLoadedInjectionWidget(module)) continue
+    if (module.metadata.id === widgetId) {
+      return { ...module, moduleId: entry.moduleId, key: entry.key }
+    }
+  }
+  return null
+}
+
+export async function loadInjectionDataWidgetById(widgetId: string): Promise<LoadedInjectionDataWidget | null> {
+  const widgetEntries = await loadWidgetEntries()
+  for (const entry of widgetEntries) {
+    const module = await loadEntry(entry)
+    if (!isLoadedInjectionDataWidget(module)) continue
+    if (module.metadata.id === widgetId) {
+      return { ...module, moduleId: entry.moduleId, key: entry.key }
     }
   }
   return null
 }
 
 export async function loadInjectionWidgetsForSpot(spotId: InjectionSpotId): Promise<LoadedInjectionWidget[]> {
-  const table = await loadInjectionTable()
-  const exactEntries = table.get(spotId) ?? []
-  const wildcardEntries: TableEntry[] = []
-  for (const [candidateSpotId, candidateEntries] of table.entries()) {
-    if (candidateSpotId === spotId) continue
-    if (!candidateSpotId.includes('*')) continue
-    const pattern = new RegExp(`^${candidateSpotId.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`)
-    if (!pattern.test(spotId)) continue
-    wildcardEntries.push(...candidateEntries)
+  const entries = await getResolvedEntriesForSpot(spotId)
+  const widgets: LoadedInjectionWidget[] = []
+  for (const { widgetId, placement, priority } of entries) {
+    const widget = await loadInjectionWidgetById(widgetId)
+    if (!widget) continue
+    const combinedPlacement = placement
+      ? { ...placement, priority: typeof priority === 'number' ? priority : 0 }
+      : { priority: typeof priority === 'number' ? priority : 0 }
+    widgets.push({ ...widget, placement: combinedPlacement })
   }
-  const dedupedEntries = new Map<string, TableEntry>()
-  for (const entry of [...exactEntries, ...wildcardEntries]) {
-    const key = `${entry.moduleId}:${entry.widgetId}`
-    const previous = dedupedEntries.get(key)
-    if (!previous || (entry.priority ?? 0) > (previous.priority ?? 0)) {
-      dedupedEntries.set(key, entry)
-    }
+  return widgets
+}
+
+export async function loadInjectionDataWidgetsForSpot(spotId: InjectionSpotId): Promise<LoadedInjectionDataWidget[]> {
+  const entries = await getResolvedEntriesForSpot(spotId)
+  const widgets: LoadedInjectionDataWidget[] = []
+  for (const { widgetId, placement, priority } of entries) {
+    const widget = await loadInjectionDataWidgetById(widgetId)
+    if (!widget) continue
+    const combinedPlacement = placement
+      ? { ...placement, priority: typeof priority === 'number' ? priority : 0 }
+      : { priority: typeof priority === 'number' ? priority : 0 }
+    widgets.push({ ...widget, placement: combinedPlacement })
   }
-  const entries = Array.from(dedupedEntries.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))
-  const widgets = await Promise.all(
-    entries.map(async ({ widgetId, placement, priority }) => {
-      const widget = await loadInjectionWidgetById(widgetId)
-      const combinedPlacement = placement
-        ? { ...placement, priority: typeof priority === 'number' ? priority : 0 }
-        : { priority: typeof priority === 'number' ? priority : 0 }
-      return widget ? { ...widget, placement: combinedPlacement } : null
-    })
-  )
-  return widgets.filter((w): w is NonNullable<typeof w> => w !== null)
+  return widgets
 }

package/src/modules/widgets/injection-position.ts

@@ -0,0 +1,59 @@
+export enum InjectionPosition {
+  Before = 'before',
+  After = 'after',
+  First = 'first',
+  Last = 'last',
+}
+
+export type InjectionPlacement = {
+  position?: InjectionPosition
+  relativeTo?: string
+}
+
+export function getInjectionPosition(placement?: InjectionPlacement): InjectionPosition {
+  if (!placement?.position) return InjectionPosition.Last
+  return placement.position
+}
+
+function warnInvalidRelativeTo(relativeTo: string | undefined) {
+  if (process.env.NODE_ENV !== 'development') return
+  if (!relativeTo) return
+  console.warn(`[InjectionPlacement] relativeTo target "${relativeTo}" not found, appending item at the end.`)
+}
+
+export function insertByInjectionPlacement<T>(
+  items: T[],
+  item: T,
+  placement: InjectionPlacement | undefined,
+  getItemId: (value: T) => string,
+): T[] {
+  const current = [...items]
+  const position = getInjectionPosition(placement)
+
+  if (position === InjectionPosition.First) {
+    current.unshift(item)
+    return current
+  }
+
+  if (position === InjectionPosition.Last) {
+    current.push(item)
+    return current
+  }
+
+  const relativeTo = placement?.relativeTo
+  if (!relativeTo) {
+    current.push(item)
+    return current
+  }
+
+  const targetIndex = current.findIndex((value) => getItemId(value) === relativeTo)
+  if (targetIndex < 0) {
+    warnInvalidRelativeTo(relativeTo)
+    current.push(item)
+    return current
+  }
+
+  const insertIndex = position === InjectionPosition.Before ? targetIndex : targetIndex + 1
+  current.splice(insertIndex, 0, item)
+  return current
+}

package/src/modules/widgets/injection-progress.ts

@@ -0,0 +1,35 @@
+/**
+ * Async Operation Progress Types
+ *
+ * Standard contract for real-time progress tracking of long-running operations
+ * (data sync imports, bulk exports, webhook replay). These events are delivered
+ * via the DOM Event Bridge (clientBroadcast: true) and consumed by the
+ * `useOperationProgress` hook.
+ */
+
+/**
+ * Structured progress payload emitted by server-side workers.
+ * Workers emit these as standard events with `clientBroadcast: true`.
+ */
+export interface OperationProgressEvent {
+  /** Unique operation ID (e.g., syncRunId) */
+  operationId: string
+  /** Operation type identifier (e.g., 'sync.import', 'bulk.export') */
+  operationType: string
+  /** Current status of the operation */
+  status: 'running' | 'completed' | 'failed' | 'cancelled'
+  /** Progress percentage (0-100) */
+  progress: number
+  /** Number of items processed so far */
+  processedCount: number
+  /** Total number of items to process */
+  totalCount: number
+  /** Human-readable current step name */
+  currentStep?: string
+  /** Number of errors encountered */
+  errors: number
+  /** Timestamp when the operation started */
+  startedAt: number
+  /** Additional operation-specific metadata */
+  metadata?: Record<string, unknown>
+}

package/src/modules/widgets/injection.ts

@@ -1,9 +1,52 @@
-import type { ComponentType } from 'react'
+import type { ComponentType, LazyExoticComponent, ReactNode } from 'react'
+import type { InjectionPlacement } from './injection-position'
 
 /**
- * Widget injection event handlers for lifecycle management
+ * Result returned by `onFieldChange` handlers.
+ */
+export type FieldChangeResult = {
+  /** Override the field value */
+  value?: unknown
+  /** Set other fields as side effects */
+  sideEffects?: Record<string, unknown>
+  /** Display a message to the user near the field */
+  message?: { text: string; severity: 'info' | 'warning' | 'error' }
+}
+
+/**
+ * Result returned by `onBeforeNavigate` handlers.
+ */
+export type NavigateGuardResult = {
+  /** Whether navigation should proceed */
+  ok: boolean
+  /** Reason shown to the user when navigation is blocked */
+  message?: string
+}
+
+/**
+ * Payload delivered by the DOM Event Bridge for server-side app events.
+ */
+export type AppEventPayload = {
+  /** Event identifier (e.g., 'example.todo.created') */
+  id: string
+  /** Event-specific payload data */
+  payload: Record<string, unknown>
+  /** Server timestamp when the event was emitted */
+  timestamp: number
+  /** Organization the event belongs to */
+  organizationId: string
+}
+
+/**
+ * Widget injection event handlers for lifecycle management.
+ *
+ * Handlers are classified into two categories:
+ * - **Action events**: Fire-and-forget or gate handlers (accumulate requestHeaders, check ok boolean)
+ * - **Transformer events**: Pipeline handlers where output of widget N becomes input of widget N+1
  */
 export type WidgetInjectionEventHandlers<TContext = unknown, TData = unknown> = {
+  // === Existing: Lifecycle Actions ===
+
   /**
    * Called when the widget is first loaded/mounted
    */
@@ -47,6 +90,52 @@ export type WidgetInjectionEventHandlers<TContext = unknown, TData = unknown> =
    * Called when delete action fails.
    */
   onDeleteError?: (data: TData, context: TContext, error: unknown) => void | Promise<void>
+
+  // === New: DOM-Inspired Lifecycle (Phase C) ===
+
+  /**
+   * Called when a form field value changes. Can return side-effects and user messages.
+   * Action event — called for each widget independently.
+   */
+  onFieldChange?: (fieldId: string, value: unknown, data: TData, context: TContext) => Promise<FieldChangeResult | void>
+
+  /**
+   * Called before navigating away from the current page. Can block navigation.
+   * Action event — first widget returning `ok: false` stops navigation.
+   */
+  onBeforeNavigate?: (target: string, context: TContext) => Promise<NavigateGuardResult>
+
+  /**
+   * Called when the widget's visibility changes (e.g., tab switches).
+   * Action event — fire-and-forget.
+   */
+  onVisibilityChange?: (visible: boolean, context: TContext) => Promise<void>
+
+  /**
+   * Called when an app event matching the widget's subscription arrives via the DOM Event Bridge.
+   * Action event — fire-and-forget.
+   */
+  onAppEvent?: (event: AppEventPayload, context: TContext) => Promise<void>
+
+  // === New: Data Transformation Pipelines (Phase C) ===
+
+  /**
+   * Transform form data before submission. Output of widget N becomes input of widget N+1.
+   * Transformer event — pipeline dispatch.
+   */
+  transformFormData?: (data: TData, context: TContext) => Promise<TData>
+
+  /**
+   * Transform data for display purposes. Output of widget N becomes input of widget N+1.
+   * Transformer event — pipeline dispatch.
+   */
+  transformDisplayData?: (data: TData, context: TContext) => Promise<TData>
+
+  /**
+   * Transform validation errors. Output of widget N becomes input of widget N+1.
+   * Transformer event — pipeline dispatch.
+   */
+  transformValidation?: (errors: Record<string, string>, data: TData, context: TContext) => Promise<Record<string, string>>
 }
 
 /**
@@ -54,7 +143,7 @@ export type WidgetInjectionEventHandlers<TContext = unknown, TData = unknown> =
  */
 export type InjectionWidgetMetadata = {
   id: string
-  title: string
+  title?: string
   description?: string
   features?: string[]
   priority?: number
@@ -123,6 +212,194 @@ export type InjectionWidgetModule<TContext = unknown, TData = unknown> = {
   eventHandlers?: WidgetInjectionEventHandlers<TContext, TData>
 }
 
+export type InjectionColumnDefinition = {
+  id: string
+  header: string
+  accessorKey: string
+  cell?: (props: { getValue: () => unknown }) => ReactNode
+  size?: number
+  sortable?: boolean
+  placement?: InjectionPlacement
+}
+
+export type InjectionRowActionDefinition = {
+  id: string
+  label: string
+  icon?: string
+  onSelect: (row: unknown, context: unknown) => void
+  placement?: InjectionPlacement
+}
+
+export type InjectionBulkActionDefinition = {
+  id: string
+  label: string
+  icon?: string
+  onExecute: (selectedRows: unknown[], context: unknown) => Promise<void>
+}
+
+export type InjectionFilterDefinition = {
+  id: string
+  label: string
+  type: 'select' | 'text' | 'date-range' | 'boolean'
+  options?: { value: string; label: string }[]
+  strategy: 'server' | 'client'
+  queryParam?: string
+  enrichedField?: string
+}
+
+export type FieldVisibilityCondition<TContext = unknown> = (
+  values: Record<string, unknown>,
+  context: TContext,
+) => boolean
+
+export type CustomFieldProps<TContext = unknown> = {
+  value: unknown
+  onChange: (value: unknown) => void
+  context: TContext
+  disabled?: boolean
+}
+
+export type FieldContext = {
+  organizationId?: string | null
+  tenantId?: string | null
+  userId?: string | null
+  record?: Record<string, unknown>
+}
+
+export type InjectionFieldDefinition = {
+  id: string
+  label: string
+  type: 'text' | 'select' | 'number' | 'date' | 'boolean' | 'textarea' | 'custom'
+  options?: { value: string; label: string }[]
+  optionsLoader?: (context: FieldContext) => Promise<{ value: string; label: string }[]>
+  optionsCacheTtl?: number
+  customComponent?: LazyExoticComponent<ComponentType<CustomFieldProps>>
+  group: string
+  placement?: InjectionPlacement
+  readOnly?: boolean
+  visibleWhen?: FieldVisibilityCondition
+}
+
+export type WizardStepProps<TContext = unknown> = {
+  data: Record<string, unknown>
+  setData: (next: Record<string, unknown>) => void
+  context: TContext
+}
+
+export type InjectionContext = {
+  organizationId?: string | null
+  tenantId?: string | null
+  userId?: string | null
+  path?: string
+  [k: string]: unknown
+}
+
+export type InjectionWizardStep = {
+  id: string
+  label: string
+  fields?: InjectionFieldDefinition[]
+  customComponent?: LazyExoticComponent<ComponentType<WizardStepProps>>
+  validate?: (
+    data: Record<string, unknown>,
+    context: InjectionContext,
+  ) => Promise<{ ok: boolean; message?: string }>
+}
+
+export type InjectionWizardWidget = {
+  metadata: InjectionWidgetMetadata
+  kind: 'wizard'
+  steps: InjectionWizardStep[]
+  onComplete?: (stepData: Record<string, unknown>, context: InjectionContext) => Promise<void>
+  eventHandlers?: WidgetInjectionEventHandlers<InjectionContext, Record<string, unknown>>
+}
+
+export type StatusBadgeResult = {
+  status: 'healthy' | 'warning' | 'error' | 'unknown'
+  tooltip?: string
+  count?: number
+}
+
+export type StatusBadgeContext = {
+  organizationId: string
+  tenantId: string
+  userId: string
+}
+
+export type InjectionStatusBadgeWidget = {
+  metadata: InjectionWidgetMetadata
+  kind: 'status-badge'
+  badge: {
+    label: string
+    statusLoader: (context: StatusBadgeContext) => Promise<StatusBadgeResult>
+    href?: string
+    pollInterval?: number
+  }
+}
+
+export type InjectionMenuItem = {
+  id: string
+  label: string
+  labelKey?: string
+  icon?: string
+  href?: string
+  onClick?: () => void
+  separator?: boolean
+  placement?: InjectionPlacement
+  features?: string[]
+  roles?: string[]
+  badge?: string | number
+  children?: Omit<InjectionMenuItem, 'children'>[]
+  groupId?: string
+  groupLabel?: string
+  groupLabelKey?: string
+  groupOrder?: number
+}
+
+export type InjectionMenuItemWidget = {
+  metadata: InjectionWidgetMetadata
+  menuItems: InjectionMenuItem[]
+}
+
+export type InjectionColumnWidget = {
+  metadata: InjectionWidgetMetadata
+  columns: InjectionColumnDefinition[]
+}
+
+export type InjectionRowActionWidget = {
+  metadata: InjectionWidgetMetadata
+  rowActions: InjectionRowActionDefinition[]
+}
+
+export type InjectionBulkActionWidget = {
+  metadata: InjectionWidgetMetadata
+  bulkActions: InjectionBulkActionDefinition[]
+}
+
+export type InjectionFilterWidget = {
+  metadata: InjectionWidgetMetadata
+  filters: InjectionFilterDefinition[]
+}
+
+export type InjectionFieldWidget = {
+  metadata: InjectionWidgetMetadata
+  fields: InjectionFieldDefinition[]
+  eventHandlers?: WidgetInjectionEventHandlers<InjectionContext, Record<string, unknown>>
+}
+
+export type InjectionDataWidgetModule =
+  | InjectionColumnWidget
+  | InjectionRowActionWidget
+  | InjectionBulkActionWidget
+  | InjectionFilterWidget
+  | InjectionFieldWidget
+  | InjectionWizardWidget
+  | InjectionStatusBadgeWidget
+  | InjectionMenuItemWidget
+
+export type InjectionAnyWidgetModule<TContext = unknown, TData = unknown> =
+  | InjectionWidgetModule<TContext, TData>
+  | InjectionDataWidgetModule
+
 /**
  * Injection spot identifier - uniquely identifies where widgets can be injected
  */