@cdx-ui/components 0.0.1-beta.121 → 0.0.1-beta.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cdx-ui/components",
-  "version": "0.0.1-beta.121",
+  "version": "0.0.1-beta.123",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
   "react-native": "src/index.ts",
@@ -72,13 +72,13 @@
     }
   },
   "dependencies": {
-    "@gorhom/bottom-sheet": "^5.2.6",
+    "@gorhom/bottom-sheet": "5.2.14",
     "class-variance-authority": "^0.7.1",
     "react-native-reanimated-carousel": "5.0.0-beta.5",
     "uniwind": "1.10.0",
-    "@cdx-ui/primitives": "0.0.1-beta.121",
-    "@cdx-ui/icons": "0.0.1-beta.121",
-    "@cdx-ui/utils": "0.0.1-beta.121"
+    "@cdx-ui/primitives": "0.0.1-beta.123",
+    "@cdx-ui/utils": "0.0.1-beta.123",
+    "@cdx-ui/icons": "0.0.1-beta.123"
   },
   "devDependencies": {
     "@react-navigation/bottom-tabs": "*",

package/src/components/ScrollShadow/index.tsx

@@ -0,0 +1,119 @@
+import { Children, cloneElement, isValidElement, type ReactNode } from 'react';
+import { StyleSheet, View, type ViewStyle } from 'react-native';
+import { cn } from '@cdx-ui/utils';
+import {
+  scrollShadowContainerVariants,
+  scrollShadowOverlayVariants,
+  scrollShadowVariants,
+  type ScrollShadowVariantProps,
+} from './styles';
+import { useScrollShadow, type ScrollShadowCapability } from './useScrollShadow';
+
+export type { ScrollShadowCapability };
+
+export interface ScrollShadowProps extends ScrollShadowVariantProps {
+  children: ReactNode;
+  className?: string;
+  /**
+   * Tailwind `from-*` utility for edge overlays — match the surface behind the scroll area.
+   * Pair with a low opacity (e.g. `from-surface-secondary/40`) for a light fade.
+   * @default 'from-background/35'
+   */
+  fadeFromClassName?: string;
+  /**
+   * Shadow fade size in pixels.
+   * @default 64
+   */
+  size?: number;
+  /**
+   * Scroll offset before showing edge shadows.
+   * @default 0
+   */
+  offset?: number;
+  onCapabilityChange?: (capability: ScrollShadowCapability) => void;
+  style?: ViewStyle;
+}
+
+interface ScrollShadowChildProps {
+  className?: string;
+  style?: ViewStyle;
+  onLayout?: (event: Parameters<ReturnType<typeof useScrollShadow>['handleLayout']>[0]) => void;
+  onContentSizeChange?: (width: number, height: number) => void;
+  onScroll?: (event: Parameters<ReturnType<typeof useScrollShadow>['handleScroll']>[0]) => void;
+  ref?: React.Ref<unknown>;
+}
+
+export function ScrollShadow({
+  children,
+  className,
+  fadeFromClassName = 'from-background/35',
+  hideScrollBar = false,
+  orientation = 'horizontal',
+  offset = 0,
+  onCapabilityChange,
+  size = 64,
+  style,
+}: ScrollShadowProps) {
+  const resolvedOrientation = orientation ?? 'horizontal';
+  const child = Children.only(children);
+
+  if (!isValidElement<ScrollShadowChildProps>(child)) {
+    throw new Error('ScrollShadow expects a single React element child.');
+  }
+
+  const { capability, handleContentSizeChange, handleLayout, handleScroll } = useScrollShadow({
+    offset,
+    onCapabilityChange,
+    orientation: resolvedOrientation,
+  });
+
+  const overlayFade = cn(fadeFromClassName, 'to-transparent');
+  const overlayAxisSize = resolvedOrientation === 'horizontal' ? { width: size } : { height: size };
+
+  return (
+    <View className={cn(scrollShadowContainerVariants(), className)} style={style}>
+      {cloneElement(child, {
+        className: cn(scrollShadowVariants({ hideScrollBar }), child.props.className),
+        onContentSizeChange: (width: number, height: number) => {
+          handleContentSizeChange(width, height);
+          child.props.onContentSizeChange?.(width, height);
+        },
+        onLayout: (event) => {
+          handleLayout(event);
+          child.props.onLayout?.(event);
+        },
+        onScroll: (event) => {
+          handleScroll(event);
+          child.props.onScroll?.(event);
+        },
+        style: StyleSheet.flatten([child.props.style]),
+      })}
+      {capability.canScrollBefore ? (
+        <View
+          pointerEvents="none"
+          className={cn(
+            scrollShadowOverlayVariants({
+              orientation: resolvedOrientation,
+              edge: 'start',
+            }),
+            overlayFade,
+          )}
+          style={overlayAxisSize}
+        />
+      ) : null}
+      {capability.canScrollAfter ? (
+        <View
+          pointerEvents="none"
+          className={cn(
+            scrollShadowOverlayVariants({
+              orientation: resolvedOrientation,
+              edge: 'end',
+            }),
+            overlayFade,
+          )}
+          style={overlayAxisSize}
+        />
+      ) : null}
+    </View>
+  );
+}

package/src/components/ScrollShadow/styles.ts

@@ -0,0 +1,57 @@
+import { cva, type VariantProps } from 'class-variance-authority';
+
+export const scrollShadowVariants = cva([], {
+  variants: {
+    orientation: {
+      horizontal: '',
+      vertical: '',
+    },
+    hideScrollBar: {
+      true: 'web:[scrollbar-width:none] web:[&::-webkit-scrollbar]:hidden',
+      false: '',
+    },
+  },
+  defaultVariants: {
+    orientation: 'horizontal',
+    hideScrollBar: false,
+  },
+});
+
+export const scrollShadowContainerVariants = cva('relative min-w-0 w-full');
+
+export const scrollShadowOverlayVariants = cva('pointer-events-none absolute z-10', {
+  variants: {
+    orientation: {
+      horizontal: '',
+      vertical: '',
+    },
+    edge: {
+      start: '',
+      end: '',
+    },
+  },
+  compoundVariants: [
+    {
+      orientation: 'horizontal',
+      edge: 'start',
+      className: 'left-0 top-0 bottom-0 bg-gradient-to-r',
+    },
+    {
+      orientation: 'horizontal',
+      edge: 'end',
+      className: 'right-0 top-0 bottom-0 bg-gradient-to-l',
+    },
+    {
+      orientation: 'vertical',
+      edge: 'start',
+      className: 'left-0 right-0 top-0 bg-gradient-to-b',
+    },
+    {
+      orientation: 'vertical',
+      edge: 'end',
+      className: 'left-0 right-0 bottom-0 bg-gradient-to-t',
+    },
+  ],
+});
+
+export type ScrollShadowVariantProps = VariantProps<typeof scrollShadowVariants>;

package/src/components/ScrollShadow/useScrollShadow.ts

@@ -0,0 +1,110 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { LayoutChangeEvent, NativeScrollEvent, NativeSyntheticEvent } from 'react-native';
+
+export interface ScrollShadowCapability {
+  canScrollBefore: boolean;
+  canScrollAfter: boolean;
+}
+
+export interface UseScrollShadowOptions {
+  orientation?: 'horizontal' | 'vertical';
+  offset?: number;
+  onCapabilityChange?: (capability: ScrollShadowCapability) => void;
+}
+
+interface ScrollMetrics {
+  scrollOffset: number;
+  viewportSize: number;
+  contentSize: number;
+}
+
+const INITIAL_METRICS: ScrollMetrics = {
+  scrollOffset: 0,
+  viewportSize: 0,
+  contentSize: 0,
+};
+
+function getScrollCapability(metrics: ScrollMetrics, offset: number): ScrollShadowCapability {
+  const { scrollOffset, viewportSize, contentSize } = metrics;
+
+  if (viewportSize <= 0 || contentSize <= viewportSize) {
+    return { canScrollBefore: false, canScrollAfter: false };
+  }
+
+  return {
+    canScrollBefore: scrollOffset > offset,
+    canScrollAfter: scrollOffset + viewportSize + offset < contentSize,
+  };
+}
+
+export function useScrollShadow({
+  orientation = 'horizontal',
+  offset = 0,
+  onCapabilityChange,
+}: UseScrollShadowOptions = {}) {
+  const metricsRef = useRef<ScrollMetrics>(INITIAL_METRICS);
+  const [capability, setCapability] = useState<ScrollShadowCapability>({
+    canScrollBefore: false,
+    canScrollAfter: false,
+  });
+
+  const updateCapability = useCallback(() => {
+    const nextCapability = getScrollCapability(metricsRef.current, offset);
+
+    setCapability((prev) => {
+      if (
+        prev.canScrollBefore === nextCapability.canScrollBefore &&
+        prev.canScrollAfter === nextCapability.canScrollAfter
+      ) {
+        return prev;
+      }
+
+      onCapabilityChange?.(nextCapability);
+      return nextCapability;
+    });
+  }, [offset, onCapabilityChange]);
+
+  useEffect(() => {
+    updateCapability();
+  }, [updateCapability]);
+
+  const handleLayout = useCallback(
+    (event: LayoutChangeEvent) => {
+      const { width, height } = event.nativeEvent.layout;
+      metricsRef.current.viewportSize = orientation === 'vertical' ? height : width;
+      updateCapability();
+    },
+    [orientation, updateCapability],
+  );
+
+  const handleContentSizeChange = useCallback(
+    (width: number, height: number) => {
+      metricsRef.current.contentSize = orientation === 'vertical' ? height : width;
+      updateCapability();
+    },
+    [orientation, updateCapability],
+  );
+
+  const handleScroll = useCallback(
+    (event: NativeSyntheticEvent<NativeScrollEvent>) => {
+      const { contentOffset, layoutMeasurement, contentSize } = event.nativeEvent;
+
+      metricsRef.current.scrollOffset =
+        orientation === 'vertical' ? contentOffset.y : contentOffset.x;
+      metricsRef.current.viewportSize =
+        orientation === 'vertical' ? layoutMeasurement.height : layoutMeasurement.width;
+      metricsRef.current.contentSize =
+        orientation === 'vertical' ? contentSize.height : contentSize.width;
+
+      updateCapability();
+    },
+    [orientation, updateCapability],
+  );
+
+  return {
+    capability,
+    handleLayout,
+    handleContentSizeChange,
+    handleScroll,
+  };
+}