embedded-react 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "embedded-react",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "description": "React Native-style component package + reconciler that drives the embedded-react C engine through the QuickJS NativeUI bridge (Flow A).",
   "license": "Apache-2.0",

package/persist-transform.mjs

@@ -86,6 +86,23 @@ function persistPlugin({ types: t }) {
   };
 }
 
+/**
+ * Whether `absPath` is an app source file that should receive the persist transform: under the project
+ * root, but NOT a dependency. The library itself lives under the project root in a consumer install
+ * (`<project>/node_modules/embedded-react`), and transforming it would rewrite the `useState` *inside*
+ * `usePersistentState` into a call to `usePersistentState` — infinite self-recursion → stack overflow.
+ * Excluding `node_modules` is what keeps the helper (and react) untransformed in a published install,
+ * not just in the monorepo (where the library happens to sit outside the demo's project root).
+ *
+ * @param {string} absPath          Absolute path of the module esbuild is loading.
+ * @param {string} projectRootNorm  Project root, forward-slash normalized.
+ * @returns {boolean}
+ */
+export function shouldPersist(absPath, projectRootNorm) {
+  const p = absPath.replace(/\\/g, '/');
+  return p.startsWith(projectRootNorm) && !p.includes('/node_modules/');
+}
+
 /**
  * Applies the persist transform to a module's source.
  *

package/sim-server.mjs

@@ -34,7 +34,7 @@ const HERE = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/,
 const require = createRequire(import.meta.url);
 const esbuild = require('esbuild');
 const { bakeAssetPack } = await import(pathToFileURL(resolve(HERE, 'assets/index.mjs')).href);
-const { transformPersist } = await import(pathToFileURL(resolve(HERE, 'persist-transform.mjs')).href);
+const { transformPersist, shouldPersist } = await import(pathToFileURL(resolve(HERE, 'persist-transform.mjs')).href);
 
 const MIME = {
   '.html': 'text/html; charset=utf-8',
@@ -127,7 +127,9 @@ function createBundle({ entry, projectRoot, libSrc, nodePaths, outDir, persist =
             fonts.clear();
           });
           b.onLoad({ filter: /\.(jsx?|tsx?)$/ }, (a) => {
-            if (!persist || !a.path.replace(/\\/g, '/').startsWith(projNorm)) return undefined;
+            // Transform ONLY the app's own source — never dependencies (see shouldPersist: excluding
+            // node_modules is what stops the library's usePersistentState being rewritten to call itself).
+            if (!persist || !shouldPersist(a.path, projNorm)) return undefined;
             try {
               return { contents: transformPersist(readFileSync(a.path, 'utf8'), relative(projectRoot, a.path).replace(/\\/g, '/')), loader: 'jsx' };
             } catch (e) {

package/src/embedded-react/Animated.js

@@ -280,8 +280,8 @@ export function loop(animation, config) {
       const done = once(onComplete);
       const startValue = resetBeforeIteration && animation._value ? animation._value.__getValue() : null;
       let count = 0;
-      const run = (result) => {
-        if (stopped || !result || result.finished === false) {
+      const startIteration = () => {
+        if (stopped) {
           done({ finished: false });
           return;
         }
@@ -293,9 +293,22 @@ export function loop(animation, config) {
         if (resetBeforeIteration && animation._value && startValue != null && count > 1) {
           animation._value.setValue(startValue);
         }
-        animation.start(run);
+        animation.start(onIterationDone);
+      };
+      const onIterationDone = (result) => {
+        if (stopped || !result || result.finished === false) {
+          done({ finished: false });
+          return;
+        }
+        // Defer the next iteration to a fresh task instead of starting it inline. A child animation can
+        // complete *synchronously* (a long-duration timing finishing inside one large catch-up frame in
+        // the simulator), and starting the next iteration from within, that completion callback would
+        // recurse — loop → child → completion → loop → … — until the stack overflows. setTimeout breaks
+        // the chain: the host pump runs it on the next frame, by which point real time has advanced so
+        // the animation runs its full duration again. (Negligible cost in the normal async case.)
+        setTimeout(startIteration, 0);
       };
-      run({ finished: true });
+      startIteration();
     },
     stop() {
       stopped = true;