@pyreon/rocketstyle 0.11.5 → 0.11.6

package/src/__tests__/hooks.test.ts

@@ -1,34 +1,34 @@
-import { popContext, pushContext } from "@pyreon/core"
-import { context } from "../context/context"
-import { localContext, useLocalContext } from "../context/localContext"
-import usePseudoState from "../hooks/usePseudoState"
-import useThemeAttrs from "../hooks/useTheme"
-
-describe("usePseudoState", () => {
-  it("returns initial state with all false", () => {
+import { popContext, pushContext } from '@pyreon/core'
+import { buildThemeContextMap } from '@pyreon/test-utils'
+import { localContext, useLocalContext } from '../context/localContext'
+import usePseudoState from '../hooks/usePseudoState'
+import useThemeAttrs from '../hooks/useTheme'
+
+describe('usePseudoState', () => {
+  it('returns initial state with all false', () => {
     const { state } = usePseudoState({})
     expect(state.hover).toBe(false)
     expect(state.focus).toBe(false)
     expect(state.pressed).toBe(false)
   })
 
-  it("returns event handlers", () => {
+  it('returns event handlers', () => {
     const { events } = usePseudoState({})
-    expect(typeof events.onMouseEnter).toBe("function")
-    expect(typeof events.onMouseLeave).toBe("function")
-    expect(typeof events.onMouseDown).toBe("function")
-    expect(typeof events.onMouseUp).toBe("function")
-    expect(typeof events.onFocus).toBe("function")
-    expect(typeof events.onBlur).toBe("function")
+    expect(typeof events.onMouseEnter).toBe('function')
+    expect(typeof events.onMouseLeave).toBe('function')
+    expect(typeof events.onMouseDown).toBe('function')
+    expect(typeof events.onMouseUp).toBe('function')
+    expect(typeof events.onFocus).toBe('function')
+    expect(typeof events.onBlur).toBe('function')
   })
 
-  it("sets hover on mouseEnter", () => {
+  it('sets hover on mouseEnter', () => {
     const { state, events } = usePseudoState({})
     events.onMouseEnter({} as any)
     expect(state.hover).toBe(true)
   })
 
-  it("clears hover and pressed on mouseLeave", () => {
+  it('clears hover and pressed on mouseLeave', () => {
     const { state, events } = usePseudoState({})
     events.onMouseEnter({} as any)
     events.onMouseDown({} as any)
@@ -40,7 +40,7 @@ describe("usePseudoState", () => {
     expect(state.pressed).toBe(false)
   })
 
-  it("sets pressed on mouseDown, clears on mouseUp", () => {
+  it('sets pressed on mouseDown, clears on mouseUp', () => {
     const { state, events } = usePseudoState({})
     events.onMouseDown({} as any)
     expect(state.pressed).toBe(true)
@@ -49,7 +49,7 @@ describe("usePseudoState", () => {
     expect(state.pressed).toBe(false)
   })
 
-  it("sets focus on focus, clears on blur", () => {
+  it('sets focus on focus, clears on blur', () => {
     const { state, events } = usePseudoState({})
     events.onFocus({} as any)
     expect(state.focus).toBe(true)
@@ -58,7 +58,7 @@ describe("usePseudoState", () => {
     expect(state.focus).toBe(false)
   })
 
-  it("calls user-provided event handlers", () => {
+  it('calls user-provided event handlers', () => {
     const onMouseEnter = vi.fn()
     const onMouseLeave = vi.fn()
     const onMouseDown = vi.fn()
@@ -92,7 +92,7 @@ describe("usePseudoState", () => {
   })
 })
 
-describe("useThemeAttrs", () => {
+describe('useThemeAttrs', () => {
   let pushed = false
 
   afterEach(() => {
@@ -102,80 +102,51 @@ describe("useThemeAttrs", () => {
     }
   })
 
-  it("returns default values when no context", () => {
+  it('returns default values when no context', () => {
     const result = useThemeAttrs({ inversed: false })
     expect(result.theme).toEqual({})
-    expect(result.mode).toBe("light")
+    expect(result.mode).toBe('light')
     expect(result.isLight).toBe(true)
   })
 
-  it("reads theme from context", () => {
-    pushContext(
-      new Map([
-        [
-          context.id,
-          {
-            theme: { rootSize: 16 },
-            mode: "light",
-            isDark: false,
-            isLight: true,
-          },
-        ],
-      ]),
-    )
+  it('reads theme from context', () => {
+    pushContext(buildThemeContextMap())
     pushed = true
 
     const result = useThemeAttrs({ inversed: false })
     expect(result.theme).toEqual({ rootSize: 16 })
-    expect(result.mode).toBe("light")
+    expect(result.mode).toBe('light')
   })
 
-  it("inverts mode when inversed is true", () => {
-    pushContext(
-      new Map([
-        [
-          context.id,
-          {
-            theme: { rootSize: 16 },
-            mode: "light",
-            isDark: false,
-            isLight: true,
-          },
-        ],
-      ]),
-    )
+  it('inverts mode when inversed is true', () => {
+    pushContext(buildThemeContextMap())
     pushed = true
 
     const result = useThemeAttrs({ inversed: true })
-    expect(result.mode).toBe("dark")
+    expect(result.mode).toBe('dark')
     expect(result.isDark).toBe(true)
     expect(result.isLight).toBe(false)
   })
 
-  it("inverts dark to light", () => {
+  it('inverts dark to light', () => {
     pushContext(
-      new Map([
-        [
-          context.id,
-          {
-            theme: {},
-            mode: "dark",
-            isDark: true,
-            isLight: false,
-          },
-        ],
-      ]),
+      buildThemeContextMap({
+        theme: {},
+        mode: 'dark',
+        isDark: true,
+        isLight: false,
+      }),
     )
     pushed = true
 
     const result = useThemeAttrs({ inversed: true })
-    expect(result.mode).toBe("light")
+    expect(result.mode).toBe('light')
     expect(result.isDark).toBe(false)
     expect(result.isLight).toBe(true)
   })
 })
 
-describe("useLocalContext", () => {
+describe('useLocalContext', () => {
   let pushed = false
 
   afterEach(() => {
@@ -185,17 +156,17 @@ describe("useLocalContext", () => {
     }
   })
 
-  it("returns default pseudo when no consumer", () => {
+  it('returns default pseudo when no consumer', () => {
     const result = useLocalContext(null)
     expect(result).toEqual({ pseudo: {} })
   })
 
-  it("returns default pseudo when consumer is undefined", () => {
+  it('returns default pseudo when consumer is undefined', () => {
     const result = useLocalContext(undefined)
     expect(result).toEqual({ pseudo: {} })
   })
 
-  it("calls consumer with getter function", () => {
+  it('calls consumer with getter function', () => {
     pushContext(new Map([[localContext.id, { pseudo: { hover: true } }]]))
     pushed = true
 

package/src/__tests__/isRocketComponent.test.ts

@@ -1,30 +1,30 @@
-import isRocketComponent from "../isRocketComponent"
+import isRocketComponent from '../isRocketComponent'
 
-describe("isRocketComponent", () => {
-  it("returns true for object with IS_ROCKETSTYLE property", () => {
+describe('isRocketComponent', () => {
+  it('returns true for object with IS_ROCKETSTYLE property', () => {
     const component = { IS_ROCKETSTYLE: true }
     expect(isRocketComponent(component)).toBe(true)
   })
 
-  it("returns false for plain object without IS_ROCKETSTYLE", () => {
+  it('returns false for plain object without IS_ROCKETSTYLE', () => {
     expect(isRocketComponent({})).toBe(false)
   })
 
-  it("returns false for null", () => {
+  it('returns false for null', () => {
     expect(isRocketComponent(null)).toBe(false)
   })
 
-  it("returns false for undefined", () => {
+  it('returns false for undefined', () => {
     expect(isRocketComponent(undefined)).toBe(false)
   })
 
-  it("returns false for primitives", () => {
-    expect(isRocketComponent("string")).toBe(false)
+  it('returns false for primitives', () => {
+    expect(isRocketComponent('string')).toBe(false)
     expect(isRocketComponent(42)).toBe(false)
     expect(isRocketComponent(true)).toBe(false)
   })
 
-  it("returns false for plain functions without IS_ROCKETSTYLE", () => {
+  it('returns false for plain functions without IS_ROCKETSTYLE', () => {
     expect(
       isRocketComponent(() => {
         /* no-op */
@@ -32,7 +32,7 @@ describe("isRocketComponent", () => {
     ).toBe(false)
   })
 
-  it("returns true for functions with IS_ROCKETSTYLE", () => {
+  it('returns true for functions with IS_ROCKETSTYLE', () => {
     const fn = () => {
       /* no-op */
     }
@@ -40,7 +40,7 @@ describe("isRocketComponent", () => {
     expect(isRocketComponent(fn)).toBe(true)
   })
 
-  it("returns true even if IS_ROCKETSTYLE is falsy", () => {
+  it('returns true even if IS_ROCKETSTYLE is falsy', () => {
     // hasOwnProperty check only, doesn't check truthiness
     const component = { IS_ROCKETSTYLE: false }
     expect(isRocketComponent(component)).toBe(true)

package/src/__tests__/misc.test.ts

@@ -1,4 +1,4 @@
-import ThemeManager from "../cache/LocalThemeManager"
+import ThemeManager from '../cache/LocalThemeManager'
 import {
   ALL_RESERVED_KEYS,
   CONFIG_KEYS,
@@ -9,93 +9,93 @@ import {
   STYLING_KEYS,
   THEME_MODES,
   THEME_MODES_INVERSED,
-} from "../constants"
-import BOOLEAN_TAGS from "../constants/booleanTags"
-import DEFAULT_DIMENSIONS from "../constants/defaultDimensions"
-import { createStaticsChainingEnhancers, createStaticsEnhancers } from "../utils/statics"
-import { calculateStyles } from "../utils/styles"
-
-describe("createStaticsChainingEnhancers", () => {
-  it("attaches chaining methods for dimension keys + static keys", () => {
+} from '../constants'
+import BOOLEAN_TAGS from '../constants/booleanTags'
+import DEFAULT_DIMENSIONS from '../constants/defaultDimensions'
+import { createStaticsChainingEnhancers, createStaticsEnhancers } from '../utils/statics'
+import { calculateStyles } from '../utils/styles'
+
+describe('createStaticsChainingEnhancers', () => {
+  it('attaches chaining methods for dimension keys + static keys', () => {
     const context: Record<string, any> = {}
     const func = vi.fn()
 
     createStaticsChainingEnhancers({
       context,
-      dimensionKeys: ["states", "sizes"],
+      dimensionKeys: ['states', 'sizes'],
       func,
       options: {} as any,
     })
 
-    expect(typeof context.states).toBe("function")
-    expect(typeof context.sizes).toBe("function")
-    expect(typeof context.theme).toBe("function")
-    expect(typeof context.styles).toBe("function")
-    expect(typeof context.compose).toBe("function")
+    expect(typeof context.states).toBe('function')
+    expect(typeof context.sizes).toBe('function')
+    expect(typeof context.theme).toBe('function')
+    expect(typeof context.styles).toBe('function')
+    expect(typeof context.compose).toBe('function')
   })
 
-  it("calls func with options and key-value pair", () => {
+  it('calls func with options and key-value pair', () => {
     const context: Record<string, any> = {}
     const func = vi.fn()
-    const options = { some: "option" } as any
+    const options = { some: 'option' } as any
 
     createStaticsChainingEnhancers({
       context,
-      dimensionKeys: ["states"],
+      dimensionKeys: ['states'],
       func,
       options,
     })
 
-    context.states({ primary: { color: "red" } })
+    context.states({ primary: { color: 'red' } })
     expect(func).toHaveBeenCalledWith(options, {
-      states: { primary: { color: "red" } },
+      states: { primary: { color: 'red' } },
     })
   })
 })
 
-describe("createStaticsEnhancers", () => {
-  it("copies options to context", () => {
+describe('createStaticsEnhancers', () => {
+  it('copies options to context', () => {
     const context: Record<string, any> = {}
-    createStaticsEnhancers({ context, options: { foo: "bar", baz: 42 } })
-    expect(context.foo).toBe("bar")
+    createStaticsEnhancers({ context, options: { foo: 'bar', baz: 42 } })
+    expect(context.foo).toBe('bar')
     expect(context.baz).toBe(42)
   })
 
-  it("does nothing when options is empty", () => {
+  it('does nothing when options is empty', () => {
     const context: Record<string, any> = { existing: true }
     createStaticsEnhancers({ context, options: {} })
     expect(context).toEqual({ existing: true })
   })
 
-  it("does nothing when options is undefined", () => {
+  it('does nothing when options is undefined', () => {
     const context: Record<string, any> = { existing: true }
     createStaticsEnhancers({ context, options: undefined as any })
     expect(context).toEqual({ existing: true })
   })
 })
 
-describe("calculateStyles", () => {
-  it("returns empty array when styles is undefined", () => {
+describe('calculateStyles', () => {
+  it('returns empty array when styles is undefined', () => {
     expect(calculateStyles(undefined)).toEqual([])
   })
 
-  it("evaluates each style callback", () => {
-    const styleFn1 = () => "style1"
-    const styleFn2 = () => "style2"
+  it('evaluates each style callback', () => {
+    const styleFn1 = () => 'style1'
+    const styleFn2 = () => 'style2'
     const result = calculateStyles([styleFn1, styleFn2] as any)
     expect(result).toHaveLength(2)
-    expect(result[0]).toBe("style1")
-    expect(result[1]).toBe("style2")
+    expect(result[0]).toBe('style1')
+    expect(result[1]).toBe('style2')
   })
 
-  it("returns empty array for empty styles array", () => {
+  it('returns empty array for empty styles array', () => {
     const result = calculateStyles([])
     expect(result).toEqual([])
   })
 })
 
-describe("ThemeManager", () => {
-  it("creates instance with WeakMap caches", () => {
+describe('ThemeManager', () => {
+  it('creates instance with WeakMap caches', () => {
     const tm = new ThemeManager()
     expect(tm.baseTheme).toBeInstanceOf(WeakMap)
     expect(tm.dimensionsThemes).toBeInstanceOf(WeakMap)
@@ -105,100 +105,100 @@ describe("ThemeManager", () => {
     expect(tm.modeDimensionTheme.dark).toBeInstanceOf(WeakMap)
   })
 
-  it("caches and retrieves values", () => {
+  it('caches and retrieves values', () => {
     const tm = new ThemeManager()
     const key = {}
-    tm.baseTheme.set(key, { color: "red" })
-    expect(tm.baseTheme.get(key)).toEqual({ color: "red" })
+    tm.baseTheme.set(key, { color: 'red' })
+    expect(tm.baseTheme.get(key)).toEqual({ color: 'red' })
   })
 
-  it("mode caches are independent", () => {
+  it('mode caches are independent', () => {
     const tm = new ThemeManager()
     const key = {}
-    tm.modeBaseTheme.light.set(key, "light-theme")
-    tm.modeBaseTheme.dark.set(key, "dark-theme")
-    expect(tm.modeBaseTheme.light.get(key)).toBe("light-theme")
-    expect(tm.modeBaseTheme.dark.get(key)).toBe("dark-theme")
+    tm.modeBaseTheme.light.set(key, 'light-theme')
+    tm.modeBaseTheme.dark.set(key, 'dark-theme')
+    expect(tm.modeBaseTheme.light.get(key)).toBe('light-theme')
+    expect(tm.modeBaseTheme.dark.get(key)).toBe('dark-theme')
   })
 })
 
-describe("constants", () => {
-  it("MODE_DEFAULT is light", () => {
-    expect(MODE_DEFAULT).toBe("light")
+describe('constants', () => {
+  it('MODE_DEFAULT is light', () => {
+    expect(MODE_DEFAULT).toBe('light')
   })
 
-  it("PSEUDO_KEYS", () => {
-    expect(PSEUDO_KEYS).toEqual(["hover", "active", "focus", "pressed"])
+  it('PSEUDO_KEYS', () => {
+    expect(PSEUDO_KEYS).toEqual(['hover', 'active', 'focus', 'pressed'])
   })
 
-  it("PSEUDO_META_KEYS", () => {
-    expect(PSEUDO_META_KEYS).toEqual(["disabled", "readOnly"])
+  it('PSEUDO_META_KEYS', () => {
+    expect(PSEUDO_META_KEYS).toEqual(['disabled', 'readOnly'])
   })
 
-  it("THEME_MODES", () => {
+  it('THEME_MODES', () => {
     expect(THEME_MODES.light).toBe(true)
     expect(THEME_MODES.dark).toBe(true)
   })
 
-  it("THEME_MODES_INVERSED", () => {
-    expect(THEME_MODES_INVERSED.light).toBe("dark")
-    expect(THEME_MODES_INVERSED.dark).toBe("light")
+  it('THEME_MODES_INVERSED', () => {
+    expect(THEME_MODES_INVERSED.light).toBe('dark')
+    expect(THEME_MODES_INVERSED.dark).toBe('light')
   })
 
-  it("CONFIG_KEYS includes expected keys", () => {
-    expect(CONFIG_KEYS).toContain("provider")
-    expect(CONFIG_KEYS).toContain("consumer")
-    expect(CONFIG_KEYS).toContain("name")
-    expect(CONFIG_KEYS).toContain("component")
-    expect(CONFIG_KEYS).toContain("inversed")
-    expect(CONFIG_KEYS).toContain("passProps")
-    expect(CONFIG_KEYS).toContain("styled")
-    expect(CONFIG_KEYS).toContain("DEBUG")
+  it('CONFIG_KEYS includes expected keys', () => {
+    expect(CONFIG_KEYS).toContain('provider')
+    expect(CONFIG_KEYS).toContain('consumer')
+    expect(CONFIG_KEYS).toContain('name')
+    expect(CONFIG_KEYS).toContain('component')
+    expect(CONFIG_KEYS).toContain('inversed')
+    expect(CONFIG_KEYS).toContain('passProps')
+    expect(CONFIG_KEYS).toContain('styled')
+    expect(CONFIG_KEYS).toContain('DEBUG')
   })
 
-  it("STYLING_KEYS", () => {
-    expect(STYLING_KEYS).toEqual(["theme", "styles"])
+  it('STYLING_KEYS', () => {
+    expect(STYLING_KEYS).toEqual(['theme', 'styles'])
   })
 
-  it("STATIC_KEYS includes styling keys and compose", () => {
-    expect(STATIC_KEYS).toContain("theme")
-    expect(STATIC_KEYS).toContain("styles")
-    expect(STATIC_KEYS).toContain("compose")
+  it('STATIC_KEYS includes styling keys and compose', () => {
+    expect(STATIC_KEYS).toContain('theme')
+    expect(STATIC_KEYS).toContain('styles')
+    expect(STATIC_KEYS).toContain('compose')
   })
 
-  it("ALL_RESERVED_KEYS includes mode keys and others", () => {
-    expect(ALL_RESERVED_KEYS).toContain("light")
-    expect(ALL_RESERVED_KEYS).toContain("dark")
-    expect(ALL_RESERVED_KEYS).toContain("attrs")
-    expect(ALL_RESERVED_KEYS).toContain("theme")
-    expect(ALL_RESERVED_KEYS).toContain("compose")
+  it('ALL_RESERVED_KEYS includes mode keys and others', () => {
+    expect(ALL_RESERVED_KEYS).toContain('light')
+    expect(ALL_RESERVED_KEYS).toContain('dark')
+    expect(ALL_RESERVED_KEYS).toContain('attrs')
+    expect(ALL_RESERVED_KEYS).toContain('theme')
+    expect(ALL_RESERVED_KEYS).toContain('compose')
   })
 })
 
-describe("DEFAULT_DIMENSIONS", () => {
-  it("has states, sizes, variants, multiple", () => {
-    expect(DEFAULT_DIMENSIONS.states).toBe("state")
-    expect(DEFAULT_DIMENSIONS.sizes).toBe("size")
-    expect(DEFAULT_DIMENSIONS.variants).toBe("variant")
+describe('DEFAULT_DIMENSIONS', () => {
+  it('has states, sizes, variants, multiple', () => {
+    expect(DEFAULT_DIMENSIONS.states).toBe('state')
+    expect(DEFAULT_DIMENSIONS.sizes).toBe('size')
+    expect(DEFAULT_DIMENSIONS.variants).toBe('variant')
     expect(DEFAULT_DIMENSIONS.multiple).toEqual({
-      propName: "multiple",
+      propName: 'multiple',
       multi: true,
     })
   })
 })
 
-describe("BOOLEAN_TAGS", () => {
-  it("is an array of HTML boolean attributes", () => {
+describe('BOOLEAN_TAGS', () => {
+  it('is an array of HTML boolean attributes', () => {
     expect(Array.isArray(BOOLEAN_TAGS)).toBe(true)
-    expect(BOOLEAN_TAGS).toContain("disabled")
-    expect(BOOLEAN_TAGS).toContain("checked")
-    expect(BOOLEAN_TAGS).toContain("readOnly")
-    expect(BOOLEAN_TAGS).toContain("required")
-    expect(BOOLEAN_TAGS).toContain("hidden")
-    expect(BOOLEAN_TAGS).toContain("autoFocus")
+    expect(BOOLEAN_TAGS).toContain('disabled')
+    expect(BOOLEAN_TAGS).toContain('checked')
+    expect(BOOLEAN_TAGS).toContain('readOnly')
+    expect(BOOLEAN_TAGS).toContain('required')
+    expect(BOOLEAN_TAGS).toContain('hidden')
+    expect(BOOLEAN_TAGS).toContain('autoFocus')
   })
 
-  it("has more than 20 entries", () => {
+  it('has more than 20 entries', () => {
     expect(BOOLEAN_TAGS.length).toBeGreaterThan(20)
   })
 })