react-native-unistyles 3.0.23 → 3.1.0

package/src/types/accessibility.ts

@@ -11,7 +11,7 @@ export enum IOSContentSizeCategory {
     Medium = 'Medium',
     Small = 'Small',
     ExtraSmall = 'xSmall',
-    Unspecified = 'unspecified'
+    Unspecified = 'unspecified',
 }
 
 export enum AndroidContentSizeCategory {
@@ -21,7 +21,7 @@ export enum AndroidContentSizeCategory {
     ExtraLarge = 'ExtraLarge',
     Huge = 'Huge',
     ExtraHuge = 'ExtraHuge',
-    ExtraExtraHuge = 'ExtraExtraHuge'
+    ExtraExtraHuge = 'ExtraExtraHuge',
 }
 
 export enum WebContentSizeCategory {

package/src/types/breakpoints.ts

@@ -1,22 +1,21 @@
 import type { ColorValue, OpaqueColorValue } from 'react-native'
+
 import type { SafeReturnType, UnionToIntersection } from './common'
 import type { TransformStyles } from './core'
 import type { BreakpointsOrMediaQueries, ToDeepUnistyles } from './stylesheet'
 
-type ExtractTransformArray<T> = T extends object
-    ? { [K in keyof T]: ExtractBreakpoints<T[K]> }
-    : never
+type ExtractTransformArray<T> = T extends object ? { [K in keyof T]: ExtractBreakpoints<T[K]> } : never
 
 type ExtractBreakpoints<T> = T extends object
     ? keyof T extends BreakpointsOrMediaQueries
         ? T[keyof T]
         : T extends Array<ToDeepUnistyles<TransformStyles>>
-            ? Array<ExtractTransformArray<T[number]>>
-            : T extends Array<infer _U>
-                ? T
-                : {
-                    [K in keyof T]: ExtractBreakpoints<T[K]>
-                }
+          ? Array<ExtractTransformArray<T[number]>>
+          : T extends Array<infer _U>
+            ? T
+            : {
+                  [K in keyof T]: ExtractBreakpoints<T[K]>
+              }
     : T
 
 // Helper type to check if the base styles (without variants) are truly empty or just {}
@@ -25,48 +24,53 @@ type IsEmptyObject<T> = T extends Record<string, never> ? true : keyof T extends
 type ParseNestedObject<T, ShouldFlatten> = T extends (...args: infer A) => infer R
     ? (...args: A) => ParseNestedObject<R, false>
     : T extends object
-        ? T extends { variants: infer R, compoundVariants: infer C }
-            ? (ParseVariants<FlattenVariants<R, false>> & FlattenCompoundVariants<C, false> & ParseNestedObject<Omit<T, 'variants' | 'compoundVariants'>, false>) extends never
-                ? ParseVariants<FlattenVariants<R, true>> & FlattenCompoundVariants<C, true> & ParseNestedObject<Omit<T, 'variants' | 'compoundVariants'>, false>
-                : ParseVariants<FlattenVariants<R, false>> & FlattenCompoundVariants<C, false> & ParseNestedObject<Omit<T, 'variants' | 'compoundVariants'>, false>
-            : T extends { variants: infer R }
-                ? IsEmptyObject<ParseNestedObject<Omit<T, 'variants'>, false>> extends true
-                    ? ParseVariants<FlattenVariants<R, false>>
-                    : (ParseVariants<FlattenVariants<R, false>> & ParseNestedObject<Omit<T, 'variants'>, false>) extends never
-                        ? ParseVariants<FlattenVariants<R, true>> & ParseNestedObject<Omit<T, 'variants'>, false>
-                        : ParseVariants<FlattenVariants<R, false>> & ParseNestedObject<Omit<T, 'variants'>, false>
-                : T extends { compoundVariants: object }
-                    ? ParseNestedObject<Omit<T, 'compoundVariants'>, false>
-                    : {
-                        [K in keyof T as K extends '_web' ? never : K]: T[K] extends object
-                            ? T[K] extends OpaqueColorValue
-                                ? ColorValue
-                                : ExtractBreakpoints<T[K]>
-                            : T[K] extends string
-                                ? ShouldFlatten extends true
-                                    ? string
-                                    : T[K]
-                                : T[K]
-                    }
-        : T
+      ? T extends { variants: infer R; compoundVariants: infer C }
+          ? ParseVariants<FlattenVariants<R, false>> &
+                FlattenCompoundVariants<C, false> &
+                ParseNestedObject<Omit<T, 'variants' | 'compoundVariants'>, false> extends never
+              ? ParseVariants<FlattenVariants<R, true>> &
+                    FlattenCompoundVariants<C, true> &
+                    ParseNestedObject<Omit<T, 'variants' | 'compoundVariants'>, false>
+              : ParseVariants<FlattenVariants<R, false>> &
+                    FlattenCompoundVariants<C, false> &
+                    ParseNestedObject<Omit<T, 'variants' | 'compoundVariants'>, false>
+          : T extends { variants: infer R }
+            ? IsEmptyObject<ParseNestedObject<Omit<T, 'variants'>, false>> extends true
+                ? ParseVariants<FlattenVariants<R, false>>
+                : ParseVariants<FlattenVariants<R, false>> & ParseNestedObject<Omit<T, 'variants'>, false> extends never
+                  ? ParseVariants<FlattenVariants<R, true>> & ParseNestedObject<Omit<T, 'variants'>, false>
+                  : ParseVariants<FlattenVariants<R, false>> & ParseNestedObject<Omit<T, 'variants'>, false>
+            : T extends { compoundVariants: object }
+              ? ParseNestedObject<Omit<T, 'compoundVariants'>, false>
+              : {
+                    [K in keyof T as K extends '_web' ? never : K]: T[K] extends object
+                        ? T[K] extends OpaqueColorValue
+                            ? ColorValue
+                            : ExtractBreakpoints<T[K]>
+                        : T[K] extends string
+                          ? ShouldFlatten extends true
+                              ? string
+                              : T[K]
+                          : T[K]
+                }
+      : T
 
 type FlattenVariants<T, ShouldFlatten> = T extends object
     ? {
-        [K in keyof T]: T[K] extends object
-            ? {
-                [key in keyof T[K]]: T[K][key] extends object
-                    ? ParseNestedObject<T[K][key], ShouldFlatten>
-                    : never
-            }
-            : never
-    }
+          [K in keyof T]: T[K] extends object
+              ? {
+                    [key in keyof T[K]]: T[K][key] extends object ? ParseNestedObject<T[K][key], ShouldFlatten> : never
+                }
+              : never
+      }
     : never
 
-type FlattenCompoundVariants<T, ShouldFlatten> = T extends Array<infer _>
-    ? FlattenCompoundVariants<T[number], ShouldFlatten>
-    : T extends { styles: infer S }
-        ? ParseNestedObject<S, ShouldFlatten>
-        : never
+type FlattenCompoundVariants<T, ShouldFlatten> =
+    T extends Array<infer _>
+        ? FlattenCompoundVariants<T[number], ShouldFlatten>
+        : T extends { styles: infer S }
+          ? ParseNestedObject<S, ShouldFlatten>
+          : never
 
 type IsNonEmpty<T> = T extends object ? (keyof T extends never ? false : true) : false
 
@@ -74,18 +78,18 @@ type IntersectCategoryValues<T> = T extends object
     ? T extends Array<any>
         ? T
         : UnionToIntersection<T[keyof T]> extends infer R
-            ? R extends never
-                ? T[keyof T]
-                : R
-            : never
+          ? R extends never
+              ? T[keyof T]
+              : R
+          : never
     : never
 
 type MergeVariantCategories<T> = T extends object
     ? UnionToIntersection<
-        {
-            [K in keyof T]: IsNonEmpty<T[K]> extends true ? T[K] : never
-        }[keyof T]
-    > extends infer R
+          {
+              [K in keyof T]: IsNonEmpty<T[K]> extends true ? T[K] : never
+          }[keyof T]
+      > extends infer R
         ? R extends never
             ? NonNullable<T[keyof T]>
             : R
@@ -97,13 +101,11 @@ type ParseVariants<T> = T extends object
         ? T[keyof T] extends Array<any>
             ? T
             : MergeVariantCategories<{
-                [K in keyof T]: T[K] extends object ? IntersectCategoryValues<T[K]> : never
-            }>
+                  [K in keyof T]: T[K] extends object ? IntersectCategoryValues<T[K]> : never
+              }>
         : T
     : T
 
