@rootnative/inertia 0.0.0-alpha.1 → 0.0.0-alpha.3

package/dist/chunk-W6IS4HAK.mjs

@@ -0,0 +1,52 @@
+import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions, isFocusVisible } from './chunk-GJD4VVAS.mjs';
+import { resolveTransition, isTopLevelTransition } from './chunk-6FENLMCA.mjs';
+import { useCallback, useMemo } from 'react';
+import { useSharedValue } from 'react-native-reanimated';
+
+function useGesture(transition) {
+  const pressed = useSharedValue(0);
+  const focused = useSharedValue(0);
+  const focusVisible = useSharedValue(0);
+  const hovered = useSharedValue(0);
+  const shouldReduceMotion = useShouldReduceMotion();
+  const resolved = resolveNamedTransitionProp(transition, useNamedTransitions());
+  const setLayer = useCallback(
+    (sv, layer, target) => {
+      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };
+      sv.value = resolveTransition(cfg, target);
+    },
+    // The transition is intentionally read on every call rather than cooked
+    // into the dep array — a fresh literal each render would otherwise
+    // rebuild the handler bag and break composing consumers that key off
+    // handler identity. `transition` is read inside the callback closure;
+    // shared values are stable so the only dep that matters is the reduce-
+    // motion flag.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [shouldReduceMotion]
+  );
+  const handlers = useMemo(
+    () => ({
+      onPressIn: () => setLayer(pressed, "pressed", 1),
+      onPressOut: () => setLayer(pressed, "pressed", 0),
+      onHoverIn: () => setLayer(hovered, "hovered", 1),
+      onHoverOut: () => setLayer(hovered, "hovered", 0),
+      onFocus: () => {
+        setLayer(focused, "focused", 1);
+        if (isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
+      },
+      onBlur: () => {
+        setLayer(focused, "focused", 0);
+        setLayer(focusVisible, "focusVisible", 0);
+      }
+    }),
+    [setLayer, pressed, focused, focusVisible, hovered]
+  );
+  return { pressed, focused, focusVisible, hovered, handlers };
+}
+function layerTransition(layer, transition) {
+  if (!transition) return void 0;
+  if (isTopLevelTransition(transition)) return transition;
+  return transition[layer];
+}
+
+export { useGesture };

package/dist/gestureLayer/index.d.mts

@@ -1,4 +1,4 @@
-import { AnimatedStyle } from 'react-native-reanimated';
+import { SharedValue, AnimatedStyle } from 'react-native-reanimated';
 import { U as UseGestureHandlers } from '../useGesture-C0GBS7d2.mjs';
 import { T as TransitionInput, n as GestureLayerTransitions } from '../types-BzEgiUdJ.mjs';
 import 'react';
@@ -55,6 +55,26 @@ interface UseGestureLayerOptions {
      */
     transition?: TransitionInput | GestureLayerTransitions;
 }
+/**
+ * The per-state 0↔1 progress shared values behind a `useGestureLayer` call.
+ * The gesture entries are the same shared values `useGesture` owns; `disabled`
+ * is driven by `options.disabled`. All five are stable across renders — feed
+ * them into any `useAnimatedStyle` / `useDerivedValue` (or hooks like
+ * `useShadow({ progress })`) to derive extra styles from the same gesture
+ * wiring without a second `useGesture` call.
+ */
+interface GestureLayerProgress {
+    /** 0↔1 progress for the hovered layer (web only — stays at 0 on native). */
+    hovered: SharedValue<number>;
+    /** 0↔1 progress for the focused layer (any focus modality). */
+    focused: SharedValue<number>;
+    /** 0↔1 progress for the focusVisible layer (keyboard focus only). */
+    focusVisible: SharedValue<number>;
+    /** 0↔1 progress for the pressed layer. */
+    pressed: SharedValue<number>;
+    /** 0↔1 progress for the disabled override (driven by `options.disabled`). */
+    disabled: SharedValue<number>;
+}
 interface UseGestureLayerResult {
     /**
      * Animated style produced by `useAnimatedStyle` — spread on an
@@ -63,6 +83,12 @@ interface UseGestureLayerResult {
     style: AnimatedStyle<Record<string, unknown>>;
     /** Handlers to spread on the receiving `Pressable`. */
     handlers: UseGestureHandlers;
+    /**
+     * Per-state progress shared values — the inputs the composed `style` is
+     * derived from. Read-only by convention: writing to them fights the
+     * handlers.
+     */
+    states: GestureLayerProgress;
 }
 /**
  * A "strongest active layer wins" interactive-feedback primitive. Sits one
@@ -85,6 +111,13 @@ interface UseGestureLayerResult {
  *   keys — when active, it lerps the composed value toward the `disabled`
  *   target.
  *
+ * Alongside `style` and `handlers`, the hook returns `states` — the per-state
+ * 0↔1 progress shared values the style is derived from (the four gesture
+ * layers plus the disabled override). Feed them into other progress-driven
+ * hooks (`useShadow`, `useColorTransition`) or a custom `useAnimatedStyle`
+ * to derive extra styles from the same gesture wiring — no second
+ * `useGesture` call, no duplicated handlers.
+ *
  * Reach for this when you want MD3 / iOS-translucent state-layer overlays
  * without rewriting the worklet by hand for every consumer; reach for plain
  * `useGesture()` when you need a composition model this hook doesn't
@@ -114,7 +147,14 @@ interface UseGestureLayerResult {
  *   )
  * }
  * ```
+ *
+ * @example Elevation crossfade driven by the hover progress
+ * ```tsx
+ * const { style, handlers, states } = useGestureLayer(layers, options)
+ * const shadow = useShadow({ from: restShadow, to: raisedShadow, progress: states.hovered })
+ * // <Animated.View style={[style, shadow]} />
+ * ```
  */
 declare function useGestureLayer(states: GestureLayerStates, options?: UseGestureLayerOptions): UseGestureLayerResult;
 
