react-native-unistyles 3.5.2 → 3.6.0

package/src/unifiber/src/fiber.ts

@@ -0,0 +1,262 @@
+// The only module that reads React's fiber fields. A missing field gives undefined / null for that call, never a throw.
+import type { Context } from 'react'
+
+// ReactWorkTags, React 19
+export const Tag = {
+    ClassComponent: 1,
+    HostRoot: 3,
+    HostComponent: 5,
+    ContextProvider: 10,
+    Suspense: 13,
+    Offscreen: 22,
+    Activity: 31,
+} as const
+
+declare const brand: unique symbol
+export type FiberNode = { readonly [brand]: 'FiberNode' }
+export type ShadowNode = { readonly __hostObjectShadowNodeWrapper?: unknown }
+
+export type RawFiber = {
+    tag: number
+    type: any
+    return: RawFiber | null
+    child: RawFiber | null
+    sibling: RawFiber | null
+    alternate: RawFiber | null
+    stateNode: any
+    memoizedProps: any
+    pendingProps: any
+    memoizedState: any
+    _debugOwner?: any
+    _debugStack?: { stack?: string } | null
+}
+
+export const raw = (fiber: FiberNode | null | undefined) => fiber as unknown as RawFiber | null | undefined
+
+export const hostFiberOf = (instance: unknown): FiberNode | null =>
+    ((instance as any)?.__internalInstanceHandle ?? null) as FiberNode | null
+
+// RN composites that keep their host behind a ref of their own, most common first
+const compositeHostRefs: Array<(handle: any) => unknown> = [
+    (handle) => handle?.getScrollResponder?.()?.getNativeScrollRef?.(), // FlatList, SectionList, VirtualizedList
+    (handle) => handle?.getNativeScrollRef?.(), // ScrollView
+    (handle) => handle?._viewRef, // ImageBackground
+    (handle) => handle?.viewRef?.current, // KeyboardAvoidingView
+    (handle) => handle?._nativeRef, // RefreshControl
+]
+
+export const resolveHostFiber = (handle: unknown): FiberNode | null => {
+    const direct = hostFiberOf(handle)
+
+    if (direct || !handle) {
+        return direct
+    }
+
+    for (let i = 0; i < compositeHostRefs.length; i++) {
+        const fiber = hostFiberOf(compositeHostRefs[i]!(handle))
+
+        if (fiber) {
+            return fiber
+        }
+    }
+
+    return null
+}
+
+export const fiberOfInstance = (instance: unknown): FiberNode | null =>
+    ((instance as any)?._reactInternals ?? null) as FiberNode | null
+
+export const firstHostBelow = (fiber: FiberNode | null): FiberNode | null => {
+    let current = raw(fiber)
+
+    while (current && current.tag !== Tag.HostComponent) {
+        current = current.child
+    }
+
+    return (current ?? null) as FiberNode | null
+}
+
+export const hostAncestor = (fiber: FiberNode | null, levels = 1): FiberNode | null => {
+    let current = raw(fiber)?.return
+
+    while (current) {
+        if (current.tag === Tag.HostComponent && --levels === 0) {
+            return current as unknown as FiberNode
+        }
+
+        current = current.return
+    }
+
+    return null
+}
+
+export const shadowNodesOf = (fiber: FiberNode | null, out: Array<ShadowNode>) => {
+    const current = raw(fiber)
+    const node = current?.stateNode?.node
+    const alternateNode = current?.alternate?.stateNode?.node
+
+    if (node) {
+        out.push(node)
+    }
+
+    if (alternateNode && alternateNode !== node) {
+        out.push(alternateNode)
+    }
+}
+
+const childOfParent = (parent: RawFiber, a: RawFiber, b: RawFiber): RawFiber | null => {
+    for (let child = parent.child; child; child = child.sibling) {
+        if (child === a || child === b) {
+            return child
+        }
+    }
+
+    return null
+}
+
+// React 19.2 findCurrentFiberUsingSlowPath, returning null where React throws
+export const committedOf = (fiber: FiberNode | null): FiberNode | null => {
+    const self = raw(fiber)
+
+    if (!self) {
+        return null
+    }
+
+    const alternate = self.alternate
+
+    if (!alternate) {
+        let root = self
+
+        while (root.return) {
+            root = root.return
+        }
+
+        return root.tag === Tag.HostRoot ? fiber : null
+    }
+
+    let a: RawFiber = self
+    let b: RawFiber = alternate
+
+    while (true) {
+        const parentA = a.return
+
+        if (!parentA) {
+            break
+        }
+
+        const parentB = parentA.alternate
+
+        if (!parentB) {
+            const next = parentA.return
+
+            if (next) {
+                a = next
+                continue
+            }
+
+            break
+        }
+
+        if (parentA.child === parentB.child) {
+            const found = childOfParent(parentA, a, b)
+
+            return found === a ? fiber : found === b ? (alternate as unknown as FiberNode) : null
+        }
+
+        if (a.return !== b.return) {
+            a = parentA
+            b = parentB
+        } else {
+            const inA = childOfParent(parentA, a, b)
+            const inB = inA ? null : childOfParent(parentB, a, b)
+
+            if (!inA && !inB) {
+                return null
+            }
+
+            const aUnderA = inA ? inA === a : inB !== a
+
+            a = aUnderA ? parentA : parentB
+            b = aUnderA ? parentB : parentA
+        }
+
+        if (a.alternate !== b) {
+            return null
+        }
+    }
+
+    if (a.tag !== Tag.HostRoot) {
+        return null
+    }
+
+    return a.stateNode?.current === a ? fiber : (alternate as unknown as FiberNode)
+}
+
+// a provider's other half can hold its previous value
+const committedProviderValue = (provider: RawFiber): unknown => {
+    const alternate = provider.alternate
+
+    if (!alternate || alternate.memoizedProps?.value === provider.memoizedProps?.value) {
+        return provider.memoizedProps?.value
+    }
+
+    return (raw(committedOf(provider as unknown as FiberNode)) ?? provider).memoizedProps?.value
+}
+
+export const readContext = <T>(fiber: FiberNode | null, context: Context<T>, fallback?: T): T | undefined => {
+    for (let current = raw(fiber)?.return; current; current = current.return) {
+        if (current.tag === Tag.ContextProvider && (current.type === context || current.type?._context === context)) {
+            return committedProviderValue(current) as T
+        }
+    }
+
+    return fallback
+}
+
+// Fabric is a secondary renderer: its context stack is `_currentValue2`. Only valid during render.
+export const readContextDuringRender = <T>(context: Context<T>): T | undefined =>
+    (context as any)?._currentValue2
+
+export type ContextReader = <T>(context: Context<T>) => T | undefined
+
+export const contextReaderFor = (instance: unknown, rendering: boolean): ContextReader =>
+    rendering ? readContextDuringRender : (context) => readCommittedContext(instance, context)
+
+const NO_PROVIDER = Symbol('no provider')
+
+const readCommittedContext = <T>(instance: unknown, context: Context<T>): T | undefined => {
+    const value = readContext(committedOf(fiberOfInstance(instance)), context, NO_PROVIDER as T)
+
+    return value === NO_PROVIDER ? readContextDuringRender(context) : value
+}
+
+// pendingProps too, so React still bails out. Replaced, not mutated: props are frozen in dev.
+export const patchRenderedProps = (
+    fiber: FiberNode | null,
+    patch: (props: Record<string, any>) => Record<string, any> | undefined,
+): boolean => {
+    const self = raw(fiber)
+
+    if (!self) {
+        return false
+    }
+
+    const patchedSelf = replaceProps(self, patch)
+    const patchedAlternate = self.alternate ? replaceProps(self.alternate, patch) : false
+
+    return patchedSelf || patchedAlternate
+}
+
+const replaceProps = (target: RawFiber, patch: (props: Record<string, any>) => Record<string, any> | undefined) => {
+    const props = target.memoizedProps
+    const next = props ? patch(props) : undefined
+
+    if (!next) {
+        return false
+    }
+
+    target.memoizedProps = next
+    target.pendingProps = next
+
+    return true
+}