-type ParseStyleKeys<T> = T extends object
-    ? { [K in keyof T]: ParseNestedObject<T[K], false> }
-    : never
+type ParseStyleKeys<T> = T extends object ? { [K in keyof T]: ParseNestedObject<T[K], false> } : never
 
 export type ReactNativeStyleSheet<T> = ParseStyleKeys<SafeReturnType<T>>

package/src/types/core.ts

@@ -12,32 +12,32 @@ import type {
     SkewXTransform,
     SkewYTransform,
     TranslateXTransform,
-    TranslateYTransform
+    TranslateYTransform,
 } from 'react-native/Libraries/StyleSheet/StyleSheetTypes'
+
 import type { UnistylesBreakpoints, UnistylesThemes } from '../global'
 
 export type ShadowOffset = {
-    width: number,
+    width: number
     height: number
 }
 
-export type TransformStyles =
-    & PerspectiveTransform
-    & RotateTransform
-    & RotateXTransform
-    & RotateYTransform
-    & RotateZTransform
-    & ScaleTransform
-    & ScaleXTransform
-    & ScaleYTransform
-    & TranslateXTransform
-    & TranslateYTransform
-    & SkewXTransform
-    & SkewYTransform
-    & MatrixTransform
+export type TransformStyles = PerspectiveTransform &
+    RotateTransform &
+    RotateXTransform &
+    RotateYTransform &
+    RotateZTransform &
+    ScaleTransform &
+    ScaleXTransform &
+    ScaleYTransform &
+    TranslateXTransform &
+    TranslateYTransform &
+    SkewXTransform &
+    SkewYTransform &
+    MatrixTransform
 
 export type ScreenSize = {
-    width: number,
+    width: number
     height: number
 }
 

