fixes #25 : use onLayout instead of one-shot measureInWindow for reliable dimensions in flex layouts

[sherucon]

Replace useLayoutEffect + measureInWindow with onLayout, which is guaranteed to fire with the correct final dimensions after every layout pass:

 function Rect({ children, ...rest }: RectProps) {
   const [rect, setRect] = useState<{ width: number; height: number } | null>(null)
-  const ref = useRef<View>(null)
-
-  useLayoutEffect(() => {
-    if (!isSyncLayoutAccessAvailable()) {
-      throw new Error("This library requires React Native's new architecture.")
-    }
-    ref.current?.measureInWindow((_x, _y, width, height) => {
-      setRect({ width, height })
-    })
-  }, [])
+
+  const handleLayout = React.useCallback(
+    (e: { nativeEvent: { layout: { width: number; height: number } } }) => {
+      const { width, height } = e.nativeEvent.layout
+      setRect((prev) => {
+        if (prev && prev.width === width && prev.height === height) {
+          return prev
+        }
+        return { width, height }
+      })
+    },
+    []
+  )

   return (
-    <View ref={ref} {...rest}>
+    <View onLayout={handleLayout} {...rest}>
       {rect ? children(rect) : null}
     </View>
   )
 }
-
-function isSyncLayoutAccessAvailable() { ... }

What changed

Aspect	Before	After
Measurement	useLayoutEffect([]) + measureInWindow — fires once on mount	onLayout — fires on every layout change
Flex compat	Can capture intermediate dimensions during flex resolution	Always receives final resolved dimensions
Re-measurement	Never re-measures after mount	Re-measures on any bounds change
Architecture	Requires New Architecture (isSyncLayoutAccessAvailable check)	Works on both old and new architecture
Re-render guard	None	Functional setState with equality check avoids unnecessary re-renders

What was removed

• useRef, useLayoutEffect imports (unused)
• Platform import (unused)
• isSyncLayoutAccessAvailable() function (no longer needed)

Note

The onLayout approach also makes the library compatible with the old architecture again, since it doesn't need measureInWindow synchronous access (the isSyncLayoutAccessAvailable guard is removed entirely).