package/src/unifiber/src/host.ts

@@ -0,0 +1,236 @@
+// A Host is the view's creation fiber behind an opaque type: no allocation, and stable identity (=== / WeakMap keys).
+import type { FiberNode, RawFiber, ShadowNode } from './fiber'
+import * as fiber from './fiber'
+
+// Bound once: Metro's inline requires would turn each imported name used in a function into a require per call
+const {
+    committedOf,
+    fiberOfInstance,
+    firstHostBelow,
+    hostAncestor,
+    patchRenderedProps: patchFiberProps,
+    raw,
+    resolveHostFiber,
+    shadowNodesOf,
+} = fiber
+const { HostComponent: HOST_COMPONENT, Offscreen: OFFSCREEN, Suspense: SUSPENSE, Activity: ACTIVITY } = fiber.Tag
+
+declare const brand: unique symbol
+export type Host = { readonly [brand]: 'Host' }
+
+export const fiberOf = (host: Host): RawFiber => host as unknown as RawFiber
+
+export const toHost = (fiber: RawFiber | FiberNode | null | undefined): Host | undefined =>
+    ((fiber as RawFiber | null | undefined)?.stateNode?.canonical?.internalInstanceHandle ?? undefined) as Host | undefined
+
+const resolveRefSlowly = (ref: unknown): RawFiber | undefined =>
+    raw(resolveHostFiber(ref)) ?? (toHost(firstHostBelow(fiberOfInstance(ref))) as unknown as RawFiber | undefined)
+
+// The fast path is inlined: legacy Hermes doesn't inline calls
+export const getHostFor = (ref: unknown): Host | undefined => {
+    const fiber = (ref as { __internalInstanceHandle?: RawFiber } | null | undefined)?.__internalInstanceHandle
+
+    if (fiber !== undefined) {
+        return fiber as unknown as Host
+    }
+
+    return resolveRefSlowly(ref) as unknown as Host | undefined
+}
+
+export const getShadowNodeFor = (ref: unknown): ShadowNode | undefined => {
+    const fiber = (ref as { __internalInstanceHandle?: RawFiber } | null | undefined)?.__internalInstanceHandle
+
+    if (fiber !== undefined) {
+        return fiber.stateNode?.node
+    }
+
+    return resolveRefSlowly(ref)?.stateNode?.node
+}
+
+export const getHostForInstanceHandle = (handle: unknown): Host | undefined => toHost(handle as RawFiber | null | undefined)
+
+// Not the first host below the scroll view: on iOS a refreshControl comes first
+export const getContentContainerFor = (ref: any): Host | undefined => {
+    const scroll = ref?.getInnerViewRef ? ref : (ref?.getNativeScrollRef?.() ?? ref?.getScrollResponder?.())
+
+    return getHostFor(scroll?.getInnerViewRef?.())
+}
+
+export const getShadowNode = (host: Host): ShadowNode | undefined => fiberOf(host).stateNode?.node
+
+// Two nodes only while a render is in flight; after a commit both halves share one
+export const getShadowNodes = (host: Host, out: Array<ShadowNode> = []): Array<ShadowNode> => {
+    shadowNodesOf(host as unknown as FiberNode, out)
+
+    return out
+}
+
+export const getNativeTag = (host: Host): number | undefined => fiberOf(host).stateNode?.canonical?.nativeTag
+
+export const getParentHost = (host: Host): Host | undefined => toHost(hostAncestor(host as unknown as FiberNode))
+
+export const patchRenderedProps = (host: Host, patch: (props: Record<string, any>) => Record<string, any> | undefined): boolean =>
+    patchFiberProps(host as unknown as FiberNode, patch)
+
+export const HiddenBy = {
+    None: 0,
+    Suspense: 1,
+    Freeze: 2,
+    Activity: 4,
+} as const
+
+// `return` can point into either half of a pair; ask which half is committed only when they disagree
+export const committedHalf = (fiber: RawFiber, differs: (a: RawFiber, b: RawFiber) => boolean): RawFiber | null => {
+    const alternate = fiber.alternate
+
+    if (!alternate || !differs(fiber, alternate)) {
+        return fiber
+    }
+
+    return raw(committedOf(fiber as unknown as FiberNode)) ?? null
+}
+
+const hiddenStateDiffers = (a: RawFiber, b: RawFiber) => (a.memoizedState === null) !== (b.memoizedState === null)
+
+// React's own visibility bit on the Offscreen instance: shared by both halves and flipped in the commit before refs
+// detach, so it also holds inside a ref cleanup, where the committed half is still the old tree
+const OFFSCREEN_VISIBLE = 1
+const isOffscreenHidden = (offscreen: RawFiber): boolean => {
+    const visibility = offscreen.stateNode?._visibility
+
+    if (typeof visibility === 'number') {
+        return (visibility & OFFSCREEN_VISIBLE) === 0
+    }
+
+    return committedHalf(offscreen, hiddenStateDiffers)?.memoizedState != null
+}
+const freezeDiffers = (a: RawFiber, b: RawFiber) => a.memoizedProps?.freeze !== b.memoizedProps?.freeze
+
+// react-freeze: Freeze > Suspense > Suspender. The Suspender keeps stale props because it throws, so read Freeze's.
+const isFrozenBoundary = (suspense: RawFiber) =>
+    committedHalf(suspense.return as RawFiber, freezeDiffers)?.memoizedProps?.freeze === true
+
+// Every hidden subtree sits under an Offscreen fiber with memoizedState set
+export const getHiddenReasons = (host: Host): number => {
+    let reasons = 0
+
+    for (let current = fiberOf(host).return; current; current = current.return) {
+        if (current.tag !== OFFSCREEN || !isOffscreenHidden(current)) {
+            continue
+        }
+
+        const boundary = current.return
+
+        if (boundary?.tag === ACTIVITY) {
+            reasons |= HiddenBy.Activity
+        } else if (boundary?.tag === SUSPENSE) {
+            reasons |= isFrozenBoundary(boundary) ? HiddenBy.Freeze : HiddenBy.Suspense
+        }
+    }
+
+    return reasons
+}
+
+// Any hidden Offscreen, as in collectVisibleAncestors. Stops at the first: the reason isn't needed
+export const isHidden = (host: Host): boolean => {
+    for (let current = fiberOf(host).return; current; current = current.return) {
+        if (current.tag === OFFSCREEN && isOffscreenHidden(current)) {
+            return true
+        }
+    }
+
+    return false
+}
+export const isSuspended = (host: Host) => (getHiddenReasons(host) & HiddenBy.Suspense) !== 0
+export const isFrozen = (host: Host) => (getHiddenReasons(host) & HiddenBy.Freeze) !== 0
+export const isInHiddenActivity = (host: Host) => (getHiddenReasons(host) & HiddenBy.Activity) !== 0
+
+const isHiddenOffscreen = (offscreen: RawFiber, boundaries: Map<RawFiber, boolean>): boolean => {
+    let hidden = boundaries.get(offscreen)
+
+    if (hidden === undefined) {
+        hidden = isOffscreenHidden(offscreen)
+        boundaries.set(offscreen, hidden)
+
+        if (offscreen.alternate) {
+            boundaries.set(offscreen.alternate, hidden)
+        }
+    }
+
+    return hidden
+}
+
+// Hot loops below: indexed loops and writes, explicit null checks, no helper calls (legacy Hermes)
+export const collectVisibleAncestors = (hosts: ReadonlyArray<Host | null | undefined>, visit: (host: Host) => void) => {
+    const visibleByTag = new Map<number, boolean>()
+    const boundaries = new Map<RawFiber, boolean>()
+    const pending: Array<RawFiber> = []
+
+    for (let h = 0; h < hosts.length; h++) {
+        let visible = true
+        let count = 0
+
+        for (let current = hosts[h] as unknown as RawFiber | null | undefined; current != null; current = current.return) {
+            if (current.tag === HOST_COMPONENT) {
+                const stateNode = current.stateNode
+
+                if (stateNode == null || stateNode.canonical == null) {
+                    break
+                }
+
+                const answer = visibleByTag.get(stateNode.canonical.nativeTag)
+
+                if (answer !== undefined) {
+                    visible = answer
+                    break
+                }
+
+                pending[count++] = current
+            } else if (current.tag === OFFSCREEN && isHiddenOffscreen(current, boundaries)) {
+                visible = false
+                break
+            }
+        }
+
+        for (let i = 0; i < count; i++) {
+            const canonical = pending[i]!.stateNode.canonical
+
+            visibleByTag.set(canonical.nativeTag, visible)
+
+            if (visible && canonical.internalInstanceHandle != null) {
+                visit(canonical.internalInstanceHandle as Host)
+            }
+        }
+    }
+}
+
+// Hidden hosts included
+export const collectAncestors = (hosts: ReadonlyArray<Host | null | undefined>, visit: (host: Host) => void) => {
+    const visitedByTag = new Set<number>()
+
+    for (let h = 0; h < hosts.length; h++) {
+        for (let current = hosts[h] as unknown as RawFiber | null | undefined; current != null; current = current.return) {
+            if (current.tag !== HOST_COMPONENT) {
+                continue
+            }
+
+            const stateNode = current.stateNode
+
+            if (stateNode == null || stateNode.canonical == null) {
+                break
+            }
+
+            const canonical = stateNode.canonical
+
+            if (visitedByTag.has(canonical.nativeTag)) {
+                break
+            }
+
+            visitedByTag.add(canonical.nativeTag)
+
+            if (canonical.internalInstanceHandle != null) {
+                visit(canonical.internalInstanceHandle as Host)
+            }
+        }
+    }
+}