-export { type GestureLayerStates, type GestureLayerStyle, type UseGestureLayerOptions, type UseGestureLayerResult, useGestureLayer };
+export { type GestureLayerProgress, type GestureLayerStates, type GestureLayerStyle, type UseGestureLayerOptions, type UseGestureLayerResult, useGestureLayer };

package/dist/gestureLayer/index.d.ts

@@ -1,4 +1,4 @@
-import { AnimatedStyle } from 'react-native-reanimated';
+import { SharedValue, AnimatedStyle } from 'react-native-reanimated';
 import { U as UseGestureHandlers } from '../useGesture-BRLgiNOC.js';
 import { T as TransitionInput, n as GestureLayerTransitions } from '../types-BzEgiUdJ.js';
 import 'react';
@@ -55,6 +55,26 @@ interface UseGestureLayerOptions {
      */
     transition?: TransitionInput | GestureLayerTransitions;
 }
+/**
+ * The per-state 0↔1 progress shared values behind a `useGestureLayer` call.
+ * The gesture entries are the same shared values `useGesture` owns; `disabled`
+ * is driven by `options.disabled`. All five are stable across renders — feed
+ * them into any `useAnimatedStyle` / `useDerivedValue` (or hooks like
+ * `useShadow({ progress })`) to derive extra styles from the same gesture
+ * wiring without a second `useGesture` call.
+ */
+interface GestureLayerProgress {
+    /** 0↔1 progress for the hovered layer (web only — stays at 0 on native). */
+    hovered: SharedValue<number>;
+    /** 0↔1 progress for the focused layer (any focus modality). */
+    focused: SharedValue<number>;
+    /** 0↔1 progress for the focusVisible layer (keyboard focus only). */
+    focusVisible: SharedValue<number>;
+    /** 0↔1 progress for the pressed layer. */
+    pressed: SharedValue<number>;
+    /** 0↔1 progress for the disabled override (driven by `options.disabled`). */
+    disabled: SharedValue<number>;
+}
 interface UseGestureLayerResult {
     /**
      * Animated style produced by `useAnimatedStyle` — spread on an
@@ -63,6 +83,12 @@ interface UseGestureLayerResult {
     style: AnimatedStyle<Record<string, unknown>>;
     /** Handlers to spread on the receiving `Pressable`. */
     handlers: UseGestureHandlers;
+    /**
+     * Per-state progress shared values — the inputs the composed `style` is
+     * derived from. Read-only by convention: writing to them fights the
+     * handlers.
+     */
+    states: GestureLayerProgress;
 }
 /**
  * A "strongest active layer wins" interactive-feedback primitive. Sits one
@@ -85,6 +111,13 @@ interface UseGestureLayerResult {
  *   keys — when active, it lerps the composed value toward the `disabled`
  *   target.
  *
+ * Alongside `style` and `handlers`, the hook returns `states` — the per-state
+ * 0↔1 progress shared values the style is derived from (the four gesture
+ * layers plus the disabled override). Feed them into other progress-driven
+ * hooks (`useShadow`, `useColorTransition`) or a custom `useAnimatedStyle`
+ * to derive extra styles from the same gesture wiring — no second
+ * `useGesture` call, no duplicated handlers.
+ *
  * Reach for this when you want MD3 / iOS-translucent state-layer overlays
  * without rewriting the worklet by hand for every consumer; reach for plain
  * `useGesture()` when you need a composition model this hook doesn't
@@ -114,7 +147,14 @@ interface UseGestureLayerResult {
  *   )
  * }
  * ```
+ *
+ * @example Elevation crossfade driven by the hover progress
+ * ```tsx
+ * const { style, handlers, states } = useGestureLayer(layers, options)
+ * const shadow = useShadow({ from: restShadow, to: raisedShadow, progress: states.hovered })
+ * // <Animated.View style={[style, shadow]} />
+ * ```
  */
 declare function useGestureLayer(states: GestureLayerStates, options?: UseGestureLayerOptions): UseGestureLayerResult;
 
