@pyreon/attrs 0.11.4 → 0.11.6

package/src/__tests__/attrsHoc.test.ts

@@ -1,98 +1,98 @@
-import createAttrsHOC from "../hoc/attrsHoc"
+import createAttrsHOC from '../hoc/attrsHoc'
 
 const Receiver = (props: any) => ({
-  type: "div",
-  props: { ...props, "data-testid": "receiver" },
-  children: props.label ?? "",
+  type: 'div',
+  props: { ...props, 'data-testid': 'receiver' },
+  children: props.label ?? '',
   key: null,
 })
 
 // --------------------------------------------------------
 // attrsHoc - props merging
 // --------------------------------------------------------
-describe("attrsHoc - props merging", () => {
-  it("should pass through props unchanged when no attrs defined", () => {
+describe('attrsHoc - props merging', () => {
+  it('should pass through props unchanged when no attrs defined', () => {
     const hoc = createAttrsHOC({ attrs: [], priorityAttrs: [] })
     const Enhanced = hoc(Receiver)
 
-    const result = Enhanced({ label: "hello", "data-custom": "yes" }) as any
-    expect(result.children).toBe("hello")
-    expect(result.props["data-custom"]).toBe("yes")
+    const result = Enhanced({ label: 'hello', 'data-custom': 'yes' }) as any
+    expect(result.children).toBe('hello')
+    expect(result.props['data-custom']).toBe('yes')
   })
 
-  it("should apply attrs as default props", () => {
+  it('should apply attrs as default props', () => {
     const hoc = createAttrsHOC({
-      attrs: [(_props: any) => ({ label: "default" })],
+      attrs: [(_props: any) => ({ label: 'default' })],
       priorityAttrs: [],
     })
     const Enhanced = hoc(Receiver)
 
     const result = Enhanced({}) as any
-    expect(result.children).toBe("default")
+    expect(result.children).toBe('default')
   })
 
-  it("should let explicit props override attrs", () => {
+  it('should let explicit props override attrs', () => {
     const hoc = createAttrsHOC({
-      attrs: [() => ({ label: "from-attrs" })],
+      attrs: [() => ({ label: 'from-attrs' })],
       priorityAttrs: [],
     })
     const Enhanced = hoc(Receiver)
 
-    const result = Enhanced({ label: "explicit" }) as any
-    expect(result.children).toBe("explicit")
+    const result = Enhanced({ label: 'explicit' }) as any
+    expect(result.children).toBe('explicit')
   })
 
-  it("should apply priorityAttrs with lowest precedence", () => {
+  it('should apply priorityAttrs with lowest precedence', () => {
     const hoc = createAttrsHOC({
-      attrs: [(_props: any) => ({ label: "from-attrs" })],
-      priorityAttrs: [(_props: any) => ({ label: "from-priority" })],
+      attrs: [(_props: any) => ({ label: 'from-attrs' })],
+      priorityAttrs: [(_props: any) => ({ label: 'from-priority' })],
     })
     const Enhanced = hoc(Receiver)
 
     const result = Enhanced({}) as any
-    expect(result.children).toBe("from-attrs")
+    expect(result.children).toBe('from-attrs')
   })
 
-  it("should merge results from multiple attrs functions", () => {
+  it('should merge results from multiple attrs functions', () => {
     const hoc = createAttrsHOC({
-      attrs: [() => ({ "data-first": "a" }), () => ({ "data-second": "b" })],
+      attrs: [() => ({ 'data-first': 'a' }), () => ({ 'data-second': 'b' })],
       priorityAttrs: [],
     })
     const Enhanced = hoc(Receiver)
 
     const result = Enhanced({}) as any
-    expect(result.props["data-first"]).toBe("a")
-    expect(result.props["data-second"]).toBe("b")
+    expect(result.props['data-first']).toBe('a')
+    expect(result.props['data-second']).toBe('b')
   })
 
-  it("should remove undefined props so they dont override defaults", () => {
+  it('should remove undefined props so they dont override defaults', () => {
     const hoc = createAttrsHOC({
-      attrs: [() => ({ label: "default-label" })],
+      attrs: [() => ({ label: 'default-label' })],
       priorityAttrs: [],
     })
     const Enhanced = hoc(Receiver)
 
     const result = Enhanced({ label: undefined }) as any
-    expect(result.children).toBe("default-label")
+    expect(result.children).toBe('default-label')
   })
 
-  it("should allow null to override defaults", () => {
+  it('should allow null to override defaults', () => {
     const hoc = createAttrsHOC({
-      attrs: [() => ({ label: "default-label" })],
+      attrs: [() => ({ label: 'default-label' })],
       priorityAttrs: [],
     })
     const Enhanced = hoc(Receiver)
 
     const result = Enhanced({ label: null }) as any
-    expect(result.children).toBe("")
+    expect(result.children).toBe('')
   })
 })
 
 // --------------------------------------------------------
 // attrsHoc - attrs callback receives props
 // --------------------------------------------------------
-describe("attrsHoc - attrs callback receives props", () => {
-  it("should pass filtered props to attrs callback", () => {
+describe('attrsHoc - attrs callback receives props', () => {
+  it('should pass filtered props to attrs callback', () => {
     const attrsFn = vi.fn(() => ({}))
     const hoc = createAttrsHOC({
       attrs: [attrsFn],
@@ -100,13 +100,13 @@ describe("attrsHoc - attrs callback receives props", () => {
     })
     const Enhanced = hoc(Receiver)
 
-    Enhanced({ variant: "primary", size: "lg" })
+    Enhanced({ variant: 'primary', size: 'lg' })
     expect(attrsFn).toHaveBeenCalledWith(
-      expect.objectContaining({ variant: "primary", size: "lg" }),
+      expect.objectContaining({ variant: 'primary', size: 'lg' }),
     )
   })
 
-  it("should pass priority attrs merged with props to attrs callback", () => {
+  it('should pass priority attrs merged with props to attrs callback', () => {
     const attrsFn = vi.fn(() => ({}))
     const hoc = createAttrsHOC({
       attrs: [attrsFn],
@@ -114,9 +114,9 @@ describe("attrsHoc - attrs callback receives props", () => {
     })
     const Enhanced = hoc(Receiver)
 
-    Enhanced({ variant: "primary" })
+    Enhanced({ variant: 'primary' })
     expect(attrsFn).toHaveBeenCalledWith(
-      expect.objectContaining({ variant: "primary", fromPriority: true }),
+      expect.objectContaining({ variant: 'primary', fromPriority: true }),
     )
   })
 })
@@ -124,8 +124,8 @@ describe("attrsHoc - attrs callback receives props", () => {
 // --------------------------------------------------------
 // attrsHoc - ref passthrough
 // --------------------------------------------------------
-describe("attrsHoc - ref passthrough", () => {
-  it("should pass ref as a normal prop to wrapped component", () => {
+describe('attrsHoc - ref passthrough', () => {
+  it('should pass ref as a normal prop to wrapped component', () => {
     const hoc = createAttrsHOC({ attrs: [], priorityAttrs: [] })
     const Enhanced = hoc(Receiver)
 

package/src/__tests__/utils.test.ts

@@ -1,54 +1,54 @@
-import { calculateChainOptions, removeUndefinedProps } from "../utils/attrs"
-import { chainOptions } from "../utils/chaining"
-import { removeNullableValues } from "../utils/collection"
-import { calculateHocsFuncs } from "../utils/compose"
-import { createStaticsEnhancers } from "../utils/statics"
+import { calculateChainOptions, removeUndefinedProps } from '../utils/attrs'
+import { chainOptions } from '../utils/chaining'
+import { removeNullableValues } from '../utils/collection'
+import { calculateHocsFuncs } from '../utils/compose'
+import { createStaticsEnhancers } from '../utils/statics'
 
 // --------------------------------------------------------
 // removeUndefinedProps
 // --------------------------------------------------------
-describe("removeUndefinedProps", () => {
-  it("should remove properties with undefined values", () => {
+describe('removeUndefinedProps', () => {
+  it('should remove properties with undefined values', () => {
     const result = removeUndefinedProps({
       a: 1,
       b: undefined,
-      c: "hello",
+      c: 'hello',
     })
-    expect(result).toEqual({ a: 1, c: "hello" })
+    expect(result).toEqual({ a: 1, c: 'hello' })
   })
 
-  it("should keep null values", () => {
+  it('should keep null values', () => {
     const result = removeUndefinedProps({ a: null, b: undefined })
     expect(result).toEqual({ a: null })
   })
 
-  it("should keep false values", () => {
+  it('should keep false values', () => {
     const result = removeUndefinedProps({ a: false, b: undefined })
     expect(result).toEqual({ a: false })
   })
 
-  it("should keep zero values", () => {
+  it('should keep zero values', () => {
     const result = removeUndefinedProps({ a: 0, b: undefined })
     expect(result).toEqual({ a: 0 })
   })
 
-  it("should keep empty string values", () => {
-    const result = removeUndefinedProps({ a: "", b: undefined })
-    expect(result).toEqual({ a: "" })
+  it('should keep empty string values', () => {
+    const result = removeUndefinedProps({ a: '', b: undefined })
+    expect(result).toEqual({ a: '' })
   })
 
-  it("should return empty object when all values are undefined", () => {
+  it('should return empty object when all values are undefined', () => {
     const result = removeUndefinedProps({ a: undefined, b: undefined })
     expect(result).toEqual({})
   })
 
-  it("should return all props when none are undefined", () => {
-    const input = { a: 1, b: "test", c: true }
+  it('should return all props when none are undefined', () => {
+    const input = { a: 1, b: 'test', c: true }
     const result = removeUndefinedProps(input)
     expect(result).toEqual(input)
   })
 
-  it("should handle empty object", () => {
+  it('should handle empty object', () => {
     const result = removeUndefinedProps({})
     expect(result).toEqual({})
   })
@@ -57,38 +57,38 @@ describe("removeUndefinedProps", () => {
 // --------------------------------------------------------
 // removeNullableValues
 // --------------------------------------------------------
-describe("removeNullableValues", () => {
-  it("should remove null values", () => {
+describe('removeNullableValues', () => {
+  it('should remove null values', () => {
     const result = removeNullableValues({ a: 1, b: null })
     expect(result).toEqual({ a: 1 })
   })
 
-  it("should remove undefined values", () => {
+  it('should remove undefined values', () => {
     const result = removeNullableValues({ a: 1, b: undefined })
     expect(result).toEqual({ a: 1 })
   })
 
-  it("should remove false values", () => {
+  it('should remove false values', () => {
     const result = removeNullableValues({ a: 1, b: false })
     expect(result).toEqual({ a: 1 })
   })
 
-  it("should keep zero values", () => {
+  it('should keep zero values', () => {
     const result = removeNullableValues({ a: 0, b: null })
     expect(result).toEqual({ a: 0 })
   })
 
-  it("should keep empty string values", () => {
-    const result = removeNullableValues({ a: "", b: null })
-    expect(result).toEqual({ a: "" })
+  it('should keep empty string values', () => {
+    const result = removeNullableValues({ a: '', b: null })
+    expect(result).toEqual({ a: '' })
   })
 
-  it("should keep truthy values", () => {
-    const result = removeNullableValues({ a: 1, b: "test", c: true })
-    expect(result).toEqual({ a: 1, b: "test", c: true })
+  it('should keep truthy values', () => {
+    const result = removeNullableValues({ a: 1, b: 'test', c: true })
+    expect(result).toEqual({ a: 1, b: 'test', c: true })
   })
 
-  it("should handle empty object", () => {
+  it('should handle empty object', () => {
     const result = removeNullableValues({})
     expect(result).toEqual({})
   })
@@ -97,48 +97,48 @@ describe("removeNullableValues", () => {
 // --------------------------------------------------------
 // calculateChainOptions
 // --------------------------------------------------------
-describe("calculateChainOptions", () => {
-  it("should return empty object when no options provided", () => {
+describe('calculateChainOptions', () => {
+  it('should return empty object when no options provided', () => {
     const calculate = calculateChainOptions(undefined)
     const result = calculate([{}])
     expect(result).toEqual({})
   })
 
-  it("should return empty object for empty options array", () => {
+  it('should return empty object for empty options array', () => {
     const calculate = calculateChainOptions([])
     const result = calculate([{}])
     expect(result).toEqual({})
   })
 
-  it("should execute a single option function", () => {
+  it('should execute a single option function', () => {
     const fn = (props: any) => ({
-      color: props.variant === "primary" ? "blue" : "gray",
+      color: props.variant === 'primary' ? 'blue' : 'gray',
     })
     const calculate = calculateChainOptions([fn])
-    const result = calculate([{ variant: "primary" }])
-    expect(result).toEqual({ color: "blue" })
+    const result = calculate([{ variant: 'primary' }])
+    expect(result).toEqual({ color: 'blue' })
   })
 
-  it("should merge results from multiple option functions", () => {
-    const fn1 = (_: any) => ({ color: "blue" })
-    const fn2 = (_: any) => ({ size: "large" })
+  it('should merge results from multiple option functions', () => {
+    const fn1 = (_: any) => ({ color: 'blue' })
+    const fn2 = (_: any) => ({ size: 'large' })
     const calculate = calculateChainOptions([fn1, fn2])
     const result = calculate([{}])
-    expect(result).toEqual({ color: "blue", size: "large" })
+    expect(result).toEqual({ color: 'blue', size: 'large' })
   })
 
-  it("should let later functions override earlier ones", () => {
-    const fn1 = (_: any) => ({ color: "blue" })
-    const fn2 = (_: any) => ({ color: "red" })
+  it('should let later functions override earlier ones', () => {
+    const fn1 = (_: any) => ({ color: 'blue' })
+    const fn2 = (_: any) => ({ color: 'red' })
     const calculate = calculateChainOptions([fn1, fn2])
     const result = calculate([{}])
-    expect(result).toEqual({ color: "red" })
+    expect(result).toEqual({ color: 'red' })
   })
 
-  it("should pass arguments to each option function", () => {
+  it('should pass arguments to each option function', () => {
     const fn = vi.fn((_: any) => ({}))
     const calculate = calculateChainOptions([fn])
-    const props = { variant: "primary" }
+    const props = { variant: 'primary' }
     calculate([props])
     expect(fn).toHaveBeenCalledWith(props)
   })
@@ -147,14 +147,14 @@ describe("calculateChainOptions", () => {
 // --------------------------------------------------------
 // chainOptions
 // --------------------------------------------------------
-describe("chainOptions", () => {
-  it("should return default options when opts is undefined", () => {
+describe('chainOptions', () => {
+  it('should return default options when opts is undefined', () => {
     const defaults = [() => ({})]
     const result = chainOptions(undefined, defaults)
     expect(result).toEqual(defaults)
   })
 
-  it("should append function to defaults", () => {
+  it('should append function to defaults', () => {
     const fn1 = () => ({ a: 1 })
     const fn2 = () => ({ b: 2 })
     const result = chainOptions(fn2, [fn1])
@@ -163,19 +163,19 @@ describe("chainOptions", () => {
     expect(result[1]).toBe(fn2)
   })
 
-  it("should wrap object in a function and append", () => {
-    const obj = { color: "blue" }
+  it('should wrap object in a function and append', () => {
+    const obj = { color: 'blue' }
     const result = chainOptions(obj, [])
     expect(result).toHaveLength(1)
     expect(result[0]?.()).toEqual(obj)
   })
 
-  it("should return empty array when no defaults and undefined opts", () => {
+  it('should return empty array when no defaults and undefined opts', () => {
     const result = chainOptions(undefined, [])
     expect(result).toEqual([])
   })
 
-  it("should not mutate the defaults array", () => {
+  it('should not mutate the defaults array', () => {
     const defaults = [() => ({})]
     const fn = () => ({ a: 1 })
     const result = chainOptions(fn, defaults)
@@ -187,46 +187,46 @@ describe("chainOptions", () => {
 // --------------------------------------------------------
 // createStaticsEnhancers
 // --------------------------------------------------------
-describe("createStaticsEnhancers", () => {
-  it("should assign options to context", () => {
+describe('createStaticsEnhancers', () => {
+  it('should assign options to context', () => {
     const context: Record<string, any> = {}
     createStaticsEnhancers({
       context,
-      options: { theme: "dark", variant: "primary" },
+      options: { theme: 'dark', variant: 'primary' },
     })
-    expect(context).toEqual({ theme: "dark", variant: "primary" })
+    expect(context).toEqual({ theme: 'dark', variant: 'primary' })
   })
 
-  it("should not modify context when options is empty", () => {
+  it('should not modify context when options is empty', () => {
     const context: Record<string, any> = { existing: true }
     createStaticsEnhancers({ context, options: {} })
     expect(context).toEqual({ existing: true })
   })
 
-  it("should merge with existing context properties", () => {
+  it('should merge with existing context properties', () => {
     const context: Record<string, any> = { existing: true }
-    createStaticsEnhancers({ context, options: { newProp: "value" } })
-    expect(context).toEqual({ existing: true, newProp: "value" })
+    createStaticsEnhancers({ context, options: { newProp: 'value' } })
+    expect(context).toEqual({ existing: true, newProp: 'value' })
   })
 })
 
 // --------------------------------------------------------
 // calculateHocsFuncs
 // --------------------------------------------------------
-describe("calculateHocsFuncs", () => {
-  it("should return empty array for empty options", () => {
+describe('calculateHocsFuncs', () => {
+  it('should return empty array for empty options', () => {
     const result = calculateHocsFuncs({})
     expect(result).toEqual([])
   })
 
-  it("should filter out non-function values", () => {
+  it('should filter out non-function values', () => {
     const fn = (x: any) => x
-    const result = calculateHocsFuncs({ a: fn, b: "string", c: 123 })
+    const result = calculateHocsFuncs({ a: fn, b: 'string', c: 123 })
     expect(result).toHaveLength(1)
     expect(result[0]).toBe(fn)
   })
 
-  it("should reverse the order of functions", () => {
+  it('should reverse the order of functions', () => {
     const fn1 = (x: any) => x
     const fn2 = (x: any) => x
     const result = calculateHocsFuncs({ a: fn1, b: fn2 })
@@ -234,7 +234,7 @@ describe("calculateHocsFuncs", () => {
     expect(result[1]).toBe(fn1)
   })
 
-  it("should return empty array for undefined input", () => {
+  it('should return empty array for undefined input', () => {
     const result = calculateHocsFuncs(undefined as any)
     expect(result).toEqual([])
   })

package/src/attrs.ts

@@ -1,12 +1,12 @@
-import { compose, hoistNonReactStatics, omit, pick } from "@pyreon/ui-core"
-import { attrsHoc } from "./hoc"
-import type { AttrsComponent as AttrsComponentType } from "./types/AttrsComponent"
-import type { Configuration, ExtendedConfiguration } from "./types/configuration"
-import type { InitAttrsComponent } from "./types/InitAttrsComponent"
-import { calculateChainOptions } from "./utils/attrs"
-import { chainOptions } from "./utils/chaining"
-import { calculateHocsFuncs } from "./utils/compose"
-import { createStaticsEnhancers } from "./utils/statics"
+import { compose, hoistNonReactStatics, omit, pick } from '@pyreon/ui-core'
+import { attrsHoc } from './hoc'
+import type { AttrsComponent as AttrsComponentType } from './types/AttrsComponent'
+import type { Configuration, ExtendedConfiguration } from './types/configuration'
+import type { InitAttrsComponent } from './types/InitAttrsComponent'
+import { calculateChainOptions } from './utils/attrs'
+import { chainOptions } from './utils/chaining'
+import { calculateHocsFuncs } from './utils/compose'
+import { createStaticsEnhancers } from './utils/statics'
 
 /**
  * Clones the current configuration and merges new options, then creates a
@@ -62,8 +62,8 @@ const attrsComponent: InitAttrsComponent = (options) => {
     const filteredProps = needsFiltering ? omit(props, options.filterAttrs) : props
 
     const finalProps =
-      process.env.NODE_ENV !== "production"
-        ? { ...filteredProps, "data-attrs": componentName }
+      process.env.NODE_ENV !== 'production'
+        ? { ...filteredProps, 'data-attrs': componentName }
         : filteredProps
 
     return RenderComponent(finalProps)
@@ -97,12 +97,12 @@ const attrsComponent: InitAttrsComponent = (options) => {
       }
 
       if (priority) {
-        result.priorityAttrs = attrs as ExtendedConfiguration["priorityAttrs"]
+        result.priorityAttrs = attrs as ExtendedConfiguration['priorityAttrs']
 
         return cloneAndEnhance(options, result)
       }
 
-      result.attrs = attrs as ExtendedConfiguration["attrs"]
+      result.attrs = attrs as ExtendedConfiguration['attrs']
 
       return cloneAndEnhance(options, result)
     },

package/src/hoc/attrsHoc.ts

@@ -1,11 +1,11 @@
-import type { Configuration } from "../types/configuration"
-import type { ComponentFn } from "../types/utils"
-import { calculateChainOptions, removeUndefinedProps } from "../utils/attrs"
+import type { Configuration } from '../types/configuration'
+import type { ComponentFn } from '../types/utils'
+import { calculateChainOptions, removeUndefinedProps } from '../utils/attrs'
 
 export type AttrsStyleHOC = ({
   attrs,
   priorityAttrs,
-}: Pick<Configuration, "attrs" | "priorityAttrs">) => (
+}: Pick<Configuration, 'attrs' | 'priorityAttrs'>) => (
   WrappedComponent: ComponentFn<any>,
 ) => ComponentFn<any>
 

package/src/hoc/index.ts

@@ -1,3 +1,3 @@
-import attrsHoc from "./attrsHoc"
+import attrsHoc from './attrsHoc'
 
 export { attrsHoc }

package/src/index.ts

@@ -1,12 +1,12 @@
-import type { Attrs } from "./init"
-import attrs from "./init"
-import type { IsAttrsComponent } from "./isAttrsComponent"
-import isAttrsComponent from "./isAttrsComponent"
-import type { AttrsComponent } from "./types/AttrsComponent"
-import type { AttrsCb } from "./types/attrs"
-import type { AttrsComponentType, ConfigAttrs } from "./types/config"
-import type { ComposeParam, GenericHoc } from "./types/hoc"
-import type { ComponentFn, ElementType, TObj } from "./types/utils"
+import type { Attrs } from './init'
+import attrs from './init'
+import type { IsAttrsComponent } from './isAttrsComponent'
+import isAttrsComponent from './isAttrsComponent'
+import type { AttrsComponent } from './types/AttrsComponent'
+import type { AttrsCb } from './types/attrs'
+import type { AttrsComponentType, ConfigAttrs } from './types/config'
+import type { ComposeParam, GenericHoc } from './types/hoc'
+import type { ComponentFn, ElementType, TObj } from './types/utils'
 
 export type {
   Attrs,

package/src/init.ts

@@ -1,7 +1,7 @@
-import { isEmpty } from "@pyreon/ui-core"
-import attrsComponent from "./attrs"
-import type { InitAttrsComponent } from "./types/InitAttrsComponent"
-import type { ElementType } from "./types/utils"
+import { isEmpty } from '@pyreon/ui-core'
+import attrsComponent from './attrs'
+import type { InitAttrsComponent } from './types/InitAttrsComponent'
+import type { ElementType } from './types/utils'
 
 /**
  * Public entry point for creating an attrs-enhanced component.
@@ -24,7 +24,7 @@ export type Attrs = <C extends ElementType>({
 
 const attrs: Attrs = ({ name, component }) => {
   // Validate required params in development — fail fast with clear errors.
-  if (process.env.NODE_ENV !== "production") {
+  if (process.env.NODE_ENV !== 'production') {
     type Errors = Partial<{
       component: string
       name: string
@@ -32,11 +32,11 @@ const attrs: Attrs = ({ name, component }) => {
 
     const errors: Errors = {}
     if (!component) {
-      errors.component = "Parameter `component` is missing in params!"
+      errors.component = 'Parameter `component` is missing in params!'
     }
 
     if (!name) {
-      errors.name = "Parameter `name` is missing in params!"
+      errors.name = 'Parameter `name` is missing in params!'
     }
 
     if (!isEmpty(errors)) {

package/src/isAttrsComponent.ts

@@ -4,8 +4,8 @@ export type IsAttrsComponent = <T>(component: T) => boolean
 const isAttrsComponent: IsAttrsComponent = (component) => {
   if (
     component &&
-    (typeof component === "object" || typeof component === "function") &&
-    Object.hasOwn(component as object, "IS_ATTRS")
+    (typeof component === 'object' || typeof component === 'function') &&
+    Object.hasOwn(component as object, 'IS_ATTRS')
   ) {
     return true
   }

package/src/types/AttrsComponent.ts

@@ -1,15 +1,15 @@
-import type { VNode } from "@pyreon/core"
-import type { AttrsCb } from "./attrs"
-import type { ConfigAttrs } from "./config"
-import type { ComposeParam } from "./hoc"
-import type { ElementType, ExtractProps, MergeTypes, TObj } from "./utils"
+import type { VNode } from '@pyreon/core'
+import type { AttrsCb } from './attrs'
+import type { ConfigAttrs } from './config'
+import type { ComposeParam } from './hoc'
+import type { ElementType, ExtractProps, MergeTypes, TObj } from './utils'
 
 /**
  * Props passed to the inner enhanced component.
  * In Pyreon there's no forwardRef — ref flows as a normal prop.
  */
 export type InnerComponentProps = {
-  "data-attrs"?: string | undefined
+  'data-attrs'?: string | undefined
 }
 
 /**