@pyreon/rocketstyle 0.24.5 → 0.24.6

package/src/__tests__/context.test.ts

@@ -1,200 +0,0 @@
-import type { VNodeChild } from '@pyreon/core'
-import { h, useContext } from '@pyreon/core'
-import { Provider as CoreProvider } from '@pyreon/ui-core'
-import Provider from '../context/context'
-
-// Mock @pyreon/core useContext to return controlled values
-vi.mock('@pyreon/core', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@pyreon/core')>()
-  return {
-    ...original,
-    useContext: vi.fn(() => (() => ({}))),
-  }
-})
-
-// Mock @pyreon/ui-core Provider and context
-vi.mock('@pyreon/ui-core', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@pyreon/ui-core')>()
-  return {
-    ...original,
-    Provider: vi.fn(((props: Record<string, unknown>) => ({
-      type: 'div',
-      props: { ...props, 'data-provider': 'core' },
-      children: props.children,
-      key: null,
-    })) as any),
-    context: original.context,
-  }
-})
-
-const mockedUseContext = vi.mocked(useContext)
-const mockedCoreProvider = vi.mocked(CoreProvider)
-
-beforeEach(() => {
-  vi.clearAllMocks()
-  // Default: empty context
-  mockedUseContext.mockReturnValue((() => ({})) as any)
-  mockedCoreProvider.mockImplementation(((props: Record<string, unknown>) => ({
-    type: 'div',
-    props: { ...props, 'data-provider': 'core' },
-    children: props.children as VNodeChild,
-    key: null,
-  })) as any)
-})
-
-describe('Provider (context)', () => {
-  it('uses MODE_DEFAULT (light) when no mode is provided', () => {
-    mockedUseContext.mockReturnValue((() => ({})) as any)
-
-    const children = h('span', null, 'Hello')
-    Provider({ children })
-
-    expect(mockedCoreProvider).toHaveBeenCalledTimes(1)
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('light')
-    expect(callArgs.isLight).toBe(true)
-    expect(callArgs.isDark).toBe(false)
-  })
-
-  it('passes mode directly when inversed is false', () => {
-    mockedUseContext.mockReturnValue((() => ({ mode: 'dark' })) as any)
-
-    const children = h('span', null, 'Hello')
-    Provider({ children, mode: 'dark', inversed: false })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('dark')
-    expect(callArgs.isDark).toBe(true)
-    expect(callArgs.isLight).toBe(false)
-  })
-
-  it('passes mode directly when inversed is undefined', () => {
-    const children = h('span', null, 'Hello')
-    Provider({ children, mode: 'dark' })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('dark')
-    expect(callArgs.isDark).toBe(true)
-    expect(callArgs.isLight).toBe(false)
-  })
-
-  it('inverts light to dark when inversed is true', () => {
-    const children = h('span', null, 'Hello')
-    Provider({ children, mode: 'light', inversed: true })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('dark')
-    expect(callArgs.isDark).toBe(true)
-    expect(callArgs.isLight).toBe(false)
-  })
-
-  it('inverts dark to light when inversed is true', () => {
-    const children = h('span', null, 'Hello')
-    Provider({ children, mode: 'dark', inversed: true })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('light')
-    expect(callArgs.isLight).toBe(true)
-    expect(callArgs.isDark).toBe(false)
-  })
-
-  it('passes theme to provider when provided', () => {
-    const theme = { rootSize: 16, breakpoints: { sm: 576 } }
-    const children = h('span', null, 'Hello')
-    Provider({ children, theme })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.theme).toEqual(theme)
-  })
-
-  it('does not pass theme key when theme is undefined', () => {
-    const children = h('span', null, 'Hello')
-    Provider({ children })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect('theme' in callArgs).toBe(false)
-  })
-
-  it('uses custom provider when specified', () => {
-    const customProvider = vi.fn((props: Record<string, unknown>) => ({
-      type: 'section',
-      props,
-      children: props.children as VNodeChild,
-      key: null,
-    }))
-
-    const children = h('span', null, 'Hello')
-    Provider({ children, provider: customProvider as any })
-
-    expect(customProvider).toHaveBeenCalledTimes(1)
-    // CoreProvider should NOT have been called
-    expect(mockedCoreProvider).not.toHaveBeenCalled()
-  })
-
-  it('defaults to CoreProvider when no provider prop is given', () => {
-    const children = h('span', null, 'Hello')
-    Provider({ children })
-
-    expect(mockedCoreProvider).toHaveBeenCalledTimes(1)
-  })
-
-  it('passes children through to the provider', () => {
-    const children = { type: 'span', props: {}, children: ['Hello World'], key: null }
-    Provider({ children })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.children).toBe(children)
-  })
-
-  it('passes provider reference to the provider call', () => {
-    const children = h('span', null, 'Hello')
-    Provider({ children })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.provider).toBe(CoreProvider)
-  })
-
-  it('returns null when provider returns null', () => {
-    mockedCoreProvider.mockReturnValue(null as any)
-
-    const children = h('span', null, 'Hello')
-    const result = Provider({ children })
-
-    expect(result).toBeNull()
-  })
-
-  it('returns null when provider returns undefined', () => {
-    mockedCoreProvider.mockReturnValue(undefined as any)
-
-    const children = h('span', null, 'Hello')
-    const result = Provider({ children })
-
-    expect(result).toBeNull()
-  })
-
-  it('merges context values with incoming props (props take precedence)', () => {
-    mockedUseContext.mockReturnValue((() => ({
-      mode: 'light',
-      theme: { rootSize: 12 },
-    })) as any)
-
-    const overrideTheme = { rootSize: 20 }
-    const children = h('span', null, 'Hello')
-    Provider({ children, theme: overrideTheme, mode: 'dark' })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('dark')
-    expect(callArgs.theme).toEqual(overrideTheme)
-  })
-
-  it('uses context mode when no mode prop is given', () => {
-    mockedUseContext.mockReturnValue((() => ({ mode: 'dark' })) as any)
-
-    const children = h('span', null, 'Hello')
-    Provider({ children })
-
-    const callArgs = mockedCoreProvider.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callArgs.mode).toBe('dark')
-    expect(callArgs.isDark).toBe(true)
-  })
-})

