react-native-gtkx 0.2.0-alpha.1 → 0.3.0-alpha.1

package/dist/components/animated.d.ts

@@ -1,5 +1,10 @@
-import { type ReactNode } from "react";
-import type { FlatStyle, TransformPart } from "../contracts";
+import { type ComponentProps, type ElementType, type ReactNode, type Ref } from "react";
+import { type InsetProperty } from "../style/absolute-insets";
+import { type SizeProperty } from "../style/animated-size";
+import { type DriveableColorProperty } from "../style/imperative-css";
+import type { DimensionValue, FlatStyle, PointerEventsValue, StyleProp, TransformPart } from "../contracts";
+import type { ResponderProps } from "../responder/types";
+import { type MeasureHandle } from "./measure";
 import { type LayoutEvent } from "./use-layout-child";
 type AnimatedValue = number | string;
 type AnimatedNode = {
@@ -12,19 +17,80 @@ type AnimatedNode = {
 type AnimatedTransformPart = {
     [key: string]: number | string | AnimatedNode;
 };
-export type AnimatedViewStyle = Omit<FlatStyle, "opacity" | "transform"> & {
+export type AnimatedViewStyle = Omit<FlatStyle, "opacity" | "zIndex" | "transform" | DriveableColorProperty | InsetProperty | SizeProperty> & {
     opacity?: number | AnimatedNode;
+    zIndex?: number | AnimatedNode;
     transform?: (TransformPart | AnimatedTransformPart)[];
-};
-export type AnimatedViewProps = {
-    style?: AnimatedViewStyle | AnimatedViewStyle[];
+} & Partial<Record<DriveableColorProperty, string | AnimatedNode>> & Partial<Record<InsetProperty, DimensionValue | AnimatedNode>> & Partial<Record<SizeProperty, DimensionValue | AnimatedNode>>;
+/** What every animated component accepts as `style`, arrays and falsy included. */
+export type AnimatedStyleProp = AnimatedViewStyle | readonly (AnimatedViewStyle | false | null | undefined)[];
+export type AnimatedViewProps = ResponderProps & {
+    style?: AnimatedStyleProp;
     children?: ReactNode;
     onLayout?: (event: LayoutEvent) => void;
     testID?: string;
+    pointerEvents?: PointerEventsValue;
+    animatedProps?: Record<string, unknown>;
+    ref?: Ref<MeasureHandle>;
+};
+/** @internal Test seam: the warning is once per property per session by design. */
+export declare const resetAnimatedInsetWarnings: () => void;
+/** @internal Test seam: the warning is once per property per session by design. */
+export declare const resetAnimatedSizeWarnings: () => void;
+/** Node-backed props from `useAnimatedProps`, spread onto the wrapped component. */
+export type AnimatedPropsProp = Record<string, unknown>;
+/** The props an animated wrapper adds on top of the component's own. */
+export type AnimatedComponentExtraProps = {
+    style?: AnimatedStyleProp;
+    animatedProps?: AnimatedPropsProp;
 };
+export type AnimatedComponent<C extends ElementType> = (props: Partial<Omit<ComponentProps<C>, "style">> & AnimatedComponentExtraProps) => ReactNode;
+/** @internal Test seam: the warning is once per component per session by design. */
+export declare const resetAnimatedComponentWarnings: () => void;
+/**
+ * Wraps a component so its `style`'s `opacity`/`transform` and its
+ * `animatedProps` can be driven imperatively — RN's own
+ * `Animated.createAnimatedComponent`.
+ *
+ * IT ADDS NO WIDGET. Wrapping in an `Animated.View` would have been three
+ * lines and would have been wrong: an extra box changes flex layout, changes
+ * what `measureLayout` is relative to, and changes which widget a parent's
+ * allocate walks. That is not a shim, it is a different tree. Instead the
+ * wrapper renders the component itself and reaches the widget through the
+ * handle the component already exposes (see measure.ts's `widgetOf`), so the
+ * rendered output is byte-for-byte what the unwrapped component produces.
+ *
+ * `animatedProps` are passed straight through as animated NODES rather than
+ * resolved to numbers, because the components that take them already accept
+ * one: the SVG shapes duck-type an animated node on every numeric geometry
+ * and paint prop and subscribe to it themselves (svg/animated-support.ts),
+ * redrawing through `queueDraw`. Nothing is resolved here that the receiver
+ * can resolve better.
+ */
+export declare const createAnimatedComponent: <C extends ElementType>(component: C) => AnimatedComponent<C>;
 export declare const Animated: {
-    View: ({ style, children, onLayout, testID, }: AnimatedViewProps) => React.JSX.Element;
+    View: ({ style, children, onLayout, testID, ref, pointerEvents, animatedProps, ...responderProps }: AnimatedViewProps) => React.JSX.Element;
+    Text: AnimatedComponent<({ style, onLayout, numberOfLines, children, testID, ref, }: import("./text").TextProps) => React.JSX.Element>;
+    Image: AnimatedComponent<({ source, style, resizeMode, onLayout, onLoad, onError, testID, ref, }: import("./image").ImageProps) => React.JSX.Element>;
+    ScrollView: AnimatedComponent<React.ForwardRefExoticComponent<ResponderProps & {
+        style?: StyleProp;
+        contentContainerStyle?: StyleProp;
+        horizontal?: boolean;
+        stickyHeaderIndices?: readonly number[];
+        onScroll?: (event: import("./scroll-view").ScrollEvent) => void;
+        onScrollBeginDrag?: (event: import("./scroll-view").ScrollEvent) => void;
+        onScrollEndDrag?: (event: import("./scroll-view").ScrollEvent) => void;
+        onMomentumScrollBegin?: (event: import("./scroll-view").ScrollEvent) => void;
+        onMomentumScrollEnd?: (event: import("./scroll-view").ScrollEvent) => void;
+        onContentSizeChange?: (width: number, height: number) => void;
+        onLayout?: (event: LayoutEvent) => void;
+        children?: ReactNode;
+        testID?: string;
+    } & React.RefAttributes<import("./scroll-view").ScrollViewHandle>>>;
+    FlatList: (props: Record<string, unknown>) => never;
+    createAnimatedComponent: <C extends ElementType>(component: C) => AnimatedComponent<C>;
     Value: typeof import("../animated/value").AnimatedValue;
+    ValueXY: typeof import("../animated/value-xy").AnimatedValueXY;
     timing(value: import("../animated/value").AnimatedValue, config: import("../animated/types").TimingConfig): import("../animated/types").CompositeAnimation;
     spring(value: import("../animated/value").AnimatedValue, config: import("../animated/types").SpringConfig): import("../animated/types").CompositeAnimation;
     sequence(animations: import("../animated/types").CompositeAnimation[]): import("../animated/types").CompositeAnimation;