@pyreon/styler 0.11.5 → 0.11.6

package/src/__tests__/forward.test.ts

@@ -1,282 +1,282 @@
-import { describe, expect, it } from "vitest"
-import { buildProps, filterProps } from "../forward"
+import { describe, expect, it } from 'vitest'
+import { buildProps, filterProps } from '../forward'
 
-describe("filterProps", () => {
-  describe("keeps standard HTML props", () => {
-    it("keeps id", () => {
-      const result = filterProps({ id: "test" })
-      expect(result.id).toBe("test")
+describe('filterProps', () => {
+  describe('keeps standard HTML props', () => {
+    it('keeps id', () => {
+      const result = filterProps({ id: 'test' })
+      expect(result.id).toBe('test')
     })
 
-    it("keeps className", () => {
-      const result = filterProps({ className: "foo" })
-      expect(result.className).toBe("foo")
+    it('keeps className', () => {
+      const result = filterProps({ className: 'foo' })
+      expect(result.className).toBe('foo')
     })
 
-    it("keeps style", () => {
-      const style = { color: "red" }
+    it('keeps style', () => {
+      const style = { color: 'red' }
       const result = filterProps({ style })
       expect(result.style).toBe(style)
     })
 
-    it("keeps href", () => {
-      const result = filterProps({ href: "/path" })
-      expect(result.href).toBe("/path")
+    it('keeps href', () => {
+      const result = filterProps({ href: '/path' })
+      expect(result.href).toBe('/path')
     })
 
-    it("keeps disabled", () => {
+    it('keeps disabled', () => {
       const result = filterProps({ disabled: true })
       expect(result.disabled).toBe(true)
     })
 
-    it("keeps multiple standard props at once", () => {
+    it('keeps multiple standard props at once', () => {
       const result = filterProps({
-        id: "main",
+        id: 'main',
         tabIndex: 0,
-        role: "button",
-        title: "Click me",
+        role: 'button',
+        title: 'Click me',
       })
       expect(result).toEqual({
-        id: "main",
+        id: 'main',
         tabIndex: 0,
-        role: "button",
-        title: "Click me",
+        role: 'button',
+        title: 'Click me',
       })
     })
   })
 
-  describe("keeps data-* attributes", () => {
-    it("keeps data-testid", () => {
-      const result = filterProps({ "data-testid": "hello" })
-      expect(result["data-testid"]).toBe("hello")
+  describe('keeps data-* attributes', () => {
+    it('keeps data-testid', () => {
+      const result = filterProps({ 'data-testid': 'hello' })
+      expect(result['data-testid']).toBe('hello')
     })
 
-    it("keeps data-custom", () => {
-      const result = filterProps({ "data-custom": "value" })
-      expect(result["data-custom"]).toBe("value")
+    it('keeps data-custom', () => {
+      const result = filterProps({ 'data-custom': 'value' })
+      expect(result['data-custom']).toBe('value')
     })
   })
 
-  describe("keeps aria-* attributes", () => {
-    it("keeps aria-label", () => {
-      const result = filterProps({ "aria-label": "Close" })
-      expect(result["aria-label"]).toBe("Close")
+  describe('keeps aria-* attributes', () => {
+    it('keeps aria-label', () => {
+      const result = filterProps({ 'aria-label': 'Close' })
+      expect(result['aria-label']).toBe('Close')
     })
 
-    it("keeps aria-hidden", () => {
-      const result = filterProps({ "aria-hidden": true })
-      expect(result["aria-hidden"]).toBe(true)
+    it('keeps aria-hidden', () => {
+      const result = filterProps({ 'aria-hidden': true })
+      expect(result['aria-hidden']).toBe(true)
     })
 
-    it("keeps aria-describedby", () => {
-      const result = filterProps({ "aria-describedby": "desc" })
-      expect(result["aria-describedby"]).toBe("desc")
+    it('keeps aria-describedby', () => {
+      const result = filterProps({ 'aria-describedby': 'desc' })
+      expect(result['aria-describedby']).toBe('desc')
     })
   })
 
-  describe("keeps event handlers", () => {
-    it("keeps onClick", () => {
+  describe('keeps event handlers', () => {
+    it('keeps onClick', () => {
       const fn = () => undefined
       const result = filterProps({ onClick: fn })
       expect(result.onClick).toBe(fn)
     })
 
-    it("keeps onMouseEnter", () => {
+    it('keeps onMouseEnter', () => {
       const fn = () => undefined
       const result = filterProps({ onMouseEnter: fn })
       expect(result.onMouseEnter).toBe(fn)
     })
 
-    it("keeps onKeyDown", () => {
+    it('keeps onKeyDown', () => {
       const fn = () => undefined
       const result = filterProps({ onKeyDown: fn })
       expect(result.onKeyDown).toBe(fn)
     })
   })
 
-  describe("strips $-prefixed transient props", () => {
-    it("strips $rocketstyle", () => {
-      const result = filterProps({ $rocketstyle: { color: "red" } })
+  describe('strips $-prefixed transient props', () => {
+    it('strips $rocketstyle', () => {
+      const result = filterProps({ $rocketstyle: { color: 'red' } })
       expect(result).toEqual({})
     })
 
-    it("strips $element", () => {
-      const result = filterProps({ $element: "button" })
+    it('strips $element', () => {
+      const result = filterProps({ $element: 'button' })
       expect(result).toEqual({})
     })
 
-    it("strips $active", () => {
+    it('strips $active', () => {
       const result = filterProps({ $active: true })
       expect(result).toEqual({})
     })
 
-    it("strips multiple $-prefixed props while keeping valid ones", () => {
+    it('strips multiple $-prefixed props while keeping valid ones', () => {
       const result = filterProps({
         $rocketstyle: {},
-        $element: "div",
-        id: "test",
-        "data-x": "y",
+        $element: 'div',
+        id: 'test',
+        'data-x': 'y',
       })
-      expect(result).toEqual({ id: "test", "data-x": "y" })
+      expect(result).toEqual({ id: 'test', 'data-x': 'y' })
     })
   })
 
-  describe("strips as prop", () => {
-    it("strips the as prop", () => {
-      const result = filterProps({ as: "button" })
+  describe('strips as prop', () => {
+    it('strips the as prop', () => {
+      const result = filterProps({ as: 'button' })
       expect(result).toEqual({})
     })
 
-    it("strips as while keeping other props", () => {
-      const result = filterProps({ as: "section", id: "main" })
-      expect(result).toEqual({ id: "main" })
+    it('strips as while keeping other props', () => {
+      const result = filterProps({ as: 'section', id: 'main' })
+      expect(result).toEqual({ id: 'main' })
     })
   })
 
-  describe("strips unknown props", () => {
-    it("strips customProp", () => {
-      const result = filterProps({ customProp: "value" })
+  describe('strips unknown props', () => {
+    it('strips customProp', () => {
+      const result = filterProps({ customProp: 'value' })
       expect(result).toEqual({})
     })
 
-    it("strips myThing", () => {
+    it('strips myThing', () => {
       const result = filterProps({ myThing: 42 })
       expect(result).toEqual({})
     })
 
-    it("strips camelCase unknown props", () => {
-      const result = filterProps({ isActive: true, backgroundColor: "red" })
+    it('strips camelCase unknown props', () => {
+      const result = filterProps({ isActive: true, backgroundColor: 'red' })
       expect(result).toEqual({})
     })
 
-    it("returns empty object for all-unknown props", () => {
+    it('returns empty object for all-unknown props', () => {
       const result = filterProps({
         foo: 1,
         bar: 2,
         baz: 3,
-        customThing: "x",
+        customThing: 'x',
       })
       expect(result).toEqual({})
     })
   })
 })
 
-describe("buildProps", () => {
-  describe("className merging", () => {
-    it("merges generatedCls with user className", () => {
-      const result = buildProps({ className: "custom" }, "pyr-abc", true)
-      expect(result.class).toBe("pyr-abc custom")
+describe('buildProps', () => {
+  describe('className merging', () => {
+    it('merges generatedCls with user className', () => {
+      const result = buildProps({ className: 'custom' }, 'pyr-abc', true)
+      expect(result.class).toBe('pyr-abc custom')
     })
 
-    it("merges generatedCls with user class", () => {
-      const result = buildProps({ class: "custom" }, "pyr-abc", true)
-      expect(result.class).toBe("pyr-abc custom")
+    it('merges generatedCls with user class', () => {
+      const result = buildProps({ class: 'custom' }, 'pyr-abc', true)
+      expect(result.class).toBe('pyr-abc custom')
     })
 
-    it("uses only generatedCls when no user className", () => {
-      const result = buildProps({}, "pyr-abc", true)
-      expect(result.class).toBe("pyr-abc")
+    it('uses only generatedCls when no user className', () => {
+      const result = buildProps({}, 'pyr-abc', true)
+      expect(result.class).toBe('pyr-abc')
     })
 
-    it("uses only user className when generatedCls is empty", () => {
-      const result = buildProps({ className: "custom" }, "", true)
-      expect(result.class).toBe("custom")
+    it('uses only user className when generatedCls is empty', () => {
+      const result = buildProps({ className: 'custom' }, '', true)
+      expect(result.class).toBe('custom')
     })
 
-    it("sets no class when both are empty/missing", () => {
-      const result = buildProps({}, "", true)
+    it('sets no class when both are empty/missing', () => {
+      const result = buildProps({}, '', true)
       expect(result.class).toBeUndefined()
     })
   })
 
-  describe("isDOM=false (component target)", () => {
-    it("forwards all props except as, className, class, and $-prefixed", () => {
+  describe('isDOM=false (component target)', () => {
+    it('forwards all props except as, className, class, and $-prefixed', () => {
       const result = buildProps(
         {
-          as: "button",
-          className: "user",
-          customProp: "hello",
+          as: 'button',
+          className: 'user',
+          customProp: 'hello',
           $rocketstyle: {},
           $rocketstate: { hover: true },
-          "data-x": "y",
+          'data-x': 'y',
           onClick: () => undefined,
         },
-        "pyr-abc",
+        'pyr-abc',
         false,
       )
 
-      expect(result.customProp).toBe("hello")
+      expect(result.customProp).toBe('hello')
       expect(result.$rocketstyle).toBeUndefined()
       expect(result.$rocketstate).toBeUndefined()
-      expect(result["data-x"]).toBe("y")
+      expect(result['data-x']).toBe('y')
       expect(result.onClick).toBeDefined()
       // as and className are not forwarded from rawProps (class is merged separately)
       expect(result.as).toBeUndefined()
-      expect(result.class).toBe("pyr-abc user")
+      expect(result.class).toBe('pyr-abc user')
     })
   })
 
-  describe("isDOM=true (default filtering)", () => {
-    it("filters unknown DOM props", () => {
-      const result = buildProps({ customProp: "hello", unknownThing: 42 }, "pyr-abc", true)
+  describe('isDOM=true (default filtering)', () => {
+    it('filters unknown DOM props', () => {
+      const result = buildProps({ customProp: 'hello', unknownThing: 42 }, 'pyr-abc', true)
       expect(result.customProp).toBeUndefined()
       expect(result.unknownThing).toBeUndefined()
-      expect(result.class).toBe("pyr-abc")
+      expect(result.class).toBe('pyr-abc')
     })
 
-    it("strips $-prefixed props", () => {
-      const result = buildProps({ $rocketstyle: {}, $active: true, id: "test" }, "pyr-abc", true)
+    it('strips $-prefixed props', () => {
+      const result = buildProps({ $rocketstyle: {}, $active: true, id: 'test' }, 'pyr-abc', true)
       expect(result.$rocketstyle).toBeUndefined()
       expect(result.$active).toBeUndefined()
-      expect(result.id).toBe("test")
+      expect(result.id).toBe('test')
     })
 
-    it("keeps data-* and aria-* attributes", () => {
-      const result = buildProps({ "data-testid": "btn", "aria-label": "Close" }, "pyr-abc", true)
-      expect(result["data-testid"]).toBe("btn")
-      expect(result["aria-label"]).toBe("Close")
+    it('keeps data-* and aria-* attributes', () => {
+      const result = buildProps({ 'data-testid': 'btn', 'aria-label': 'Close' }, 'pyr-abc', true)
+      expect(result['data-testid']).toBe('btn')
+      expect(result['aria-label']).toBe('Close')
     })
 
-    it("keeps standard HTML attributes", () => {
-      const result = buildProps({ id: "main", disabled: true, tabIndex: 0 }, "pyr-abc", true)
-      expect(result.id).toBe("main")
+    it('keeps standard HTML attributes', () => {
+      const result = buildProps({ id: 'main', disabled: true, tabIndex: 0 }, 'pyr-abc', true)
+      expect(result.id).toBe('main')
       expect(result.disabled).toBe(true)
       expect(result.tabIndex).toBe(0)
     })
 
-    it("strips as prop", () => {
-      const result = buildProps({ as: "section" }, "pyr-abc", true)
+    it('strips as prop', () => {
+      const result = buildProps({ as: 'section' }, 'pyr-abc', true)
       expect(result.as).toBeUndefined()
     })
   })
 
-  describe("isDOM=true with customFilter", () => {
-    it("uses customFilter to decide which props to forward", () => {
-      const customFilter = (prop: string) => prop.startsWith("my")
+  describe('isDOM=true with customFilter', () => {
+    it('uses customFilter to decide which props to forward', () => {
+      const customFilter = (prop: string) => prop.startsWith('my')
       const result = buildProps(
-        { myProp: "yes", otherProp: "no", id: "skip" },
-        "pyr-abc",
+        { myProp: 'yes', otherProp: 'no', id: 'skip' },
+        'pyr-abc',
         true,
         customFilter,
       )
-      expect(result.myProp).toBe("yes")
+      expect(result.myProp).toBe('yes')
       expect(result.otherProp).toBeUndefined()
       expect(result.id).toBeUndefined()
     })
 
-    it("customFilter still skips as and className from rawProps", () => {
+    it('customFilter still skips as and className from rawProps', () => {
       const customFilter = () => true
       const result = buildProps(
-        { as: "button", className: "user", id: "test" },
-        "pyr-abc",
+        { as: 'button', className: 'user', id: 'test' },
+        'pyr-abc',
         true,
         customFilter,
       )
       // as is always skipped
       expect(result.as).toBeUndefined()
       // class is merged, not forwarded from rawProps
-      expect(result.class).toBe("pyr-abc user")
-      expect(result.id).toBe("test")
+      expect(result.class).toBe('pyr-abc user')
+      expect(result.id).toBe('test')
     })
   })
 })

package/src/__tests__/globalStyle.test.ts

@@ -1,50 +1,50 @@
-import { afterEach, describe, expect, it } from "vitest"
-import { createGlobalStyle } from "../globalStyle"
-import { sheet } from "../sheet"
+import { afterEach, describe, expect, it } from 'vitest'
+import { createGlobalStyle } from '../globalStyle'
+import { sheet } from '../sheet'
 
-describe("createGlobalStyle -- empty CSS paths", () => {
+describe('createGlobalStyle -- empty CSS paths', () => {
   afterEach(() => {
     sheet.clearAll()
   })
 
-  it("static: returns null for empty template", () => {
+  it('static: returns null for empty template', () => {
     const GlobalStyle = createGlobalStyle``
     const result = GlobalStyle({})
     expect(result).toBeNull()
   })
 
-  it("static: returns null for whitespace-only template", () => {
+  it('static: returns null for whitespace-only template', () => {
     const GlobalStyle = createGlobalStyle`   `
     const result = GlobalStyle({})
     expect(result).toBeNull()
   })
 
-  it("dynamic: returns null when interpolation resolves to empty CSS", () => {
-    const GlobalStyle = createGlobalStyle`${({ theme }: any) => (theme.empty ? "" : "")}`
+  it('dynamic: returns null when interpolation resolves to empty CSS', () => {
+    const GlobalStyle = createGlobalStyle`${({ theme }: any) => (theme.empty ? '' : '')}`
     const result = GlobalStyle({})
     expect(result).toBeNull()
   })
 
-  it("dynamic: returns null when interpolation resolves to whitespace", () => {
-    const GlobalStyle = createGlobalStyle`${() => "   "}`
+  it('dynamic: returns null when interpolation resolves to whitespace', () => {
+    const GlobalStyle = createGlobalStyle`${() => '   '}`
     const result = GlobalStyle({})
     expect(result).toBeNull()
   })
 })
 
-describe("createGlobalStyle", () => {
+describe('createGlobalStyle', () => {
   afterEach(() => {
     sheet.clearAll()
   })
 
-  it("returns a component function", () => {
+  it('returns a component function', () => {
     const GlobalStyle = createGlobalStyle`
       body { margin: 0; }
     `
-    expect(typeof GlobalStyle).toBe("function")
+    expect(typeof GlobalStyle).toBe('function')
   })
 
-  it("renders nothing (returns null)", () => {
+  it('renders nothing (returns null)', () => {
     const GlobalStyle = createGlobalStyle`
       body { margin: 0; padding: 0; }
     `
@@ -52,17 +52,17 @@ describe("createGlobalStyle", () => {
     expect(result).toBeNull()
   })
 
-  it("handles dynamic interpolations with theme", () => {
+  it('handles dynamic interpolations with theme', () => {
     // Dynamic path: function interpolation causes per-render resolution
     const GlobalStyle = createGlobalStyle`
-      body { font-family: ${({ theme }: any) => theme?.font ?? "sans-serif"}; }
+      body { font-family: ${({ theme }: any) => theme?.font ?? 'sans-serif'}; }
     `
     const result = GlobalStyle({})
     expect(result).toBeNull()
   })
 
-  it("handles static interpolations", () => {
-    const color = "red"
+  it('handles static interpolations', () => {
+    const color = 'red'
     const GlobalStyle = createGlobalStyle`
       body { color: ${color}; }
     `

package/src/__tests__/hash.test.ts

@@ -1,59 +1,59 @@
-import { describe, expect, it } from "vitest"
-import { hash } from "../hash"
+import { describe, expect, it } from 'vitest'
+import { hash } from '../hash'
 
-describe("hash", () => {
-  it("returns a string", () => {
-    expect(typeof hash("test")).toBe("string")
+describe('hash', () => {
+  it('returns a string', () => {
+    expect(typeof hash('test')).toBe('string')
   })
 
-  it("is deterministic — same input always produces same output", () => {
-    const input = "display: flex; color: red;"
+  it('is deterministic — same input always produces same output', () => {
+    const input = 'display: flex; color: red;'
     expect(hash(input)).toBe(hash(input))
   })
 
-  it("produces different hashes for different inputs", () => {
-    expect(hash("color: red")).not.toBe(hash("color: blue"))
+  it('produces different hashes for different inputs', () => {
+    expect(hash('color: red')).not.toBe(hash('color: blue'))
   })
 
-  it("returns base-36 string (compact)", () => {
-    const result = hash("some css")
+  it('returns base-36 string (compact)', () => {
+    const result = hash('some css')
     expect(result).toMatch(/^[0-9a-z]+$/)
   })
 
-  it("handles empty string", () => {
-    const result = hash("")
-    expect(typeof result).toBe("string")
+  it('handles empty string', () => {
+    const result = hash('')
+    expect(typeof result).toBe('string')
     expect(result.length).toBeGreaterThan(0)
   })
 
-  it("handles long CSS strings", () => {
-    const longCSS = "display: flex; ".repeat(100)
+  it('handles long CSS strings', () => {
+    const longCSS = 'display: flex; '.repeat(100)
     const result = hash(longCSS)
-    expect(typeof result).toBe("string")
+    expect(typeof result).toBe('string')
     // base-36 uint32 is at most 7 chars
     expect(result.length).toBeLessThan(10)
   })
 
-  it("handles special characters in CSS", () => {
+  it('handles special characters in CSS', () => {
     const css = `@media (min-width: 48em) { .foo { content: "hello"; } }`
     const result = hash(css)
-    expect(typeof result).toBe("string")
+    expect(typeof result).toBe('string')
   })
 
-  it("produces consistent hash for FNV-1a offset basis on empty string", () => {
+  it('produces consistent hash for FNV-1a offset basis on empty string', () => {
     // Empty string: h stays at FNV_OFFSET = 2166136261, base36 = "zzzzzz" range
-    const result = hash("")
+    const result = hash('')
     // Just verify it is stable
-    expect(result).toBe(hash(""))
+    expect(result).toBe(hash(''))
   })
 
-  it("handles unicode characters", () => {
+  it('handles unicode characters', () => {
     const result = hash('content: "🎉";')
-    expect(typeof result).toBe("string")
+    expect(typeof result).toBe('string')
     expect(result.length).toBeGreaterThan(0)
   })
 
-  it("single character inputs produce distinct hashes", () => {
+  it('single character inputs produce distinct hashes', () => {
     const hashes = new Set<string>()
     for (let i = 0; i < 26; i++) {
       hashes.add(hash(String.fromCharCode(97 + i)))
@@ -62,9 +62,9 @@ describe("hash", () => {
     expect(hashes.size).toBe(26)
   })
 
-  it("hash is unsigned 32-bit (no negative values)", () => {
+  it('hash is unsigned 32-bit (no negative values)', () => {
     // base-36 of a uint32 is always positive
-    const result = hash("test negative")
+    const result = hash('test negative')
     expect(Number.parseInt(result, 36)).toBeGreaterThanOrEqual(0)
   })
 })