package/src/__tests__/createLocalProvider.test.ts

@@ -1,280 +0,0 @@
-import { h, provide } from '@pyreon/core'
-import createLocalProvider from '../context/createLocalProvider'
-
-// Mock @pyreon/core provide
-vi.mock('@pyreon/core', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@pyreon/core')>()
-  return {
-    ...original,
-    provide: vi.fn(),
-  }
-})
-
-const mockedProvide = vi.mocked(provide)
-
-beforeEach(() => {
-  vi.clearAllMocks()
-})
-
-/** Simple base component that returns its received props as a VNode for inspection. */
-const BaseComponent: any = vi.fn((props: Record<string, unknown>) => ({
-  type: 'div',
-  props,
-  children: props.children,
-  key: null,
-}))
-
-describe('createLocalProvider', () => {
-  it('returns a component function', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    expect(typeof HOC).toBe('function')
-  })
-
-  it('calls the wrapped component with forwarded props', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({ 'data-testid': 'test', title: 'Hello', children: 'Content' } as any)
-
-    expect(BaseComponent).toHaveBeenCalledTimes(1)
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(callProps['data-testid']).toBe('test')
-    expect(callProps.title).toBe('Hello')
-    expect(callProps.children).toBe('Content')
-  })
-
-  it('provides local context via provide()', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({} as any)
-
-    expect(mockedProvide).toHaveBeenCalledTimes(1)
-  })
-
-  it('initial pseudo state is all false', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({} as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    const rocketstate = callProps.$rocketstate as Record<string, unknown>
-    const pseudo = rocketstate?.pseudo as Record<string, boolean>
-
-    expect(pseudo.hover).toBe(false)
-    expect(pseudo.focus).toBe(false)
-    expect(pseudo.pressed).toBe(false)
-  })
-
-  it('injects mouse and focus event handlers', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({} as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    expect(typeof callProps.onMouseEnter).toBe('function')
-    expect(typeof callProps.onMouseLeave).toBe('function')
-    expect(typeof callProps.onMouseDown).toBe('function')
-    expect(typeof callProps.onMouseUp).toBe('function')
-    expect(typeof callProps.onFocus).toBe('function')
-    expect(typeof callProps.onBlur).toBe('function')
-  })
-
-  it('forwards original onMouseEnter handler', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent('mouseenter')
-
-    HOC({ onMouseEnter: originalHandler } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    ;(callProps.onMouseEnter as (e: MouseEvent) => void)(mockEvent)
-
-    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
-  })
-
-  it('forwards original onMouseLeave handler', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent('mouseleave')
-
-    HOC({ onMouseLeave: originalHandler } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    ;(callProps.onMouseLeave as (e: MouseEvent) => void)(mockEvent)
-
-    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
-  })
-
-  it('forwards original onMouseDown handler', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent('mousedown')
-
-    HOC({ onMouseDown: originalHandler } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    ;(callProps.onMouseDown as (e: MouseEvent) => void)(mockEvent)
-
-    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
-  })
-
-  it('forwards original onMouseUp handler', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalHandler = vi.fn()
-    const mockEvent = new MouseEvent('mouseup')
-
-    HOC({ onMouseUp: originalHandler } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    ;(callProps.onMouseUp as (e: MouseEvent) => void)(mockEvent)
-
-    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
-  })
-
-  it('forwards original onFocus handler', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalHandler = vi.fn()
-    const mockEvent = new FocusEvent('focus')
-
-    HOC({ onFocus: originalHandler } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    ;(callProps.onFocus as (e: FocusEvent) => void)(mockEvent)
-
-    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
-  })
-
-  it('forwards original onBlur handler', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalHandler = vi.fn()
-    const mockEvent = new FocusEvent('blur')
-
-    HOC({ onBlur: originalHandler } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    ;(callProps.onBlur as (e: FocusEvent) => void)(mockEvent)
-
-    expect(originalHandler).toHaveBeenCalledWith(mockEvent)
-  })
-
-  it('does not forward event handlers that were not provided', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({} as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    // The HOC event handlers should not throw when no original handler exists
-    expect(() => {
-      ;(callProps.onMouseEnter as (e: MouseEvent) => void)(new MouseEvent('mouseenter'))
-      ;(callProps.onMouseLeave as (e: MouseEvent) => void)(new MouseEvent('mouseleave'))
-      ;(callProps.onMouseDown as (e: MouseEvent) => void)(new MouseEvent('mousedown'))
-      ;(callProps.onMouseUp as (e: MouseEvent) => void)(new MouseEvent('mouseup'))
-      ;(callProps.onFocus as (e: FocusEvent) => void)(new FocusEvent('focus'))
-      ;(callProps.onBlur as (e: FocusEvent) => void)(new FocusEvent('blur'))
-    }).not.toThrow()
-  })
-
-  it('merges existing $rocketstate with pseudo state', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({
-      $rocketstate: { someExisting: 'value', pseudo: { disabled: true } },
-    } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    const rocketstate = callProps.$rocketstate as Record<string, unknown>
-
-    expect(rocketstate.someExisting).toBe('value')
-    const pseudo = rocketstate.pseudo as Record<string, unknown>
-    expect(pseudo.disabled).toBe(true)
-    expect(pseudo.hover).toBe(false)
-    expect(pseudo.focus).toBe(false)
-    expect(pseudo.pressed).toBe(false)
-  })
-
-  it('provides updated state to local context', () => {
-    const HOC = createLocalProvider(BaseComponent)
-
-    HOC({} as any)
-
-    expect(mockedProvide).toHaveBeenCalledTimes(1)
-    const [, providedValue] = mockedProvide.mock.calls[0] as [unknown, Record<string, unknown>]
-    const pseudo = providedValue.pseudo as Record<string, boolean>
-    expect(pseudo.hover).toBe(false)
-    expect(pseudo.focus).toBe(false)
-    expect(pseudo.pressed).toBe(false)
-  })
-
-  it('does not pass event handler props to wrapped component as original handler names', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalMouseEnter = vi.fn()
-
-    HOC({ onMouseEnter: originalMouseEnter, customProp: 'keep' } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    // The wrapped component should receive the HOC event handlers, not the original ones
-    expect(callProps.customProp).toBe('keep')
-    // The onMouseEnter on the component should be the HOC wrapper, not the original
-    expect(callProps.onMouseEnter).not.toBe(originalMouseEnter)
-  })
-
-  it('strips $rocketstate from forwarded props and passes updated version', () => {
-    const HOC = createLocalProvider(BaseComponent)
-    const originalState = { existing: true }
-
-    HOC({ $rocketstate: originalState } as any)
-
-    const callProps = BaseComponent.mock.calls[0]?.[0] as Record<string, unknown>
-    const rocketstate = callProps.$rocketstate as Record<string, unknown>
-    // Should have merged pseudo state
-    expect(rocketstate.pseudo).toBeDefined()
-    // Original state is preserved
-    expect(rocketstate.existing).toBe(true)
-  })
-
-  it('returns the result of the wrapped component', () => {
-    const expectedResult = {
-      type: 'div',
-      props: { 'data-result': 'yes' },
-      children: ['Result'],
-      key: null,
-    }
-    const MockComponent = vi.fn(() => expectedResult)
-    const HOC = createLocalProvider(MockComponent as any)
-
-    const result = HOC({} as any)
-
-    expect(result).toBe(expectedResult)
-  })
-})
-
-// ─── createLocalProvider — real h() round-trip ──────────────────────
-//
-// The tests above use a `BaseComponent` mock that returns
-// `{ type, props, children, key }` literals and assert against the
-// shape. This block re-runs key contracts with a base component
-// that returns real h() output — same divergence guard as the
-// attrs / connector-document parallels.
-
-describe('createLocalProvider — real h() round-trip', () => {
-  it('passes children through a real h() base component', () => {
-    const BaseComponentH = vi.fn((props: Record<string, unknown>) =>
-      h('div', { 'data-real-h': 'yes', ...props }, props.children as never),
-    )
-    const HOC = createLocalProvider(BaseComponentH as any)
-    const result = HOC({ children: 'hello' } as any) as any
-    expect(BaseComponentH).toHaveBeenCalled()
-    expect(result.type).toBe('div')
-    expect(result.props['data-real-h']).toBe('yes')
-  })
-
-  it('forwards arbitrary props through real h() output', () => {
-    const BaseComponentH = vi.fn((props: Record<string, unknown>) =>
-      h('button', props, props.label as never),
-    )
-    const HOC = createLocalProvider(BaseComponentH as any)
-    const result = HOC({ label: 'Click', 'data-id': '42' } as any) as any
-    expect(result.type).toBe('button')
-    expect(result.props.label).toBe('Click')
-    expect(result.props['data-id']).toBe('42')
-  })
-})

