@rootnative/inertia 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/chunk-IJNVUM5U.mjs

@@ -0,0 +1,6 @@
+import { createMotionComponent } from './chunk-I76OC6RX.mjs';
+import { Text } from 'react-native';
+
+var MotionText = createMotionComponent(Text);
+
+export { MotionText };

package/dist/chunk-K4KR5BIS.mjs

@@ -0,0 +1,6 @@
+import { createMotionComponent } from './chunk-I76OC6RX.mjs';
+import { Image } from 'react-native';
+
+var MotionImage = createMotionComponent(Image);
+
+export { MotionImage };

package/dist/chunk-L2EVRKSC.mjs

@@ -0,0 +1,104 @@
+import { stableSig, isTopLevelTransition } from './chunk-6FENLMCA.mjs';
+import { createContext, useContext, useMemo } from 'react';
+import { useReducedMotion } from 'react-native-reanimated';
+import { jsx } from 'react/jsx-runtime';
+import { Platform } from 'react-native';
+
+var DEFAULT_MOTION_CONFIG = {
+  reducedMotion: "user",
+  transitions: {}
+};
+var MotionConfigContext = createContext(
+  DEFAULT_MOTION_CONFIG
+);
+function useMotionConfig() {
+  return useContext(MotionConfigContext);
+}
+function useNamedTransitions() {
+  return useMotionConfig().transitions;
+}
+function useShouldReduceMotion() {
+  const { reducedMotion } = useMotionConfig();
+  const osReduced = useReducedMotion();
+  if (reducedMotion === "never") return false;
+  if (reducedMotion === "always") return true;
+  return osReduced;
+}
+function MotionConfig({
+  reducedMotion,
+  transitions,
+  children
+}) {
+  const parent = useMotionConfig();
+  const transitionsSig = stableSig(transitions);
+  const value = useMemo(
+    () => ({
+      reducedMotion: reducedMotion ?? parent.reducedMotion,
+      transitions: transitions ? { ...parent.transitions, ...transitions } : parent.transitions
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [reducedMotion, transitionsSig, parent]
+  );
+  return /* @__PURE__ */ jsx(MotionConfigContext.Provider, { value, children });
+}
+
+// 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 resolveNamedTransition(input, registry) {
+  if (input === void 0) return void 0;
+  if (typeof input === "string") return lookupNamedTransition(input, registry);
+  return input;
+}
+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;
+}
+var modality = "keyboard";
+var installed = false;
+function setKeyboard() {
+  modality = "keyboard";
+}
+function setPointer() {
+  modality = "pointer";
+}
+function ensureInstalled() {
+  if (installed) return;
+  if (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;
+}
+ensureInstalled();
+function isFocusVisible() {
+  if (Platform.OS !== "web") return true;
+  ensureInstalled();
+  return modality === "keyboard";
+}
+
+export { MotionConfig, isFocusVisible, lookupNamedTransition, resolveNamedTransition, resolveNamedTransitionProp, useMotionConfig, useNamedTransitions, useShouldReduceMotion };

package/dist/chunk-NDKVHL3N.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunk6UQ4KA6V_js = require('./chunk-6UQ4KA6V.js');
+var reactNative = require('react-native');
+
+var MotionImage = chunk6UQ4KA6V_js.createMotionComponent(reactNative.Image);
+
+exports.MotionImage = MotionImage;

package/dist/chunk-OBE7KTMK.mjs

@@ -0,0 +1,6 @@
+import { createMotionComponent } from './chunk-I76OC6RX.mjs';
+import { Pressable } from 'react-native';
+
+var MotionPressable = createMotionComponent(Pressable);
+
+export { MotionPressable };

package/dist/chunk-OM5FXU4I.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunk6UQ4KA6V_js = require('./chunk-6UQ4KA6V.js');
+var reactNative = require('react-native');
+
+var MotionPressable = chunk6UQ4KA6V_js.createMotionComponent(reactNative.Pressable);
+
+exports.MotionPressable = MotionPressable;

package/dist/chunk-Q6ZTMLTI.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var chunk6EP3S2PN_js = require('./chunk-6EP3S2PN.js');
+var chunkSFRNO6AW_js = require('./chunk-SFRNO6AW.js');
+var react = require('react');
+var reactNativeReanimated = require('react-native-reanimated');
+
+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 = chunk6EP3S2PN_js.useShouldReduceMotion();
+  const resolved = chunk6EP3S2PN_js.resolveNamedTransitionProp(transition, chunk6EP3S2PN_js.useNamedTransitions());
+  const setLayer = react.useCallback(
+    (sv, layer, target) => {
+      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };
+      sv.value = chunkSFRNO6AW_js.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 (chunk6EP3S2PN_js.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 (chunkSFRNO6AW_js.isTopLevelTransition(transition)) return transition;
+  return transition[layer];
+}
+
+exports.useGesture = useGesture;

package/dist/chunk-QQJSBIXV.mjs

@@ -0,0 +1,6 @@
+import { createMotionComponent } from './chunk-I76OC6RX.mjs';
+import { ScrollView } from 'react-native';
+
+var MotionScrollView = createMotionComponent(ScrollView);
+
+export { MotionScrollView };

package/dist/chunk-SCTX5Z7I.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunk6UQ4KA6V_js = require('./chunk-6UQ4KA6V.js');
+var reactNative = require('react-native');
+
+var MotionView = chunk6UQ4KA6V_js.createMotionComponent(reactNative.View);
+
+exports.MotionView = MotionView;

package/dist/chunk-SFRNO6AW.js

@@ -0,0 +1,267 @@
+'use strict';
+
+var reactNativeWorklets = require('react-native-worklets');
+var reactNativeReanimated = require('react-native-reanimated');
+
+// src/transitions/easing.ts
+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") {
+    if (cb) cb(true, toValue);
+    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 stripRepeat(cfg) {
+  if (!cfg) return cfg;
+  if (cfg.type === "no-animation" || cfg.type === "decay") return cfg;
+  if (cfg.repeat === void 0) return cfg;
+  const next = { ...cfg };
+  delete next.repeat;
+  return next;
+}
+function delayOf(cfg) {
+  if (cfg.type === "no-animation") return void 0;
+  return cfg.delay;
+}
+function isStepObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && "to" in v;
+}
+function resolveAnimatableValue(value, base, factory) {
+  if (Array.isArray(value)) {
+    const steps = value;
+    const stepBase = stripRepeat(base);
+    const animations = steps.map(
+      (step2, i) => resolveStep(step2, stepBase, factory?.("step", i))
+    );
+    const seq = reactNativeReanimated.withSequence(...animations);
+    return applyRepeat(seq, base ? repeatOf(base) : void 0);
+  }
+  const step = value;
+  const cb = factory?.("animation", void 0);
+  if (isStepObject(step)) {
+    return resolveStep(step, base, cb);
+  }
+  return resolveTransition(base, step, cb);
+}
+function resolveStep(step, base, cb) {
+  if (isStepObject(step)) {
+    const { to, ...override } = step;
+    const merged = mergeTransition(base, override);
+    return resolveTransition(merged, to, cb);
+  }
+  return resolveTransition(base, step, cb);
+}
+function mergeTransition(base, override) {
+  if (override.type && base && override.type !== base.type) {
+    return override;
+  }
+  return { ...base ?? { type: "spring" }, ...override };
+}
+var CSS_KEYWORDS = {
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+var CSS_FUNCTION = /^cubic-bezier\((.*)\)$/;
+function cubicBezier(first, y1, x2, y2) {
+  if (typeof first === "string") return fromCss(first);
+  return bezier(first, y1, x2, y2, void 0);
+}
+function fromCss(input) {
+  const token = input.trim().toLowerCase();
+  if (token === "linear") return reactNativeReanimated.Easing.linear;
+  const keyword = CSS_KEYWORDS[token];
+  if (keyword) return bezier(...keyword, input);
+  const match = CSS_FUNCTION.exec(token);
+  if (!match) {
+    throw new Error(
+      `[inertia] cubicBezier: unsupported easing token ${JSON.stringify(input)}. Expected four numbers, a 'cubic-bezier(x1, y1, x2, y2)' string, or one of the CSS keywords 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out'.`
+    );
+  }
+  const parts = match[1].split(",").map((p) => Number(p.trim()));
+  if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n))) {
+    throw new Error(
+      `[inertia] cubicBezier: could not parse ${JSON.stringify(input)} \u2014 expected exactly four finite numbers inside cubic-bezier(...).`
+    );
+  }
+  return bezier(parts[0], parts[1], parts[2], parts[3], input);
+}
+function bezier(x1, y1, x2, y2, source) {
+  const describe = () => source !== void 0 ? JSON.stringify(source) : `cubicBezier(${x1}, ${y1}, ${x2}, ${y2})`;
+  for (const n of [x1, y1, x2, y2]) {
+    if (typeof n !== "number" || !Number.isFinite(n)) {
+      throw new Error(
+        `[inertia] cubicBezier: ${describe()} \u2014 every control point must be a finite number.`
+      );
+    }
+  }
+  if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
+    throw new Error(
+      `[inertia] cubicBezier: ${describe()} \u2014 x1 and x2 must be within [0, 1] (got x1=${x1}, x2=${x2}).`
+    );
+  }
+  return reactNativeReanimated.Easing.bezier(x1, y1, x2, y2);
+}
+var DEFAULT_TIMING_DURATION2 = 250;
+function buildReleaseAnimation(transition, toValue) {
+  "worklet";
+  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "decay") {
+    const cfg = { velocity: transition.velocity ?? 0 };
+    if (transition.deceleration !== void 0) {
+      cfg.deceleration = transition.deceleration;
+    }
+    if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
+    return reactNativeReanimated.withDecay(cfg);
+  }
+  if (transition.type === "timing") {
+    const e = transition.easing;
+    const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? reactNativeReanimated.Easing.inOut(reactNativeReanimated.Easing.ease);
+    return reactNativeReanimated.withTiming(toValue, {
+      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+      easing: easingFn
+    });
+  }
+  return reactNativeReanimated.withSpring(toValue, springToReanimated(transition));
+}
+
+// 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/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(",") + "}";
+}
+
+exports.DEFAULT_SPRING = DEFAULT_SPRING;
+exports.buildReleaseAnimation = buildReleaseAnimation;
+exports.cubicBezier = cubicBezier;
+exports.ensureWorkletEasing = ensureWorkletEasing;
+exports.isTopLevelTransition = isTopLevelTransition;
+exports.resolveAnimatableValue = resolveAnimatableValue;
+exports.resolveTransition = resolveTransition;
+exports.springToReanimated = springToReanimated;
+exports.stableSig = stableSig;

package/dist/chunk-WPPLZNM4.mjs

@@ -0,0 +1,6 @@
+import { createMotionComponent } from './chunk-I76OC6RX.mjs';
+import { View } from 'react-native';
+
+var MotionView = createMotionComponent(View);
+
+export { MotionView };

package/dist/chunk-WZGMAXKC.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunk6UQ4KA6V_js = require('./chunk-6UQ4KA6V.js');
+var reactNative = require('react-native');
+
+var MotionText = chunk6UQ4KA6V_js.createMotionComponent(reactNative.Text);
+
+exports.MotionText = MotionText;

package/dist/chunk-ZQUCQRZT.mjs

@@ -0,0 +1,52 @@
+import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions, isFocusVisible } from './chunk-L2EVRKSC.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 };