@pyreon/rocketstyle 0.11.5 → 0.11.7

package/src/__tests__/attrs.test.ts

@@ -3,102 +3,102 @@ import {
   calculateStylingAttrs,
   pickStyledAttrs,
   removeUndefinedProps,
-} from "../utils/attrs"
+} from '../utils/attrs'
 
-describe("removeUndefinedProps", () => {
-  it("removes keys with undefined values", () => {
-    const result = removeUndefinedProps({ a: 1, b: undefined, c: "hello" })
-    expect(result).toEqual({ a: 1, c: "hello" })
+describe('removeUndefinedProps', () => {
+  it('removes keys with undefined values', () => {
+    const result = removeUndefinedProps({ a: 1, b: undefined, c: 'hello' })
+    expect(result).toEqual({ a: 1, c: 'hello' })
   })
 
-  it("keeps null values", () => {
+  it('keeps null values', () => {
     const result = removeUndefinedProps({ a: null, b: 0 })
     expect(result).toEqual({ a: null, b: 0 })
   })
 
-  it("keeps all falsy non-undefined values", () => {
-    const result = removeUndefinedProps({ a: 0, b: "", c: false, d: null })
-    expect(result).toEqual({ a: 0, b: "", c: false, d: null })
+  it('keeps all falsy non-undefined values', () => {
+    const result = removeUndefinedProps({ a: 0, b: '', c: false, d: null })
+    expect(result).toEqual({ a: 0, b: '', c: false, d: null })
   })
 
-  it("returns empty for all undefined", () => {
+  it('returns empty for all undefined', () => {
     expect(removeUndefinedProps({ a: undefined, b: undefined })).toEqual({})
   })
 
-  it("returns empty for empty input", () => {
+  it('returns empty for empty input', () => {
     expect(removeUndefinedProps({})).toEqual({})
   })
 })
 
-describe("pickStyledAttrs", () => {
-  it("picks keys that exist in keywords with truthy values", () => {
+describe('pickStyledAttrs', () => {
+  it('picks keys that exist in keywords with truthy values', () => {
     const result = pickStyledAttrs(
-      { state: "primary", size: "large", label: "hello" },
+      { state: 'primary', size: 'large', label: 'hello' },
       { state: true, size: true },
     )
-    expect(result).toEqual({ state: "primary", size: "large" })
+    expect(result).toEqual({ state: 'primary', size: 'large' })
   })
 
-  it("ignores falsy prop values", () => {
-    const result = pickStyledAttrs({ state: "", size: "large" }, { state: true, size: true })
-    expect(result).toEqual({ size: "large" })
+  it('ignores falsy prop values', () => {
+    const result = pickStyledAttrs({ state: '', size: 'large' }, { state: true, size: true })
+    expect(result).toEqual({ size: 'large' })
   })
 
-  it("returns empty when no keywords match", () => {
-    const result = pickStyledAttrs({ label: "hello" } as any, { state: true })
+  it('returns empty when no keywords match', () => {
+    const result = pickStyledAttrs({ label: 'hello' } as any, { state: true })
     expect(result).toEqual({})
   })
 
-  it("returns empty for empty props", () => {
+  it('returns empty for empty props', () => {
     const result = pickStyledAttrs({}, { state: true })
     expect(result).toEqual({})
   })
 })
 
-describe("calculateChainOptions", () => {
-  it("returns empty object when options is empty array", () => {
+describe('calculateChainOptions', () => {
+  it('returns empty object when options is empty array', () => {
     const calc = calculateChainOptions([])
     expect(calc([])).toEqual({})
   })
 
-  it("returns empty object when options is undefined", () => {
+  it('returns empty object when options is undefined', () => {
     const calc = calculateChainOptions(undefined)
     expect(calc([])).toEqual({})
   })
 
-  it("evaluates chain of functions and merges via Object.assign", () => {
+  it('evaluates chain of functions and merges via Object.assign', () => {
     const fn1 = (props: any) => ({ a: 1, ...props })
     const fn2 = (_props: any) => ({ b: 2 })
     const calc = calculateChainOptions([fn1, fn2])
     expect(calc([{ c: 3 }])).toEqual({ a: 1, b: 2, c: 3 })
   })
 
-  it("later functions override earlier ones (shallow)", () => {
+  it('later functions override earlier ones (shallow)', () => {
     const fn1 = () => ({ a: 1 })
     const fn2 = () => ({ a: 2 })
     const calc = calculateChainOptions([fn1, fn2])
     expect(calc([])).toEqual({ a: 2 })
   })
 
-  it("passes all args to each function", () => {
+  it('passes all args to each function', () => {
     const fn = vi.fn(() => ({}))
     const calc = calculateChainOptions([fn])
-    calc(["arg1", "arg2"] as any)
-    expect(fn).toHaveBeenCalledWith("arg1", "arg2")
+    calc(['arg1', 'arg2'] as any)
+    expect(fn).toHaveBeenCalledWith('arg1', 'arg2')
   })
 })
 
-describe("calculateStylingAttrs", () => {
-  it("picks string values from props for dimensions", () => {
+describe('calculateStylingAttrs', () => {
+  it('picks string values from props for dimensions', () => {
     const calc = calculateStylingAttrs({ useBooleans: false, multiKeys: {} })
     const result = calc({
-      props: { state: "primary", size: "large" },
+      props: { state: 'primary', size: 'large' },
       dimensions: { state: {}, size: {} },
     })
-    expect(result).toEqual({ state: "primary", size: "large" })
+    expect(result).toEqual({ state: 'primary', size: 'large' })
   })
 
-  it("picks number values from props", () => {
+  it('picks number values from props', () => {
     const calc = calculateStylingAttrs({ useBooleans: false, multiKeys: {} })
     const result = calc({
       props: { state: 0 },
@@ -107,7 +107,7 @@ describe("calculateStylingAttrs", () => {
     expect(result).toEqual({ state: 0 })
   })
 
-  it("sets undefined for non-string/non-number values when booleans disabled", () => {
+  it('sets undefined for non-string/non-number values when booleans disabled', () => {
     const calc = calculateStylingAttrs({ useBooleans: false, multiKeys: {} })
     const result = calc({
       props: { state: true },
@@ -116,19 +116,19 @@ describe("calculateStylingAttrs", () => {
     expect(result).toEqual({ state: undefined })
   })
 
-  it("allows arrays for multi-key dimensions", () => {
+  it('allows arrays for multi-key dimensions', () => {
     const calc = calculateStylingAttrs({
       useBooleans: false,
       multiKeys: { multiple: true },
     })
     const result = calc({
-      props: { multiple: ["a", "b"] },
+      props: { multiple: ['a', 'b'] },
       dimensions: { multiple: {} },
     })
-    expect(result).toEqual({ multiple: ["a", "b"] })
+    expect(result).toEqual({ multiple: ['a', 'b'] })
   })
 
-  it("resolves boolean props when useBooleans is true (single key)", () => {
+  it('resolves boolean props when useBooleans is true (single key)', () => {
     const calc = calculateStylingAttrs({
       useBooleans: true,
       multiKeys: {},
@@ -137,10 +137,10 @@ describe("calculateStylingAttrs", () => {
       props: { primary: true },
       dimensions: { state: { primary: true, secondary: true } },
     })
-    expect(result).toEqual({ state: "primary" })
+    expect(result).toEqual({ state: 'primary' })
   })
 
-  it("resolves multi-key boolean props as array", () => {
+  it('resolves multi-key boolean props as array', () => {
     const calc = calculateStylingAttrs({
       useBooleans: true,
       multiKeys: { multiple: true },
@@ -149,22 +149,22 @@ describe("calculateStylingAttrs", () => {
       props: { a: true, b: true },
       dimensions: { multiple: { a: true, b: true, c: true } },
     })
-    expect(result.multiple).toEqual(expect.arrayContaining(["a", "b"]))
+    expect(result.multiple).toEqual(expect.arrayContaining(['a', 'b']))
   })
 
-  it("prefers explicit string prop over boolean shorthand", () => {
+  it('prefers explicit string prop over boolean shorthand', () => {
     const calc = calculateStylingAttrs({
       useBooleans: true,
       multiKeys: {},
     })
     const result = calc({
-      props: { state: "secondary", primary: true },
+      props: { state: 'secondary', primary: true },
       dimensions: { state: { primary: true, secondary: true } },
     })
-    expect(result).toEqual({ state: "secondary" })
+    expect(result).toEqual({ state: 'secondary' })
   })
 
-  it("skips boolean keyword when prop value is falsy", () => {
+  it('skips boolean keyword when prop value is falsy', () => {
     const calc = calculateStylingAttrs({
       useBooleans: true,
       multiKeys: {},
@@ -176,15 +176,15 @@ describe("calculateStylingAttrs", () => {
     expect(result.state).toBeUndefined()
   })
 
-  it("skips boolean resolution when value is already set", () => {
+  it('skips boolean resolution when value is already set', () => {
     const calc = calculateStylingAttrs({
       useBooleans: true,
       multiKeys: {},
     })
     const result = calc({
-      props: { state: "primary", secondary: true },
+      props: { state: 'primary', secondary: true },
       dimensions: { state: { primary: true, secondary: true } },
     })
-    expect(result.state).toBe("primary")
+    expect(result.state).toBe('primary')
   })
 })

package/src/__tests__/chaining.test.ts

@@ -1,7 +1,7 @@
-import { chainOptions, chainOrOptions, chainReservedKeyOptions } from "../utils/chaining"
+import { chainOptions, chainOrOptions, chainReservedKeyOptions } from '../utils/chaining'
 
-describe("chainOptions", () => {
-  it("appends function to defaults", () => {
+describe('chainOptions', () => {
+  it('appends function to defaults', () => {
     const fn1 = () => ({ a: 1 })
     const fn2 = () => ({ b: 2 })
     const result = chainOptions(fn2, [fn1])
@@ -10,26 +10,26 @@ describe("chainOptions", () => {
     expect(result[1]).toBe(fn2)
   })
 
-  it("wraps object in function and appends", () => {
+  it('wraps object in function and appends', () => {
     const obj = { a: 1 }
     const result = chainOptions(obj, [])
     expect(result).toHaveLength(1)
     expect(result[0]?.()).toEqual({ a: 1 })
   })
 
-  it("returns defaults when opts is undefined", () => {
+  it('returns defaults when opts is undefined', () => {
     const fn1 = () => ({ a: 1 })
     const result = chainOptions(undefined, [fn1])
     expect(result).toEqual([fn1])
   })
 
-  it("handles empty defaults", () => {
+  it('handles empty defaults', () => {
     const fn = () => ({ a: 1 })
     const result = chainOptions(fn, [])
     expect(result).toHaveLength(1)
   })
 
-  it("defaults to empty array when defaultOpts missing", () => {
+  it('defaults to empty array when defaultOpts missing', () => {
     const fn = () => ({ a: 1 })
     // @ts-expect-error testing with undefined defaults
     const result = chainOptions(fn, undefined)
@@ -37,33 +37,33 @@ describe("chainOptions", () => {
   })
 })
 
-describe("chainOrOptions", () => {
-  it("merges opts with defaults using keys", () => {
-    const keys = ["a", "b", "c"] as const
-    const opts = { a: "new", c: "also" }
-    const defaults = { a: "old", b: "default", c: "orig" }
+describe('chainOrOptions', () => {
+  it('merges opts with defaults using keys', () => {
+    const keys = ['a', 'b', 'c'] as const
+    const opts = { a: 'new', c: 'also' }
+    const defaults = { a: 'old', b: 'default', c: 'orig' }
     const result = chainOrOptions(keys, opts, defaults)
-    expect(result).toEqual({ a: "new", b: "default", c: "also" })
+    expect(result).toEqual({ a: 'new', b: 'default', c: 'also' })
   })
 
-  it("uses default when opt is falsy", () => {
-    const keys = ["a"] as const
-    const opts = { a: "" }
-    const defaults = { a: "default" }
+  it('uses default when opt is falsy', () => {
+    const keys = ['a'] as const
+    const opts = { a: '' }
+    const defaults = { a: 'default' }
     const result = chainOrOptions(keys, opts, defaults)
-    expect(result).toEqual({ a: "default" })
+    expect(result).toEqual({ a: 'default' })
   })
 
-  it("handles missing keys in both", () => {
-    const keys = ["x"] as const
+  it('handles missing keys in both', () => {
+    const keys = ['x'] as const
     const result = chainOrOptions(keys, {}, {})
     expect(result).toEqual({ x: undefined })
   })
 })
 
-describe("chainReservedKeyOptions", () => {
-  it("chains options for each reserved key", () => {
-    const keys = ["theme", "styles"] as const
+describe('chainReservedKeyOptions', () => {
+  it('chains options for each reserved key', () => {
+    const keys = ['theme', 'styles'] as const
     const fn1 = () => ({ a: 1 })
     const fn2 = () => ({ b: 2 })
     const opts = { theme: fn2 }
@@ -74,13 +74,13 @@ describe("chainReservedKeyOptions", () => {
     expect(result.styles).toHaveLength(0)
   })
 
-  it("wraps object opts into functions", () => {
-    const keys = ["theme"] as const
-    const opts = { theme: { color: "red" } }
+  it('wraps object opts into functions', () => {
+    const keys = ['theme'] as const
+    const opts = { theme: { color: 'red' } }
     const defaults = { theme: [] }
 
     const result = chainReservedKeyOptions(keys, opts, defaults)
     expect(result.theme).toHaveLength(1)
-    expect(result.theme?.[0]?.()).toEqual({ color: "red" })
+    expect(result.theme?.[0]?.()).toEqual({ color: 'red' })
   })
 })

package/src/__tests__/collection.test.ts

@@ -1,35 +1,35 @@
-import { removeNullableValues } from "../utils/collection"
+import { removeNullableValues } from '../utils/collection'
 
-describe("removeNullableValues", () => {
-  it("removes null values", () => {
+describe('removeNullableValues', () => {
+  it('removes null values', () => {
     expect(removeNullableValues({ a: 1, b: null })).toEqual({ a: 1 })
   })
 
-  it("removes undefined values", () => {
+  it('removes undefined values', () => {
     expect(removeNullableValues({ a: 1, b: undefined })).toEqual({ a: 1 })
   })
 
-  it("removes false values", () => {
+  it('removes false values', () => {
     expect(removeNullableValues({ a: 1, b: false })).toEqual({ a: 1 })
   })
 
-  it("keeps truthy values", () => {
-    expect(removeNullableValues({ a: 1, b: "hello", c: true })).toEqual({
+  it('keeps truthy values', () => {
+    expect(removeNullableValues({ a: 1, b: 'hello', c: true })).toEqual({
       a: 1,
-      b: "hello",
+      b: 'hello',
       c: true,
     })
   })
 
-  it("keeps zero and empty string", () => {
-    expect(removeNullableValues({ a: 0, b: "" })).toEqual({ a: 0, b: "" })
+  it('keeps zero and empty string', () => {
+    expect(removeNullableValues({ a: 0, b: '' })).toEqual({ a: 0, b: '' })
   })
 
-  it("returns empty object for all nullable", () => {
+  it('returns empty object for all nullable', () => {
     expect(removeNullableValues({ a: null, b: undefined, c: false })).toEqual({})
   })
 
-  it("handles empty object", () => {
+  it('handles empty object', () => {
     expect(removeNullableValues({})).toEqual({})
   })
 })

package/src/__tests__/compose.test.ts

@@ -1,7 +1,7 @@
-import { calculateHocsFuncs } from "../utils/compose"
+import { calculateHocsFuncs } from '../utils/compose'
 
-describe("calculateHocsFuncs", () => {
-  it("extracts functions from object values", () => {
+describe('calculateHocsFuncs', () => {
+  it('extracts functions from object values', () => {
     const fn1 = (x: any) => x
     const fn2 = (x: any) => x
     const options = { a: fn1, b: fn2 }
@@ -9,28 +9,28 @@ describe("calculateHocsFuncs", () => {
     expect(result).toHaveLength(2)
   })
 
-  it("filters out non-function values", () => {
+  it('filters out non-function values', () => {
     const fn = (x: any) => x
-    const options = { a: fn, b: "string", c: 42, d: null }
+    const options = { a: fn, b: 'string', c: 42, d: null }
     const result = calculateHocsFuncs(options)
     expect(result).toHaveLength(1)
     expect(result[0]).toBe(fn)
   })
 
-  it("reverses the order", () => {
-    const fn1 = () => "first"
-    const fn2 = () => "second"
+  it('reverses the order', () => {
+    const fn1 = () => 'first'
+    const fn2 = () => 'second'
     const options = { a: fn1, b: fn2 }
     const result = calculateHocsFuncs(options)
     expect(result[0]).toBe(fn2)
     expect(result[1]).toBe(fn1)
   })
 
-  it("returns empty array for empty options", () => {
+  it('returns empty array for empty options', () => {
     expect(calculateHocsFuncs({})).toEqual([])
   })
 
-  it("handles undefined options", () => {
+  it('handles undefined options', () => {
     expect(calculateHocsFuncs(undefined as any)).toEqual([])
   })
 })