-export { type GestureLayerStates, type GestureLayerStyle, type UseGestureLayerOptions, type UseGestureLayerResult, useGestureLayer };
+export { type GestureLayerProgress, type GestureLayerStates, type GestureLayerStyle, type UseGestureLayerOptions, type UseGestureLayerResult, useGestureLayer };

package/dist/gestureLayer/index.js

@@ -1,287 +1,25 @@
 'use strict';
 
+var chunkK7ICHCTZ_js = require('../chunk-K7ICHCTZ.js');
+var chunkJWHKMNYA_js = require('../chunk-JWHKMNYA.js');
+var chunkSFRNO6AW_js = require('../chunk-SFRNO6AW.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
-var reactNativeWorklets = require('react-native-worklets');
-var reactNative = require('react-native');
 
-// src/gestureLayer/useGestureLayer.ts
-
-// src/transitions/sig.ts
-function stableSig(value) {
-  if (value === void 0) return "";
-  try {
-    return stableStringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function stableStringify(v) {
-  if (v === null || typeof v !== "object") {
-    if (typeof v === "function" || v === void 0) return "null";
-    return JSON.stringify(v);
-  }
-  if (Array.isArray(v)) {
-    return "[" + v.map(stableStringify).join(",") + "]";
-  }
-  const obj = v;
-  const keys = Object.keys(obj).sort();
-  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
-}
-var DEFAULT_MOTION_CONFIG = {
-  reducedMotion: "user",
-  transitions: {}
-};
-var MotionConfigContext = react.createContext(
-  DEFAULT_MOTION_CONFIG
-);
-function useMotionConfig() {
-  return react.useContext(MotionConfigContext);
-}
-function useNamedTransitions() {
-  return useMotionConfig().transitions;
-}
-function useShouldReduceMotion() {
-  const { reducedMotion } = useMotionConfig();
-  const osReduced = reactNativeReanimated.useReducedMotion();
-  if (reducedMotion === "never") return false;
-  if (reducedMotion === "always") return true;
-  return osReduced;
-}
-
-// src/transitions/keys.ts
-var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "tension",
-  "friction",
-  "mass",
-  "velocity",
-  "restSpeedThreshold",
-  "restDisplacementThreshold",
-  "duration",
-  "easing",
-  "delay",
-  "repeat",
-  "deceleration",
-  "clamp"
-]);
-function isTopLevelTransition(t) {
-  if (t === null || typeof t !== "object") return false;
-  const keys = Object.keys(t);
-  if (keys.length === 0) return false;
-  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
-}
-
-// src/config/namedTransitions.ts
-var UNKNOWN_NAME_FALLBACK = { type: "spring" };
-function lookupNamedTransition(name, registry) {
-  const cfg = registry[name];
-  if (cfg) return cfg;
-  if (__DEV__) {
-    console.warn(
-      `[inertia] Unknown transition name "${name}" \u2014 falling back to the default spring. Register it on a provider: <MotionConfig transitions={{ '${name}': { ... } }}>.`
-    );
-  }
-  return UNKNOWN_NAME_FALLBACK;
-}
-function resolveNamedTransitionProp(transition, registry) {
-  if (transition === void 0) return void 0;
-  if (typeof transition === "string") {
-    return lookupNamedTransition(transition, registry);
-  }
-  if (isTopLevelTransition(transition)) return transition;
-  const map = transition;
-  let out = null;
-  for (const key in map) {
-    const value = map[key];
-    if (typeof value === "string") {
-      if (out === null) out = { ...map };
-      out[key] = lookupNamedTransition(value, registry);
-    }
-  }
-  return out ?? transition;
-}
-function ensureWorkletEasing(easing) {
-  if (!easing) return void 0;
-  const fn = isEasingFactory(easing) ? easing.factory() : easing;
-  if (reactNativeWorklets.isWorkletFunction(fn)) return fn;
-  const wrapped = (t) => {
-    "worklet";
-    return fn(t);
-  };
-  return wrapped;
-}
-function isEasingFactory(value) {
-  return typeof value === "object" && value !== null && "factory" in value && typeof value.factory === "function";
-}
-
-// src/transitions/spring.ts
-var DEFAULT_SPRING = {
-  tension: 170,
-  friction: 26,
-  mass: 1
-};
-function springToReanimated(t) {
-  "worklet";
-  return {
-    stiffness: t.tension ?? DEFAULT_SPRING.tension,
-    damping: t.friction ?? DEFAULT_SPRING.friction,
-    mass: t.mass ?? DEFAULT_SPRING.mass,
-    velocity: t.velocity,
-    restSpeedThreshold: t.restSpeedThreshold,
-    restDisplacementThreshold: t.restDisplacementThreshold
-  };
-}
-
-// src/transitions/resolve.ts
-var DEFAULT_TIMING_DURATION = 250;
-function buildSpring(cfg, toValue, cb) {
-  return reactNativeReanimated.withSpring(toValue, springToReanimated(cfg), cb);
-}
-function buildTiming(cfg, toValue, cb) {
-  return reactNativeReanimated.withTiming(
-    toValue,
-    {
-      duration: cfg.duration ?? DEFAULT_TIMING_DURATION,
-      easing: ensureWorkletEasing(cfg.easing) ?? reactNativeReanimated.Easing.inOut(reactNativeReanimated.Easing.ease)
-    },
-    cb
-  );
-}
-function buildDecay(cfg, cb) {
-  return reactNativeReanimated.withDecay(
-    {
-      velocity: cfg.velocity ?? 0,
-      deceleration: cfg.deceleration,
-      clamp: cfg.clamp
-    },
-    cb
-  );
-}
-function buildOne(cfg, toValue, cb) {
-  if (cfg.type === "no-animation") {
-    return toValue;
-  }
-  if (cfg.type === "decay") return buildDecay(cfg, cb);
-  if (cfg.type === "timing") return buildTiming(cfg, toValue, cb);
-  return buildSpring(cfg, toValue, cb);
-}
-function applyRepeat(animation, repeat) {
-  if (repeat === void 0) return animation;
-  if (repeat === "infinite") {
-    return reactNativeReanimated.withRepeat(animation, -1, true);
-  }
-  if (typeof repeat === "number") {
-    return reactNativeReanimated.withRepeat(animation, repeat, true);
-  }
-  const count = repeat.count === "infinite" ? -1 : repeat.count;
-  const alternate = repeat.alternate ?? true;
-  return reactNativeReanimated.withRepeat(animation, count, alternate);
-}
-function applyDelay(animation, delay) {
-  if (!delay || delay <= 0) return animation;
-  return reactNativeReanimated.withDelay(delay, animation);
-}
-function resolveTransition(config, toValue, callback) {
-  const cfg = config ?? { type: "spring" };
-  const base = buildOne(cfg, toValue, callback);
-  const repeated = applyRepeat(base, repeatOf(cfg));
-  return applyDelay(repeated, delayOf(cfg));
-}
-function repeatOf(cfg) {
-  if (cfg.type === "no-animation" || cfg.type === "decay") return void 0;
-  return cfg.repeat;
-}
-function delayOf(cfg) {
-  if (cfg.type === "no-animation") return void 0;
-  return cfg.delay;
-}
-var modality = "keyboard";
-var installed = false;
-function setKeyboard() {
-  modality = "keyboard";
-}
-function setPointer() {
-  modality = "pointer";
-}
-function ensureInstalled() {
-  if (installed) return;
-  if (reactNative.Platform.OS !== "web") return;
-  if (typeof document === "undefined") return;
-  document.addEventListener("keydown", setKeyboard, true);
-  document.addEventListener("mousedown", setPointer, true);
-  document.addEventListener("pointerdown", setPointer, true);
-  document.addEventListener("touchstart", setPointer, true);
-  installed = true;
-}
-function isFocusVisible() {
-  if (reactNative.Platform.OS !== "web") return true;
-  ensureInstalled();
-  return modality === "keyboard";
-}
-
-// src/values/useGesture.ts
-function useGesture(transition) {
-  const pressed = reactNativeReanimated.useSharedValue(0);
-  const focused = reactNativeReanimated.useSharedValue(0);
-  const focusVisible = reactNativeReanimated.useSharedValue(0);
-  const hovered = reactNativeReanimated.useSharedValue(0);
-  const shouldReduceMotion = useShouldReduceMotion();
-  const resolved = resolveNamedTransitionProp(transition, useNamedTransitions());
-  const setLayer = react.useCallback(
-    (sv, layer, target) => {
-      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };
-      sv.value = resolveTransition(cfg, target);
-    },
-    // The transition is intentionally read on every call rather than cooked
-    // into the dep array — a fresh literal each render would otherwise
-    // rebuild the handler bag and break composing consumers that key off
-    // handler identity. `transition` is read inside the callback closure;
-    // shared values are stable so the only dep that matters is the reduce-
-    // motion flag.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [shouldReduceMotion]
-  );
-  const handlers = react.useMemo(
-    () => ({
-      onPressIn: () => setLayer(pressed, "pressed", 1),
-      onPressOut: () => setLayer(pressed, "pressed", 0),
-      onHoverIn: () => setLayer(hovered, "hovered", 1),
-      onHoverOut: () => setLayer(hovered, "hovered", 0),
-      onFocus: () => {
-        setLayer(focused, "focused", 1);
-        if (isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
-      },
-      onBlur: () => {
-        setLayer(focused, "focused", 0);
-        setLayer(focusVisible, "focusVisible", 0);
-      }
-    }),
-    [setLayer, pressed, focused, focusVisible, hovered]
-  );
-  return { pressed, focused, focusVisible, hovered, handlers };
-}
-function layerTransition(layer, transition) {
-  if (!transition) return void 0;
-  if (isTopLevelTransition(transition)) return transition;
-  return transition[layer];
-}
-
-// src/gestureLayer/useGestureLayer.ts
 function useGestureLayer(states, options = {}) {
   const { disabled: isDisabled = false, transition: transitionInput } = options;
-  const shouldReduceMotion = useShouldReduceMotion();
-  const transition = resolveNamedTransitionProp(
+  const shouldReduceMotion = chunkJWHKMNYA_js.useShouldReduceMotion();
+  const transition = chunkJWHKMNYA_js.resolveNamedTransitionProp(
     transitionInput,
-    useNamedTransitions()
+    chunkJWHKMNYA_js.useNamedTransitions()
   );
-  const gesture = useGesture(transition);
+  const gesture = chunkK7ICHCTZ_js.useGesture(transition);
   const disabledProgress = reactNativeReanimated.useSharedValue(0);
-  const transitionSig = stableSig(transition);
+  const transitionSig = chunkSFRNO6AW_js.stableSig(transition);
   react.useEffect(() => {
     const target = isDisabled ? 1 : 0;
     const cfg = shouldReduceMotion ? { type: "no-animation" } : disabledTransition(transition) ?? { type: "spring" };
-    disabledProgress.value = resolveTransition(cfg, target);
+    disabledProgress.value = chunkSFRNO6AW_js.resolveTransition(cfg, target);
   }, [isDisabled, shouldReduceMotion, transitionSig, disabledProgress]);
   const meta = react.useMemo(() => {
     const layers = {
@@ -392,17 +130,32 @@ function useGestureLayer(states, options = {}) {
     }
     return out;
   });
+  const progress = react.useMemo(
+    () => ({
+      hovered: gesture.hovered,
+      focused: gesture.focused,
+      focusVisible: gesture.focusVisible,
+      pressed: gesture.pressed,
+      disabled: disabledProgress
+    }),
+    [
+      gesture.hovered,
+      gesture.focused,
+      gesture.focusVisible,
+      gesture.pressed,
+      disabledProgress
+    ]
+  );
   return {
     style,
-    handlers: gesture.handlers
+    handlers: gesture.handlers,
+    states: progress
   };
 }
 function disabledTransition(transition) {
   if (!transition) return void 0;
-  if (isTopLevelTransition(transition)) return transition;
+  if (chunkSFRNO6AW_js.isTopLevelTransition(transition)) return transition;
   return void 0;
 }
 
 exports.useGestureLayer = useGestureLayer;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map