@pixodesk/svg-animator-rn 1.0.21 → 1.0.22

package/dist/index.cjs

@@ -60,9 +60,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   PixodeskSvgAnimator: () => PixodeskSvgAnimator,
+  PxRnErrorBoundary: () => PxRnErrorBoundary,
   RN_SVG_COMPONENTS: () => RN_SVG_COMPONENTS,
   compileTracks: () => compileTracks,
   default: () => PixodeskSvgAnimator_default,
+  openClosedTextPathTargets: () => openClosedTextPathTargets,
   renderRnNode: () => renderRnNode,
   sampleProps: () => sampleProps,
   toRnPropName: () => toRnPropName,
@@ -71,8 +73,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/PixodeskSvgAnimator.tsx
-var import_svg_animator_core4 = require("@pixodesk/svg-animator-core");
-var import_react2 = require("react");
+var import_svg_animator_core5 = require("@pixodesk/svg-animator-core");
+var import_react3 = require("react");
+var import_react_native = require("react-native");
 var import_react_native_reanimated = __toESM(require("react-native-reanimated"), 1);
 
 // src/PxRnTracks.ts
@@ -80,6 +83,74 @@ var import_svg_animator_core2 = require("@pixodesk/svg-animator-core");
 
 // src/PxRnPropNames.ts
 var import_svg_animator_core = require("@pixodesk/svg-animator-core");
+
+// src/PxRnMatrix.ts
+var DEG = Math.PI / 180;
+function multiply(m1, m2) {
+  const [a1, b1, c1, d1, e1, f1] = m1;
+  const [a2, b2, c2, d2, e2, f2] = m2;
+  return [
+    a1 * a2 + c1 * b2,
+    b1 * a2 + d1 * b2,
+    a1 * c2 + c1 * d2,
+    b1 * c2 + d1 * d2,
+    a1 * e2 + c1 * f2 + e1,
+    b1 * e2 + d1 * f2 + f1
+  ];
+}
+var FN_RE = /([a-zA-Z]+)\s*\(([^)]*)\)/g;
+function numbers(raw) {
+  return raw.split(/[\s,]+/).filter((s) => s.length > 0).map(Number).filter((n) => Number.isFinite(n));
+}
+function svgTransformToMatrix(value) {
+  var _a;
+  let m;
+  FN_RE.lastIndex = 0;
+  let match;
+  while ((match = FN_RE.exec(value)) !== null) {
+    const fn = match[1].toLowerCase();
+    const n = numbers(match[2]);
+    let step;
+    switch (fn) {
+      case "translate":
+        step = [1, 0, 0, 1, n[0] || 0, n[1] || 0];
+        break;
+      case "scale": {
+        const sx = (_a = n[0]) != null ? _a : 1;
+        const sy = n.length > 1 ? n[1] : sx;
+        step = [sx, 0, 0, sy, 0, 0];
+        break;
+      }
+      case "rotate": {
+        const rad = (n[0] || 0) * DEG;
+        const cos = Math.cos(rad), sin = Math.sin(rad);
+        const rot = [cos, sin, -sin, cos, 0, 0];
+        if (n.length >= 3) {
+          const cx = n[1], cy = n[2];
+          step = multiply(multiply([1, 0, 0, 1, cx, cy], rot), [1, 0, 0, 1, -cx, -cy]);
+        } else {
+          step = rot;
+        }
+        break;
+      }
+      case "skewx":
+        step = [1, 0, Math.tan((n[0] || 0) * DEG), 1, 0, 0];
+        break;
+      case "skewy":
+        step = [1, Math.tan((n[0] || 0) * DEG), 0, 1, 0, 0];
+        break;
+      case "matrix":
+        if (n.length >= 6) step = [n[0], n[1], n[2], n[3], n[4], n[5]];
+        break;
+      default:
+        step = void 0;
+    }
+    if (step) m = m ? multiply(m, step) : step;
+  }
+  return m;
+}
+
+// src/PxRnPropNames.ts
 var ATTR_NAME_OVERRIDES = {
   "xlink:href": "href"
 };
@@ -91,7 +162,11 @@ function toRnPropName(attrName) {
   return (0, import_svg_animator_core.kebabToCamelCaseWord)(attrName);
 }
 var LENGTH_LIST_PROPS = /* @__PURE__ */ new Set(["strokeDasharray"]);