package/src/unifiber/src/index.ts

@@ -0,0 +1,43 @@
+import { createOwnerRegistry } from './adapters/registry'
+import { animatedComponentOf, reanimatedCSSAdapter } from './adapters/reanimated'
+import { getCreationStack, getOwners, verify } from './diagnostics'
+import * as HostApi from './host'
+
+export type { Host } from './host'
+export type { Drift } from './diagnostics'
+export type { ShadowNode } from './fiber'
+export type { OwnerAdapter, OwnerRegistry, StyleSource } from './adapters/registry'
+
+// Object literals, not classes: static methods on a Babel-transpiled class are slower on Hermes
+export const Fiber = {
+    getHostFor: HostApi.getHostFor,
+    getShadowNodeFor: HostApi.getShadowNodeFor,
+    getHostForInstanceHandle: HostApi.getHostForInstanceHandle,
+    getContentContainerFor: HostApi.getContentContainerFor,
+
+    getShadowNode: HostApi.getShadowNode,
+    getShadowNodes: HostApi.getShadowNodes,
+    getNativeTag: HostApi.getNativeTag,
+    getParentHost: HostApi.getParentHost,
+
+    isHidden: HostApi.isHidden,
+    isSuspended: HostApi.isSuspended,
+    isFrozen: HostApi.isFrozen,
+    isInHiddenActivity: HostApi.isInHiddenActivity,
+
+    collectVisibleAncestors: HostApi.collectVisibleAncestors,
+    collectAncestors: HostApi.collectAncestors,
+
+    patchRenderedProps: HostApi.patchRenderedProps,
+
+    verify,
+    getOwners,
+    getCreationStack,
+
+    createOwnerRegistry,
+}
+
+export const Reanimated = {
+    animatedComponentOf,
+    cssAdapter: reanimatedCSSAdapter,
+}

