@pixodesk/svg-animator-rn 1.0.39 → 1.0.40

package/README.md

@@ -188,9 +188,10 @@ const [time, setTime] = useState(0);
 | `onCancel` | `() => void` | Called on cancel |
 | `onRemove` | `() => void` | Called when the animator is thrown away — the component unmounted, or a new `doc` replaced it |
 | `onStop` | `() => void` | Called whenever playback halts (pause / cancel / finish / remove) |
-| `onError` | `(error, componentStack?) => void` | Called when a document cannot be compiled or rendered |
-| `onWarn` | `(diagnostic) => void` | something is off but the animation still plays; without it → `console.warn` |
-| `silent` | `boolean \| PxDiagnosticKind[]` | silences the console fallback — everything, or just the kinds listed |
+| `onError` | `(diagnostic) => void` | this instance will not play — the document could not be compiled or rendered; `fallback` shows instead. `diagnostic.error` is the Error, `diagnostic.detail.componentStack` when the error boundary caught it |
+| `onWarn` | `(diagnostic) => void` | it plays, but something was ignored, degraded or misspelled; without it → `console.warn` |
+| `muteWarn` | `boolean` | switch the `console.warn` fallback off — for when you know the player has something to say about this document and are prepared to tolerate it. `onWarn`, if you gave it, still fires: mute is about the console, not about you |
+| `muteError` | `boolean` | the same switch for `console.error` |
 | `fallback` | `(error) => ReactElement \| null` | Rendered in place of a failed animation (default: nothing) |
 
 With none of `autoplay` / `play` / `pause` / `progress` / `time` set, the component
@@ -200,14 +201,14 @@ renders the animation statically (initial state, no playback).
 
 The component never throws for a bad document. Compilation and rendering both
 run inside `try`/`catch`, and the rendered tree sits behind an error boundary,
-so a failure is reported through `onError` and shows `fallback` while the
-surrounding screen keeps working.
+so a failure is reported through `onError` — the shared diagnostic (`diagnostic.error` is the
+Error), exactly as on the web — and shows `fallback` while the surrounding screen keeps working.
 
 ```tsx
 <PixodeskSvgAnimator
     doc={doc}
     autoplay
-    onError={e => console.warn('animation failed:', e.message)}
+    onError={d => console.warn('animation failed:', d.message)}
     fallback={() => <Text>could not play this animation</Text>}
 />
 ```
@@ -222,7 +223,7 @@ renderer never reaches JavaScript and cannot be caught — see
 | Prop | Why it differs |
 |---|---|
 | `timeline.engine` | Accepted inside `timeline` but ignored. There is no Web Animations API on React Native; playback is always native-driven. |
-| `timeline.frameRate` | Ignored. The screen's own refresh rate is used. The player does not compute values frame by frame: when the document loads it works out the animated values in advance, as a list of snapshots (60 per second of animation), and each screen refresh shows the nearest one. The closest thing to a frame rate is how many snapshots per second are prepared — `compileTracks({ sampleRate })`, only available when you use the lower-level API instead of the component. |
+| `timeline.frameRate` | Ignored. The screen's own refresh rate is used. The player does not compute values frame by frame: when the document loads it works out the animated values in advance, as a list of snapshots (60 per second of animation), and each screen refresh shows the nearest one. The closest thing to a frame rate is how many snapshots per second are prepared, which the player fixes at 60. |
 | `startOn: 'mouseOver'` | Has no touch equivalent, so it is not honored. The other four values (`load`, `click`, `scrollIntoView`, `programmatic`) work as they do on the web, from the file or from the `startOn` prop. |
 | `className` / `style` | Not accepted — you cannot style the component itself. It fills whatever `View` you put it in, so to set its size, give that `View` a `width` and `height`. Styling *inside* the document (`style` on an element in the JSON) is supported. |
 | `onRemove` | Never called. On the web it tells you the animator was thrown away; here there is nothing to tell — when the component leaves the screen, React removes it and everything it created. To run code at that moment, use a `useEffect` cleanup function in your own component. |