-function toRnPropValue(rnPropName, value) {
+function toRnPropValue(rnPropName, value, tag, native = false) {
+  if (native && rnPropName === "transform" && typeof value === "string" && tag !== "svg") {
+    const m = svgTransformToMatrix(value);
+    if (m) return m;
+  }
   if (LENGTH_LIST_PROPS.has(rnPropName)) {
     const parts = String(value).trim().replace(/,/g, " ").split(/\s+/).map(Number).filter((n) => Number.isFinite(n));
     return parts.length % 2 === 1 ? parts.concat(parts) : parts;
@@ -103,7 +178,7 @@ function toRnPropValue(rnPropName, value) {
 
 // src/PxRnTracks.ts
 function compileTracks(doc, opts) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const config = (0, import_svg_animator_core2.getAnimatorConfig)(doc) || {};
   const duration = +(config.duration || import_svg_animator_core2.DEFAULT_DURATION_MS);
   const _iterations = config.iterations;
@@ -111,11 +186,19 @@ function compileTracks(doc, opts) {
   if (typeof _iterations === "number") iterations = _iterations || 1;
   if (_iterations === "infinite") iterations = Infinity;
   if (iterations < 1) iterations = 1;
-  const sampleRate = (_a = opts == null ? void 0 : opts.sampleRate) != null ? _a : 60;
-  const maxSamples = (_b = opts == null ? void 0 : opts.maxSamples) != null ? _b : 600;
+  const native = (_a = opts == null ? void 0 : opts.native) != null ? _a : false;
+  const sampleRate = (_b = opts == null ? void 0 : opts.sampleRate) != null ? _b : 60;
+  const maxSamples = (_c = opts == null ? void 0 : opts.maxSamples) != null ? _c : 600;
   let sampleCount = Math.max(2, Math.round(duration / 1e3 * sampleRate) + 1);
   if (sampleCount > maxSamples) sampleCount = maxSamples;
   const stepMs = duration / (sampleCount - 1);
+  const tagById = /* @__PURE__ */ new Map();
+  const indexTags = (n) => {
+    var _a2;
+    if (n && typeof n.id === "string") tagById.set(n.id, String(n.type));
+    ((_a2 = n == null ? void 0 : n.children) != null ? _a2 : []).forEach(indexTags);
+  };
+  indexTags(doc);
   const bindings = (0, import_svg_animator_core2.getNormalisedBindings)(doc, import_svg_animator_core2.PxAnimatorEngine.frames) || [];
   const elements = [];
   for (const binding of bindings) {
@@ -131,9 +214,9 @@ function compileTracks(doc, opts) {
         let arr = props[rnProp];
         if (!arr) {
           arr = props[rnProp] = new Array(sampleCount);
-          for (let j = 0; j < i; j++) arr[j] = toRnPropValue(rnProp, value);
+          for (let j = 0; j < i; j++) arr[j] = toRnPropValue(rnProp, value, tagById.get(binding.id), native);
         }
-        arr[i] = toRnPropValue(rnProp, value);
+        arr[i] = toRnPropValue(rnProp, value, tagById.get(binding.id), native);
       }
     }
     for (const arr of Object.values(props)) {
@@ -150,20 +233,27 @@ function compileTracks(doc, opts) {
     iterations,
     direction: config.direction || "normal",
     delay: config.delay || 0,
-    fill: (_c = config.fill) != null ? _c : "forwards",
+    fill: (_d = config.fill) != null ? _d : "forwards",
+    resetOnFinish: !!config.resetOnFinish,
     stepMs,
     sampleCount,
     elements
   };
 }
-function sampleProps(tracks, tMs, stepMs, sampleCount) {
+function sampleProps(tracks, tMs, stepMs, sampleCount, native = false) {
   "worklet";
+  const out = {};
+  if (!tracks || !tracks.props || !(stepMs > 0)) return out;
   let idx = Math.round(tMs / stepMs);
   if (idx < 0) idx = 0;
   if (idx >= sampleCount) idx = sampleCount - 1;
-  const out = {};
   for (const key in tracks.props) {
-    out[key] = tracks.props[key][idx];
+    const values = tracks.props[key];
+    if (!values) continue;
+    const value = values[idx];
+    if (value === void 0) continue;
+    const name = native && key === "transform" ? "matrix" : key;
+    out[name] = value;
   }
   return out;
 }
@@ -175,8 +265,13 @@ var import_react = require("react");
 // src/PxRnTypeMap.ts
 var import_react_native_svg = require("react-native-svg");
 var RN_SVG_COMPONENTS = {
+  // Root & containers
   svg: import_react_native_svg.Svg,
   g: import_react_native_svg.G,
+  defs: import_react_native_svg.Defs,
+  symbol: import_react_native_svg.Symbol,
+  use: import_react_native_svg.Use,
+  // Shapes
   rect: import_react_native_svg.Rect,
   circle: import_react_native_svg.Circle,
   ellipse: import_react_native_svg.Ellipse,
@@ -184,24 +279,53 @@ var RN_SVG_COMPONENTS = {
   path: import_react_native_svg.Path,
   polygon: import_react_native_svg.Polygon,
   polyline: import_react_native_svg.Polyline,
+  image: import_react_native_svg.Image,
+  // Text
   text: import_react_native_svg.Text,
   tspan: import_react_native_svg.TSpan,
   textPath: import_react_native_svg.TextPath,
-  defs: import_react_native_svg.Defs,
+  // Paint servers & clipping
   linearGradient: import_react_native_svg.LinearGradient,
   radialGradient: import_react_native_svg.RadialGradient,
   stop: import_react_native_svg.Stop,
-  use: import_react_native_svg.Use,
-  symbol: import_react_native_svg.Symbol,
+  pattern: import_react_native_svg.Pattern,
   mask: import_react_native_svg.Mask,
   clipPath: import_react_native_svg.ClipPath,
-  pattern: import_react_native_svg.Pattern,
   marker: import_react_native_svg.Marker,
-  image: import_react_native_svg.Image
+  // Filters — react-native-svg implements the full primitive set.
+  // NOTE: filter rendering requires the New Architecture (Fabric) and is
+  // newer than the rest of react-native-svg; treat visual parity with the
+  // web player as unverified until checked on a device.
+  filter: import_react_native_svg.Filter,
+  feBlend: import_react_native_svg.FeBlend,
+  feColorMatrix: import_react_native_svg.FeColorMatrix,
+  feComponentTransfer: import_react_native_svg.FeComponentTransfer,
+  feComposite: import_react_native_svg.FeComposite,
+  feConvolveMatrix: import_react_native_svg.FeConvolveMatrix,
+  feDiffuseLighting: import_react_native_svg.FeDiffuseLighting,
+  feDisplacementMap: import_react_native_svg.FeDisplacementMap,
+  feDistantLight: import_react_native_svg.FeDistantLight,
+  feDropShadow: import_react_native_svg.FeDropShadow,
+  feFlood: import_react_native_svg.FeFlood,
+  feFuncA: import_react_native_svg.FeFuncA,
+  feFuncB: import_react_native_svg.FeFuncB,
+  feFuncG: import_react_native_svg.FeFuncG,
+  feFuncR: import_react_native_svg.FeFuncR,
+  feGaussianBlur: import_react_native_svg.FeGaussianBlur,
+  feImage: import_react_native_svg.FeImage,
+  feMerge: import_react_native_svg.FeMerge,
+  feMergeNode: import_react_native_svg.FeMergeNode,
+  feMorphology: import_react_native_svg.FeMorphology,
+  feOffset: import_react_native_svg.FeOffset,
+  fePointLight: import_react_native_svg.FePointLight,
+  feSpecularLighting: import_react_native_svg.FeSpecularLighting,
+  feSpotLight: import_react_native_svg.FeSpotLight,
+  feTile: import_react_native_svg.FeTile,
+  feTurbulence: import_react_native_svg.FeTurbulence
 };
 
 // src/PxRnRender.tsx
-function toRnProps(props, warnings) {
+function toRnProps(props, warnings, tag) {
   const normalised = (0, import_svg_animator_core3.getNormalizedProps)(props);
   const out = {};
   for (const key of Object.keys(normalised)) {
@@ -209,7 +333,7 @@ function toRnProps(props, warnings) {
     if (sanitised === void 0) continue;
     const rnKey = toRnPropName(key);
     if (!rnKey) continue;
-    out[rnKey] = toRnPropValue(rnKey, String(sanitised));
+    out[rnKey] = toRnPropValue(rnKey, String(sanitised), tag);
   }
   return out;
 }
@@ -218,42 +342,164 @@ function renderRnNode(node, opts = {}, key) {
   if (!node) return null;
   const _a = node, { type, children, style, animate, meta, effects } = _a, props = __objRest(_a, ["type", "children", "style", "animate", "meta", "effects"]);
   const tag = String(type || "g");
+  const feFuncType = props.funcType;
+  if (feFuncType !== void 0) delete props.funcType;
   if (import_svg_animator_core3.DISALLOWED_SVG_TAGS_LOWER.has(tag.toLowerCase())) {
     (_b = opts.warnings) == null ? void 0 : _b.push("tag blocked (dangerous): " + tag);
     return null;
   }
-  const Component = RN_SVG_COMPONENTS[tag];
-  if (!Component) {
+  const Component2 = RN_SVG_COMPONENTS[tag];
+  if (!Component2) {
     (_c = opts.warnings) == null ? void 0 : _c.push("tag not supported in react-native-svg mapping: " + tag);
     return null;
   }
-  const rnProps = toRnProps(props, opts.warnings);
-  if (key !== void 0) rnProps.key = key;
+  const rnProps = toRnProps(props, opts.warnings, tag);
+  if (feFuncType !== void 0) rnProps.type = feFuncType;
+  const resolved = (0, import_svg_animator_core3.resolveStyle)(style, opts.defs);
+  if (resolved) {
+    for (const [k, v] of Object.entries(resolved)) {
+      const rnKey = toRnPropName(k);
+      if (!rnKey || rnKey in rnProps) continue;
+      const sanitised = (0, import_svg_animator_core3.sanitiseAttributeValue)(rnKey, v);
+      if (sanitised === void 0) continue;
+      rnProps[rnKey] = toRnPropValue(rnKey, String(sanitised), tag);
+    }
+  }
   const textContent = props[import_svg_animator_core3.TEXT_ATTR] || props[import_svg_animator_core3.TEXT_CONTENT_ATTR];
   let childElements = void 0;
   if (Array.isArray(children) && children.length > 0) {
-    childElements = children.map((ch, i) => renderRnNode(ch, opts, i)).filter(Boolean);
+    childElements = children.map((ch, i) => {
+      var _a2;
+      try {
+        return renderRnNode(ch, opts, i);
+      } catch (e) {
+        (_a2 = opts.warnings) == null ? void 0 : _a2.push("child failed to render: " + (e instanceof Error ? e.message : String(e)));
+        return null;
+      }
+    }).filter(Boolean);
   } else if (textContent !== void 0) {
     childElements = String(textContent);
   }
-  const decorated = (_d = opts.decorate) == null ? void 0 : _d.call(opts, node, Component, rnProps, childElements);
+  const decorated = (_d = opts.decorate) == null ? void 0 : _d.call(opts, node, Component2, rnProps, childElements, key);
   if (decorated !== void 0) return decorated;
-  return (0, import_react.createElement)(Component, rnProps, childElements);
+  return (0, import_react.createElement)(
+    Component2,
+    key !== void 0 ? __spreadProps(__spreadValues({}, rnProps), { key }) : rnProps,
+    childElements
+  );
+}
+
+// src/PxRnErrorBoundary.tsx
+var import_react2 = require("react");
+var PxRnErrorBoundary = class extends import_react2.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    var _a, _b, _c, _d;
+    (_c = (_b = this.props).onError) == null ? void 0 : _c.call(_b, error, (_a = info == null ? void 0 : info.componentStack) != null ? _a : void 0);
+    console.warn("[PixodeskSvgAnimator] render failed:", (_d = error == null ? void 0 : error.message) != null ? _d : error);
+  }
+  componentDidUpdate(prev) {
+    if (this.state.error && prev.children !== this.props.children) {
+      this.setState({ error: null });
+    }
+  }
+  render() {
+    const { error } = this.state;
+    if (error) return this.props.fallback ? this.props.fallback(error) : null;
+    return this.props.children;
+  }
+};
+
+// src/PxRnSafety.ts
+var import_svg_animator_core4 = require("@pixodesk/svg-animator-core");
+function isClosedPath(d) {
+  return typeof d === "string" && /[zZ]/.test(d);
+}
+function openPath(d) {
+  return d.replace(/[zZ]/g, "").trimEnd();
+}
+function localRef(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.startsWith("#") ? trimmed.slice(1) : void 0;
+}
+function forEachNode(node, visit, parent) {
+  var _a;
+  if (!node) return;
+  visit(node, parent);
+  for (const child of (_a = node.children) != null ? _a : []) forEachNode(child, visit, node);
+}
+function openClosedTextPathTargets(doc, warnings) {
+  var _a;
+  let hasTextPath = false;
+  forEachNode(doc, (n) => {
+    if (String(n.type) === "textPath") hasTextPath = true;
+  });
+  if (!hasTextPath) return doc;
+  const result = (0, import_svg_animator_core4.deepClone)(doc);
+  const byId = /* @__PURE__ */ new Map();
+  forEachNode(result, (n) => {
+    const id = n.id;
+    if (typeof id === "string") byId.set(id, n);
+  });
+  let defs = ((_a = result.children) != null ? _a : []).find((c) => String(c.type) === "defs");
+  const ensureDefs = () => {
+    var _a2;
+    if (!defs) {
+      defs = { type: "defs", children: [] };
+      ((_a2 = result.children) != null ? _a2 : result.children = []).unshift(defs);
+    }
+    return defs;
+  };
+  const openCopies = /* @__PURE__ */ new Map();
+  forEachNode(result, (node) => {
+    var _a2, _b;
+    if (String(node.type) !== "textPath") return;
+    const anyNode = node;
+    const attr = anyNode.href !== void 0 ? "href" : "xlink:href";
+    const targetId = localRef(anyNode[attr]);
+    if (!targetId) return;
+    const target = byId.get(targetId);
+    if (!target || !isClosedPath(target.d)) return;
+    let copyId = openCopies.get(targetId);
+    if (!copyId) {
+      const copy = (0, import_svg_animator_core4.deepClone)(target);
+      copyId = "px_open_" + (0, import_svg_animator_core4.generateUniqueId)();
+      copy.id = copyId;
+      copy.d = openPath(String(copy.d));
+      delete copy.animate;
+      delete copy.effects;
+      ((_b = (_a2 = ensureDefs()).children) != null ? _b : _a2.children = []).push(copy);
+      openCopies.set(targetId, copyId);
+      warnings == null ? void 0 : warnings.push(
+        "textPath follows a closed path (#" + targetId + "); using an open copy to avoid a react-native-svg native crash"
+      );
+    }
+    anyNode[attr] = "#" + copyId;
+  });
+  return result;
 }
 
 // src/PixodeskSvgAnimator.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
+var NATIVE_SVG_VIEWS = import_react_native.Platform.OS !== "web";
 var animatedComponentCache = /* @__PURE__ */ new Map();
-function getAnimatedComponent(Component) {
-  let cached = animatedComponentCache.get(Component);
+function getAnimatedComponent(Component2) {
+  let cached = animatedComponentCache.get(Component2);
   if (!cached) {
-    cached = import_react_native_reanimated.default.createAnimatedComponent(Component);
-    animatedComponentCache.set(Component, cached);
+    cached = import_react_native_reanimated.default.createAnimatedComponent(Component2);
+    animatedComponentCache.set(Component2, cached);
   }
   return cached;
 }
 function AnimatedPxElement({
-  Component,
+  Component: Component2,
   staticProps,
   children,
   tracks,
@@ -261,12 +507,83 @@ function AnimatedPxElement({
   stepMs,
   sampleCount
 }) {
-  const AnimatedComponent = (0, import_react2.useMemo)(() => getAnimatedComponent(Component), [Component]);
+  const AnimatedComponent = (0, import_react3.useMemo)(() => getAnimatedComponent(Component2), [Component2]);
   const animatedProps = (0, import_react_native_reanimated.useAnimatedProps)(() => {
-    return sampleProps(tracks, progress.value, stepMs, sampleCount);
+    return sampleProps(tracks, progress.value, stepMs, sampleCount, NATIVE_SVG_VIEWS);
   }, [tracks, stepMs, sampleCount]);
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedComponent, __spreadProps(__spreadValues({}, staticProps), { animatedProps, children }));
 }
+var NON_HOST_TAGS = /* @__PURE__ */ new Set(["stop", "feMergeNode"]);
+var SAMPLED_DEF_TAGS = /* @__PURE__ */ new Set(["linearGradient", "radialGradient", ...NON_HOST_TAGS]);
+function needsJsSampling(node, trackById) {
+  var _a;
+  const id = node.id;
+  if (SAMPLED_DEF_TAGS.has(String(node.type)) && id && trackById.has(id)) return true;
+  return ((_a = node.children) != null ? _a : []).some((c) => needsJsSampling(c, trackById));
+}
+function SampledSubtree({
+  node,
+  trackById,
+  progress,
+  stepMs,
+  sampleCount,
+  renderOpts
+}) {
+  const [idx, setIdx] = (0, import_react3.useState)(0);
+  (0, import_react_native_reanimated.useAnimatedReaction)(
+    () => Math.floor(Math.round(progress.value / stepMs) / 2) * 2,
+    // half-rate
+    (next, prev) => {
+      if (next !== prev) (0, import_react_native_reanimated.runOnJS)(setIdx)(next);
+    },
+    [stepMs]
+  );
+  const tMs = Math.min(Math.max(idx, 0), sampleCount - 1) * stepMs;
+  return renderRnNode(node, __spreadProps(__spreadValues({}, renderOpts), {
+    // Sampled values are baked in as PLAIN props — nothing reanimated-driven.
+    decorate: (n, Component2, staticProps, children, key) => {
+      const id = n.id;
+      const tracks = id ? trackById.get(id) : void 0;
+      if (!tracks) return void 0;
+      const sampled = sampleProps(tracks, tMs, stepMs, sampleCount);
+      return (0, import_react3.createElement)(Component2, __spreadProps(__spreadValues(__spreadValues({}, staticProps), sampled), { key }), children);
+    }
+  }));
+}
+var EMPTY_TRACKS = {
+  duration: 1,
+  iterations: 1,
+  direction: "normal",
+  delay: 0,
+  fill: "forwards",
+  resetOnFinish: false,
+  stepMs: 1,
+  sampleCount: 2,
+  elements: []
+};
+function compileDocument(doc, overrides) {
+  const { duration, delay, iterations, fill, direction, resetOnFinish } = overrides;
+  const warnings = (0, import_svg_animator_core5.validateNodeEffects)(doc);
+  for (const w of warnings) console.warn("[PixodeskSvgAnimator] effects shape warning:", w);
+  let prepared = (0, import_svg_animator_core5.materialiseAllInTree)(doc, import_svg_animator_core5.PxAnimatorEngine.webapi);
+  if (NATIVE_SVG_VIEWS) {
+    prepared = openClosedTextPathTargets(prepared);
+  }
+  const animator = (0, import_svg_animator_core5.getAnimatorConfig)(prepared) || {};
+  prepared = __spreadProps(__spreadValues({}, prepared), {
+    animator: __spreadProps(__spreadValues({}, animator), {
+      duration: duration !== void 0 ? duration : animator.duration,
+      delay: delay !== void 0 ? delay : animator.delay,
+      iterations: iterations !== void 0 ? iterations : animator.iterations,
+      fill: fill !== void 0 ? fill : animator.fill,
+      direction: direction !== void 0 ? direction : animator.direction,
+      resetOnFinish: resetOnFinish !== void 0 ? resetOnFinish : animator.resetOnFinish
+    })
+  });
+  prepared = (0, import_svg_animator_core5.generateNewIds)(prepared);
+  const tracks = compileTracks(prepared, { native: NATIVE_SVG_VIEWS });
+  return { doc: prepared, tracks, error: null };
+}
 function PixodeskSvgAnimator({
   doc,
   duration,
@@ -274,6 +591,8 @@ function PixodeskSvgAnimator({
   iterations,
   fill,
   direction,
+  resetOnFinish,
+  outAction: outActionProp,
   autoplay,
   play,
   pause,
@@ -284,49 +603,54 @@ function PixodeskSvgAnimator({
   onStop,
   onPause,
   onCancel,
-  onFinish
+  onFinish,
+  onError,
+  fallback
 }) {
-  var _a, _b, _c;
-  const compiled = (0, import_react2.useMemo)(() => {
-    const warnings = (0, import_svg_animator_core4.validateNodeEffects)(doc);
-    for (const w of warnings) console.warn("[PixodeskSvgAnimator] effects shape warning:", w);
-    let prepared = (0, import_svg_animator_core4.materialiseAllInTree)(doc, import_svg_animator_core4.PxAnimatorEngine.webapi);
-    const animator = (0, import_svg_animator_core4.getAnimatorConfig)(prepared) || {};
-    prepared = __spreadProps(__spreadValues({}, prepared), {
-      animator: __spreadProps(__spreadValues({}, animator), {
-        duration: duration !== void 0 ? duration : animator.duration,
-        delay: delay !== void 0 ? delay : animator.delay,
-        iterations: iterations !== void 0 ? iterations : animator.iterations,
-        fill: fill !== void 0 ? fill : animator.fill,
-        direction: direction !== void 0 ? direction : animator.direction
-      })
-    });
-    prepared = (0, import_svg_animator_core4.generateNewIds)(prepared);
-    const tracks2 = compileTracks(prepared);
-    return { doc: prepared, tracks: tracks2 };
-  }, [doc, duration, delay, iterations, fill, direction]);
+  var _a, _b, _c, _d;
+  const compiled = (0, import_react3.useMemo)(() => {
+    try {
+      return compileDocument(
+        doc,
+        { duration, delay, iterations, fill, direction, resetOnFinish }
+      );
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      console.warn("[PixodeskSvgAnimator] could not compile the document:", error.message);
+      return { doc: null, tracks: EMPTY_TRACKS, error };
+    }
+  }, [doc, duration, delay, iterations, fill, direction, resetOnFinish]);
   const tracks = compiled.tracks;
   const totalDuration = tracks.duration * (tracks.iterations === Infinity ? 1 : tracks.iterations);
   const progress = (0, import_react_native_reanimated.useSharedValue)(0);
-  const playingRef = (0, import_react2.useRef)(false);
-  const rateRef = (0, import_react2.useRef)(1);
+  const playingRef = (0, import_react3.useRef)(false);
+  const rateRef = (0, import_react3.useRef)(1);
+  const reversePlayback = () => rateRef.current < 0;
+  const restingPosition = () => {
+    if (tracks.resetOnFinish) return 0;
+    if (tracks.fill === "none" || tracks.fill === "backwards") return 0;
+    return reversePlayback() ? 0 : tracks.duration;
+  };
   const notifyFinish = () => {
     playingRef.current = false;
-    if (tracks.fill === "none" || tracks.fill === "backwards") progress.value = 0;
+    progress.value = restingPosition();
     onFinish == null ? void 0 : onFinish();
     onStop == null ? void 0 : onStop();
   };
   const startFrom = (fromMs) => {
     const dur = tracks.duration;
     const rate = rateRef.current || 1;
-    const reversedStart = tracks.direction === "reverse" || tracks.direction === "alternate-reverse";
+    const backwards = rate < 0;
+    const speed = Math.abs(rate);
+    const directionReversed = tracks.direction === "reverse" || tracks.direction === "alternate-reverse";
+    const reversedStart = backwards ? !directionReversed : directionReversed;
     const alternates = tracks.direction === "alternate" || tracks.direction === "alternate-reverse";
     const from = Math.max(0, Math.min(fromMs, dur));
     const legTarget = reversedStart ? 0 : dur;
-    const legRemaining = Math.abs(legTarget - from) / rate;
+    const legRemaining = Math.abs(legTarget - from) / speed;
     const repeats = tracks.iterations === Infinity ? -1 : tracks.iterations;
     (0, import_react_native_reanimated.cancelAnimation)(progress);
-    progress.value = reversedStart ? from === 0 ? dur : from : from;
+    progress.value = reversedStart ? from <= 0 ? dur : from : from >= dur ? 0 : from;
     const animation = repeats === 1 ? (0, import_react_native_reanimated.withTiming)(legTarget, { duration: legRemaining, easing: import_react_native_reanimated.Easing.linear }, (finished) => {
       "worklet";
       if (finished) (0, import_react_native_reanimated.runOnJS)(notifyFinish)();
@@ -339,14 +663,13 @@ function PixodeskSvgAnimator({
         if (finished) (0, import_react_native_reanimated.runOnJS)(notifyFinish)();
       }
     );
-    progress.value = tracks.delay > 0 && from === 0 ? (0, import_react_native_reanimated.withDelay)(tracks.delay / rate, animation) : animation;
+    progress.value = tracks.delay > 0 && from === 0 ? (0, import_react_native_reanimated.withDelay)(tracks.delay / speed, animation) : animation;
     playingRef.current = true;
   };
   const api = {
     isPlaying: () => playingRef.current,
     play: () => {
-      const from = playingRef.current ? progress.value : progress.value >= tracks.duration ? 0 : progress.value;
-      startFrom(from);
+      startFrom(progress.value);
       onPlay == null ? void 0 : onPlay();
     },
     pause: () => {
@@ -364,14 +687,14 @@ function PixodeskSvgAnimator({
     },
     finish: () => {
       (0, import_react_native_reanimated.cancelAnimation)(progress);
-      progress.value = tracks.fill === "none" || tracks.fill === "backwards" ? 0 : tracks.duration;
       playingRef.current = false;
+      progress.value = restingPosition();
       onFinish == null ? void 0 : onFinish();
       onStop == null ? void 0 : onStop();
     },
     setPlaybackRate: (rate) => {
-      if (!isFinite(rate) || rate <= 0) {
-        console.warn("setPlaybackRate: only finite positive rates are supported in the RN player (reverse is on the feature-gap list)");
+      if (!isFinite(rate) || rate === 0) {
+        console.warn("setPlaybackRate: rate must be finite and non-zero");
         return;
       }
       rateRef.current = rate;
@@ -379,15 +702,20 @@ function PixodeskSvgAnimator({
     },
     getCurrentTime: () => progress.value,
     setCurrentTime: (t) => {
+      const wasPlaying = playingRef.current;
       (0, import_react_native_reanimated.cancelAnimation)(progress);
       playingRef.current = false;
       const clamped = Math.max(0, Math.min(t, totalDuration));
-      progress.value = tracks.duration > 0 ? clamped % tracks.duration || (clamped === 0 ? 0 : tracks.duration) : 0;
+      const withinIteration = tracks.duration > 0 ? clamped % tracks.duration || (clamped === 0 ? 0 : tracks.duration) : 0;
+      progress.value = withinIteration;
+      if (wasPlaying) startFrom(withinIteration);
     }
   };
-  (0, import_react2.useImperativeHandle)(apiRef, () => api, [compiled]);
-  const startOn = (_c = (_b = (_a = (0, import_svg_animator_core4.getAnimatorConfig)(compiled.doc)) == null ? void 0 : _a.trigger) == null ? void 0 : _b.startOn) != null ? _c : "load";
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useImperativeHandle)(apiRef, () => api, [compiled]);
+  const trigger = compiled.doc ? (_a = (0, import_svg_animator_core5.getAnimatorConfig)(compiled.doc)) == null ? void 0 : _a.trigger : void 0;
+  const startOn = (_b = trigger == null ? void 0 : trigger.startOn) != null ? _b : "load";
+  const outAction = (_c = outActionProp != null ? outActionProp : trigger == null ? void 0 : trigger.outAction) != null ? _c : "pause";
+  (0, import_react3.useEffect)(() => {
     if (time !== void 0 || timeMs !== void 0) {
       const seekMs = timeMs !== void 0 ? timeMs : (time != null ? time : 0) * totalDuration;
       api.setCurrentTime(seekMs);
@@ -404,53 +732,142 @@ function PixodeskSvgAnimator({
       api.play();
     }
   }, [compiled, autoplay, play, pause, time, timeMs]);
-  (0, import_react2.useEffect)(() => {
+  const scrollRef = (0, import_react3.useRef)(null);
+  const inViewRef = (0, import_react3.useRef)(false);
+  (0, import_react3.useEffect)(() => {
+    var _a2;
+    if (!autoplay || startOn !== "scrollIntoView") return;
+    const threshold = (_a2 = trigger == null ? void 0 : trigger.scrollIntoViewThreshold) != null ? _a2 : 0;
+    inViewRef.current = false;
+    const check = () => {
+      const node = scrollRef.current;
+      if (!node) return;
+      node.measureInWindow((_x, y, _w, h) => {
+        if (!h) return;
+        const screen = import_react_native.Dimensions.get("window").height;
+        const visible = Math.max(0, Math.min(y + h, screen) - Math.max(y, 0));
+        const ratio = visible / h;
+        const isIn = ratio > 0 && ratio >= threshold;
+        if (isIn === inViewRef.current) return;
+        inViewRef.current = isIn;
+        if (isIn) {
+          if (rateRef.current < 0) api.setPlaybackRate(Math.abs(rateRef.current));
+          api.play();
+        } else if (outAction === "reset") api.cancel();
+        else if (outAction === "reverse") {
+          api.setPlaybackRate(-Math.abs(rateRef.current || 1));
+          api.play();
+        } else if (outAction !== "continue") api.pause();
+      });
+    };
+    check();
+    const id = setInterval(check, 200);
+    return () => clearInterval(id);
+  }, [compiled, autoplay, startOn, outAction]);
+  (0, import_react3.useEffect)(() => {
     return () => {
       (0, import_react_native_reanimated.cancelAnimation)(progress);
       playingRef.current = false;
     };
   }, [compiled]);
-  const trackById = (0, import_react2.useMemo)(() => {
+  const trackById = (0, import_react3.useMemo)(() => {
     const map = /* @__PURE__ */ new Map();
     for (const el of tracks.elements) map.set(el.id, el);
     return map;
   }, [tracks]);
-  const warningsRef = (0, import_react2.useRef)([]);
-  const root = (0, import_react2.useMemo)(() => {
+  const warningsRef = (0, import_react3.useRef)([]);
+  const renderErrorRef = (0, import_react3.useRef)(null);
+  const root = (0, import_react3.useMemo)(() => {
     warningsRef.current = [];
-    return renderRnNode(compiled.doc, {
+    renderErrorRef.current = null;
+    if (!compiled.doc) return null;
+    const renderOpts = {
       warnings: warningsRef.current,
-      decorate: (node, Component, staticProps, children) => {
-        const id = node.id;
-        const elTracks = id ? trackById.get(id) : void 0;
-        if (!elTracks) return void 0;
-        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-          AnimatedPxElement,
-          {
-            Component,
-            staticProps,
-            tracks: elTracks,
-            progress,
-            stepMs: tracks.stepMs,
-            sampleCount: tracks.sampleCount,
-            children
-          },
-          staticProps.key
-        );
-      }
-    });
+      defs: (0, import_svg_animator_core5.getDefs)(compiled.doc)
+    };
+    try {
+      return renderRnNode(compiled.doc, __spreadProps(__spreadValues({}, renderOpts), {
+        decorate: (node, Component2, staticProps, children, key) => {
+          if (needsJsSampling(node, trackById)) {
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              SampledSubtree,
+              {
+                node,
+                trackById,
+                progress,
+                stepMs: tracks.stepMs,
+                sampleCount: tracks.sampleCount,
+                renderOpts
+              },
+              key
+            );
+          }
+          const id = node.id;
+          const elTracks = id ? trackById.get(id) : void 0;
+          if (!elTracks) return void 0;
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            AnimatedPxElement,
+            {
+              Component: Component2,
+              staticProps,
+              tracks: elTracks,
+              progress,
+              stepMs: tracks.stepMs,
+              sampleCount: tracks.sampleCount,
+              children
+            },
+            key
+          );
+        }
+      }));
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      renderErrorRef.current = error;
+      console.warn("[PixodeskSvgAnimator] could not render the document:", error.message);
+      return null;
+    }
   }, [compiled, trackById]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     for (const w of warningsRef.current) console.warn("[PixodeskSvgAnimator]", w);
   }, [root]);
-  return root;
+  const failure = (_d = compiled.error) != null ? _d : renderErrorRef.current;
+  (0, import_react3.useEffect)(() => {
+    if (failure) onError == null ? void 0 : onError(failure);
+  }, [failure]);
+  if (failure) return fallback ? fallback(failure) : null;
+  let content = root;
+  if (autoplay && startOn === "scrollIntoView" && root) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.View, { ref: scrollRef, collapsable: false, children: root });
+  } else if (autoplay && startOn === "click" && root) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_react_native.Pressable,
+      {
+        onPress: () => {
+          if (playingRef.current) {
+            if (outAction === "reset") api.cancel();
+            else if (outAction === "reverse") {
+              api.setPlaybackRate(-Math.abs(rateRef.current || 1));
+              api.play();
+            } else if (outAction !== "continue") api.pause();
+          } else {
+            if (rateRef.current < 0) api.setPlaybackRate(Math.abs(rateRef.current));
+            api.play();
+          }
+        },
+        children: root
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PxRnErrorBoundary, { onError, fallback, children: content });
 }
 var PixodeskSvgAnimator_default = PixodeskSvgAnimator;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PixodeskSvgAnimator,
+  PxRnErrorBoundary,
   RN_SVG_COMPONENTS,
   compileTracks,
+  openClosedTextPathTargets,
   renderRnNode,
   sampleProps,
   toRnPropName,