@keepsnappy/react-native 0.0.0-stage → 0.1.0-alpha.11

package/js/hook.polyfill.js

@@ -0,0 +1,333 @@
+// perf-lab React DevTools hook, installed as a Metro polyfill: it runs before
+// any module, so it exists before the React renderer evaluates and injects.
+// A polyfill is a plain script (no require), so this file stays self-contained:
+// it only counts and buffers. The SDK boot module attaches a listener later.
+//
+// Dormant builds (EXPO_PUBLIC_PERF_LAB_MODE=dormant) first read the activation
+// record through the native module, synchronously (Expo installs
+// `expo.modules` before the bundle runs; on Android the polyfill installs them itself). Not activated: nothing is installed
+// and the React DevTools global stays exactly as without the SDK. If the native
+// module cannot be reached yet, the hook is prepared but not installed and the
+// boot module decides (it still runs before the renderer loads).
+//
+// `profile` on __PERFLAB_ACTIVATION__ picks the React renderer in a
+// PERF_LAB_REACT_PROFILING=switch bundle (js/renderer-switch.js): the
+// activation's `profile` in a dormant build, EXPO_PUBLIC_PERF_LAB_PROFILE otherwise.
+(function (g) {
+  if (g.__PERFLAB_HOOK__ || g.__PERFLAB_ACTIVATION__) {
+    return;
+  }
+  var HOOK = '__REACT_DEVTOOLS_GLOBAL_HOOK__';
+
+  // process.env.EXPO_PUBLIC_* below are inlined at bundle time by the SDK's
+  // transformer; the guard only matters if they were not.
+  var env = function (read) {
+    try {
+      return read();
+    } catch (_e) {
+      return undefined;
+    }
+  };
+  var modeEnv = env(function () {
+    return (process.env.EXPO_PUBLIC_KEEPSNAPPY_MODE ?? process.env.EXPO_PUBLIC_PERF_LAB_MODE);
+  });
+  var autoEnv = env(function () {
+    return (process.env.EXPO_PUBLIC_KEEPSNAPPY_AUTO ?? process.env.EXPO_PUBLIC_PERF_LAB_AUTO);
+  });
+  var profileEnv = env(function () {
+    return (process.env.EXPO_PUBLIC_KEEPSNAPPY_PROFILE ?? process.env.EXPO_PUBLIC_PERF_LAB_PROFILE);
+  });
+  var MODE =
+    modeEnv === 'dormant' || modeEnv === 'auto'
+      ? modeEnv
+      : autoEnv === '1'
+        ? 'auto'
+        : 'manual';
+
+  // Same rule as decide() in js/sdk/activation.ts: null when not active.
+  var activeRecord = function (raw, nowMs) {
+    if (typeof raw !== 'string' || raw === '') {
+      return null;
+    }
+    try {
+      var record = JSON.parse(raw);
+      return !!record &&
+        record.active === true &&
+        typeof record.expiresAt === 'number' &&
+        record.expiresAt > nowMs
+        ? record
+        : null;
+    } catch (_e) {
+      return null;
+    }
+  };
+
+  var activation = {
+    mode: MODE,
+    read: 'none',
+    raw: null,
+    active: MODE !== 'dormant',
+    profile: MODE !== 'dormant' && profileEnv === '1',
+    t: Date.now(),
+  };
+  if (MODE === 'dormant') {
+    try {
+      if (!g.expo) {
+        // Android installs `expo.modules` only when expo-modules-core first loads, after this
+        // polyfill. Run the same synchronous install it runs (ensureNativeModulesAreInstalled).
+        var core =
+          (typeof g.__turboModuleProxy === 'function' && g.__turboModuleProxy('ExpoModulesCore')) ||
+          (g.nativeModuleProxy && g.nativeModuleProxy.ExpoModulesCore);
+        if (core && typeof core.installModules === 'function') {
+          var installStart = Date.now();
+          core.installModules();
+          activation.installMs = Date.now() - installStart;
+        }
+      }
+      var modules = g.expo && g.expo.modules;
+      var native = modules ? modules.PerfLab : undefined;
+      if (native && typeof native.activationRead === 'function') {
+        activation.raw = native.activationRead();
+        activation.read = 'polyfill';
+        var record = activeRecord(activation.raw, activation.t);
+        activation.active = record !== null;
+        activation.profile = record !== null && record.profile === true;
+      } else {
+        activation.read = 'deferred';
+      }
+    } catch (_e) {
+      activation.read = 'deferred';
+    }
+  }
+  g.__PERFLAB_ACTIVATION__ = activation;
+  if (MODE === 'dormant' && activation.read === 'polyfill' && !activation.active) {
+    return;
+  }
+  var MAX_ERRORS = 3;
+
+  var clock = function () {
+    if (typeof g.nativePerformanceNow === 'function') {
+      return g.nativePerformanceNow();
+    }
+    if (g.performance && typeof g.performance.now === 'function') {
+      return g.performance.now();
+    }
+    return Date.now();
+  };
+
+  var state = {
+    installedAt: clock(),
+    typeofHookAtPolyfill: typeof g[HOOK],
+    // Metro's prelude declares __DEV__ as a global var before any polyfill.
+    dev: g.__DEV__ === true,
+    mode: 'none',
+    chainedTargets: 0,
+    replacedAfterInstall: 0,
+    injections: [],
+    commitsByRenderer: {},
+    unmountsByRenderer: {},
+    lastRootByRenderer: {},
+    errors: 0,
+    invalid: false,
+    listener: null,
+  };
+
+  var log = function (message) {
+    try {
+      if (g.console && typeof g.console.log === 'function') {
+        g.console.log('PERF_LAB ' + message);
+      }
+    } catch (_e) {
+      return;
+    }
+  };
+
+  var fail = function (where, error) {
+    state.errors++;
+    log('hook listener error where=' + where + ' ' + String(error));
+    if (state.errors >= MAX_ERRORS) {
+      state.listener = null;
+      state.invalid = true;
+      log('hook listener detached after ' + state.errors + ' errors');
+    }
+  };
+
+  var recordInject = function (id, internals) {
+    var entry = {
+      id: id,
+      pkg: internals && internals.rendererPackageName,
+      version: internals && internals.version,
+      bundleType: internals && internals.bundleType,
+      t: clock(),
+    };
+    state.injections.push(entry);
+    state.commitsByRenderer[id] = 0;
+    state.unmountsByRenderer[id] = 0;
+    log(
+      'hook inject id=' +
+        id +
+        ' renderer=' +
+        entry.pkg +
+        ' version=' +
+        entry.version +
+        ' bundleType=' +
+        entry.bundleType +
+        ' mode=' +
+        state.mode +
+        ' t=' +
+        entry.t.toFixed(3) +
+        ' hookInstalledAt=' +
+        state.installedAt.toFixed(3),
+    );
+    if (state.listener && state.listener.onInject) {
+      try {
+        state.listener.onInject(id, internals);
+      } catch (e) {
+        fail('inject', e);
+      }
+    }
+  };
+
+  var recordCommit = function (id, root) {
+    state.commitsByRenderer[id] = (state.commitsByRenderer[id] || 0) + 1;
+    state.lastRootByRenderer[id] = root;
+    if (state.listener) {
+      try {
+        state.listener.onCommit(id, root);
+      } catch (e) {
+        fail('commit', e);
+      }
+    }
+  };
+
+  var recordUnmount = function (id, fiber) {
+    state.unmountsByRenderer[id] = (state.unmountsByRenderer[id] || 0) + 1;
+    if (state.listener && state.listener.onUnmount) {
+      try {
+        state.listener.onUnmount(id, fiber);
+      } catch (e) {
+        fail('unmount', e);
+      }
+    }
+  };
+
+  var nextId = 1;
+  var noop = function () {
+    return undefined;
+  };
+
+  var ownHook = {
+    supportsFiber: true,
+    isDisabled: false,
+    renderers: new Map(),
+    __perflab: true,
+    inject: function (internals) {
+      var id = nextId++;
+      ownHook.renderers.set(id, internals);
+      recordInject(id, internals);
+      return id;
+    },
+    onCommitFiberRoot: function (id, root) {
+      recordCommit(id, root);
+    },
+    onCommitFiberUnmount: function (id, fiber) {
+      recordUnmount(id, fiber);
+    },
+    onPostCommitFiberRoot: noop,
+    setStrictMode: noop,
+    checkDCE: noop,
+  };
+
+  // Wrap a hook someone else installed (React DevTools, bippy, ...): theirs runs
+  // first, ours after, and the renderer id stays theirs.
+  var chain = function (hook) {
+    if (!hook || hook.__perflab || hook.__perflabChained) {
+      return;
+    }
+    var origInject = hook.inject;
+    var origCommit = hook.onCommitFiberRoot;
+    var origUnmount = hook.onCommitFiberUnmount;
+    hook.inject = function (internals) {
+      var id = origInject ? origInject.apply(hook, arguments) : nextId++;
+      recordInject(id, internals);
+      return id;
+    };
+    hook.onCommitFiberRoot = function (id, root) {
+      var result = origCommit ? origCommit.apply(hook, arguments) : undefined;
+      recordCommit(id, root);
+      return result;
+    };
+    hook.onCommitFiberUnmount = function (id, fiber) {
+      var result = origUnmount ? origUnmount.apply(hook, arguments) : undefined;
+      recordUnmount(id, fiber);
+      return result;
+    };
+    if (hook.renderers && typeof hook.renderers.forEach === 'function') {
+      hook.renderers.forEach(function (internals, id) {
+        recordInject(id, internals);
+      });
+    }
+    hook.__perflabChained = true;
+    state.chainedTargets++;
+    state.mode = 'chained';
+  };
+
+  var installOwn = function () {
+    var current = ownHook;
+    try {
+      // A later installer that replaces the global gets wrapped, not lost.
+      Object.defineProperty(g, HOOK, {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+          return current;
+        },
+        set: function (next) {
+          if (next && next !== current) {
+            state.replacedAfterInstall++;
+            chain(next);
+            current = next;
+          }
+        },
+      });
+    } catch (_e) {
+      g[HOOK] = ownHook;
+    }
+    state.mode = 'own';
+  };
+
+  // Idempotent: installs our hook if none exists, chains the one that does.
+  var ensure = function () {
+    var existing = g[HOOK];
+    if (existing === undefined || existing === null) {
+      installOwn();
+    } else if (!existing.__perflab) {
+      chain(existing);
+    }
+    return state.mode;
+  };
+
+  // In dev, InitializeCore installs the real DevTools hook later; installing
+  // ours first would make it bail out. The boot module calls ensure() then.
+  // A dormant build whose activation is not known yet waits for boot as well.
+  if (!state.dev && activation.active) {
+    ensure();
+  }
+
+  g.__PERFLAB_HOOK__ = {
+    state: state,
+    ensure: ensure,
+    attach: function (listener) {
+      state.listener = listener;
+    },
+    now: clock,
+  };
+})(
+  typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof global !== 'undefined'
+      ? global
+      : typeof window !== 'undefined'
+        ? window
+        : this,
+);

package/js/renderer-switch.js

@@ -0,0 +1,16 @@
+// React Native's production renderer in a PERF_LAB_REACT_PROFILING=switch bundle.
+// Both renderers are in the bundle; this module picks one when React Native
+// first requires it, from what hook.polyfill.js (or the boot module) read out
+// of the activation record before React loaded. withPerfLab (metro.js)
+// resolves the two module names below to RN's own implementation files.
+'use strict';
+
+var activation = globalThis.__PERFLAB_ACTIVATION__;
+var profiling = !!activation && activation.profile === true;
+if (activation) {
+  activation.renderer = profiling ? 'profiling' : 'prod';
+}
+
+module.exports = profiling
+  ? require('@keepsnappy/react-native/renderer/ReactFabric-profiling')
+  : require('@keepsnappy/react-native/renderer/ReactFabric-prod');