package/src/__tests__/dimensions.test.ts

@@ -1,183 +0,0 @@
-import {
-  getDimensionsMap,
-  getDimensionsValues,
-  getKeys,
-  getMultipleDimensions,
-  getTransformDimensions,
-  getValues,
-  isMultiKey,
-  isValidKey,
-} from '../utils/dimensions'
-
-describe('isValidKey', () => {
-  it('returns true for truthy values', () => {
-    expect(isValidKey('a')).toBe(true)
-    expect(isValidKey(1)).toBe(true)
-    expect(isValidKey(true)).toBe(true)
-    expect(isValidKey(0)).toBe(true)
-    expect(isValidKey('')).toBe(true)
-  })
-
-  it('returns false for undefined, null, false', () => {
-    expect(isValidKey(undefined)).toBe(false)
-    expect(isValidKey(null)).toBe(false)
-    expect(isValidKey(false)).toBe(false)
-  })
-})
-
-describe('isMultiKey', () => {
-  it('returns [true, propName] for object with propName', () => {
-    expect(isMultiKey({ propName: 'tags', multi: true })).toEqual([true, 'tags'])
-  })
-
-  it('returns [false, value] for string', () => {
-    expect(isMultiKey('variant')).toEqual([false, 'variant'])
-  })
-})
-
-describe('getKeys', () => {
-  it('returns object keys', () => {
-    expect(getKeys({ a: 1, b: 2 })).toEqual(['a', 'b'])
-  })
-
-  it('returns empty array for empty object', () => {
-    expect(getKeys({})).toEqual([])
-  })
-})
-
-describe('getValues', () => {
-  it('returns object values', () => {
-    expect(getValues({ a: 1, b: 2 })).toEqual([1, 2])
-  })
-})
-
-describe('getDimensionsValues', () => {
-  it('extracts string dimension values', () => {
-    const dimensions = { size: 'size', variant: 'variant' }
-    expect(getDimensionsValues(dimensions)).toEqual(['size', 'variant'])
-  })
-
-  it('extracts propName from object dimensions', () => {
-    const dimensions = {
-      size: 'size',
-      tags: { propName: 'tags', multi: true },
-    }
-    expect(getDimensionsValues(dimensions)).toEqual(['size', 'tags'])
-  })
-})
-
-describe('getMultipleDimensions', () => {
-  it('identifies multi-key dimensions', () => {
-    const dimensions = {
-      size: 'size',
-      tags: { propName: 'tags', multi: true },
-    }
-    expect(getMultipleDimensions(dimensions)).toEqual({ tags: true })
-  })
-
-  it('returns empty for no multi dimensions', () => {
-    const dimensions = { size: 'size', variant: 'variant' }
-    expect(getMultipleDimensions(dimensions)).toEqual({})
-  })
-
-  it('skips multi=false', () => {
-    const dimensions = {
-      tags: { propName: 'tags', multi: false },
-    }
-    expect(getMultipleDimensions(dimensions)).toEqual({})
-  })
-})
-
-describe('getDimensionsMap', () => {
-  it('builds keysMap and keywords from themes', () => {
-    const themes = {
-      size: { small: { fontSize: 12 }, large: { fontSize: 18 } },
-    }
-    const result = getDimensionsMap({ themes })
-    expect(result.keysMap).toEqual({
-      size: { small: true, large: true },
-    })
-    expect(result.keywords.size).toBe(true)
-  })
-
-  it('adds dimension keys to keywords when useBooleans', () => {
-    const themes = {
-      size: { small: { fontSize: 12 }, large: { fontSize: 18 } },
-    }
-    const result = getDimensionsMap({ themes, useBooleans: true })
-    expect(result.keywords.small).toBe(true)
-    expect(result.keywords.large).toBe(true)
-  })
-
-  it('skips invalid values (false, null, undefined)', () => {
-    const themes = {
-      size: { small: { fontSize: 12 }, disabled: false, hidden: null },
-    }
-    const result = getDimensionsMap({ themes })
-    expect(result.keysMap.size).toEqual({ small: true })
-  })
-
-  it('returns empty for empty themes', () => {
-    const result = getDimensionsMap({ themes: {} })
-    expect(result.keysMap).toEqual({})
-    expect(result.keywords).toEqual({})
-  })
-
-  it('includes function values (transform modifiers) as valid keys', () => {
-    const themes = {
-      modifier: {
-        outlined: (theme: any) => ({ color: theme.bg }),
-        ghost: () => ({ bg: 'transparent' }),
-      },
-    }
-    const result = getDimensionsMap({ themes })
-    expect(result.keysMap).toEqual({
-      modifier: { outlined: true, ghost: true },
-    })
-    expect(result.keywords.modifier).toBe(true)
-  })
-
-  it('includes function values as boolean keywords when useBooleans', () => {
-    const themes = {
-      modifier: {
-        outlined: (theme: any) => ({ color: theme.bg }),
-      },
-    }
-    const result = getDimensionsMap({ themes, useBooleans: true })
-    expect(result.keywords.outlined).toBe(true)
-  })
-})
-
-describe('getTransformDimensions', () => {
-  it('identifies transform dimensions', () => {
-    const dimensions = {
-      states: 'state',
-      modifiers: { propName: 'modifier', multi: true, transform: true },
-    }
-    expect(getTransformDimensions(dimensions)).toEqual({ modifier: true })
-  })
-
-  it('returns empty when no transform dimensions exist', () => {
-    const dimensions = {
-      states: 'state',
-      sizes: 'size',
-      multiple: { propName: 'multiple', multi: true },
-    }
-    expect(getTransformDimensions(dimensions)).toEqual({})
-  })
-
-  it('skips dimensions without transform flag', () => {
-    const dimensions = {
-      states: 'state',
-      tags: { propName: 'tags', multi: true },
-    }
-    expect(getTransformDimensions(dimensions)).toEqual({})
-  })
-
-  it('skips transform=false', () => {
-    const dimensions = {
-      modifiers: { propName: 'modifier', multi: true, transform: false },
-    }
-    expect(getTransformDimensions(dimensions)).toEqual({})
-  })
-})