package/src/types/index.ts

@@ -1,12 +1,5 @@
 export type { Optional, Nullable, UnionToIntersection } from './common'
-export type {
-    NestedStylePairs,
-    UnistylesTheme,
-    ScreenSize,
-    NestedStyle,
-    RNValue,
-    RNStyle
-} from './core'
+export type { NestedStylePairs, UnistylesTheme, ScreenSize, NestedStyle, RNValue, RNStyle } from './core'
 export type {
     CreateUnistylesStyleSheet,
     StyleSheet,
@@ -14,7 +7,7 @@ export type {
     UnistylesValues,
     UnistyleText,
     UnistyleView,
-    UnistyleImage
+    UnistyleImage,
 } from './stylesheet'
 export type { ReactNativeStyleSheet } from './breakpoints'
 export type { ExtractVariantNames, UnistylesVariants } from './variants'

package/src/types/stylesheet.ts

@@ -1,5 +1,6 @@
 import type { CSSProperties } from 'react'
 import type { BoxShadowValue, FilterFunction, ImageStyle, TextStyle, ViewStyle } from 'react-native'
+
 import type { UnistylesBreakpoints } from '../global'
 import type { UnistylesMiniRuntime } from '../specs'
 import type { Pseudo } from '../web/convert/pseudo'
@@ -15,10 +16,10 @@ export type UnistyleText = Omit<TextStyle, NestedKeys>
 export type UnistyleImage = Omit<ImageStyle, NestedKeys>
 
 type UnistyleNestedStyles = {
-    shadowOffset?: ToDeepUnistyles<ShadowOffset>,
-    textShadowOffset?: ToDeepUnistyles<ShadowOffset>,
-    transform?: Array<ToDeepUnistyles<TransformStyles>>,
-    boxShadow?: Array<ToDeepUnistyles<BoxShadowValue>> | string,
+    shadowOffset?: ToDeepUnistyles<ShadowOffset>
+    textShadowOffset?: ToDeepUnistyles<ShadowOffset>
+    transform?: Array<ToDeepUnistyles<TransformStyles>>
+    boxShadow?: Array<ToDeepUnistyles<BoxShadowValue>> | string
     filter?: Array<ToDeepUnistyles<FilterFunction>> | string
 }
 
@@ -37,14 +38,16 @@ type CompoundVariant = {
 }
 
 type VariantsAndCompoundVariants = {
-    variants?: VariantsObject,
+    variants?: VariantsObject
     compoundVariants?: Array<CompoundVariant>
 }
 
 export type ToDeepUnistyles<T> = {
-    [K in keyof T]?: T[K] | {
-        [key in BreakpointsOrMediaQueries]?: T[K]
-    }
+    [K in keyof T]?:
+        | T[K]
+        | {
+              [key in BreakpointsOrMediaQueries]?: T[K]
+          }
 }
 
 type AllAvailableStyles = UnistyleView & UnistyleText & UnistyleImage & UnistyleNestedStyles
@@ -53,19 +56,21 @@ export type AllAvailableKeys = keyof (UnistyleView & UnistyleText & UnistyleImag
 export type BreakpointsOrMediaQueries = keyof UnistylesBreakpoints | symbol
 
 type FlatUnistylesValues = {
-    [propName in AllAvailableKeys]?: AllAvailableStyles[propName] | {
-        [key in BreakpointsOrMediaQueries]?: AllAvailableStyles[propName]
-    }
+    [propName in AllAvailableKeys]?:
+        | AllAvailableStyles[propName]
+        | {
+              [key in BreakpointsOrMediaQueries]?: AllAvailableStyles[propName]
+          }
 }
 
-export type UnistylesValues = FlatUnistylesValues & {
-} & VariantsAndCompoundVariants & {
-    [propName in NestedKeys]?: UnistyleNestedStyles[propName]
-} & {
-    _web?: ToDeepUnistyles<CSSProperties> & CustomClassName & {
-        [propName in Pseudo]?: ToDeepUnistyles<CSSProperties>
+export type UnistylesValues = FlatUnistylesValues & {} & VariantsAndCompoundVariants & {
+        [propName in NestedKeys]?: UnistyleNestedStyles[propName]
+    } & {
+        _web?: ToDeepUnistyles<CSSProperties> &
+            CustomClassName & {
+                [propName in Pseudo]?: ToDeepUnistyles<CSSProperties>
+            }
     }
-}
 
 export type StyleSheet = {
     [styleName: string]: UnistylesValues | ((...args: any) => UnistylesValues)
@@ -79,6 +84,9 @@ type UseVariantsFn<T> = {
     useVariants: (variants: ExtractVariantNames<T>) => void
 }
 
-const create = <S extends StyleSheet>(stylesheet: StyleSheetWithSuperPowers<S>): (ReactNativeStyleSheet<S> & UseVariantsFn<typeof stylesheet>) => stylesheet as (ReactNativeStyleSheet<S> & UseVariantsFn<typeof stylesheet>)
+const create = <S extends StyleSheet>(
+    stylesheet: StyleSheetWithSuperPowers<S>,
+): ReactNativeStyleSheet<S> & UseVariantsFn<typeof stylesheet> =>
+    stylesheet as ReactNativeStyleSheet<S> & UseVariantsFn<typeof stylesheet>
 
 export type CreateUnistylesStyleSheet = typeof create

package/src/types/variants.ts

@@ -2,15 +2,9 @@ import type { SafeReturnType } from './common'
 
 export type ExtractVariantNames<T> = ExtractVariantKeys<SafeReturnType<T>>
 
-type ExtractVariantKeys<T> = T extends object
-    ? ExtractVariant<SafeReturnType<T[keyof T]>>
-    : never
+type ExtractVariantKeys<T> = T extends object ? ExtractVariant<SafeReturnType<T[keyof T]>> : never
 
-type HasBooleanVariants<T> = T extends Record<'true', any>
-    ? true
-    : T extends Record<'false', any>
-        ? true
-        : false
+type HasBooleanVariants<T> = T extends Record<'true', any> ? true : T extends Record<'false', any> ? true : false
 
 type ExtractSubVariantKeys<T> = T extends object
     ? HasBooleanVariants<T> extends true
@@ -18,9 +12,7 @@ type ExtractSubVariantKeys<T> = T extends object
         : keyof Omit<T, 'default'> | undefined
     : never
 
-type ExtractVariant<T> = T extends { variants: infer V }
-    ? { [key in keyof V]?: ExtractSubVariantKeys<V[key]> }
-    : never
+type ExtractVariant<T> = T extends { variants: infer V } ? { [key in keyof V]?: ExtractSubVariantKeys<V[key]> } : never
 
 export type UnistylesVariants<ST> = ST extends { useVariants: infer V }
     ? V extends (variants: infer T) => void

package/src/utils.ts

@@ -3,22 +3,20 @@ export const isDefined = <T>(value: T): value is NonNullable<T> => value !== und
 export const deepMergeObjects = <T extends Record<PropertyKey, any>>(...sources: Array<T>) => {
     const target = {} as T
 
-    sources
-        .filter(isDefined)
-        .forEach(source => {
-            Object.keys(source).forEach(key => {
-                const sourceValue = source[key]
-                const targetValue = target[key]
+    sources.filter(isDefined).forEach((source) => {
+        Object.keys(source).forEach((key) => {
+            const sourceValue = source[key]
+            const targetValue = target[key]
 
-                if (Object(sourceValue) === sourceValue && Object(targetValue) === targetValue) {
-                    // @ts-expect-error - can't assign to generic
-                    target[key] = deepMergeObjects(targetValue, sourceValue)
+            if (Object(sourceValue) === sourceValue && Object(targetValue) === targetValue) {
+                // @ts-expect-error - can't assign to generic
+                target[key] = deepMergeObjects(targetValue, sourceValue)
 
-                    return
-                }
+                return
+            }
 
-                // @ts-expect-error - can't assign to generic
-                target[key] = sourceValue
+            // @ts-expect-error - can't assign to generic
+            target[key] = sourceValue
         })
     })
 
@@ -36,7 +34,7 @@ export const copyComponentProperties = (Component: any, UnistylesComponent: any)
     })
 
     UnistylesComponent.displayName = Component.displayName
-    
+
     return UnistylesComponent
 }
 
@@ -59,8 +57,10 @@ export const parseMq = (mq: string) => {
 }
 
 export const isValidMq = (parsedMQ: ReturnType<typeof parseMq>) => {
-    const isWidthValid = parsedMQ.minWidth === undefined || parsedMQ.maxWidth === undefined || parsedMQ.minWidth <= parsedMQ.maxWidth
-    const isHeightValid = parsedMQ.minHeight === undefined || parsedMQ.maxHeight === undefined || parsedMQ.minHeight <= parsedMQ.maxHeight
+    const isWidthValid =
+        parsedMQ.minWidth === undefined || parsedMQ.maxWidth === undefined || parsedMQ.minWidth <= parsedMQ.maxWidth
+    const isHeightValid =
+        parsedMQ.minHeight === undefined || parsedMQ.maxHeight === undefined || parsedMQ.minHeight <= parsedMQ.maxHeight
 
     return isWidthValid && isHeightValid
 }

package/src/web/convert/index.ts

@@ -1,6 +1,7 @@
 import type { UnistylesValues } from '../../types'
-import { deepMergeObjects } from '../../utils'
 import type { UnistylesRuntime } from '../runtime'
+
+import { deepMergeObjects } from '../../utils'
 import { getBoxShadow, getFilterStyle, getTransformStyle } from './object'
 import { isPseudo } from './pseudo'
 import { getBoxShadowStyle, getTextShadowStyle } from './shadow'
@@ -15,7 +16,10 @@ export const convertUnistyles = (value: UnistylesValues, runtime: UnistylesRunti
 
     const stylesArray = Object.entries(value).flatMap(([unistylesKey, unistylesValue]) => {
         // Keys to omit
-        if (['_classNames', '_web', 'variants', 'compoundVariants', 'uni__dependencies'].includes(unistylesKey) || unistylesKey.startsWith('unistyles_')) {
+        if (
+            ['_classNames', '_web', 'variants', 'compoundVariants', 'uni__dependencies'].includes(unistylesKey) ||
+            unistylesKey.startsWith('unistyles_')
+        ) {
             return []
         }
 

package/src/web/convert/object/boxShadow.ts

@@ -1,4 +1,5 @@
 import type { BoxShadowValue } from 'react-native'
+
 import { deepMergeObjects } from '../../../utils'
 import { keyInObject } from '../../utils'
 import { normalizeNumericValue } from '../utils'
@@ -11,43 +12,47 @@ const createBoxShadowValue = (style: BoxShadowValue) => {
 
 export const getBoxShadow = (boxShadow: Array<BoxShadowValue>) => {
     const breakpoints = new Set<string>()
-    boxShadow.forEach(shadow => {
+    boxShadow.forEach((shadow) => {
         const [key] = Object.keys(shadow)
         const value = shadow[key as keyof BoxShadowValue]
 
         // Breakpoints
         if (typeof value === 'object') {
-            Object.keys(value).forEach(breakpoint => breakpoints.add(breakpoint))
+            Object.keys(value).forEach((breakpoint) => breakpoints.add(breakpoint))
         }
     })
 
     if (breakpoints.size === 0) {
-        const boxShadowStyle = Object.fromEntries(boxShadow.map(shadow => {
-            const [key] = Object.keys(shadow)
-            return [key, shadow[key as keyof BoxShadowValue]]
-        })) as BoxShadowValue
+        const boxShadowStyle = Object.fromEntries(
+            boxShadow.map((shadow) => {
+                const [key] = Object.keys(shadow)
+                return [key, shadow[key as keyof BoxShadowValue]]
+            }),
+        ) as BoxShadowValue
 
         return {
-            boxShadow: createBoxShadowValue(boxShadowStyle)
+            boxShadow: createBoxShadowValue(boxShadowStyle),
         }
     }
 
-    const breakpointStyles = Array.from(breakpoints).map(breakpoint => {
-        const styles = Object.fromEntries(boxShadow.map(shadow => {
-            const [key] = Object.keys(shadow)
-            const value = shadow[key as keyof BoxShadowValue]
+    const breakpointStyles = Array.from(breakpoints).map((breakpoint) => {
+        const styles = Object.fromEntries(
+            boxShadow.map((shadow) => {
+                const [key] = Object.keys(shadow)
+                const value = shadow[key as keyof BoxShadowValue]
 
-            if (typeof value === 'object' && keyInObject(value, breakpoint)) {
-                return [key, value[breakpoint]]
-            }
+                if (typeof value === 'object' && keyInObject(value, breakpoint)) {
+                    return [key, value[breakpoint]]
+                }
 
-            return [key, value]
-        })) as BoxShadowValue
+                return [key, value]
+            }),
+        ) as BoxShadowValue
 
         return {
             [breakpoint]: {
-                boxShadow: createBoxShadowValue(styles)
-            }
+                boxShadow: createBoxShadowValue(styles),
+            },
         }
     })
 

package/src/web/convert/object/filter.ts

@@ -1,8 +1,10 @@
 import type { DropShadowValue } from 'react-native'
-import { isUnistylesMq } from '../../../utils'
+
 import type { UnistylesRuntime } from '../../runtime'
-import { hyphenate } from '../../utils'
 import type { Filters } from '../types'
+
+import { isUnistylesMq } from '../../../utils'
+import { hyphenate } from '../../utils'
 import { normalizeColor, normalizeNumericValue } from '../utils'
 import { getObjectStyle } from './objectStyle'
 
@@ -13,27 +15,42 @@ const getDropShadowStyle = (dropShadow: DropShadowValue) => {
 }
 
 export const getFilterStyle = (filters: Array<Filters>, runtime: UnistylesRuntime) => {
-    const restFilters = filters.filter(filter => Object.keys(filter)[0] !== 'dropShadow')
+    const restFilters = filters.filter((filter) => Object.keys(filter)[0] !== 'dropShadow')
     const dropShadow = (() => {
-        const dropShadowValue = filters.find(filter => Object.keys(filter)[0] === 'dropShadow')?.dropShadow as Record<string, any>
+        const dropShadowValue = filters.find((filter) => Object.keys(filter)[0] === 'dropShadow')?.dropShadow as Record<
+            string,
+            any
+        >
 
         if (typeof dropShadowValue !== 'object') {
             return []
         }
 
-        const breakpoints = Object.keys(dropShadowValue).filter(key => Object.keys(runtime.breakpoints).includes(key) || isUnistylesMq(key))
-        const breakpointsDropShadow = Object.fromEntries(breakpoints.map(breakpoint => [breakpoint, getDropShadowStyle(dropShadowValue[breakpoint])]))
+        const breakpoints = Object.keys(dropShadowValue).filter(
+            (key) => Object.keys(runtime.breakpoints).includes(key) || isUnistylesMq(key),
+        )
+        const breakpointsDropShadow = Object.fromEntries(
+            breakpoints.map((breakpoint) => [breakpoint, getDropShadowStyle(dropShadowValue[breakpoint])]),
+        )
 
         if (breakpoints.length === 0) {
-            return [{
-                dropShadow: getDropShadowStyle(dropShadowValue as DropShadowValue)
-            }]
+            return [
+                {
+                    dropShadow: getDropShadowStyle(dropShadowValue as DropShadowValue),
+                },
+            ]
         }
 
-        return [{
-            dropShadow: breakpointsDropShadow
-        }]
+        return [
+            {
+                dropShadow: breakpointsDropShadow,
+            },
+        ]
     })()
 
-    return getObjectStyle([...restFilters, ...dropShadow], 'filter', (key, value) => `${hyphenate(key)}(${normalizeNumericValue(value as number | string)})`)
+    return getObjectStyle(
+        [...restFilters, ...dropShadow],
+        'filter',
+        (key, value) => `${hyphenate(key)}(${normalizeNumericValue(value as number | string)})`,
+    )
 }