@pyreon/coolgrid 0.11.5 → 0.11.6

package/src/__tests__/Col.test.ts

@@ -1,11 +1,11 @@
-import type { VNode } from "@pyreon/core"
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { VNode } from '@pyreon/core'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mockProvide = vi.fn()
 const mockUseContext = vi.fn()
 
-vi.mock("@pyreon/core", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/core")>()
+vi.mock('@pyreon/core', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/core')>()
   return {
     ...original,
     provide: (...args: any[]) => {
@@ -21,8 +21,8 @@ vi.mock("@pyreon/core", async (importOriginal) => {
 })
 
 // Mock unistyle context to return empty theme
-vi.mock("@pyreon/unistyle", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/unistyle")>()
+vi.mock('@pyreon/unistyle', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/unistyle')>()
   return {
     ...original,
   }
@@ -30,102 +30,102 @@ vi.mock("@pyreon/unistyle", async (importOriginal) => {
 
 const asVNode = (v: unknown) => v as VNode
 
-describe("Col", () => {
+describe('Col', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     // Default: no context (empty object)
     mockUseContext.mockReturnValue({})
   })
 
-  it("returns a VNode", async () => {
-    const Col = (await import("../Col")).default
-    const result = asVNode(Col({ children: "test" }))
+  it('returns a VNode', async () => {
+    const Col = (await import('../Col')).default
+    const result = asVNode(Col({ children: 'test' }))
     expect(result).toBeDefined()
     expect(result.type).toBeDefined()
   })
 
-  it("has correct displayName", async () => {
-    const Col = (await import("../Col")).default
-    expect(Col.displayName).toBe("@pyreon/coolgrid/Col")
+  it('has correct displayName', async () => {
+    const Col = (await import('../Col')).default
+    expect(Col.displayName).toBe('@pyreon/coolgrid/Col')
   })
 
-  it("has correct pkgName", async () => {
-    const Col = (await import("../Col")).default
-    expect(Col.pkgName).toBe("@pyreon/coolgrid")
+  it('has correct pkgName', async () => {
+    const Col = (await import('../Col')).default
+    expect(Col.pkgName).toBe('@pyreon/coolgrid')
   })
 
-  it("has PYREON__COMPONENT static", async () => {
-    const Col = (await import("../Col")).default
-    expect(Col.PYREON__COMPONENT).toBe("@pyreon/coolgrid/Col")
+  it('has PYREON__COMPONENT static', async () => {
+    const Col = (await import('../Col')).default
+    expect(Col.PYREON__COMPONENT).toBe('@pyreon/coolgrid/Col')
   })
 
-  it("passes $coolgrid prop with grid values", async () => {
-    const Col = (await import("../Col")).default
-    const result = asVNode(Col({ size: 6, children: "test" }))
-    expect(result.props).toHaveProperty("$coolgrid")
+  it('passes $coolgrid prop with grid values', async () => {
+    const Col = (await import('../Col')).default
+    const result = asVNode(Col({ size: 6, children: 'test' }))
+    expect(result.props).toHaveProperty('$coolgrid')
   })
 
-  it("does not provide context (Col only reads, never provides)", async () => {
-    const Col = (await import("../Col")).default
-    Col({ children: "test" })
+  it('does not provide context (Col only reads, never provides)', async () => {
+    const Col = (await import('../Col')).default
+    Col({ children: 'test' })
     expect(mockProvide).not.toHaveBeenCalled()
   })
 
-  it("strips context keys from DOM props", async () => {
-    const Col = (await import("../Col")).default
+  it('strips context keys from DOM props', async () => {
+    const Col = (await import('../Col')).default
     const result = asVNode(
       Col({
         columns: 12,
         gap: 16,
         size: 6,
-        "data-testid": "my-col",
-        children: "test",
+        'data-testid': 'my-col',
+        children: 'test',
       }),
     )
     // context keys should be stripped from the rendered props
     // but $coolgrid should be present
     expect(result.props.$coolgrid).toBeDefined()
-    expect(result.props["data-testid"]).toBe("my-col")
+    expect(result.props['data-testid']).toBe('my-col')
   })
 
-  it("passes css as extraStyles when provided", async () => {
-    const Col = (await import("../Col")).default
-    const customCss = "background: green;"
-    const result = asVNode(Col({ css: customCss, children: "test" }))
+  it('passes css as extraStyles when provided', async () => {
+    const Col = (await import('../Col')).default
+    const customCss = 'background: green;'
+    const result = asVNode(Col({ css: customCss, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).extraStyles).toBe(customCss)
   })
 
-  it("includes columns and gap in $coolgrid", async () => {
-    const Col = (await import("../Col")).default
-    const result = asVNode(Col({ columns: 12, gap: 16, size: 6, children: "test" }))
+  it('includes columns and gap in $coolgrid', async () => {
+    const Col = (await import('../Col')).default
+    const result = asVNode(Col({ columns: 12, gap: 16, size: 6, children: 'test' }))
     const coolgrid = result.props.$coolgrid as Record<string, unknown>
     expect(coolgrid.columns).toBe(12)
     expect(coolgrid.gap).toBe(16)
     expect(coolgrid.size).toBe(6)
   })
 
-  it("renders with data-coolgrid attribute in dev mode", async () => {
-    const Col = (await import("../Col")).default
-    const result = asVNode(Col({ children: "test" }))
-    expect(result.props["data-coolgrid"]).toBe("col")
+  it('renders with data-coolgrid attribute in dev mode', async () => {
+    const Col = (await import('../Col')).default
+    const result = asVNode(Col({ children: 'test' }))
+    expect(result.props['data-coolgrid']).toBe('col')
   })
 
   it("passes component prop as 'as'", async () => {
-    const Col = (await import("../Col")).default
+    const Col = (await import('../Col')).default
     const customComponent = (() => null) as any
-    const result = asVNode(Col({ component: customComponent, children: "test" }))
+    const result = asVNode(Col({ component: customComponent, children: 'test' }))
     expect(result.props.as).toBe(customComponent)
   })
 
-  it("includes padding in $coolgrid", async () => {
-    const Col = (await import("../Col")).default
-    const result = asVNode(Col({ padding: 8, children: "test" }))
+  it('includes padding in $coolgrid', async () => {
+    const Col = (await import('../Col')).default
+    const result = asVNode(Col({ padding: 8, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).padding).toBe(8)
   })
 
-  it("renders children in VNode", async () => {
-    const Col = (await import("../Col")).default
-    const result = asVNode(Col({ children: "hello" }))
+  it('renders children in VNode', async () => {
+    const Col = (await import('../Col')).default
+    const result = asVNode(Col({ children: 'hello' }))
     expect(result.children).toBeDefined()
   })
 })

package/src/__tests__/Container.styled.test.ts

@@ -1,49 +1,49 @@
-import { describe, expect, it } from "vitest"
-import { getContainerWidth } from "../Container/utils"
+import { describe, expect, it } from 'vitest'
+import { getContainerWidth } from '../Container/utils'
 
-describe("Container/utils – getContainerWidth", () => {
-  it("returns width from props when present", () => {
+describe('Container/utils – getContainerWidth', () => {
+  it('returns width from props when present', () => {
     const result = getContainerWidth({ width: 960 }, {})
     expect(result).toBe(960)
   })
 
-  it("prefers props.width over theme.grid.container", () => {
+  it('prefers props.width over theme.grid.container', () => {
     const result = getContainerWidth(
       { width: 800 },
-      { grid: { container: { xs: "100%", md: 720 } } },
+      { grid: { container: { xs: '100%', md: 720 } } },
     )
     expect(result).toBe(800)
   })
 
-  it("falls back to theme.grid.container", () => {
-    const result = getContainerWidth({}, { grid: { container: { xs: "100%", md: 720 } } })
-    expect(result).toEqual({ xs: "100%", md: 720 })
+  it('falls back to theme.grid.container', () => {
+    const result = getContainerWidth({}, { grid: { container: { xs: '100%', md: 720 } } })
+    expect(result).toEqual({ xs: '100%', md: 720 })
   })
 
-  it("falls back to theme.coolgrid.container when grid is missing", () => {
-    const result = getContainerWidth({}, { coolgrid: { container: { xs: "100%", lg: 960 } } })
-    expect(result).toEqual({ xs: "100%", lg: 960 })
+  it('falls back to theme.coolgrid.container when grid is missing', () => {
+    const result = getContainerWidth({}, { coolgrid: { container: { xs: '100%', lg: 960 } } })
+    expect(result).toEqual({ xs: '100%', lg: 960 })
   })
 
-  it("returns undefined/falsy when nothing matches", () => {
+  it('returns undefined/falsy when nothing matches', () => {
     expect(getContainerWidth({}, {})).toBeFalsy()
   })
 
-  it("returns undefined/falsy when both are undefined", () => {
+  it('returns undefined/falsy when both are undefined', () => {
     expect(getContainerWidth(undefined, undefined)).toBeFalsy()
   })
 
-  it("returns undefined/falsy when both are empty objects", () => {
+  it('returns undefined/falsy when both are empty objects', () => {
     expect(getContainerWidth({}, {})).toBeFalsy()
   })
 
-  it("returns string width from props", () => {
-    const result = getContainerWidth({ width: "100%" }, {})
-    expect(result).toBe("100%")
+  it('returns string width from props', () => {
+    const result = getContainerWidth({ width: '100%' }, {})
+    expect(result).toBe('100%')
   })
 
-  it("returns responsive object from props", () => {
-    const result = getContainerWidth({ width: { xs: "100%", md: 720, lg: 960 } }, {})
-    expect(result).toEqual({ xs: "100%", md: 720, lg: 960 })
+  it('returns responsive object from props', () => {
+    const result = getContainerWidth({ width: { xs: '100%', md: 720, lg: 960 } }, {})
+    expect(result).toEqual({ xs: '100%', md: 720, lg: 960 })
   })
 })

package/src/__tests__/Container.test.ts

@@ -1,11 +1,11 @@
-import type { VNode } from "@pyreon/core"
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { VNode } from '@pyreon/core'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mockProvide = vi.fn()
 const mockUseContext = vi.fn()
 
-vi.mock("@pyreon/core", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/core")>()
+vi.mock('@pyreon/core', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/core')>()
   return {
     ...original,
     provide: (...args: any[]) => {
@@ -22,126 +22,126 @@ vi.mock("@pyreon/core", async (importOriginal) => {
 
 const asVNode = (v: unknown) => v as VNode
 
-describe("Container", () => {
+describe('Container', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     // unistyle context returns empty theme
     mockUseContext.mockReturnValue({ theme: {} })
   })
 
-  it("returns a VNode", async () => {
-    const Container = (await import("../Container")).default
-    const result = asVNode(Container({ children: "test" }))
+  it('returns a VNode', async () => {
+    const Container = (await import('../Container')).default
+    const result = asVNode(Container({ children: 'test' }))
     expect(result).toBeDefined()
     expect(result.type).toBeDefined()
   })
 
-  it("has correct displayName", async () => {
-    const Container = (await import("../Container")).default
-    expect(Container.displayName).toBe("@pyreon/coolgrid/Container")
+  it('has correct displayName', async () => {
+    const Container = (await import('../Container')).default
+    expect(Container.displayName).toBe('@pyreon/coolgrid/Container')
   })
 
-  it("has correct pkgName", async () => {
-    const Container = (await import("../Container")).default
-    expect(Container.pkgName).toBe("@pyreon/coolgrid")
+  it('has correct pkgName', async () => {
+    const Container = (await import('../Container')).default
+    expect(Container.pkgName).toBe('@pyreon/coolgrid')
   })
 
-  it("has PYREON__COMPONENT static", async () => {
-    const Container = (await import("../Container")).default
-    expect(Container.PYREON__COMPONENT).toBe("@pyreon/coolgrid/Container")
+  it('has PYREON__COMPONENT static', async () => {
+    const Container = (await import('../Container')).default
+    expect(Container.PYREON__COMPONENT).toBe('@pyreon/coolgrid/Container')
   })
 
-  it("passes $coolgrid prop with width and extraStyles", async () => {
-    const Container = (await import("../Container")).default
-    const result = asVNode(Container({ children: "test" }))
-    expect(result.props).toHaveProperty("$coolgrid")
-    expect(result.props.$coolgrid).toHaveProperty("width")
+  it('passes $coolgrid prop with width and extraStyles', async () => {
+    const Container = (await import('../Container')).default
+    const result = asVNode(Container({ children: 'test' }))
+    expect(result.props).toHaveProperty('$coolgrid')
+    expect(result.props.$coolgrid).toHaveProperty('width')
   })
 
-  it("provides ContainerContext", async () => {
-    const Container = (await import("../Container")).default
-    Container({ columns: 12, gap: 16, children: "test" })
+  it('provides ContainerContext', async () => {
+    const Container = (await import('../Container')).default
+    Container({ columns: 12, gap: 16, children: 'test' })
     expect(mockProvide).toHaveBeenCalledTimes(1)
   })
 
-  it("provides context with grid values", async () => {
-    const Container = (await import("../Container")).default
-    Container({ columns: 24, gap: 16, gutter: 8, children: "test" })
+  it('provides context with grid values', async () => {
+    const Container = (await import('../Container')).default
+    Container({ columns: 24, gap: 16, gutter: 8, children: 'test' })
     const config = mockProvide.mock.calls[0]?.[1] as Record<string, unknown>
     expect(config.columns).toBe(24)
     expect(config.gap).toBe(16)
     expect(config.gutter).toBe(8)
   })
 
-  it("uses width prop to override containerWidth", async () => {
-    const Container = (await import("../Container")).default
-    const result = asVNode(Container({ width: 960, children: "test" }))
+  it('uses width prop to override containerWidth', async () => {
+    const Container = (await import('../Container')).default
+    const result = asVNode(Container({ width: 960, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).width).toBe(960)
   })
 
-  it("accepts width as function", async () => {
-    const Container = (await import("../Container")).default
+  it('accepts width as function', async () => {
+    const Container = (await import('../Container')).default
     const widthFn = (_containerWidth: any) => 800
-    const result = asVNode(Container({ width: widthFn as any, children: "test" }))
+    const result = asVNode(Container({ width: widthFn as any, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).width).toBe(800)
   })
 
-  it("strips context keys from DOM props", async () => {
-    const Container = (await import("../Container")).default
+  it('strips context keys from DOM props', async () => {
+    const Container = (await import('../Container')).default
     const result = asVNode(
       Container({
         columns: 12,
         gap: 16,
-        "data-testid": "container",
-        children: "test",
+        'data-testid': 'container',
+        children: 'test',
       }),
     )
-    expect(result.props["data-testid"]).toBe("container")
+    expect(result.props['data-testid']).toBe('container')
   })
 
-  it("passes css as extraStyles in $coolgrid", async () => {
-    const Container = (await import("../Container")).default
-    const customCss = "background: red;"
-    const result = asVNode(Container({ css: customCss, children: "test" }))
+  it('passes css as extraStyles in $coolgrid', async () => {
+    const Container = (await import('../Container')).default
+    const customCss = 'background: red;'
+    const result = asVNode(Container({ css: customCss, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).extraStyles).toBe(customCss)
   })
 
-  it("provides context with all grid keys", async () => {
-    const Container = (await import("../Container")).default
+  it('provides context with all grid keys', async () => {
+    const Container = (await import('../Container')).default
     Container({
       columns: 12,
       gap: 16,
       gutter: 8,
       padding: 4,
       size: 6,
-      contentAlignX: "center",
-      children: "test",
+      contentAlignX: 'center',
+      children: 'test',
     })
     const config = mockProvide.mock.calls[0]?.[1] as Record<string, unknown>
-    expect(config).toHaveProperty("columns")
-    expect(config).toHaveProperty("gap")
-    expect(config).toHaveProperty("gutter")
-    expect(config).toHaveProperty("padding")
-    expect(config).toHaveProperty("size")
-    expect(config).toHaveProperty("contentAlignX")
+    expect(config).toHaveProperty('columns')
+    expect(config).toHaveProperty('gap')
+    expect(config).toHaveProperty('gutter')
+    expect(config).toHaveProperty('padding')
+    expect(config).toHaveProperty('size')
+    expect(config).toHaveProperty('contentAlignX')
   })
 
-  it("renders with data-coolgrid attribute in dev mode", async () => {
-    const Container = (await import("../Container")).default
-    const result = asVNode(Container({ children: "test" }))
-    expect(result.props["data-coolgrid"]).toBe("container")
+  it('renders with data-coolgrid attribute in dev mode', async () => {
+    const Container = (await import('../Container')).default
+    const result = asVNode(Container({ children: 'test' }))
+    expect(result.props['data-coolgrid']).toBe('container')
   })
 
   it("passes component prop as 'as'", async () => {
-    const Container = (await import("../Container")).default
+    const Container = (await import('../Container')).default
     const customComponent = (() => null) as any
-    const result = asVNode(Container({ component: customComponent, children: "test" }))
+    const result = asVNode(Container({ component: customComponent, children: 'test' }))
     expect(result.props.as).toBe(customComponent)
   })
 
-  it("renders children in VNode", async () => {
-    const Container = (await import("../Container")).default
-    const result = asVNode(Container({ children: "hello world" }))
+  it('renders children in VNode', async () => {
+    const Container = (await import('../Container')).default
+    const result = asVNode(Container({ children: 'hello world' }))
     expect(result.children).toBeDefined()
   })
 })

package/src/__tests__/Row.test.ts

@@ -1,11 +1,11 @@
-import type { VNode } from "@pyreon/core"
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { VNode } from '@pyreon/core'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mockProvide = vi.fn()
 const mockUseContext = vi.fn()
 
-vi.mock("@pyreon/core", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@pyreon/core")>()
+vi.mock('@pyreon/core', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@pyreon/core')>()
   return {
     ...original,
     provide: (...args: any[]) => {
@@ -22,114 +22,114 @@ vi.mock("@pyreon/core", async (importOriginal) => {
 
 const asVNode = (v: unknown) => v as VNode
 
-describe("Row", () => {
+describe('Row', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     // unistyle context returns empty theme, container context returns empty
     mockUseContext.mockReturnValue({})
   })
 
-  it("returns a VNode", async () => {
-    const Row = (await import("../Row")).default
-    const result = asVNode(Row({ children: "test" }))
+  it('returns a VNode', async () => {
+    const Row = (await import('../Row')).default
+    const result = asVNode(Row({ children: 'test' }))
     expect(result).toBeDefined()
     expect(result.type).toBeDefined()
   })
 
-  it("has correct displayName", async () => {
-    const Row = (await import("../Row")).default
-    expect(Row.displayName).toBe("@pyreon/coolgrid/Row")
+  it('has correct displayName', async () => {
+    const Row = (await import('../Row')).default
+    expect(Row.displayName).toBe('@pyreon/coolgrid/Row')
   })
 
-  it("has correct pkgName", async () => {
-    const Row = (await import("../Row")).default
-    expect(Row.pkgName).toBe("@pyreon/coolgrid")
+  it('has correct pkgName', async () => {
+    const Row = (await import('../Row')).default
+    expect(Row.pkgName).toBe('@pyreon/coolgrid')
   })
 
-  it("has PYREON__COMPONENT static", async () => {
-    const Row = (await import("../Row")).default
-    expect(Row.PYREON__COMPONENT).toBe("@pyreon/coolgrid/Row")
+  it('has PYREON__COMPONENT static', async () => {
+    const Row = (await import('../Row')).default
+    expect(Row.PYREON__COMPONENT).toBe('@pyreon/coolgrid/Row')
   })
 
-  it("passes $coolgrid prop with row values", async () => {
-    const Row = (await import("../Row")).default
-    const result = asVNode(Row({ gap: 16, children: "test" }))
-    expect(result.props).toHaveProperty("$coolgrid")
-    expect(result.props.$coolgrid).toHaveProperty("gap")
+  it('passes $coolgrid prop with row values', async () => {
+    const Row = (await import('../Row')).default
+    const result = asVNode(Row({ gap: 16, children: 'test' }))
+    expect(result.props).toHaveProperty('$coolgrid')
+    expect(result.props.$coolgrid).toHaveProperty('gap')
   })
 
-  it("provides RowContext", async () => {
-    const Row = (await import("../Row")).default
-    Row({ gap: 16, columns: 12, children: "test" })
+  it('provides RowContext', async () => {
+    const Row = (await import('../Row')).default
+    Row({ gap: 16, columns: 12, children: 'test' })
     expect(mockProvide).toHaveBeenCalledTimes(1)
   })
 
-  it("provides context with grid values", async () => {
-    const Row = (await import("../Row")).default
-    Row({ columns: 24, gap: 16, gutter: 8, children: "test" })
+  it('provides context with grid values', async () => {
+    const Row = (await import('../Row')).default
+    Row({ columns: 24, gap: 16, gutter: 8, children: 'test' })
     const config = mockProvide.mock.calls[0]?.[1] as Record<string, unknown>
     expect(config.columns).toBe(24)
     expect(config.gap).toBe(16)
     expect(config.gutter).toBe(8)
   })
 
-  it("passes contentAlignX to $coolgrid", async () => {
-    const Row = (await import("../Row")).default
-    const result = asVNode(Row({ contentAlignX: "center", children: "test" }))
-    expect((result.props.$coolgrid as Record<string, unknown>).contentAlignX).toBe("center")
+  it('passes contentAlignX to $coolgrid', async () => {
+    const Row = (await import('../Row')).default
+    const result = asVNode(Row({ contentAlignX: 'center', children: 'test' }))
+    expect((result.props.$coolgrid as Record<string, unknown>).contentAlignX).toBe('center')
   })
 
-  it("strips context keys from DOM props", async () => {
-    const Row = (await import("../Row")).default
+  it('strips context keys from DOM props', async () => {
+    const Row = (await import('../Row')).default
     const result = asVNode(
       Row({
         columns: 12,
         gap: 16,
-        "data-testid": "row",
-        children: "test",
+        'data-testid': 'row',
+        children: 'test',
       }),
     )
-    expect(result.props["data-testid"]).toBe("row")
+    expect(result.props['data-testid']).toBe('row')
   })
 
-  it("passes css as extraStyles in $coolgrid when provided", async () => {
-    const Row = (await import("../Row")).default
-    const customCss = "background: blue;"
-    const result = asVNode(Row({ css: customCss, children: "test" }))
+  it('passes css as extraStyles in $coolgrid when provided', async () => {
+    const Row = (await import('../Row')).default
+    const customCss = 'background: blue;'
+    const result = asVNode(Row({ css: customCss, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).extraStyles).toBe(customCss)
   })
 
-  it("passes gutter in $coolgrid", async () => {
-    const Row = (await import("../Row")).default
-    const result = asVNode(Row({ gutter: 24, children: "test" }))
+  it('passes gutter in $coolgrid', async () => {
+    const Row = (await import('../Row')).default
+    const result = asVNode(Row({ gutter: 24, children: 'test' }))
     expect((result.props.$coolgrid as Record<string, unknown>).gutter).toBe(24)
   })
 
-  it("provides context including colCss and colComponent", async () => {
-    const Row = (await import("../Row")).default
+  it('provides context including colCss and colComponent', async () => {
+    const Row = (await import('../Row')).default
     const colComp = (() => null) as any
-    Row({ colCss: "color: red;", colComponent: colComp, children: "test" })
+    Row({ colCss: 'color: red;', colComponent: colComp, children: 'test' })
     const config = mockProvide.mock.calls[0]?.[1] as Record<string, unknown>
-    expect(config.colCss).toBe("color: red;")
+    expect(config.colCss).toBe('color: red;')
     expect(config.colComponent).toBe(colComp)
   })
 
-  it("renders with data-coolgrid attribute in dev mode", async () => {
-    const Row = (await import("../Row")).default
-    const result = asVNode(Row({ children: "test" }))
-    expect(result.props["data-coolgrid"]).toBe("row")
+  it('renders with data-coolgrid attribute in dev mode', async () => {
+    const Row = (await import('../Row')).default
+    const result = asVNode(Row({ children: 'test' }))
+    expect(result.props['data-coolgrid']).toBe('row')
   })
 
   it("passes component prop as 'as'", async () => {
-    const Row = (await import("../Row")).default
+    const Row = (await import('../Row')).default
     const customComponent = (() => null) as any
-    const result = asVNode(Row({ component: customComponent, children: "test" }))
+    const result = asVNode(Row({ component: customComponent, children: 'test' }))
     expect(result.props.as).toBe(customComponent)
   })
 
-  it("renders children in VNode", async () => {
-    const Row = (await import("../Row")).default
-    const result = asVNode(Row({ children: "hello" }))
+  it('renders children in VNode', async () => {
+    const Row = (await import('../Row')).default
+    const result = asVNode(Row({ children: 'hello' }))
     expect(result.children).toBeDefined()
   })
 })