package/src/web/css/core.ts

@@ -3,6 +3,31 @@ import type { CSSState } from './state'
 import { isPseudoClass } from '../convert/pseudo'
 import { getMediaQuery } from '../utils'
 
+type SetProps = Parameters<CSSState['set']>[0]
+
+// box-none and box-only aren't CSS values, polyfill them like react-native-web: [element, children]
+const POINTER_EVENTS: Record<string, [string, string]> = {
+    'box-none': ['none', 'auto'],
+    'box-only': ['auto', 'none'],
+}
+
+export const getChildrenClassName = (className: string) => `:where(.${className})>*`
+
+const setStyle = (state: CSSState, props: SetProps) => {
+    if (props.propertyKey !== 'pointerEvents') {
+        state.set(props)
+
+        return
+    }
+
+    const [value, childrenValue] = POINTER_EVENTS[props.value] ?? [props.value]
+
+    state.set({ ...props, value })
+    // :where() has no specificity, so a child's own pointerEvents always wins
+    // set it for every value, so re-applying the style can't leave a stale children rule
+    state.set({ ...props, className: getChildrenClassName(props.className), value: childrenValue })
+}
+
 export const convertToCSS = (hash: string, value: Record<string, any>, state: CSSState) => {
     Object.entries(value).forEach(([styleKey, styleValue]) => {
         if (styleKey[0] === '_') {
@@ -15,7 +40,7 @@ export const convertToCSS = (hash: string, value: Record<string, any>, state: CS
                     Object.entries(pseudoStyleValue).forEach(([breakpointStyleKey, breakpointStyleValue]) => {
                         const mediaQuery = getMediaQuery(pseudoStyleKey, allBreakpoints)
 
-                        state.set({
+                        setStyle(state, {
                             mediaQuery,
                             className: pseudoClassName,
                             propertyKey: breakpointStyleKey,
@@ -26,7 +51,7 @@ export const convertToCSS = (hash: string, value: Record<string, any>, state: CS
                     return
                 }
 
-                state.set({
+                setStyle(state, {
                     className: pseudoClassName,
                     propertyKey: pseudoStyleKey,
                     value: pseudoStyleValue,
@@ -49,7 +74,7 @@ export const convertToCSS = (hash: string, value: Record<string, any>, state: CS
                     .map(([key]) => key)
                 const mediaQuery = getMediaQuery(styleKey, allBreakpoints)
 
-                state.set({
+                setStyle(state, {
                     mediaQuery,
                     className: hash,
                     propertyKey: breakpointStyleKey,
@@ -60,7 +85,7 @@ export const convertToCSS = (hash: string, value: Record<string, any>, state: CS
             return
         }
 
-        state.set({
+        setStyle(state, {
             className: hash,
             propertyKey: styleKey,
             value: styleValue,

package/src/web/css/state.ts

@@ -3,7 +3,7 @@ import type { UnistylesServices } from '../types'
 
 import { convertUnistyles } from '../convert'
 import { hyphenate, isServer } from '../utils'
-import { convertToCSS } from './core'
+import { convertToCSS, getChildrenClassName } from './core'
 
 type MapType = Map<string, Map<string, Map<string, any>>>
 type SetProps = {
@@ -105,11 +105,15 @@ export class CSSState {
     }
 
     remove = (hash: string) => {
+        const childrenClassName = getChildrenClassName(hash)
+
         this.mainMap.forEach((styles) => {
             styles.delete(hash)
+            styles.delete(childrenClassName)
         })
         this.mqMap.forEach((styles) => {
             styles.delete(hash)
+            styles.delete(childrenClassName)
         })
         this.recreate()
     }
@@ -125,7 +129,7 @@ export class CSSState {
             }
 
             for (const [className, thirdLevelMap] of secondLevelMap) {
-                styles += `.${className}{`
+                styles += className[0] === ':' ? `${className}{` : `.${className}{`
 
                 for (const [propertyKey, value] of thirdLevelMap) {
                     if (value === undefined) {

package/src/web/registry.ts

@@ -112,7 +112,7 @@ export class UnistylesRegistry {
 
     add = (value: UnistylesValues, forChild?: boolean) => {
         const generatedHash = generateHash(value)
-        const hash = forChild ? `${generatedHash} > *` : generatedHash
+        const hash = forChild ? `${generatedHash}_child > *` : generatedHash
 
         if (!this.stylesCache.has(hash)) {
             this.applyStyles(hash, value)

package/src/web/utils/unistyle.ts

@@ -98,9 +98,13 @@ export const getMediaQuery = (query: string, allBreakpoints: Array<string>) => {
         .map((b) => unistyles.services.runtime.breakpoints[b] as number)
         .sort((a, b) => a - b)
         .find((b) => b > breakpointValue)
+    // Viewport widths are fractional CSS px under browser zoom / OS scaling, so an integer
+    // `max-width: next - 1` leaves a dead band (e.g. 767 < width < 768) that matches neither
+    // this breakpoint nor the next one. 0.02px below the next breakpoint (the Bootstrap
+    // convention) closes it without overlapping `(min-width: next)`.
     const queries = [
         `(min-width: ${breakpointValue}px)`,
-        nextBreakpoint ? `(max-width: ${nextBreakpoint - 1}px)` : undefined,
+        nextBreakpoint ? `(max-width: ${nextBreakpoint - 0.02}px)` : undefined,
     ]
         .filter(Boolean)
         .join(' and ')
@@ -138,12 +142,17 @@ export const checkForAnimated = (value: any): boolean => {
     }
 
     if (typeof value === 'object' && value !== null) {
+        // Reanimated useAnimatedStyle handle, it's a plain object, not an Animated.Node
+        // styleUpdaterContainer was added in Reanimated 4.1, so check only the keys every version has
+        if ('viewDescriptors' in value && 'initial' in value) {
+            return true
+        }
+
         const objectValues = Object.values(value)
         const secrets = extractSecrets(value)
 
-        // @ts-expect-error React Native Web exports Animated.AnimatedNode as Animated.Node
         // prettier-ignore
-        return value instanceof Animated.Node || objectValues.length > 0 && objectValues.some(checkForAnimated) || secrets && Object.keys(secrets).length === 0
+        return value instanceof Animated.Node || objectValues.length > 0 && objectValues.some(checkForAnimated) || !!secrets && Object.keys(secrets).length === 0
     }
 
     return false

package/lib/typescript/src/__tests__/mocks.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mocks.spec.d.ts.map

package/lib/typescript/src/__tests__/mocks.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mocks.spec.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/mocks.spec.ts"],"names":[],"mappings":""}