@@ -259,7 +260,7 @@ properties actually change over time.
 |---|---|---|
 | `svg`, `g`, `defs` | ✅ | |
 | `rect`, `circle`, `ellipse`, `line`, `path`, `polygon`, `polyline` | ✅ | |
-| `text`, `tspan` | ✅ | content via the `text` attribute |
+| `text`, `tspan` | ✅ | content via `textContent` |
 | `textPath` | ✅ | see *Text along a path* below |
 | `image` | ✅ | `href` accepts `data:` URIs; remote URLs are blocked by the sanitizer |
 | `use`, `symbol` | ✅ | animated targets are **inlined into real clones** before render — `<use>` does not propagate animation natively in React Native |
@@ -275,16 +276,16 @@ properties actually change over time.
 <!-- px-check off support matrix, prose -->
 | Attribute | Animates | Notes |
 |---|---|---|
-| `opacity`, `fill-opacity`, `stroke-opacity` | ✅ | |
-| `fill`, `stroke`, `stop-color` | ✅ | interpolated as RGBA |
-| `stroke-width`, `stroke-dasharray`, `stroke-dashoffset` | ✅ | dash arrays are converted to the numeric form React Native expects |
+| `opacity`, `fillOpacity`, `strokeOpacity` | ✅ | |
+| `fill`, `stroke`, `stopColor` | ✅ | interpolated as RGBA |
+| `strokeWidth`, `strokeDasharray`, `strokeDashoffset` | ✅ | dash arrays are converted to the numeric form React Native expects |
 | `x`, `y`, `width`, `height`, `cx`, `cy`, `r`, `rx`, `ry` | ✅ | |
 | `d` (**path morphing**) | ✅ | keyframes must share command structure |
 | `transform` (unified parts record) | ✅ | `translate`, `rotate`, `skew`, `scale`, `origin` |
 | `translate` / `rotate` / `scale` (legacy per-key form) | ✅ | |
-| `offset` and `stop-color` on gradient stops | ✅ | |
+| `offset` and `stopColor` on gradient stops | ✅ | |
 | filter primitive attrs (e.g. `stdDeviation`) | ✅ | compiles correctly; on-device rendering unverified |
-| `font-size` | ✅ | |
+| `fontSize` | ✅ | |
 | Any other numeric SVG attribute | ✅ | interpolated numerically and written straight through |
 
 ### Effects (`node.effects`)
@@ -314,8 +315,8 @@ player sees plain nodes. **All are supported:**
 | **Text along a path** | ✅ two ways | native `textPath` (incl. animated `startOffset`), or **per-letter motion paths** for smooth results — the example app uses the latter, since animating native `startOffset` is janky in `react-native-svg` |
 | Per-property `loop` (incl. `alternate` pingpong) | ✅ | expanded before playback |
 | Easing (cubic-bezier and named refs) | ✅ | baked into the sampled tracks |
-| `definitions.animations` / `easings` / `styles` / `fonts` | ✅ | named refs resolved; `style` presets applied as props |
-| `node.style` (inline or named) | ✅ | resolved to props — React Native has no CSS, so explicit attributes win |
+| `definitions.animations` / `easings` / `fonts` | ✅ | named refs resolved |
+| `node.style` (inline record) | ✅ | applied as props — React Native has no CSS, so explicit attributes win |
 
 ### Playback and triggers
 
@@ -333,7 +334,7 @@ player sees plain nodes. **All are supported:**
 | Trigger `click` | ✅ | wrapped in a `Pressable`; a second tap applies `outAction` |
 | Trigger `scrollIntoView` | ✅ | visibility sampled by measuring against the window (React Native has no `IntersectionObserver`); honors `scrollIntoViewThreshold` and `outAction` |
 | Trigger `mouseOver` | ❌ | no touch equivalent — use `click`, or drive `play` yourself |
