@carto/ps-react-ui 5.0.0 → 6.0.0

package/src/widgets/stores/widget-store.test.ts

@@ -1,942 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { useWidgetStore } from './widget-store'
-import type { ToolRegistration } from './types'
-
-describe('WidgetStore', () => {
-  beforeEach(() => {
-    // Reset the store before each test
-    useWidgetStore.setState({
-      widgets: {},
-    })
-  })
-
-  describe('setWidget', () => {
-    it('should add a new widget to the store', () => {
-      const widgetId = 'test-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        title: 'Test Formula',
-        isLoading: false,
-        visible: true,
-        data: {
-          value: 100,
-          prefix: '$',
-        },
-      })
-
-      const widgets = useWidgetStore.getState().widgets
-      expect(widgets[widgetId]).toBeDefined()
-      expect(widgets[widgetId]?.id).toBe(widgetId)
-      expect(widgets[widgetId]?.type).toBe('formula')
-    })
-
-    it('should update an existing widget', () => {
-      const widgetId = 'test-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        title: 'Test Formula',
-        isLoading: false,
-        visible: true,
-        data: {
-          value: 100,
-        },
-      })
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        title: 'Updated Formula',
-        data: {
-          value: 200,
-        },
-      })
-
-      const widgets = useWidgetStore.getState().widgets
-      expect((widgets[widgetId]?.data as { value: number })?.value).toBe(200)
-    })
-
-    it('should handle multiple widgets', () => {
-      useWidgetStore.getState().setWidget('widget-1', {
-        type: 'formula',
-        isLoading: false,
-        visible: true,
-      })
-
-      useWidgetStore.getState().setWidget('widget-2', {
-        type: 'bar',
-        isLoading: false,
-        visible: true,
-      })
-
-      const widgets = useWidgetStore.getState().widgets
-      expect(Object.keys(widgets)).toHaveLength(2)
-      expect(widgets['widget-1']).toBeDefined()
-      expect(widgets['widget-2']).toBeDefined()
-    })
-  })
-
-  describe('removeWidget', () => {
-    it('should remove a widget from the store', () => {
-      const widgetId = 'test-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        isLoading: false,
-        visible: true,
-      })
-
-      expect(useWidgetStore.getState().widgets[widgetId]).toBeDefined()
-
-      useWidgetStore.getState().removeWidget(widgetId)
-      expect(useWidgetStore.getState().widgets[widgetId]).toBeUndefined()
-    })
-
-    it('should handle removing non-existent widget gracefully', () => {
-      useWidgetStore.getState().removeWidget('non-existent')
-      expect(useWidgetStore.getState().widgets).toEqual({})
-    })
-
-    it('should only remove the specified widget', () => {
-      useWidgetStore.getState().setWidget('widget-1', {
-        type: 'formula',
-        isLoading: false,
-        visible: true,
-      })
-
-      useWidgetStore.getState().setWidget('widget-2', {
-        type: 'formula',
-        isLoading: false,
-        visible: true,
-      })
-
-      useWidgetStore.getState().removeWidget('widget-1')
-
-      const widgets = useWidgetStore.getState().widgets
-      expect(widgets['widget-1']).toBeUndefined()
-      expect(widgets['widget-2']).toBeDefined()
-    })
-  })
-
-  describe('clearWidgets', () => {
-    it('should remove all widgets', () => {
-      useWidgetStore.getState().setWidget('widget-1', {
-        type: 'formula',
-        isLoading: false,
-        visible: true,
-      })
-
-      useWidgetStore.getState().setWidget('widget-2', {
-        type: 'bar',
-        isLoading: false,
-        visible: true,
-      })
-
-      expect(Object.keys(useWidgetStore.getState().widgets)).toHaveLength(2)
-
-      useWidgetStore.getState().clearWidgets()
-
-      expect(useWidgetStore.getState().widgets).toEqual({})
-    })
-
-    it('should work on empty store', () => {
-      useWidgetStore.getState().clearWidgets()
-      expect(useWidgetStore.getState().widgets).toEqual({})
-    })
-  })
-
-  describe('getWidget', () => {
-    it('should get a widget by id', () => {
-      const widgetId = 'test-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        title: 'Test Widget',
-        isLoading: false,
-        visible: true,
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget).toBeDefined()
-      expect(widget?.id).toBe(widgetId)
-    })
-
-    it('should return undefined for non-existent widget', () => {
-      const widget = useWidgetStore.getState().getWidget('non-existent')
-      expect(widget).toBeUndefined()
-    })
-  })
-
-  describe('unknown type data handling', () => {
-    it('should handle widget with unknown type and data structure', () => {
-      const widgetId = 'custom-widget'
-
-      // Example: A custom widget type with arbitrary data
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'custom',
-        title: 'Custom Widget',
-        isLoading: false,
-        visible: true,
-        data: {
-          customField: 'value',
-          nestedData: {
-            foo: 'bar',
-            count: 42,
-          },
-        },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget).toBeDefined()
-      expect(widget?.type).toBe('custom')
-
-      // Type assertion needed when accessing unknown data
-      const customData = widget?.data as {
-        customField: string
-        nestedData: { foo: string; count: number }
-      }
-      expect(customData?.customField).toBe('value')
-      expect(customData?.nestedData?.foo).toBe('bar')
-      expect(customData?.nestedData?.count).toBe(42)
-    })
-
-    it('should handle widget updates with different data structures', () => {
-      const widgetId = 'flexible-widget'
-
-      // Initial data structure
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'dynamic',
-        isLoading: false,
-        visible: true,
-        data: {
-          format: 'json',
-          content: { items: [] },
-        },
-      })
-
-      // Update with different data structure
-      useWidgetStore.getState().setWidget(widgetId, {
-        data: {
-          format: 'text',
-          content: 'Plain text content',
-          metadata: {
-            length: 18,
-          },
-        },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      const widgetData = widget?.data as {
-        format: string
-        content: string
-        metadata: { length: number }
-      }
-
-      expect(widgetData?.format).toBe('text')
-      expect(widgetData?.content).toBe('Plain text content')
-      expect(widgetData?.metadata?.length).toBe(18)
-    })
-
-    it('should handle complex nested unknown data', () => {
-      const widgetId = 'complex-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'analytics',
-        title: 'Analytics Dashboard',
-        isLoading: false,
-        visible: true,
-        data: {
-          metrics: [
-            { name: 'revenue', value: 1000, trend: 'up' },
-            { name: 'users', value: 500, trend: 'down' },
-          ],
-          timeRange: {
-            start: '2025-01-01',
-            end: '2025-01-31',
-          },
-          settings: {
-            displayMode: 'chart',
-            refreshInterval: 5000,
-          },
-        },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-
-      // Type assertion for complex unknown data
-      const analyticsData = widget?.data as {
-        metrics: { name: string; value: number; trend: string }[]
-        timeRange: { start: string; end: string }
-        settings: { displayMode: string; refreshInterval: number }
-      }
-
-      expect(analyticsData.metrics).toHaveLength(2)
-      expect(analyticsData.metrics[0]?.name).toBe('revenue')
-      expect(analyticsData.metrics[0]?.value).toBe(1000)
-      expect(analyticsData.timeRange.start).toBe('2025-01-01')
-      expect(analyticsData.settings.displayMode).toBe('chart')
-    })
-
-    it('should handle widget with no data', () => {
-      const widgetId = 'no-data-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'placeholder',
-        title: 'Empty Widget',
-        isLoading: false,
-        visible: true,
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.data).toBeUndefined()
-    })
-
-    it('should preserve unknown type through updates', () => {
-      const widgetId = 'type-test-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'special-type-123',
-        isLoading: false,
-        visible: true,
-        data: { initial: true },
-      })
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        title: 'Updated Title',
-        data: { updated: true },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.type).toBe('special-type-123')
-    })
-  })
-
-  describe('isFetching property', () => {
-    it('should set isFetching on a new widget', () => {
-      const widgetId = 'fetching-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        title: 'Fetching Widget',
-        isLoading: false,
-        isFetching: true,
-        visible: true,
-        data: { value: 100 },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isFetching).toBe(true)
-    })
-
-    it('should update isFetching on an existing widget', () => {
-      const widgetId = 'update-fetching-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        isLoading: false,
-        isFetching: false,
-        visible: true,
-      })
-
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        false,
-      )
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        isFetching: true,
-      })
-
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        true,
-      )
-    })
-
-    it('should handle undefined isFetching (optional property)', () => {
-      const widgetId = 'no-fetching-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        isLoading: false,
-        visible: true,
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isFetching).toBeUndefined()
-    })
-
-    it('should handle different combinations of isLoading and isFetching', () => {
-      const widgetId = 'state-combination-widget'
-
-      // Both false
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        isLoading: false,
-        isFetching: false,
-        visible: true,
-      })
-
-      let widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isLoading).toBe(false)
-      expect(widget?.isFetching).toBe(false)
-
-      // Loading true, fetching false
-      useWidgetStore.getState().setWidget(widgetId, {
-        isLoading: true,
-        isFetching: false,
-      })
-
-      widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isLoading).toBe(true)
-      expect(widget?.isFetching).toBe(false)
-
-      // Loading false, fetching true
-      useWidgetStore.getState().setWidget(widgetId, {
-        isLoading: false,
-        isFetching: true,
-      })
-
-      widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isLoading).toBe(false)
-      expect(widget?.isFetching).toBe(true)
-
-      // Both true
-      useWidgetStore.getState().setWidget(widgetId, {
-        isLoading: true,
-        isFetching: true,
-      })
-
-      widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isLoading).toBe(true)
-      expect(widget?.isFetching).toBe(true)
-    })
-
-    it('should toggle isFetching multiple times', () => {
-      const widgetId = 'toggle-fetching-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        isLoading: false,
-        isFetching: false,
-        visible: true,
-      })
-
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        false,
-      )
-
-      useWidgetStore.getState().setWidget(widgetId, { isFetching: true })
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        true,
-      )
-
-      useWidgetStore.getState().setWidget(widgetId, { isFetching: false })
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        false,
-      )
-
-      useWidgetStore.getState().setWidget(widgetId, { isFetching: true })
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        true,
-      )
-    })
-
-    it('should preserve isFetching when updating other properties', () => {
-      const widgetId = 'preserve-fetching-widget'
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'formula',
-        title: 'Original Title',
-        isLoading: false,
-        isFetching: true,
-        visible: true,
-        data: { value: 100 },
-      })
-
-      expect(useWidgetStore.getState().getWidget(widgetId)?.isFetching).toBe(
-        true,
-      )
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        title: 'Updated Title',
-        data: { value: 200 },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.isFetching).toBe(true)
-      expect((widget?.data as { value: number })?.value).toBe(200)
-    })
-  })
-
-  describe('executeToolPipeline sourceData', () => {
-    const widgetId = 'test-widget-source'
-
-    beforeEach(() => {
-      useWidgetStore.getState().clearWidgets()
-    })
-
-    it('stores sourceData alongside data after pipeline execution', async () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      const source = [{ value: 1 }, { value: 2 }]
-      await useWidgetStore.getState().executeToolPipeline(widgetId, source)
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.sourceData).toBe(source)
-      expect(widget?.data).toBe(source) // No tools, passthrough
-    })
-
-    it('preserves sourceData when a tool transforms data to empty', async () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      const emptyFilterTool: ToolRegistration = {
-        id: 'empty-filter',
-        order: 10,
-        enabled: true,
-        fn: () => [], // Transforms any data to empty array
-      }
-
-      useWidgetStore.getState().registerTool(widgetId, emptyFilterTool)
-
-      const source = [{ value: 1 }, { value: 2 }]
-      await useWidgetStore.getState().executeToolPipeline(widgetId, source)
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect(widget?.sourceData).toBe(source)
-      expect(widget?.data).toEqual([])
-    })
-
-    it('updates sourceData when input changes but pipeline output stays the same', async () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      const constantTool: ToolRegistration = {
-        id: 'constant',
-        order: 10,
-        enabled: true,
-        fn: () => 'constant-output',
-      }
-
-      useWidgetStore.getState().registerTool(widgetId, constantTool)
-
-      const source1 = [{ value: 1 }]
-      await useWidgetStore.getState().executeToolPipeline(widgetId, source1)
-
-      expect(useWidgetStore.getState().getWidget(widgetId)?.sourceData).toBe(
-        source1,
-      )
-
-      const source2 = [{ value: 2 }]
-      await useWidgetStore.getState().executeToolPipeline(widgetId, source2)
-
-      // sourceData should reflect the new input
-      expect(useWidgetStore.getState().getWidget(widgetId)?.sourceData).toBe(
-        source2,
-      )
-    })
-  })
-
-  describe('Config Tool Pipeline', () => {
-    const widgetId = 'test-widget-config'
-
-    beforeEach(() => {
-      useWidgetStore.getState().clearWidgets()
-    })
-
-    it('executes config tools and sets transformed config', async () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      const configTool: ToolRegistration = {
-        id: 'stack-tool',
-        type: 'config',
-        order: 10,
-        enabled: true,
-        fn: (config) => {
-          const c = config as Record<string, unknown>
-          const option = c.option as { series?: { name: string }[] }
-          const series = option?.series ?? []
-          return {
-            ...c,
-            option: {
-              ...option,
-              series: series.map((s) => ({ ...s, stack: 'group' })),
-            },
-          }
-        },
-      }
-
-      useWidgetStore.getState().registerTool(widgetId, configTool)
-
-      await useWidgetStore.getState().executeConfigPipeline(widgetId, {
-        option: {
-          series: [{ name: 'Series 1' }, { name: 'Series 2' }],
-        },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      const option = (widget as { option?: { series?: { stack?: string }[] } })
-        ?.option
-      expect(option?.series?.[0]?.stack).toBe('group')
-      expect(option?.series?.[1]?.stack).toBe('group')
-    })
-
-    it('passes base config through when no config tools registered', async () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      await useWidgetStore.getState().executeConfigPipeline(widgetId, {
-        option: { series: [{ name: 'Series 1' }] },
-      })
-
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      const option = (widget as { option?: { series?: { name: string }[] } })
-        ?.option
-      expect(option?.series?.[0]?.name).toBe('Series 1')
-    })
-
-    it('does not include config tools in data pipeline', async () => {
-      const executionOrder: string[] = []
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      const dataTool: ToolRegistration = {
-        id: 'data-tool',
-        type: 'data',
-        order: 10,
-        enabled: true,
-        fn: (data) => {
-          executionOrder.push('data-tool')
-          return data
-        },
-      }
-
-      const configTool: ToolRegistration = {
-        id: 'config-tool',
-        type: 'config',
-        order: 10,
-        enabled: true,
-        fn: (config) => {
-          executionOrder.push('config-tool')
-          return config
-        },
-      }
-
-      useWidgetStore.getState().registerTool(widgetId, dataTool)
-      useWidgetStore.getState().registerTool(widgetId, configTool)
-
-      await useWidgetStore.getState().executeToolPipeline(widgetId, {})
-
-      expect(executionOrder).toEqual(['data-tool'])
-      expect(executionOrder).not.toContain('config-tool')
-    })
-
-    it('respects disables across tool types', async () => {
-      const executionOrder: string[] = []
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      const configTool: ToolRegistration = {
-        id: 'config-tool',
-        type: 'config',
-        order: 10,
-        enabled: true,
-        fn: (config) => {
-          executionOrder.push('config-tool')
-          return config
-        },
-      }
-
-      const disablerTool: ToolRegistration = {
-        id: 'disabler',
-        type: 'data',
-        order: 10,
-        enabled: true,
-        fn: (data) => data,
-        disables: ['config-tool'],
-      }
-
-      useWidgetStore.getState().registerTool(widgetId, configTool)
-      useWidgetStore.getState().registerTool(widgetId, disablerTool)
-
-      await useWidgetStore.getState().executeConfigPipeline(widgetId, {
-        option: {},
-      })
-
-      expect(executionOrder).not.toContain('config-tool')
-    })
-
-    it('should not overwrite user-modified state when config lacks that property', async () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'table',
-        isLoading: false,
-      })
-
-      // Apply initial config (without selected — clean config pattern)
-      await useWidgetStore.getState().executeConfigPipeline(widgetId, {
-        columns: [],
-        selectable: true,
-        mode: 'local',
-      })
-
-      // Simulate user selecting rows via UI action
-      useWidgetStore.getState().setWidget(widgetId, {
-        selected: [1, 2, 3],
-      })
-
-      // Re-run config pipeline (e.g., triggered by tool registration or data change)
-      await useWidgetStore.getState().executeConfigPipeline(widgetId, {
-        columns: [],
-        selectable: true,
-        mode: 'local',
-      })
-
-      // Selection should be preserved — config doesn't include 'selected'
-      const widget = useWidgetStore.getState().getWidget(widgetId)
-      expect((widget as { selected?: (string | number)[] }).selected).toEqual([
-        1, 2, 3,
-      ])
-    })
-
-    it('should not overwrite user-modified state when a tool passes base config through unchanged', async () => {
-      const baseConfig = {
-        option: { series: [{ name: 'A' }] },
-        selected: [] as number[],
-      }
-
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      // Register a config tool that only changes `option` but spreads
-      // the entire base config (the typical { ...config, option: modified } pattern)
-      useWidgetStore.getState().registerTool(widgetId, {
-        id: 'stack-tool',
-        type: 'config',
-        order: 10,
-        enabled: true,
-        fn: (config: unknown) => {
-          const c = config as typeof baseConfig
-          return { ...c, option: { series: [{ name: 'A', stack: 'group' }] } }
-        },
-      })
-
-      // Initial pipeline sets option and selected
-      await useWidgetStore
-        .getState()
-        .executeConfigPipeline(widgetId, baseConfig)
-
-      // Simulate user modifying selected via UI
-      useWidgetStore.getState().setWidget(widgetId, { selected: [1, 2] })
-
-      // Re-run pipeline — tool still only changes `option`,
-      // but spreads { ...config, option: modified } which includes selected: []
-      await useWidgetStore
-        .getState()
-        .executeConfigPipeline(widgetId, baseConfig)
-
-      const widget = useWidgetStore.getState().getWidget(widgetId) as {
-        selected?: number[]
-        option?: { series?: { stack?: string }[] }
-      }
-
-      // Tool's change should be applied
-      expect(widget.option?.series?.[0]?.stack).toBe('group')
-      // User's selection should be preserved — the tool didn't change `selected`
-      expect(widget.selected).toEqual([1, 2])
-    })
-  })
-
-  describe('triggerToolPipeline', () => {
-    const widgetId = 'test-widget-trigger'
-
-    beforeEach(() => {
-      useWidgetStore.getState().clearWidgets()
-    })
-
-    it('creates new registeredTools reference', () => {
-      useWidgetStore.getState().setWidget(widgetId, {
-        type: 'bar',
-        isLoading: false,
-      })
-
-      useWidgetStore.getState().registerTool(widgetId, {
-        id: 'my-tool',
-        order: 10,
-        enabled: true,
-        fn: (data) => data,
-      })
-
-      const toolsBefore =
-        useWidgetStore.getState().widgets[widgetId]?.registeredTools
-
-      useWidgetStore.getState().triggerToolPipeline(widgetId)
-
-      const toolsAfter =
-        useWidgetStore.getState().widgets[widgetId]?.registeredTools
-
-      // New reference — triggers Effect 4 in WidgetLoader
-      expect(toolsBefore).not.toBe(toolsAfter)
-
-      // But same content
-      expect(toolsAfter?.length).toBe(toolsBefore?.length)
-      expect(toolsAfter?.[0]?.id).toBe(toolsBefore?.[0]?.id)
-    })
-
-    it('does nothing for non-existent widget', () => {
-      useWidgetStore.getState().triggerToolPipeline('non-existent')
-      // No error thrown
-    })
-  })
-
-  describe('Tool Dependency Management', () => {
-    const widgetId = 'test-widget-deps'
-
-    beforeEach(() => {
-      useWidgetStore.getState().clearWidgets()
-    })
-
-    describe('Pipeline Filtering', () => {
-      it('skips tools disabled by other enabled tools', async () => {
-        const executionOrder: string[] = []
-
-        const toolA: ToolRegistration = {
-          id: 'tool-a',
-          order: 10,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-a')
-            return data
-          },
-        }
-
-        const toolB: ToolRegistration = {
-          id: 'tool-b',
-          order: 20,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-b')
-            return data
-          },
-        }
-
-        const toolC: ToolRegistration = {
-          id: 'tool-c',
-          order: 30,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-c')
-            return data
-          },
-          disables: ['tool-b'],
-        }
-
-        useWidgetStore.getState().registerTool(widgetId, toolA)
-        useWidgetStore.getState().registerTool(widgetId, toolB)
-        useWidgetStore.getState().registerTool(widgetId, toolC)
-
-        await useWidgetStore.getState().executeToolPipeline(widgetId, {})
-
-        // tool-b should be skipped because tool-c disables it
-        expect(executionOrder).toEqual(['tool-a', 'tool-c'])
-        expect(executionOrder).not.toContain('tool-b')
-      })
-
-      it('includes tool when disabling tool is not enabled', async () => {
-        const executionOrder: string[] = []
-
-        const toolA: ToolRegistration = {
-          id: 'tool-a',
-          order: 10,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-a')
-            return data
-          },
-        }
-
-        const toolB: ToolRegistration = {
-          id: 'tool-b',
-          order: 20,
-          enabled: false, // Disabled
-          fn: (data) => {
-            executionOrder.push('tool-b')
-            return data
-          },
-          disables: ['tool-a'],
-        }
-
-        useWidgetStore.getState().registerTool(widgetId, toolA)
-        useWidgetStore.getState().registerTool(widgetId, toolB)
-
-        await useWidgetStore.getState().executeToolPipeline(widgetId, {})
-
-        // tool-a should execute because tool-b is disabled
-        expect(executionOrder).toEqual(['tool-a'])
-      })
-
-      it('handles multiple tools disabling the same target', async () => {
-        const executionOrder: string[] = []
-
-        const toolA: ToolRegistration = {
-          id: 'tool-a',
-          order: 10,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-a')
-            return data
-          },
-        }
-
-        const toolB: ToolRegistration = {
-          id: 'tool-b',
-          order: 20,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-b')
-            return data
-          },
-          disables: ['tool-a'],
-        }
-
-        const toolC: ToolRegistration = {
-          id: 'tool-c',
-          order: 30,
-          enabled: true,
-          fn: (data) => {
-            executionOrder.push('tool-c')
-            return data
-          },
-          disables: ['tool-a'],
-        }
-
-        useWidgetStore.getState().registerTool(widgetId, toolA)
-        useWidgetStore.getState().registerTool(widgetId, toolB)
-        useWidgetStore.getState().registerTool(widgetId, toolC)
-
-        await useWidgetStore.getState().executeToolPipeline(widgetId, {})
-
-        // tool-a should be skipped (disabled by both tool-b and tool-c)
-        expect(executionOrder).toEqual(['tool-b', 'tool-c'])
-        expect(executionOrder).not.toContain('tool-a')
-      })
-    })
-  })
-})