@ansight/react-native 1.3.0-preview.9 → 1.4.0-preview.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansight/react-native",
-  "version": "1.3.0-preview.9",
+  "version": "1.4.0-preview.3",
   "description": "React Native bridge for the Ansight mobile SDK.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -25,6 +25,11 @@
     "README.md",
     "index.js",
     "index.d.ts",
+    "react-inspection-hook.js",
+    "react-tree-geometry.js",
+    "react-tree-semantics.js",
+    "network.js",
+    "session-properties.js",
     "app.plugin.js",
     "expo-plugin.js",
     "tsconfig.json",
@@ -44,7 +49,8 @@
     "react-native": ">=0.72"
   },
   "scripts": {
-    "check": "node --check index.js && node --check app.plugin.js && node --check expo-plugin.js && tsc --noEmit",
+    "check": "node --check index.js && node --check session-properties.js && node --check app.plugin.js && node --check expo-plugin.js && tsc --noEmit && npm test",
+    "test": "node --test test/*.test.js",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {

package/react-inspection-hook.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const ANSIGHT_HOOK_MARKER = "__ansightReactInspectionHook";
+
+function hasElementState(current) {
+  const state = current && current.memoizedState;
+  if (!state || typeof state !== "object") {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(state, "element")) {
+    return true;
+  }
+  return state.element != null;
+}
+
+function createReactInspectionHook() {
+  const renderers = new Map();
+  const fiberRoots = new Map();
+  let nextRendererId = 1;
+
+  function rootsForRenderer(rendererId) {
+    let roots = fiberRoots.get(rendererId);
+    if (!roots) {
+      roots = new Set();
+      fiberRoots.set(rendererId, roots);
+    }
+    return roots;
+  }
+
+  return {
+    [ANSIGHT_HOOK_MARKER]: true,
+    supportsFiber: true,
+    isDisabled: false,
+    renderers,
+    _fiberRoots: fiberRoots,
+    inject(renderer) {
+      const rendererId = nextRendererId++;
+      renderers.set(rendererId, renderer);
+      rootsForRenderer(rendererId);
+      return rendererId;
+    },
+    getFiberRoots(rendererId) {
+      return rootsForRenderer(rendererId);
+    },
+    onCommitFiberRoot(rendererId, root) {
+      const roots = rootsForRenderer(rendererId);
+      if (root && root.current && hasElementState(root.current)) {
+        roots.add(root);
+      } else {
+        roots.delete(root);
+      }
+    },
+    onCommitFiberUnmount() {},
+  };
+}
+
+function ensureReactInspectionHook(runtimeGlobal) {
+  if (!runtimeGlobal || typeof runtimeGlobal !== "object") {
+    return undefined;
+  }
+
+  const existing = runtimeGlobal.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (existing) {
+    return existing;
+  }
+
+  const hook = createReactInspectionHook();
+  runtimeGlobal.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+  return hook;
+}
+
+module.exports = {
+  ANSIGHT_HOOK_MARKER,
+  createReactInspectionHook,
+  ensureReactInspectionHook,
+};

package/react-tree-geometry.js

@@ -0,0 +1,61 @@
+"use strict";
+
+function readDimensionSize(dimensions, name) {
+  if (!dimensions || typeof dimensions.get !== "function") {
+    return null;
+  }
+  try {
+    const value = dimensions.get(name);
+    const width = Number(value && value.width);
+    const height = Number(value && value.height);
+    if (Number.isFinite(width) && width > 0 && Number.isFinite(height) && height > 0) {
+      return { width, height };
+    }
+  } catch (_) {
+    // Some non-native React renderers do not expose screen dimensions.
+  }
+  return null;
+}
+
+function viewportHostBounds(nodes, screenSize) {
+  const candidates = (nodes || [])
+    .map((node) => node && node.bounds)
+    .filter((bounds) => bounds
+      && Number.isFinite(Number(bounds.x))
+      && Number.isFinite(Number(bounds.y))
+      && Number.isFinite(Number(bounds.width))
+      && Number.isFinite(Number(bounds.height))
+      && Number(bounds.width) >= screenSize.width * 0.85
+      && Number(bounds.height) >= screenSize.height * 0.5);
+  if (candidates.length === 0) {
+    return null;
+  }
+  return candidates.reduce((largest, candidate) => (
+    Number(candidate.width) * Number(candidate.height)
+      > Number(largest.width) * Number(largest.height)
+      ? candidate
+      : largest
+  ));
+}
+
+function createReactCoordinateSpace(dimensions, measuredNodes = []) {
+  const screenSize = readDimensionSize(dimensions, "screen");
+  const windowSize = readDimensionSize(dimensions, "window");
+  const size = screenSize || windowSize;
+  if (!size) {
+    return undefined;
+  }
+
+  const hostBounds = viewportHostBounds(measuredNodes, size);
+  return {
+    x: hostBounds ? Math.min(0, Number(hostBounds.x)) : 0,
+    y: hostBounds ? Math.min(0, Number(hostBounds.y)) : 0,
+    width: size.width,
+    height: size.height,
+    source: screenSize ? "react-native.screen" : "react-native.window",
+  };
+}
+
+module.exports = {
+  createReactCoordinateSpace,
+};

package/react-tree-semantics.js

@@ -0,0 +1,33 @@
+"use strict";
+
+function reactSemanticRole(type, props, fiberTag) {
+  const declared = props && (props.accessibilityRole || props.role);
+  if (declared) return String(declared).toLowerCase();
+  if (fiberTag === 6 || /text/i.test(type)) return "text";
+  if (/button|pressable|touchable/i.test(type)) return "button";
+  if (/textinput/i.test(type)) return "textbox";
+  if (/switch/i.test(type)) return "switch";
+  if (/scrollview|flatlist|sectionlist/i.test(type)) return "scrollview";
+  return "view";
+}
+
+function reactSupportedActions(type, props) {
+  const actions = [];
+  if (props && (
+    typeof props.onPress === "function"
+    || typeof props.onClick === "function"
+    || typeof props.onResponderRelease === "function"
+  )) actions.push("tap");
+  if (props && (typeof props.onChangeText === "function" || /textinput/i.test(type))) {
+    actions.push("typeText", "focus");
+  }
+  if (/scrollview|flatlist|sectionlist/i.test(type) || (props && typeof props.onScroll === "function")) {
+    actions.push("scroll", "swipe");
+  }
+  return actions;
+}
+
+module.exports = {
+  reactSemanticRole,
+  reactSupportedActions,
+};

package/session-properties.js

@@ -0,0 +1,151 @@
+"use strict";
+
+const { version: sdkVersion } = require("./package.json");
+
+const REACT_NATIVE_GROUP = "reactNative";
+const LOCALIZATION_GROUP = "localization";
+
+function formatBoolean(value) {
+  return value ? "true" : "false";
+}
+
+function normalizeString(value) {
+  if (value == null) {
+    return undefined;
+  }
+  const normalized = String(value).trim();
+  return normalized || undefined;
+}
+
+function formatReactNativeVersion(version) {
+  if (!version || typeof version !== "object") {
+    return undefined;
+  }
+  const major = normalizeString(version.major);
+  const minor = normalizeString(version.minor);
+  const patch = normalizeString(version.patch);
+  if (major == null || minor == null || patch == null) {
+    return undefined;
+  }
+  const prerelease = normalizeString(version.prerelease);
+  return `${major}.${minor}.${patch}${prerelease ? `-${prerelease}` : ""}`;
+}
+
+function resolveJavaScriptEngine(runtimeGlobal) {
+  if (runtimeGlobal && runtimeGlobal.HermesInternal) {
+    return "hermes";
+  }
+  if (runtimeGlobal && runtimeGlobal._v8runtime) {
+    return "v8";
+  }
+  return "javascriptCore";
+}
+
+function readHermesProperties(runtimeGlobal) {
+  try {
+    return runtimeGlobal?.HermesInternal?.getRuntimeProperties?.() || {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function canonicalizeLocale(value) {
+  const normalized = normalizeString(value)?.replace(/_/g, "-");
+  if (!normalized) {
+    return undefined;
+  }
+  try {
+    return Intl.getCanonicalLocales(normalized)[0] || normalized;
+  } catch (_) {
+    return normalized;
+  }
+}
+
+function parseLocale(locale) {
+  const parts = (locale || "").split("-").filter(Boolean);
+  const language = parts[0]?.toLowerCase();
+  const region = parts.find(
+    (part, index) => index > 0 && (/^[A-Za-z]{2}$/.test(part) || /^\d{3}$/.test(part))
+  );
+  return {
+    language,
+    region: region ? region.toUpperCase() : undefined,
+  };
+}
+
+function createLocalizationProperties() {
+  let resolved = {};
+  try {
+    resolved = Intl.DateTimeFormat().resolvedOptions();
+  } catch (_) {
+    // Older JavaScript runtimes may not provide Intl data.
+  }
+
+  const locale = canonicalizeLocale(resolved.locale);
+  const parsed = parseLocale(locale);
+  const properties = {
+    utcOffsetMinutes: String(-new Date().getTimezoneOffset()),
+  };
+  if (locale) properties.locale = locale;
+  if (parsed.language) properties.language = parsed.language;
+  if (parsed.region) properties.region = parsed.region;
+  if (normalizeString(resolved.timeZone)) properties.timeZone = resolved.timeZone;
+  return properties;
+}
+
+function createAutomaticSessionProperties({
+  platform,
+  reactVersion,
+  runtimeGlobal,
+  developmentMode,
+} = {}) {
+  const reactNativeVersion = formatReactNativeVersion(platform?.constants?.reactNativeVersion);
+  const newArchitectureEnabled = Boolean(
+    runtimeGlobal?.nativeFabricUIManager || runtimeGlobal?.__turboModuleProxy
+  );
+  const hermesProperties = readHermesProperties(runtimeGlobal);
+  const engineVersion = normalizeString(
+    hermesProperties["OSS Release Version"] || hermesProperties["Release Version"]
+  );
+  const bytecodeVersion = normalizeString(hermesProperties["Bytecode Version"]);
+
+  const properties = {
+    sdkVersion,
+    platform: normalizeString(platform?.OS) || "unknown",
+    runtimeLanguage: "javascript",
+    javascriptEngine: resolveJavaScriptEngine(runtimeGlobal),
+    architecture: newArchitectureEnabled ? "new" : "legacy",
+    newArchitectureEnabled: formatBoolean(newArchitectureEnabled),
+    bridgelessEnabled: formatBoolean(Boolean(runtimeGlobal?.RN$Bridgeless)),
+    developmentMode: formatBoolean(Boolean(developmentMode)),
+  };
+  if (reactNativeVersion) properties.reactNativeVersion = reactNativeVersion;
+  if (normalizeString(reactVersion)) properties.reactVersion = String(reactVersion).trim();
+  if (engineVersion) properties.javascriptEngineVersion = engineVersion;
+  if (bytecodeVersion) properties.hermesBytecodeVersion = bytecodeVersion;
+
+  return {
+    [REACT_NATIVE_GROUP]: properties,
+    [LOCALIZATION_GROUP]: createLocalizationProperties(),
+  };
+}
+
+function mergeSessionProperties(automaticProperties, customProperties) {
+  const merged = {};
+  for (const [group, properties] of Object.entries(automaticProperties || {})) {
+    merged[group] = { ...(properties || {}) };
+  }
+  for (const [group, properties] of Object.entries(customProperties || {})) {
+    merged[group] = { ...(merged[group] || {}), ...(properties || {}) };
+  }
+  return merged;
+}
+
+module.exports = {
+  LOCALIZATION_GROUP,
+  REACT_NATIVE_GROUP,
+  createAutomaticSessionProperties,
+  createLocalizationProperties,
+  formatReactNativeVersion,
+  mergeSessionProperties,
+};