-| `timeline.frameRate` | n/a | reanimated runs at the display refresh rate; use `compileTracks({sampleRate})` to trade memory for temporal precision |
+| `timeline.frameRate` | n/a | reanimated runs at the display refresh rate; the player prepares 60 snapshots per second of animation |
 | `timeline.engine` (`auto` / `native` / `js`) | n/a | there is no Web Animations API on React Native — playback is always native-driven |
 
 ### Known limitations
@@ -352,7 +353,7 @@ player sees plain nodes. **All are supported:**
   glyph placement by `startOffset … startOffset + pathLength` instead of
   `0 … pathLength`, so glyphs past the end of the path reach a lookup that
   returns `NSNotFound`. On native the player gives such a `<textPath>` its own
-  open copy of the path (`openClosedTextPathTargets`), which restores the
+  open copy of the path, which restores the
   correct bounds. Text that would have wrapped around past the end of the loop
   is clipped instead. Web is unaffected and left untouched.
 
@@ -391,25 +392,6 @@ config.resolver.resolveRequest = (context, moduleName, platform) => {
 A complete config is in
 [`examples/react-native-preview-player/metro.config.js`](../../examples/react-native-preview-player/metro.config.js).
 
-## Advanced exports
-
-For custom rendering or diagnostics:
-
-- `renderRnNode(node, opts)` — render a `PxNode` tree to `react-native-svg`
-  elements, with a `decorate` hook for wrapping animated elements.
-- `compileTracks(doc, { sampleRate, maxSamples, native })` — build the sampled
-  tracks yourself; `sampleRate` trades memory for temporal precision
-  (default 60/s). `native` selects the value form: the default is the SVG/DOM
-  one, `true` gives what the native views want (a `transform` becomes a
-  6-number matrix).
-- `sampleProps(tracks, tMs, stepMs, sampleCount, native)` — the worklet-safe
-  lookup. `native` renames `transform` to the native views' `matrix`; pass it
-  only for values going through reanimated's animated-props path on a device.
-- `openClosedTextPathTargets(doc, warnings?)` — the closed-path `<textPath>`
-  workaround described under [Known limitations](#known-limitations).
-- `PxRnErrorBoundary` — the boundary the component wraps itself in.
-- `RN_SVG_COMPONENTS`, `toRnPropName` — the tag and attribute maps.
-
 ## Example app
 
 A full preview player with six animations and transport controls:

package/dist/index.cjs

@@ -60,29 +60,23 @@ 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,
-  toRnProps: () => toRnProps
+  default: () => PixodeskSvgAnimator_default
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/PixodeskSvgAnimator.tsx
-var import_svg_animator_core6 = require("@pixodesk/svg-animator-core");
+var import_svg_animator_core4 = require("@pixodesk/svg-animator-core");
+var import_internal6 = require("@pixodesk/svg-animator-core/internal");
 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
-var import_svg_animator_core2 = require("@pixodesk/svg-animator-core");
+var import_svg_animator_core = require("@pixodesk/svg-animator-core");
+var import_internal2 = require("@pixodesk/svg-animator-core/internal");
 
 // src/PxRnPropNames.ts
-var import_svg_animator_core = require("@pixodesk/svg-animator-core");
+var import_internal = require("@pixodesk/svg-animator-core/internal");
 
 // src/PxRnMatrix.ts
 var DEG = Math.PI / 180;
@@ -159,7 +153,7 @@ function toRnPropName(attrName) {
   if (DROPPED_ATTRS.has(attrName)) return void 0;
   const override = ATTR_NAME_OVERRIDES[attrName];
   if (override) return override;
-  return (0, import_svg_animator_core.kebabToCamelCaseWord)(attrName);
+  return (0, import_internal.kebabToCamelCaseWord)(attrName);
 }
 var LENGTH_LIST_PROPS = /* @__PURE__ */ new Set(["strokeDasharray"]);
 function toRnPropValue(rnPropName, value, tag, native = false) {
@@ -179,8 +173,8 @@ function toRnPropValue(rnPropName, value, tag, native = false) {
 // src/PxRnTracks.ts
 function compileTracks(doc, opts) {
   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 config = (0, import_svg_animator_core.getAnimatorConfig)(doc) || {};
+  const duration = +(config.duration || import_internal2.DEFAULT_DURATION_MS);
   const _iterations = config.iterations;
   let iterations = 1;
   if (typeof _iterations === "number") iterations = _iterations || 1;
@@ -199,7 +193,7 @@ function compileTracks(doc, opts) {
     ((_a2 = n == null ? void 0 : n.children) != null ? _a2 : []).forEach(indexTags);
   };
   indexTags(doc);
-  const bindings = (0, import_svg_animator_core2.getNormalizedBindings)(doc, import_svg_animator_core2.PxTimelineEngine.js) || [];
+  const bindings = (0, import_svg_animator_core.getNormalizedBindings)(doc, import_svg_animator_core.PxTimelineEngine.js) || [];
   const elements = [];
   for (const binding of bindings) {
     const animDef = binding.animate;
@@ -207,7 +201,7 @@ function compileTracks(doc, opts) {
     const props = {};
     for (let i = 0; i < sampleCount; i++) {
       const t = i === sampleCount - 1 ? duration : i * stepMs;
-      const values = (0, import_svg_animator_core2.calcAnimationValues)(animDef, t);
+      const values = (0, import_svg_animator_core.calcAnimationValues)(animDef, t);
       for (const [attr, value] of Object.entries(values)) {
         const rnProp = toRnPropName(attr);
         if (!rnProp) continue;
@@ -259,7 +253,8 @@ function sampleProps(tracks, tMs, stepMs, sampleCount, native = false) {
 }
 
 // src/PxRnRender.tsx
-var import_svg_animator_core3 = require("@pixodesk/svg-animator-core");
+var import_svg_animator_core2 = require("@pixodesk/svg-animator-core");
+var import_internal3 = require("@pixodesk/svg-animator-core/internal");
 var import_react = require("react");
 
 // src/PxRnTypeMap.ts
@@ -326,10 +321,10 @@ var RN_SVG_COMPONENTS = {
 
 // src/PxRnRender.tsx
 function toRnProps(props, warnings, tag) {
-  const normalized = (0, import_svg_animator_core3.getNormalizedProps)(props);
+  const normalized = (0, import_svg_animator_core2.getNormalizedProps)(props);
   const out = {};
   for (const key of Object.keys(normalized)) {
-    const sanitized = (0, import_svg_animator_core3.sanitizeAttributeValue)(key, normalized[key]);
+    const sanitized = (0, import_internal3.sanitizeAttributeValue)(key, normalized[key]);
     if (sanitized === void 0) continue;
     const rnKey = toRnPropName(key);
     if (!rnKey) continue;
@@ -344,7 +339,7 @@ function renderRnNode(node, opts = {}, key) {
   const tag = String(type || "g");
   const domType = props.domType;
   if (domType !== void 0) delete props.domType;
-  if (import_svg_animator_core3.DISALLOWED_SVG_TAGS_LOWER.has(tag.toLowerCase())) {
+  if (import_internal3.DISALLOWED_SVG_TAGS_LOWER.has(tag.toLowerCase())) {
     (_b = opts.warnings) == null ? void 0 : _b.push("tag blocked (dangerous): " + tag);
     return null;
   }
@@ -355,17 +350,17 @@ function renderRnNode(node, opts = {}, key) {
   }
   const rnProps = toRnProps(props, opts.warnings, tag);
   if (domType !== void 0) rnProps.type = domType;
-  const resolved = (0, import_svg_animator_core3.resolveStyle)(style, opts.defs);
+  const resolved = style;
   if (resolved) {
     for (const [k, v] of Object.entries(resolved)) {
       const rnKey = toRnPropName(k);
       if (!rnKey || rnKey in rnProps) continue;
-      const sanitized = (0, import_svg_animator_core3.sanitizeAttributeValue)(rnKey, v);
+      const sanitized = (0, import_internal3.sanitizeAttributeValue)(rnKey, v);
       if (sanitized === void 0) continue;
       rnProps[rnKey] = toRnPropValue(rnKey, String(sanitized), tag);
     }
   }
-  const textContent = props[import_svg_animator_core3.TEXT_CONTENT_ATTR];
+  const textContent = props[import_internal3.TEXT_CONTENT_ATTR];
   let childElements = void 0;
   if (Array.isArray(children) && children.length > 0) {
     childElements = children.map((ch, i) => {
@@ -391,7 +386,8 @@ function renderRnNode(node, opts = {}, key) {
 
 // src/PxRnErrorBoundary.tsx
 var import_react2 = require("react");
-var import_svg_animator_core4 = require("@pixodesk/svg-animator-core");
+var import_svg_animator_core3 = require("@pixodesk/svg-animator-core");
+var import_internal4 = require("@pixodesk/svg-animator-core/internal");
 var PxRnErrorBoundary = class extends import_react2.Component {
   constructor() {
     super(...arguments);
@@ -401,9 +397,8 @@ var PxRnErrorBoundary = class extends import_react2.Component {
     return { error };
   }
   componentDidCatch(error, info) {
-    var _a, _b, _c, _d, _e;
-    (_c = (_b = this.props).onError) == null ? void 0 : _c.call(_b, error, (_a = info == null ? void 0 : info.componentStack) != null ? _a : void 0);
-    ((_d = this.props.diag) != null ? _d : (0, import_svg_animator_core4.createDiagnostics)(void 0, "[PixodeskSvgAnimator]")).warn(import_svg_animator_core4.PxDiagnosticKind.internal, "render failed: " + ((_e = error == null ? void 0 : error.message) != null ? _e : String(error)));
+    var _a, _b;
+    ((_a = this.props.diag) != null ? _a : (0, import_internal4.createDiagnostics)(void 0, "[PixodeskSvgAnimator]")).error(import_svg_animator_core3.PxDiagnosticKind.internal, error, { componentStack: (_b = info == null ? void 0 : info.componentStack) != null ? _b : void 0 });
   }
   componentDidUpdate(prev) {
     if (this.state.error && prev.children !== this.props.children) {
@@ -418,7 +413,7 @@ var PxRnErrorBoundary = class extends import_react2.Component {
 };
 
 // src/PxRnSafety.ts
-var import_svg_animator_core5 = require("@pixodesk/svg-animator-core");
+var import_internal5 = require("@pixodesk/svg-animator-core/internal");
 function isClosedPath(d) {
   return typeof d === "string" && /[zZ]/.test(d);
 }
@@ -443,7 +438,7 @@ function openClosedTextPathTargets(doc, warnings) {
     if (String(n.type) === "textPath") hasTextPath = true;
   });
   if (!hasTextPath) return doc;
-  const result = (0, import_svg_animator_core5.deepClone)(doc);
+  const result = (0, import_internal5.deepClone)(doc);
   const byId = /* @__PURE__ */ new Map();
   forEachNode(result, (n) => {
     const id = n.id;
@@ -470,8 +465,8 @@ function openClosedTextPathTargets(doc, warnings) {
     if (!target || !isClosedPath(target.d)) return;
     let copyId = openCopies.get(targetId);
     if (!copyId) {
-      const copy = (0, import_svg_animator_core5.deepClone)(target);
-      copyId = "px_open_" + (0, import_svg_animator_core5.generateUniqueId)();
+      const copy = (0, import_internal5.deepClone)(target);
+      copyId = "px_open_" + (0, import_internal5.generateUniqueId)();
       copy.id = copyId;
       copy.d = openPath(String(copy.d));
       delete copy.animate;
@@ -564,20 +559,20 @@ var EMPTY_TRACKS = {
 };
 function compileDocument(doc, overrides, diag) {
   const { timeline, resetTimeline, duration, delay, iterations, startOn } = overrides;
-  const warnings = (0, import_svg_animator_core6.validateNodeEffects)(doc);
-  for (const w of warnings) diag.warn(import_svg_animator_core6.PxDiagnosticKind.document, "effects shape: " + w);
-  (0, import_svg_animator_core6.reportDocumentDiagnostics)(doc, "[PixodeskSvgAnimator]");
-  const patch = (0, import_svg_animator_core6.foldTimelineOverride)(timeline, { duration, delay, iterations, startOn });
+  const warnings = (0, import_svg_animator_core4.validateNodeEffects)(doc);
+  for (const w of warnings) diag.warn(import_svg_animator_core4.PxDiagnosticKind.document, "effects shape: " + w);
+  (0, import_internal6.reportDocumentDiagnostics)(doc, "[PixodeskSvgAnimator]");
+  const patch = (0, import_svg_animator_core4.foldTimelineOverride)(timeline, { duration, delay, iterations, startOn });
   if (patch !== void 0 || resetTimeline) {
-    const applied = (0, import_svg_animator_core6.applyAnimatorConfig)(doc, patch != null ? patch : {}, { resetDefaults: !!resetTimeline });
-    for (const w of applied.warnings) diag.warn(import_svg_animator_core6.PxDiagnosticKind.usage, "timeline override: " + w);
+    const applied = (0, import_svg_animator_core4.applyAnimatorConfig)(doc, patch != null ? patch : {}, { resetDefaults: !!resetTimeline });
+    for (const w of applied.warnings) diag.warn(import_svg_animator_core4.PxDiagnosticKind.usage, "timeline override: " + w);
     doc = applied.doc;
   }
-  let prepared = (0, import_svg_animator_core6.materializeAllInTree)(doc, import_svg_animator_core6.PxTimelineEngine.native);
+  let prepared = (0, import_svg_animator_core4.materializeAllInTree)(doc, import_svg_animator_core4.PxTimelineEngine.native);
   if (NATIVE_SVG_VIEWS) {
     prepared = openClosedTextPathTargets(prepared);
   }
-  prepared = (0, import_svg_animator_core6.generateNewIds)(prepared);
+  prepared = (0, import_svg_animator_core4.generateNewIds)(prepared);
   const tracks = compileTracks(prepared, { native: NATIVE_SVG_VIEWS });
   return { doc: prepared, tracks, error: null };
 }
@@ -605,21 +600,15 @@ function PixodeskSvgAnimator({
   onError,
   fallback,
   onWarn,
-  silent
+  muteWarn,
+  muteError
 }) {
   var _a, _b;
   const timelineKey = typeof timeline === "string" ? timeline : JSON.stringify(timeline != null ? timeline : null);
-  const makeDiag = () => (0, import_svg_animator_core6.createDiagnostics)({
-    onWarn,
-    // This component's public `onError` is richer — `(error, componentStack?)` — and the
-    // error boundary hands it a component stack. Adapt rather than narrow it; the ternary
-    // keeps "not given" as undefined, so the console fallback still fires.
-    onError: onError ? (d) => {
-      var _a2;
-      return onError((_a2 = d.error) != null ? _a2 : new Error(d.message));
-    } : void 0,
-    silent
-  }, "[PixodeskSvgAnimator]");
+  const makeDiag = () => (0, import_internal6.createDiagnostics)(
+    { onWarn, onError, muteWarn, muteError },
+    "[PixodeskSvgAnimator]"
+  );
   const compiled = (0, import_react3.useMemo)(() => {
     try {
       return compileDocument(
@@ -629,14 +618,14 @@ function PixodeskSvgAnimator({
       );
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
-      makeDiag().warn(import_svg_animator_core6.PxDiagnosticKind.internal, "could not compile the document: " + error.message);
+      makeDiag().error(import_svg_animator_core4.PxDiagnosticKind.internal, error, { phase: "compile" });
       return { doc: null, tracks: EMPTY_TRACKS, error };
     }
   }, [doc, timelineKey, resetTimeline, duration, delay, iterations, startOn]);
   const tracks = compiled.tracks;
-  const totalDuration = (0, import_svg_animator_core6.progressSpanMs)(tracks.duration, tracks.iterations);
-  const seekCeiling = (0, import_svg_animator_core6.seekCeilingMs)(tracks.duration, tracks.iterations);
-  const runClock = (0, import_react3.useMemo)(() => (0, import_svg_animator_core6.createRunClock)(seekCeiling), [seekCeiling]);
+  const totalDuration = (0, import_svg_animator_core4.progressSpanMs)(tracks.duration, tracks.iterations);
+  const seekCeiling = (0, import_svg_animator_core4.seekCeilingMs)(tracks.duration, tracks.iterations);
+  const runClock = (0, import_react3.useMemo)(() => (0, import_svg_animator_core4.createRunClock)(seekCeiling), [seekCeiling]);
   const progress = (0, import_react_native_reanimated.useSharedValue)(0);
   const playingRef = (0, import_react3.useRef)(false);
   const rateRef = (0, import_react3.useRef)(1);
@@ -717,8 +706,8 @@ function PixodeskSvgAnimator({
       onStop == null ? void 0 : onStop();
     },
     setPlaybackRate: (rate) => {
-      if (!(0, import_svg_animator_core6.isValidPlaybackRate)(rate)) {
-        makeDiag().warn(import_svg_animator_core6.PxDiagnosticKind.usage, import_svg_animator_core6.PX_RATE_REJECTED);
+      if (!(0, import_svg_animator_core4.isValidPlaybackRate)(rate)) {
+        makeDiag().warn(import_svg_animator_core4.PxDiagnosticKind.usage, import_svg_animator_core4.PX_RATE_REJECTED);
         return;
       }
       rateRef.current = rate;
@@ -735,41 +724,41 @@ function PixodeskSvgAnimator({
       const wasPlaying = playingRef.current;
       (0, import_react_native_reanimated.cancelAnimation)(progress);
       playingRef.current = false;
-      const clamped = (0, import_svg_animator_core6.clampSeekMs)(t, seekCeiling);
+      const clamped = (0, import_svg_animator_core4.clampSeekMs)(t, seekCeiling);
       runClock.seek(clamped);
       const withinIteration = tracks.duration > 0 ? clamped % tracks.duration || (clamped === 0 ? 0 : tracks.duration) : 0;
       progress.value = withinIteration;
       if (wasPlaying) startFrom(withinIteration);
       else runClock.stop();
     },
-    getCurrentProgress: () => (0, import_svg_animator_core6.timeToProgress)(runClock.now(), tracks.duration, tracks.iterations),
+    getCurrentProgress: () => (0, import_svg_animator_core4.timeToProgress)(runClock.now(), tracks.duration, tracks.iterations),
     setCurrentProgress: (p) => {
-      api.setCurrentTime((0, import_svg_animator_core6.progressToTimeMs)(p, tracks.duration, tracks.iterations));
+      api.setCurrentTime((0, import_svg_animator_core4.progressToTimeMs)(p, tracks.duration, tracks.iterations));
     }
   };
   (0, import_react3.useImperativeHandle)(apiRef, () => api, [compiled]);
-  const trigger = (0, import_svg_animator_core6.resolveTrigger)(compiled.doc ? (_a = (0, import_svg_animator_core6.getAnimatorConfig)(compiled.doc)) == null ? void 0 : _a.trigger : void 0);
+  const trigger = (0, import_svg_animator_core4.resolveTrigger)(compiled.doc ? (_a = (0, import_svg_animator_core4.getAnimatorConfig)(compiled.doc)) == null ? void 0 : _a.trigger : void 0);
   const effectiveStartOn = trigger.startOn;
   const effectiveOutAction = trigger.outAction;
-  const { mode: compMode, warnings: modeWarnings } = (0, import_svg_animator_core6.resolveControlMode)({ progress: progressProp, time, play, pause, autoplay });
+  const { mode: compMode, warnings: modeWarnings } = (0, import_svg_animator_core4.resolveControlMode)({ progress: progressProp, time, play, pause, autoplay });
   (0, import_react3.useEffect)(() => {
     const diag = makeDiag();
-    for (const w of modeWarnings) diag.warn(import_svg_animator_core6.PxDiagnosticKind.usage, w);
+    for (const w of modeWarnings) diag.warn(import_svg_animator_core4.PxDiagnosticKind.usage, w);
   }, [modeWarnings.join("|")]);
   (0, import_react3.useEffect)(() => {
-    if (compMode === import_svg_animator_core6.PxControlMode.fixedTime) {
-      const seekMs = time !== void 0 ? time : (0, import_svg_animator_core6.progressToTimeMs)(progressProp != null ? progressProp : 0, tracks.duration, tracks.iterations);
+    if (compMode === import_svg_animator_core4.PxControlMode.fixedTime) {
+      const seekMs = time !== void 0 ? time : (0, import_svg_animator_core4.progressToTimeMs)(progressProp != null ? progressProp : 0, tracks.duration, tracks.iterations);
       api.setCurrentTime(seekMs);
       return;
     }
-    if (compMode === import_svg_animator_core6.PxControlMode.play) {
+    if (compMode === import_svg_animator_core4.PxControlMode.play) {
       if (play && !pause) api.play();
       else if (pause) api.pause();
       else if (play === false) api.pause();
       else api.play();
       return;
     }
-    if (compMode === import_svg_animator_core6.PxControlMode.autoplay && effectiveStartOn === "load") {
+    if (compMode === import_svg_animator_core4.PxControlMode.autoplay && effectiveStartOn === "load") {
       api.play();
     }
   }, [compiled, compMode, autoplay, play, pause, progressProp, time]);
@@ -825,7 +814,7 @@ function PixodeskSvgAnimator({
     if (!compiled.doc) return null;
     const renderOpts = {
       warnings: warningsRef.current,
-      defs: (0, import_svg_animator_core6.getDefs)(compiled.doc)
+      defs: (0, import_svg_animator_core4.getDefs)(compiled.doc)
     };
     try {
       return renderRnNode(compiled.doc, __spreadProps(__spreadValues({}, renderOpts), {
@@ -865,18 +854,15 @@ function PixodeskSvgAnimator({
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e));
       renderErrorRef.current = error;
-      makeDiag().warn(import_svg_animator_core6.PxDiagnosticKind.internal, "could not render the document: " + error.message);
+      makeDiag().error(import_svg_animator_core4.PxDiagnosticKind.internal, error, { phase: "render" });
       return null;
     }
   }, [compiled, trackById]);
   (0, import_react3.useEffect)(() => {
     const diag = makeDiag();
-    for (const w of warningsRef.current) diag.warn(import_svg_animator_core6.PxDiagnosticKind.platform, w);
+    for (const w of warningsRef.current) diag.warn(import_svg_animator_core4.PxDiagnosticKind.platform, w);
   }, [root]);
   const failure = (_b = compiled.error) != null ? _b : 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 && effectiveStartOn === "scrollIntoView" && root) {
@@ -901,19 +887,11 @@ function PixodeskSvgAnimator({
       }
     );
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PxRnErrorBoundary, { onError, fallback, diag: makeDiag(), children: content });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PxRnErrorBoundary, { fallback, diag: makeDiag(), 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,
-  toRnProps
+  PixodeskSvgAnimator
 });
 //# sourceMappingURL=index.cjs.map