@carto/ps-react-ui 4.5.1 → 4.6.0

package/dist/widgets/stores.js

@@ -1,5 +1,5 @@
-import { u as o, w as r } from "../widget-store-CIrb9RKP.js";
-import { u as i } from "../use-widget-selector-DqRmWQ1K.js";
+import { u as o, w as r } from "../widget-store-Bw5zRUGg.js";
+import { u as i } from "../use-widget-selector-DFl2hW0R.js";
 export {
   i as useWidgetSelector,
   o as useWidgetStore,

package/dist/widgets/table.js

@@ -6,10 +6,10 @@ import se from "@mui/icons-material/FirstPage";
 import ce from "@mui/icons-material/KeyboardArrowLeft";
 import ae from "@mui/icons-material/KeyboardArrowRight";
 import fe from "@mui/icons-material/LastPage";
+import { u as de } from "../use-widget-ref-Ddr_SlJJ.js";
 import "react";
-import { u as de } from "../use-widget-ref-BFazQvJK.js";
-import { w as x } from "../widget-store-CIrb9RKP.js";
-import { u as B } from "../use-widget-selector-DqRmWQ1K.js";
+import { w as x } from "../widget-store-Bw5zRUGg.js";
+import { u as B } from "../use-widget-selector-DFl2hW0R.js";
 import "zustand/shallow";
 import "@mui/icons-material";
 import { d as J, a as F } from "../exports-Cr43OCul.js";

package/dist/widgets/timeseries.js

@@ -2,11 +2,11 @@ import { jsxs as m, jsx as r } from "react/jsx-runtime";
 import { c as y } from "react/compiler-runtime";
 import "react";
 import "echarts";
-import "../widget-store-CIrb9RKP.js";
+import "../widget-store-Bw5zRUGg.js";
 import "zustand/shallow";
 import { g as b } from "../options-D9wflre6.js";
 import { m as k } from "../utils-BOhInag6.js";
-import { c as v, f as w } from "../download-config-DemuQ3Jm.js";
+import { c as v, f as w } from "../download-config-C3I0jWIL.js";
 import { g as L, b as C, a as I, d as S, e as _, c as A } from "../styles-Y8q7Jff3.js";
 import { Box as l, Skeleton as s } from "@mui/material";
 const Y = v(w);

package/dist/widgets/utils.js

@@ -1,5 +1,5 @@
 import { d as i, a as n } from "../formatter-B9Bxn1k7.js";
-import { c as f, f as p, s as c } from "../download-config-DemuQ3Jm.js";
+import { c as f, f as p, s as c } from "../download-config-C3I0jWIL.js";
 import { a as m, b as u, c as C, d as b, e as x, f as g, g as F, h as y, n as A } from "../styles-Y8q7Jff3.js";
 function r({
   type: a,

package/dist/widgets/wrapper.js

@@ -6,8 +6,8 @@ import { useState as H, useLayoutEffect as G } from "react";
 import "../lasso-tool-BYbxrJ-7.js";
 import "../cjs-D4KH3azB.js";
 import { S as U } from "../smart-tooltip-D4vwQpFf.js";
-import { u as V } from "../use-widget-selector-DqRmWQ1K.js";
-import { w as M } from "../widget-store-CIrb9RKP.js";
+import { u as V } from "../use-widget-selector-DFl2hW0R.js";
+import { w as M } from "../widget-store-Bw5zRUGg.js";
 const k = {
   root: {
     ".Mui-disabled .MuiAccordionSummary-expandIconWrapper": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carto/ps-react-ui",
-  "version": "4.5.1",
+  "version": "4.6.0",
   "description": "CARTO's Professional Service React Material library",
   "type": "module",
   "devDependencies": {
@@ -38,10 +38,6 @@
       "import": "./dist/components.js",
       "types": "./dist/types/components/index.d.ts"
     },
-    "./widgets": {
-      "import": "./dist/widgets.js",
-      "types": "./dist/types/widgets/index.d.ts"
-    },
     "./widgets/actions": {
       "import": "./dist/widgets/actions.js",
       "types": "./dist/types/widgets/actions/index.d.ts"

package/src/hooks/index.ts

@@ -1,2 +1 @@
-export { useDebounce } from './use-debounce'
 export { useWidgetRef } from './use-widget-ref'

package/src/widgets/actions/brush-toggle/brush-toggle.tsx

@@ -2,7 +2,7 @@ import { Box, IconButton } from '@mui/material'
 import { HighlightAltOutlined } from '@mui/icons-material'
 import { useEffect, useCallback, useRef } from 'react'
 import { widgetStoreActions } from '../../stores/widget-store'
-import type { BrushSelectedItems, BrushToggleProps } from './types'
+import type { BrushSelectedItems, BrushToggleProps, BrushState } from './types'
 import { styles } from './style'
 import { Tooltip } from '../../../components'
 import { getEChartBrushConfig } from '../../echart/utils'
@@ -17,6 +17,9 @@ export const BRUSH_TOGGLE_TOOL_ID = 'brush-toggle'
  * Registers as a config pipeline tool so that brush configuration is automatically
  * re-applied when the base config is updated (e.g., by WidgetLoader).
  *
+ * Brush state is stored in the widget store root, and the tool derives its
+ * `enabled` flag from the store. This keeps state accessible across component instances.
+ *
  * When brush is active, users can drag across bars to select a range.
  * Selection clearing is handled via the chart's brush interactions/toolbox configuration.
  * Only intended for use in fullscreen ToolbarActions for bar and histogram widgets.
@@ -38,26 +41,19 @@ export function BrushToggle({
 }: BrushToggleProps) {
   const selected = useRef<BrushSelectedItems>({ dataIndex: [], seriesIndex: 0 })
 
+  // Read brush state from widget store root — single source of truth
   const { brush } = useWidgetSelector(id, (w) => ({
-    brush: w?.registeredTools?.find((tool) => tool.id === BRUSH_TOGGLE_TOOL_ID)
-      ?.enabled,
+    brush: (w as BrushState | undefined)?.brush ?? false,
   }))
 
-  const toggleTool = useCallback(
-    (value: boolean) => {
-      widgetStoreActions.setToolEnabled(id, BRUSH_TOGGLE_TOOL_ID, value)
-    },
-    [id],
-  )
-
   const handleToggle = useCallback(() => {
     const newBrush = !brush
-    toggleTool(newBrush)
+    widgetStoreActions.setWidget(id, { brush: newBrush })
 
     if (newBrush) {
       onBrushSelected?.({ dataIndex: [], seriesIndex: 0 }) // Clear selection when enabling brush
     }
-  }, [brush, onBrushSelected, toggleTool])
+  }, [brush, id, onBrushSelected])
 
   // Re-dispatch brush action after every ECharts render while brush is active
   useEffect(() => {
@@ -135,22 +131,17 @@ export function BrushToggle({
 
   const handleBrushEnd = useCallback(() => {
     onBrushSelected?.(selected.current)
-    toggleTool(false) // Disable brush after selection is made
-  }, [onBrushSelected, toggleTool])
+    widgetStoreActions.setWidget(id, { brush: false }) // Disable brush after selection is made
+  }, [onBrushSelected, id])
 
-  // Register config tool with all reactive deps — store's no-op detection handles performance
+  // Register config tool once — fn closure depends on event handlers.
+  // Enabled is synced separately to avoid full re-registration on toggle.
   useEffect(() => {
-    const existingTool = widgetStoreActions
-      .getWidget(id)
-      ?.registeredTools?.find((tool) => tool.id === BRUSH_TOGGLE_TOOL_ID)
-
-    const initialEnabled = existingTool?.enabled ?? false
-
     widgetStoreActions.registerTool(id, {
       id: BRUSH_TOGGLE_TOOL_ID,
       type: 'config',
       order: 25,
-      enabled: initialEnabled,
+      enabled: false,
       fn: (currentConfig) => {
         const config = currentConfig as Record<string, unknown>
         const option = config.option as EchartOptionsProps | undefined
@@ -178,6 +169,11 @@ export function BrushToggle({
     return () => widgetStoreActions.unregisterTool(id, BRUSH_TOGGLE_TOOL_ID)
   }, [id, handleBrushSelected, handleBrushEnd])
 
+  // Sync enabled from store — lightweight, no re-registration
+  useEffect(() => {
+    widgetStoreActions.setToolEnabled(id, BRUSH_TOGGLE_TOOL_ID, brush)
+  }, [id, brush])
+
   const enableLabel = labels?.enable ?? 'Enable brush selection'
   const disableLabel = labels?.disable ?? 'Disable brush selection'
   const tooltipLabel = brush ? disableLabel : enableLabel

package/src/widgets/actions/change-column/change-column.test.tsx

@@ -217,7 +217,7 @@ describe('ChangeColumn', () => {
 
       // When config columns match widget columns, fn returns the same reference
       const input = { columns: mockColumns }
-      const result = tool?.fn(input, tool.config)
+      const result = tool?.fn(input)
       expect(result).toBe(input)
     })
 

package/src/widgets/actions/download/download.test.tsx

@@ -1,7 +1,7 @@
 import { describe, test, expect, beforeEach, vi } from 'vitest'
 import { render, screen, fireEvent, waitFor } from '@testing-library/react'
 import { Download } from './download'
-import { useWidgetStore } from '../../../widgets'
+import { useWidgetStore } from '../../../widgets/stores'
 import type { DownloadItem } from './types'
 
 describe('Download', () => {

package/src/widgets/actions/index.ts

@@ -1,6 +1,10 @@
 /* Fullscreen Widget */
 export { FullScreen } from './fullscreen/fullscreen'
-export type { FullScreenState, FullScreenConfig } from './fullscreen/types'
+export type {
+  FullScreenState,
+  FullScreenConfig,
+  FullScreenProps,
+} from './fullscreen/types'
 
 /* Download Widget */
 export { Download } from './download/download'
@@ -13,7 +17,10 @@ export {
   RELATIVE_DATA_TOOL_ID,
   RELATIVE_DATA_CONFIG_TOOL_ID,
 } from './relative-data/relative-data'
-export type { RelativeDataProps } from './relative-data/types'
+export type {
+  RelativeDataProps,
+  RelativeDataState,
+} from './relative-data/types'
 
 /* Zoom Toggle Widget */
 export { ZoomToggle, ZOOM_TOGGLE_TOOL_ID } from './zoom-toggle/zoom-toggle'
@@ -35,6 +42,7 @@ export type {
   SearcherProps,
   SearcherFilterFn,
   SearcherState,
+  SearcherStateProps,
 } from './searcher/types'
 
 /* Change Column Widget */
@@ -52,6 +60,7 @@ export {
 export type {
   LockSelectionProps,
   LockSelectionState,
+  LockSelectionStateProps,
 } from './lock-selection/types'
 
 /* Brush Toggle Widget */

package/src/widgets/actions/lock-selection/lock-selection.test.tsx

@@ -3,6 +3,7 @@ import { render, screen, fireEvent } from '@testing-library/react'
 import { LockSelection, LOCK_SELECTION_TOOL_ID } from './lock-selection'
 import { useWidgetStore } from '../../stores/widget-store'
 import type { EchartWidgetData } from '../../echart/types'
+import type { LockSelectionState } from './types'
 import { WidgetLoader } from '../../loader/loader'
 
 // Test data
@@ -110,6 +111,19 @@ describe('LockSelection', () => {
     expect(tool?.enabled).toBe(false)
   })
 
+  test('clears lock state when selectedItems becomes empty while locked', () => {
+    // Simulate remount: isLocked persists in store but selectedItems is now empty
+    useWidgetStore
+      .getState()
+      .setWidget(widgetId, { isLocked: true, lockedItems: ['Electronics'] })
+
+    render(<LockSelection id={widgetId} selectedItems={[]} />)
+
+    const widget = useWidgetStore.getState().getWidget(widgetId)
+    expect((widget as LockSelectionState | undefined)?.isLocked).toBe(false)
+    expect((widget as LockSelectionState | undefined)?.lockedItems).toEqual([])
+  })
+
   test('has active state when locked', () => {
     render(<LockSelection id={widgetId} selectedItems={['Electronics']} />)
 

package/src/widgets/actions/lock-selection/lock-selection.tsx

@@ -1,6 +1,6 @@
 import { IconButton } from '@mui/material'
 import { CheckBoxOutlined } from '@mui/icons-material'
-import { useCallback, useEffect, useMemo } from 'react'
+import { useCallback, useEffect } from 'react'
 import type { LockSelectionProps, LockSelectionState } from './types'
 import { actionButtonStyles } from '../shared/styles'
 import { Tooltip } from '../../../components'
@@ -39,28 +39,35 @@ export function LockSelection({
   }))
 
   const isLocked = storeIsLocked ?? false
-  const lockedItems = useMemo(
-    () => (isLocked ? selectedItems : []),
-    [isLocked, selectedItems],
-  )
 
-  // Register tool with all reactive deps — store's no-op detection handles performance
+  // Register tool once — fn reads lockedItems from the store at execution time
   useEffect(() => {
     widgetStoreActions.registerTool(id, {
       id: LOCK_SELECTION_TOOL_ID,
       order,
-      enabled: isLocked,
-      fn: (data, config) => {
-        const items = (config?.lockedItems as string[]) || []
+      enabled: false,
+      fn: (data) => {
+        const widget = widgetStoreActions.getWidget<LockSelectionState>(id)
+        const items = widget?.lockedItems ?? []
         if (items.length === 0) return data
 
         return filterDataByLockedItems(data as EchartWidgetData, items)
       },
-      config: { lockedItems },
     })
 
     return () => widgetStoreActions.unregisterTool(id, LOCK_SELECTION_TOOL_ID)
-  }, [id, order, isLocked, lockedItems])
+  }, [id, order])
+
+  // Sync enabled from store — lightweight, no re-registration.
+  // When selectedItems is empty (e.g., remount with no active selection),
+  // disable the tool and clear stale lock state.
+  useEffect(() => {
+    if (isLocked && selectedItems.length === 0) {
+      widgetStoreActions.setWidget(id, { isLocked: false, lockedItems: [] })
+      return
+    }
+    widgetStoreActions.setToolEnabled(id, LOCK_SELECTION_TOOL_ID, isLocked)
+  }, [id, isLocked, selectedItems.length])
 
   const handleToggle = useCallback(() => {
     if (isLocked) {

package/src/widgets/actions/lock-selection/types.ts

@@ -38,4 +38,6 @@ export interface LockSelectionProps {
 export interface LockSelectionStateProps {
   /** Whether the selection is currently locked */
   isLocked?: boolean
+  /** Items locked for filtering */
+  lockedItems?: string[]
 }

package/src/widgets/actions/relative-data/relative-data.test.tsx

@@ -7,6 +7,7 @@ import {
 } from './relative-data'
 import { useWidgetStore } from '../../stores/widget-store'
 import type { EchartWidgetData } from '../../echart/types'
+import type { RelativeDataState } from './types'
 
 describe('RelativeData', () => {
   const widgetId = 'test-relative-widget'
@@ -227,23 +228,28 @@ describe('RelativeData', () => {
     expect(button.hasAttribute('disabled')).toBeTruthy()
   })
 
-  test('registers config tool on mount', async () => {
+  test('registers both data and config tools on mount', async () => {
     render(<RelativeData id={widgetId} />)
 
     await waitFor(() => {
       const widget = useWidgetStore.getState().getWidget(widgetId)
-      const tool = widget?.registeredTools?.find(
+      const dataTool = widget?.registeredTools?.find(
+        (t) => t.id === RELATIVE_DATA_TOOL_ID,
+      )
+      const configTool = widget?.registeredTools?.find(
         (t) => t.id === RELATIVE_DATA_CONFIG_TOOL_ID,
       )
-      expect(tool).toBeTruthy()
-      expect(tool?.type).toBe('config')
-      expect(tool?.enabled).toBe(true)
+      expect(dataTool).toBeTruthy()
+      expect(configTool).toBeTruthy()
+      expect(configTool?.type).toBe('config')
+      // Data tool disabled by default (isRelative=false)
+      expect(dataTool?.enabled).toBe(false)
+      // Config tool always enabled — it reads isRelative from store internally
+      expect(configTool?.enabled).toBe(true)
     })
   })
 
-  test('sets formatter via config pipeline when toggling to relative mode', async () => {
-    useWidgetStore.getState().setWidget(widgetId, { max: 500 })
-
+  test('data tool enabled when toggled to relative mode', async () => {
     render(<RelativeData id={widgetId} />)
 
     const button = screen.getByRole('button')
@@ -251,16 +257,77 @@ describe('RelativeData', () => {
 
     await waitFor(() => {
       const widget = useWidgetStore.getState().getWidget(widgetId)
-      const tool = widget?.registeredTools?.find(
-        (t) => t.id === RELATIVE_DATA_CONFIG_TOOL_ID,
+      const dataTool = widget?.registeredTools?.find(
+        (t) => t.id === RELATIVE_DATA_TOOL_ID,
       )
-      expect(tool?.config?.isRelative).toBe(true)
-      expect(tool?.config?.originalFormatter).toBeUndefined()
-      expect(tool?.config?.originalMax).toBe(500)
+      expect(dataTool?.enabled).toBe(true)
     })
   })
 
-  test('restores original formatter via config pipeline when toggling back', () => {
+  test('stores isRelative in widget root state', () => {
+    render(<RelativeData id={widgetId} />)
+
+    // Default: isRelative=false in store
+    let widget = useWidgetStore.getState().getWidget(widgetId)
+    expect((widget as RelativeDataState | undefined)?.isRelative).toBe(false)
+
+    // Toggle to relative
+    const button = screen.getByRole('button')
+    fireEvent.click(button)
+
+    widget = useWidgetStore.getState().getWidget(widgetId)
+    expect((widget as RelativeDataState | undefined)?.isRelative).toBe(true)
+
+    // Toggle back
+    fireEvent.click(button)
+
+    widget = useWidgetStore.getState().getWidget(widgetId)
+    expect((widget as RelativeDataState | undefined)?.isRelative).toBe(false)
+  })
+
+  test('config tool does not apply formatter when sourceData is empty', async () => {
+    const customFormatter = (value: number) => `$${value}`
+    useWidgetStore
+      .getState()
+      .setWidget(widgetId, { formatter: customFormatter, sourceData: [] })
+
+    render(<RelativeData id={widgetId} />)
+
+    const button = screen.getByRole('button')
+    fireEvent.click(button)
+
+    // Execute config pipeline — sourceData is empty, so formatter should pass through
+    await useWidgetStore
+      .getState()
+      .executeConfigPipeline(widgetId, { formatter: customFormatter, max: 200 })
+
+    const widget = useWidgetStore.getState().getWidget(widgetId)
+    expect(widget?.formatter).toBe(customFormatter)
+    expect((widget as unknown as Record<string, unknown>)?.max).toBe(200)
+  })
+
+  test('config pipeline applies percentage formatter when in relative mode', async () => {
+    useWidgetStore
+      .getState()
+      .setWidget(widgetId, { max: 500, sourceData: mockData })
+
+    render(<RelativeData id={widgetId} />)
+
+    const button = screen.getByRole('button')
+    fireEvent.click(button)
+
+    // Execute config pipeline
+    await useWidgetStore
+      .getState()
+      .executeConfigPipeline(widgetId, { max: 500 })
+
+    const widget = useWidgetStore.getState().getWidget(widgetId)
+    expect((widget as unknown as Record<string, unknown>)?.max).toBe(100)
+    expect(widget?.formatter).toBeDefined()
+    expect(typeof widget?.formatter).toBe('function')
+  })
+
+  test('config tool passes config through unchanged when not in relative mode', async () => {
     const customFormatter = (value: number) => `$${value}`
     useWidgetStore
       .getState()
@@ -268,20 +335,144 @@ describe('RelativeData', () => {
 
     render(<RelativeData id={widgetId} />)
 
+    // Execute config pipeline — config tool is enabled but isRelative=false in store,
+    // so it passes through the config unchanged
+    await useWidgetStore
+      .getState()
+      .executeConfigPipeline(widgetId, { formatter: customFormatter, max: 200 })
+
+    const widget = useWidgetStore.getState().getWidget(widgetId)
+    expect(widget?.formatter).toBe(customFormatter)
+    expect((widget as unknown as Record<string, unknown>)?.max).toBe(200)
+  })
+
+  test('restores original formatter/max when toggling back to absolute', async () => {
+    const customFormatter = (value: number) => `$${value}`
+    useWidgetStore.getState().setWidget(widgetId, {
+      formatter: customFormatter,
+      max: 200,
+      sourceData: mockData,
+    })
+
+    render(<RelativeData id={widgetId} />)
+
     const button = screen.getByRole('button')
 
-    // Toggle to relative
+    // Toggle to relative — captures originalFormatter/originalMax in store
     fireEvent.click(button)
-    // Toggle back to absolute
+
+    await useWidgetStore
+      .getState()
+      .executeConfigPipeline(widgetId, { max: 200 })
+
+    let widget = useWidgetStore.getState().getWidget(widgetId)
+    expect((widget as unknown as Record<string, unknown>)?.max).toBe(100)
+
+    // Toggle back to absolute — config tool restores originals from store
+    fireEvent.click(button)
+
+    await useWidgetStore
+      .getState()
+      .executeConfigPipeline(widgetId, { max: 200 })
+
+    widget = useWidgetStore.getState().getWidget(widgetId)
+    expect(widget?.formatter).toBe(customFormatter)
+    expect((widget as unknown as Record<string, unknown>)?.max).toBe(200)
+  })
+
+  test('removes percentage formatter when toggling back with no original formatter', async () => {
+    // Widget has no formatter — originalFormatter will be captured as undefined
+    useWidgetStore.getState().setWidget(widgetId, { sourceData: mockData })
+
+    render(<RelativeData id={widgetId} />)
+
+    const button = screen.getByRole('button')
+
+    // Toggle to relative — captures originalFormatter=undefined
+    fireEvent.click(button)
+
+    await useWidgetStore.getState().executeConfigPipeline(widgetId, {})
+
+    let widget = useWidgetStore.getState().getWidget(widgetId)
+    expect(widget?.formatter).toBeDefined()
+    expect(typeof widget?.formatter).toBe('function')
+
+    // Toggle back to absolute — should remove percentage formatter
+    fireEvent.click(button)
+
+    await useWidgetStore.getState().executeConfigPipeline(widgetId, {})
+
+    widget = useWidgetStore.getState().getWidget(widgetId)
+    expect(widget?.formatter).toBeUndefined()
+  })
+
+  test('stores originalFormatter/originalMax in widget root on toggle', () => {
+    const customFormatter = (value: number) => `$${value}`
+    useWidgetStore
+      .getState()
+      .setWidget(widgetId, { formatter: customFormatter, max: 200 })
+
+    render(<RelativeData id={widgetId} />)
+
+    const button = screen.getByRole('button')
+    fireEvent.click(button)
+
+    const widget = useWidgetStore
+      .getState()
+      .getWidget<RelativeDataState>(widgetId)
+    expect(widget?.originalFormatter).toBe(customFormatter)
+    expect(widget?.originalMax).toBe(200)
+  })
+
+  test('restores original formatter/max when unmounting while in relative mode', async () => {
+    const customFormatter = (value: number) => `$${value}`
+    useWidgetStore
+      .getState()
+      .setWidget(widgetId, { formatter: customFormatter, max: 200 })
+
+    const { unmount } = render(<RelativeData id={widgetId} />)
+
+    const button = screen.getByRole('button')
+
+    // Toggle to relative — captures originalFormatter/originalMax in store
     fireEvent.click(button)
 
+    await waitFor(() => {
+      const widget = useWidgetStore
+        .getState()
+        .getWidget<RelativeDataState>(widgetId)
+      expect(widget?.isRelative).toBe(true)
+      expect(widget?.originalFormatter).toBe(customFormatter)
+      expect(widget?.originalMax).toBe(200)
+    })
+
+    // Unmount while still in relative mode
+    unmount()
+
+    const widget = useWidgetStore.getState().getWidget(widgetId)
+    expect(widget?.formatter).toBe(customFormatter)
+    expect((widget as unknown as Record<string, unknown>)?.max).toBe(200)
+  })
+
+  test('unregisters tools on unmount', async () => {
+    const { unmount } = render(<RelativeData id={widgetId} />)
+
+    await waitFor(() => {
+      const widget = useWidgetStore.getState().getWidget(widgetId)
+      expect(widget?.registeredTools?.length).toBeGreaterThan(0)
+    })
+
+    unmount()
+
     const widget = useWidgetStore.getState().getWidget(widgetId)
-    const tool = widget?.registeredTools?.find(
+    const dataTool = widget?.registeredTools?.find(
+      (t) => t.id === RELATIVE_DATA_TOOL_ID,
+    )
+    const configTool = widget?.registeredTools?.find(
       (t) => t.id === RELATIVE_DATA_CONFIG_TOOL_ID,
     )
-    expect(tool?.config?.isRelative).toBe(false)
-    expect(tool?.config?.originalFormatter).toBe(customFormatter)
-    expect(tool?.config?.originalMax).toBe(200)
+    expect(dataTool).toBeUndefined()
+    expect(configTool).toBeUndefined()
   })
 
   test('recalculates relative values when store data changes externally while in relative mode', async () => {