@garrix82/reactgenie-lib 1.3.0

package/dist/adapters/navigation-adapter.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createScreenWrapper = createScreenWrapper;
+exports.isExpoRouter = isExpoRouter;
+exports.useNavigationAdapter = useNavigationAdapter;
+exports.useRouteParams = useRouteParams;
+exports.withNavigationAdapter = withNavigationAdapter;
+var _react = _interopRequireWildcard(require("react"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); } /**
+ * Navigation Adapter for expo-router and @react-navigation/native
+ * Provides a unified navigation interface that works with both paradigms
+ */
+// Type definitions for navigation adapters
+
+// Detect if expo-router is available
+let expoRouter = null;
+let expoRouterHooks = null;
+try {
+  expoRouter = require('expo-router');
+  expoRouterHooks = {
+    useRouter: expoRouter.useRouter,
+    useLocalSearchParams: expoRouter.useLocalSearchParams,
+    usePathname: expoRouter.usePathname,
+    useNavigation: expoRouter.useNavigation
+  };
+} catch (e) {
+  // expo-router not available, will use @react-navigation/native
+}
+
+/**
+ * Hook to get unified navigation adapter
+ * Works with both expo-router and @react-navigation/native
+ */
+function useNavigationAdapter() {
+  if (expoRouterHooks) {
+    // Use expo-router
+    const router = expoRouterHooks.useRouter();
+    const navigation = expoRouterHooks.useNavigation();
+    return {
+      push: (routeName, params) => {
+        // Convert route name to expo-router path
+        const path = routeName.toLowerCase().replace(/\s+/g, '-');
+        router.push({
+          pathname: `/${path}`,
+          params: params || {}
+        });
+      },
+      navigate: (routeName, params) => {
+        const path = routeName.toLowerCase().replace(/\s+/g, '-');
+        router.navigate({
+          pathname: `/${path}`,
+          params: params || {}
+        });
+      },
+      goBack: () => {
+        if (router.canGoBack()) {
+          router.back();
+        }
+      },
+      canGoBack: () => router.canGoBack(),
+      setOptions: options => {
+        if (navigation && navigation.setOptions) {
+          navigation.setOptions(options);
+        }
+      },
+      getState: () => navigation?.getState?.() || null
+    };
+  } else {
+    // Fallback: will be injected by NavigationContainer
+    throw new Error('Navigation adapter must be used within NavigationContainer or expo-router context');
+  }
+}
+
+/**
+ * HOC to inject navigation adapter into components
+ * Provides backward compatibility with class components
+ */
+function withNavigationAdapter(Component) {
+  return props => {
+    const navigation = useNavigationAdapter();
+    return /*#__PURE__*/_react.default.createElement(Component, _extends({}, props, {
+      navigation: navigation
+    }));
+  };
+}
+
+/**
+ * Hook to get route params (works with both navigation systems)
+ */
+function useRouteParams() {
+  if (expoRouterHooks) {
+    return expoRouterHooks.useLocalSearchParams();
+  }
+  // Will be provided by NavigationContainer route prop
+  return {};
+}
+
+/**
+ * Compatibility wrapper for screens
+ * Normalizes props between expo-router and react-navigation
+ */
+function createScreenWrapper(Screen, options) {
+  return function WrappedScreen(props) {
+    const params = useRouteParams();
+    const navigation = props.navigation || useNavigationAdapter();
+    (0, _react.useEffect)(() => {
+      if (options && navigation.setOptions) {
+        const screenOptions = {
+          headerShown: options.headerShown !== false
+        };
+        if (options.title) {
+          screenOptions.title = options.title(params);
+        }
+        navigation.setOptions(screenOptions);
+      }
+    }, [navigation, params]);
+    return /*#__PURE__*/_react.default.createElement(Screen, _extends({}, props, params, {
+      navigation: navigation
+    }));
+  };
+}
+
+/**
+ * Check if running in expo-router environment
+ */
+function isExpoRouter() {
+  return expoRouter !== null;
+}
+
+/**
+ * Export for type checking
+ */
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","_extends","assign","bind","arguments","length","apply","expoRouter","expoRouterHooks","useRouter","useLocalSearchParams","usePathname","useNavigation","useNavigationAdapter","router","navigation","push","routeName","params","path","toLowerCase","replace","pathname","navigate","goBack","canGoBack","back","setOptions","options","getState","Error","withNavigationAdapter","Component","props","createElement","useRouteParams","createScreenWrapper","Screen","WrappedScreen","useEffect","screenOptions","headerShown","title","isExpoRouter"],"sources":["../../src/adapters/navigation-adapter.tsx"],"sourcesContent":["/**\n * Navigation Adapter for expo-router and @react-navigation/native\n * Provides a unified navigation interface that works with both paradigms\n */\n\nimport React, { useEffect } from 'react';\n\n// Type definitions for navigation adapters\nexport interface NavigationAdapter {\n  push: (routeName: string, params?: any) => void;\n  navigate: (routeName: string, params?: any) => void;\n  goBack: () => void;\n  canGoBack: () => boolean;\n  setOptions: (options: any) => void;\n  getState: () => any;\n}\n\n// Detect if expo-router is available\nlet expoRouter: any = null;\nlet expoRouterHooks: any = null;\ntry {\n  expoRouter = require('expo-router');\n  expoRouterHooks = {\n    useRouter: expoRouter.useRouter,\n    useLocalSearchParams: expoRouter.useLocalSearchParams,\n    usePathname: expoRouter.usePathname,\n    useNavigation: expoRouter.useNavigation,\n  };\n} catch (e) {\n  // expo-router not available, will use @react-navigation/native\n}\n\n/**\n * Hook to get unified navigation adapter\n * Works with both expo-router and @react-navigation/native\n */\nexport function useNavigationAdapter(): NavigationAdapter {\n  if (expoRouterHooks) {\n    // Use expo-router\n    const router = expoRouterHooks.useRouter();\n    const navigation = expoRouterHooks.useNavigation();\n    \n    return {\n      push: (routeName: string, params?: any) => {\n        // Convert route name to expo-router path\n        const path = routeName.toLowerCase().replace(/\\s+/g, '-');\n        router.push({\n          pathname: `/${path}`,\n          params: params || {},\n        });\n      },\n      navigate: (routeName: string, params?: any) => {\n        const path = routeName.toLowerCase().replace(/\\s+/g, '-');\n        router.navigate({\n          pathname: `/${path}`,\n          params: params || {},\n        });\n      },\n      goBack: () => {\n        if (router.canGoBack()) {\n          router.back();\n        }\n      },\n      canGoBack: () => router.canGoBack(),\n      setOptions: (options: any) => {\n        if (navigation && navigation.setOptions) {\n          navigation.setOptions(options);\n        }\n      },\n      getState: () => navigation?.getState?.() || null,\n    };\n  } else {\n    // Fallback: will be injected by NavigationContainer\n    throw new Error('Navigation adapter must be used within NavigationContainer or expo-router context');\n  }\n}\n\n/**\n * HOC to inject navigation adapter into components\n * Provides backward compatibility with class components\n */\nexport function withNavigationAdapter<P extends object>(\n  Component: React.ComponentType<P & { navigation: NavigationAdapter }>\n): React.FC<P> {\n  return (props: P) => {\n    const navigation = useNavigationAdapter();\n    return <Component {...props} navigation={navigation} />;\n  };\n}\n\n/**\n * Hook to get route params (works with both navigation systems)\n */\nexport function useRouteParams<T = any>(): T {\n  if (expoRouterHooks) {\n    return expoRouterHooks.useLocalSearchParams() as T;\n  }\n  // Will be provided by NavigationContainer route prop\n  return {} as T;\n}\n\n/**\n * Compatibility wrapper for screens\n * Normalizes props between expo-router and react-navigation\n */\nexport function createScreenWrapper(\n  Screen: React.ComponentType<any>,\n  options?: {\n    title?: (params?: any) => string;\n    headerShown?: boolean;\n  }\n) {\n  return function WrappedScreen(props: any) {\n    const params = useRouteParams();\n    const navigation = props.navigation || useNavigationAdapter();\n    \n    useEffect(() => {\n      if (options && navigation.setOptions) {\n        const screenOptions: any = {\n          headerShown: options.headerShown !== false,\n        };\n        \n        if (options.title) {\n          screenOptions.title = options.title(params);\n        }\n        \n        navigation.setOptions(screenOptions);\n      }\n    }, [navigation, params]);\n    \n    return <Screen {...props} {...params} navigation={navigation} />;\n  };\n}\n\n/**\n * Check if running in expo-router environment\n */\nexport function isExpoRouter(): boolean {\n  return expoRouter !== null;\n}\n\n/**\n * Export for type checking\n */\nexport type { NavigationAdapter as Navigation };\n"],"mappings":"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","ignoreList":[]}

package/dist/audio-visualizer.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface AudioVisualizerProps {
+    audioLevel: number;
+    barCount?: number;
+    barColor?: string;
+    style?: any;
+}
+export declare const AudioVisualizer: React.FC<AudioVisualizerProps>;
+export declare const AudioLevelIndicator: React.FC<{
+    audioLevel: number;
+    size?: number;
+    color?: string;
+}>;
+export default AudioVisualizer;

package/dist/audio-visualizer.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.AudioVisualizer = exports.AudioLevelIndicator = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _reactNative = require("react-native");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Audio Level Visualization Component
+ * Shows real-time audio levels with animated bars
+ * Works on Web, iOS, and Android
+ */
+
+/**
+ * Audio Visualizer Component
+ * Displays animated bars representing audio input level
+ */
+const AudioVisualizer = ({
+  audioLevel,
+  barCount = 5,
+  barColor = '#0000ff',
+  style
+}) => {
+  // Create animated values for each bar
+  const animatedValues = _react.default.useMemo(() => Array.from({
+    length: barCount
+  }, () => new _reactNative.Animated.Value(0.2)), [barCount]);
+
+  // Animate bars based on audio level
+  _react.default.useEffect(() => {
+    const normalizedLevel = Math.min(100, Math.max(0, audioLevel)) / 100;
+    animatedValues.forEach((animValue, index) => {
+      // Each bar has slightly different timing for wave effect
+      const delay = index * 50;
+      const targetHeight = 0.2 + normalizedLevel * 0.8 * (Math.random() * 0.3 + 0.7);
+      _reactNative.Animated.timing(animValue, {
+        toValue: targetHeight,
+        duration: 100,
+        delay,
+        useNativeDriver: false
+      }).start();
+    });
+  }, [audioLevel, animatedValues]);
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: [styles.container, style]
+  }, animatedValues.map((animValue, index) => /*#__PURE__*/_react.default.createElement(_reactNative.Animated.View, {
+    key: index,
+    style: [styles.bar, {
+      backgroundColor: barColor,
+      height: animValue.interpolate({
+        inputRange: [0, 1],
+        outputRange: ['20%', '100%']
+      })
+    }]
+  })));
+};
+
+/**
+ * Circular Audio Level Indicator
+ * Shows audio level as a pulsing circle
+ */
+exports.AudioVisualizer = AudioVisualizer;
+const AudioLevelIndicator = ({
+  audioLevel,
+  size = 80,
+  color = '#0000ff'
+}) => {
+  const scale = _react.default.useMemo(() => new _reactNative.Animated.Value(1), []);
+  _react.default.useEffect(() => {
+    const normalizedLevel = Math.min(100, Math.max(0, audioLevel)) / 100;
+    const targetScale = 1 + normalizedLevel * 0.3;
+    _reactNative.Animated.spring(scale, {
+      toValue: targetScale,
+      tension: 50,
+      friction: 3,
+      useNativeDriver: true
+    }).start();
+  }, [audioLevel, scale]);
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: [indicatorStyles.indicatorContainer, {
+      width: size,
+      height: size
+    }]
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.Animated.View, {
+    style: [indicatorStyles.indicator, {
+      backgroundColor: color,
+      transform: [{
+        scale
+      }],
+      opacity: 0.7
+    }]
+  }));
+};
+exports.AudioLevelIndicator = AudioLevelIndicator;
+const styles = _reactNative.StyleSheet.create({
+  container: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    height: 60,
+    gap: 4
+  },
+  bar: {
+    width: 4,
+    borderRadius: 2,
+    minHeight: '20%'
+  }
+});
+const indicatorStyles = _reactNative.StyleSheet.create({
+  indicatorContainer: {
+    justifyContent: 'center',
+    alignItems: 'center'
+  },
+  indicator: {
+    width: '100%',
+    height: '100%',
+    borderRadius: 999
+  }
+});
+var _default = exports.default = AudioVisualizer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_reactNative","e","__esModule","default","AudioVisualizer","audioLevel","barCount","barColor","style","animatedValues","React","useMemo","Array","from","length","Animated","Value","useEffect","normalizedLevel","Math","min","max","forEach","animValue","index","delay","targetHeight","random","timing","toValue","duration","useNativeDriver","start","createElement","View","styles","container","map","key","bar","backgroundColor","height","interpolate","inputRange","outputRange","exports","AudioLevelIndicator","size","color","scale","targetScale","spring","tension","friction","indicatorStyles","indicatorContainer","width","indicator","transform","opacity","StyleSheet","create","flexDirection","alignItems","justifyContent","gap","borderRadius","minHeight","_default"],"sources":["../src/audio-visualizer.tsx"],"sourcesContent":["/**\n * Audio Level Visualization Component\n * Shows real-time audio levels with animated bars\n * Works on Web, iOS, and Android\n */\n\nimport React from 'react';\nimport { View, Animated, StyleSheet } from 'react-native';\n\nexport interface AudioVisualizerProps {\n  audioLevel: number; // 0-100\n  barCount?: number;\n  barColor?: string;\n  style?: any;\n}\n\n/**\n * Audio Visualizer Component\n * Displays animated bars representing audio input level\n */\nexport const AudioVisualizer: React.FC<AudioVisualizerProps> = ({\n  audioLevel,\n  barCount = 5,\n  barColor = '#0000ff',\n  style,\n}) => {\n  // Create animated values for each bar\n  const animatedValues = React.useMemo(\n    () => Array.from({ length: barCount }, () => new Animated.Value(0.2)),\n    [barCount]\n  );\n\n  // Animate bars based on audio level\n  React.useEffect(() => {\n    const normalizedLevel = Math.min(100, Math.max(0, audioLevel)) / 100;\n\n    animatedValues.forEach((animValue, index) => {\n      // Each bar has slightly different timing for wave effect\n      const delay = index * 50;\n      const targetHeight = 0.2 + normalizedLevel * 0.8 * (Math.random() * 0.3 + 0.7);\n\n      Animated.timing(animValue, {\n        toValue: targetHeight,\n        duration: 100,\n        delay,\n        useNativeDriver: false,\n      }).start();\n    });\n  }, [audioLevel, animatedValues]);\n\n  return (\n    <View style={[styles.container, style]}>\n      {animatedValues.map((animValue, index) => (\n        <Animated.View\n          key={index}\n          style={[\n            styles.bar,\n            {\n              backgroundColor: barColor,\n              height: animValue.interpolate({\n                inputRange: [0, 1],\n                outputRange: ['20%', '100%'],\n              }),\n            },\n          ]}\n        />\n      ))}\n    </View>\n  );\n};\n\n/**\n * Circular Audio Level Indicator\n * Shows audio level as a pulsing circle\n */\nexport const AudioLevelIndicator: React.FC<{\n  audioLevel: number;\n  size?: number;\n  color?: string;\n}> = ({ audioLevel, size = 80, color = '#0000ff' }) => {\n  const scale = React.useMemo(() => new Animated.Value(1), []);\n\n  React.useEffect(() => {\n    const normalizedLevel = Math.min(100, Math.max(0, audioLevel)) / 100;\n    const targetScale = 1 + normalizedLevel * 0.3;\n\n    Animated.spring(scale, {\n      toValue: targetScale,\n      tension: 50,\n      friction: 3,\n      useNativeDriver: true,\n    }).start();\n  }, [audioLevel, scale]);\n\n  return (\n    <View style={[indicatorStyles.indicatorContainer, { width: size, height: size }]}>\n      <Animated.View\n        style={[\n          indicatorStyles.indicator,\n          {\n            backgroundColor: color,\n            transform: [{ scale }],\n            opacity: 0.7,\n          },\n        ]}\n      />\n    </View>\n  );\n};\n\nconst styles = StyleSheet.create({\n  container: {\n    flexDirection: 'row',\n    alignItems: 'center',\n    justifyContent: 'center',\n    height: 60,\n    gap: 4,\n  },\n  bar: {\n    width: 4,\n    borderRadius: 2,\n    minHeight: '20%',\n  },\n});\n\nconst indicatorStyles = StyleSheet.create({\n  indicatorContainer: {\n    justifyContent: 'center',\n    alignItems: 'center',\n  },\n  indicator: {\n    width: '100%',\n    height: '100%',\n    borderRadius: 999,\n  },\n});\n\nexport default AudioVisualizer;\n"],"mappings":"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","ignoreList":[]}

package/dist/current-selection.d.ts

@@ -0,0 +1,27 @@
+export interface CurrentSelectionRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface CurrentSelectionInterface {
+    className: string;
+    key: any;
+    rect: CurrentSelectionRect;
+}
+type CurrentSelectionOptions = {
+    tapSlopPx?: number;
+    blockedRects?: CurrentSelectionRect[];
+};
+export declare class CurrentContextError extends Error {
+    constructor(message: string);
+}
+export declare function pickNearestInterface(candidates: CurrentSelectionInterface[], clickPoint: {
+    x: number;
+    y: number;
+}): CurrentSelectionInterface;
+export declare function pickCurrentInterface(currentClassName: string, interfaces: CurrentSelectionInterface[], clickPoints: {
+    x: number;
+    y: number;
+}[], options?: CurrentSelectionOptions): CurrentSelectionInterface;
+export {};

package/dist/current-selection.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CurrentContextError = void 0;
+exports.pickCurrentInterface = pickCurrentInterface;
+exports.pickNearestInterface = pickNearestInterface;
+class CurrentContextError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CurrentContextError';
+  }
+}
+exports.CurrentContextError = CurrentContextError;
+function pointToRectDistanceSq(pointX, pointY, rect) {
+  const closestX = Math.max(rect.x, Math.min(pointX, rect.x + rect.width));
+  const closestY = Math.max(rect.y, Math.min(pointY, rect.y + rect.height));
+  return Math.pow(pointX - closestX, 2) + Math.pow(pointY - closestY, 2);
+}
+function pointHitsRect(pointX, pointY, rect, slopPx) {
+  const left = rect.x - slopPx;
+  const right = rect.x + rect.width + slopPx;
+  const top = rect.y - slopPx;
+  const bottom = rect.y + rect.height + slopPx;
+  return pointX >= left && pointX <= right && pointY >= top && pointY <= bottom;
+}
+function pointIsBlocked(pointX, pointY, blockedRects) {
+  for (const rect of blockedRects) {
+    if (pointHitsRect(pointX, pointY, rect, 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+function pickNearestInterface(candidates, clickPoint) {
+  let closest = candidates[0];
+  let closestDistance = pointToRectDistanceSq(clickPoint.x, clickPoint.y, closest.rect);
+  for (let i = 1; i < candidates.length; i++) {
+    const distance = pointToRectDistanceSq(clickPoint.x, clickPoint.y, candidates[i].rect);
+    if (distance < closestDistance) {
+      closest = candidates[i];
+      closestDistance = distance;
+    }
+  }
+  console.log(`[Current] nearest match for tap (${clickPoint.x}, ${clickPoint.y}) -> ${closest.className} ${JSON.stringify(closest.key)} distance=${closestDistance}`);
+  return closest;
+}
+function pickCurrentInterface(currentClassName, interfaces, clickPoints, options = {}) {
+  const tapSlopPx = options.tapSlopPx ?? 14;
+  const blockedRects = options.blockedRects ?? [];
+  console.log(`[Current] resolving ${currentClassName}; interfaces=${interfaces.length}; clickPoints=${clickPoints.length}`);
+  console.log(`[Current] interfaces: ${interfaces.map(genieInterface => `${genieInterface.className}:${JSON.stringify(genieInterface.key)}@(${genieInterface.rect.x},${genieInterface.rect.y},${genieInterface.rect.width},${genieInterface.rect.height})`).join(" | ")}`);
+  const candidates = interfaces.filter(genieInterface => genieInterface.className === currentClassName);
+  console.log(`[Current] candidates for ${currentClassName}: ${candidates.map(genieInterface => `${JSON.stringify(genieInterface.key)}@(${genieInterface.rect.x},${genieInterface.rect.y},${genieInterface.rect.width},${genieInterface.rect.height})`).join(" | ") || "none"}`);
+  if (candidates.length === 0) {
+    throw new CurrentContextError(`No visible ${currentClassName} context is available on this screen.`);
+  }
+
+  // Resolution order:
+  // 1. If the user tapped while listening (for example on /probes), resolve the
+  //    nearest visible wrapper of the requested class only.
+  // 2. Otherwise fall back to the largest visible wrapper of that class (for
+  //    example the single Probe on /probes/[probeId]).
+  if (clickPoints.length > 0) {
+    for (let index = clickPoints.length - 1; index >= 0; index -= 1) {
+      const tap = clickPoints[index];
+      if (pointIsBlocked(tap.x, tap.y, blockedRects)) {
+        console.log(`[Current] skipping tap (${tap.x}, ${tap.y}) at index ${index}; occluded by voice UI`);
+        continue;
+      }
+      const tappedCandidates = candidates.filter(candidate => pointHitsRect(tap.x, tap.y, candidate.rect, tapSlopPx));
+      if (tappedCandidates.length === 0) {
+        console.log(`[Current] skipping tap (${tap.x}, ${tap.y}) at index ${index}; no ${currentClassName} hit`);
+        continue;
+      }
+      console.log(`[Current] using tap (${tap.x}, ${tap.y}) at index ${index}; matched ${tappedCandidates.length} candidate(s)`);
+      return pickNearestInterface(tappedCandidates, tap);
+    }
+    console.log(`[Current] no captured taps hit visible ${currentClassName}; falling back to largest visible candidate`);
+  }
+  let result = candidates[0];
+  let biggestArea = result.rect.width * result.rect.height;
+  for (let i = 1; i < candidates.length; i++) {
+    const area = candidates[i].rect.width * candidates[i].rect.height;
+    if (area > biggestArea) {
+      result = candidates[i];
+      biggestArea = area;
+    }
+  }
+  console.log(`[Current] no tap available; using largest visible ${currentClassName} ${JSON.stringify(result.key)} area=${biggestArea}`);
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CurrentContextError","Error","constructor","message","name","exports","pointToRectDistanceSq","pointX","pointY","rect","closestX","Math","max","x","min","width","closestY","y","height","pow","pointHitsRect","slopPx","left","right","top","bottom","pointIsBlocked","blockedRects","pickNearestInterface","candidates","clickPoint","closest","closestDistance","i","length","distance","console","log","className","JSON","stringify","key","pickCurrentInterface","currentClassName","interfaces","clickPoints","options","tapSlopPx","map","genieInterface","join","filter","index","tap","tappedCandidates","candidate","result","biggestArea","area"],"sources":["../src/current-selection.ts"],"sourcesContent":["export interface CurrentSelectionRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface CurrentSelectionInterface {\n  className: string;\n  key: any;\n  rect: CurrentSelectionRect;\n}\n\ntype CurrentSelectionOptions = {\n  tapSlopPx?: number;\n  blockedRects?: CurrentSelectionRect[];\n};\n\nexport class CurrentContextError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'CurrentContextError';\n  }\n}\n\nfunction pointToRectDistanceSq(\n  pointX: number,\n  pointY: number,\n  rect: CurrentSelectionRect,\n): number {\n  const closestX = Math.max(rect.x, Math.min(pointX, rect.x + rect.width));\n  const closestY = Math.max(rect.y, Math.min(pointY, rect.y + rect.height));\n  return Math.pow(pointX - closestX, 2) + Math.pow(pointY - closestY, 2);\n}\n\nfunction pointHitsRect(\n  pointX: number,\n  pointY: number,\n  rect: CurrentSelectionRect,\n  slopPx: number,\n): boolean {\n  const left = rect.x - slopPx;\n  const right = rect.x + rect.width + slopPx;\n  const top = rect.y - slopPx;\n  const bottom = rect.y + rect.height + slopPx;\n  return pointX >= left && pointX <= right && pointY >= top && pointY <= bottom;\n}\n\nfunction pointIsBlocked(\n  pointX: number,\n  pointY: number,\n  blockedRects: CurrentSelectionRect[],\n): boolean {\n  for (const rect of blockedRects) {\n    if (pointHitsRect(pointX, pointY, rect, 0)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function pickNearestInterface(\n  candidates: CurrentSelectionInterface[],\n  clickPoint: { x: number; y: number },\n): CurrentSelectionInterface {\n  let closest = candidates[0];\n  let closestDistance = pointToRectDistanceSq(\n    clickPoint.x,\n    clickPoint.y,\n    closest.rect,\n  );\n\n  for (let i = 1; i < candidates.length; i++) {\n    const distance = pointToRectDistanceSq(\n      clickPoint.x,\n      clickPoint.y,\n      candidates[i].rect,\n    );\n    if (distance < closestDistance) {\n      closest = candidates[i];\n      closestDistance = distance;\n    }\n  }\n\n  console.log(\n    `[Current] nearest match for tap (${clickPoint.x}, ${clickPoint.y}) -> ${closest.className} ${JSON.stringify(closest.key)} distance=${closestDistance}`,\n  );\n  return closest;\n}\n\nexport function pickCurrentInterface(\n  currentClassName: string,\n  interfaces: CurrentSelectionInterface[],\n  clickPoints: { x: number; y: number }[],\n  options: CurrentSelectionOptions = {},\n): CurrentSelectionInterface {\n  const tapSlopPx = options.tapSlopPx ?? 14;\n  const blockedRects = options.blockedRects ?? [];\n  console.log(\n    `[Current] resolving ${currentClassName}; interfaces=${interfaces.length}; clickPoints=${clickPoints.length}`,\n  );\n  console.log(\n    `[Current] interfaces: ${interfaces\n      .map(\n        (genieInterface) =>\n          `${genieInterface.className}:${JSON.stringify(genieInterface.key)}@(${genieInterface.rect.x},${genieInterface.rect.y},${genieInterface.rect.width},${genieInterface.rect.height})`,\n      )\n      .join(\" | \")}`,\n  );\n  const candidates = interfaces.filter(\n    (genieInterface) => genieInterface.className === currentClassName,\n  );\n\n  console.log(\n    `[Current] candidates for ${currentClassName}: ${candidates\n      .map(\n        (genieInterface) =>\n          `${JSON.stringify(genieInterface.key)}@(${genieInterface.rect.x},${genieInterface.rect.y},${genieInterface.rect.width},${genieInterface.rect.height})`,\n      )\n      .join(\" | \") || \"none\"}`,\n  );\n\n  if (candidates.length === 0) {\n    throw new CurrentContextError(\n      `No visible ${currentClassName} context is available on this screen.`,\n    );\n  }\n\n  // Resolution order:\n  // 1. If the user tapped while listening (for example on /probes), resolve the\n  //    nearest visible wrapper of the requested class only.\n  // 2. Otherwise fall back to the largest visible wrapper of that class (for\n  //    example the single Probe on /probes/[probeId]).\n  if (clickPoints.length > 0) {\n    for (let index = clickPoints.length - 1; index >= 0; index -= 1) {\n      const tap = clickPoints[index];\n      if (pointIsBlocked(tap.x, tap.y, blockedRects)) {\n        console.log(\n          `[Current] skipping tap (${tap.x}, ${tap.y}) at index ${index}; occluded by voice UI`,\n        );\n        continue;\n      }\n\n      const tappedCandidates = candidates.filter((candidate) =>\n        pointHitsRect(tap.x, tap.y, candidate.rect, tapSlopPx),\n      );\n      if (tappedCandidates.length === 0) {\n        console.log(\n          `[Current] skipping tap (${tap.x}, ${tap.y}) at index ${index}; no ${currentClassName} hit`,\n        );\n        continue;\n      }\n\n      console.log(\n        `[Current] using tap (${tap.x}, ${tap.y}) at index ${index}; matched ${tappedCandidates.length} candidate(s)`,\n      );\n      return pickNearestInterface(tappedCandidates, tap);\n    }\n\n    console.log(\n      `[Current] no captured taps hit visible ${currentClassName}; falling back to largest visible candidate`,\n    );\n  }\n\n  let result = candidates[0];\n  let biggestArea = result.rect.width * result.rect.height;\n\n  for (let i = 1; i < candidates.length; i++) {\n    const area = candidates[i].rect.width * candidates[i].rect.height;\n    if (area > biggestArea) {\n      result = candidates[i];\n      biggestArea = area;\n    }\n  }\n\n  console.log(\n    `[Current] no tap available; using largest visible ${currentClassName} ${JSON.stringify(result.key)} area=${biggestArea}`,\n  );\n  return result;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+export type GenieUserFacingErrorType = "info" | "error" | "success" | "warning";
+export type GenieUserFacingErrorParams = {
+    minimalText: string;
+    fullText?: string;
+    type?: GenieUserFacingErrorType;
+    code?: string;
+    shouldSpeak?: boolean;
+    cause?: unknown;
+};
+export declare class GenieUserFacingError extends Error {
+    code?: string;
+    minimalText: string;
+    fullText: string;
+    type: GenieUserFacingErrorType;
+    shouldSpeak?: boolean;
+    cause?: unknown;
+    constructor({ minimalText, fullText, type, code, shouldSpeak, cause, }: GenieUserFacingErrorParams);
+}
+export declare function isGenieUserFacingError(error: unknown): error is GenieUserFacingError;

package/dist/errors.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GenieUserFacingError = void 0;
+exports.isGenieUserFacingError = isGenieUserFacingError;
+class GenieUserFacingError extends Error {
+  constructor({
+    minimalText,
+    fullText,
+    type = "error",
+    code,
+    shouldSpeak,
+    cause
+  }) {
+    super(fullText || minimalText);
+    this.code = void 0;
+    this.minimalText = void 0;
+    this.fullText = void 0;
+    this.type = void 0;
+    this.shouldSpeak = void 0;
+    this.cause = void 0;
+    this.name = "GenieUserFacingError";
+    this.code = code;
+    this.minimalText = minimalText;
+    this.fullText = fullText || minimalText;
+    this.type = type;
+    this.shouldSpeak = shouldSpeak;
+    this.cause = cause;
+  }
+}
+exports.GenieUserFacingError = GenieUserFacingError;
+function isGenieUserFacingError(error) {
+  return error instanceof GenieUserFacingError;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/genie/DateTime.d.ts

@@ -0,0 +1,66 @@
+import { HelperClass } from "@garrix82/reactgenie-dsl";
+import "reflect-metadata";
+import { int } from "@garrix82/reactgenie-dsl";
+export declare class DateTime extends HelperClass {
+    private _date;
+    year: int;
+    month: int;
+    day: int;
+    dayOfWeek: int;
+    hour: int;
+    minute: int;
+    second: int;
+    static sunday: int;
+    static monday: int;
+    static tuesday: int;
+    static wednesday: int;
+    static thursday: int;
+    static friday: int;
+    static saturday: int;
+    private updateDate;
+    static now(): DateTime;
+    static today(): DateTime;
+    static fromDate(date: Date): DateTime;
+    constructor({ year, month, day, hour, minute, second, }: {
+        year?: int;
+        month?: int;
+        day?: int;
+        hour?: int;
+        minute?: int;
+        second?: int;
+    });
+    static setup(): void;
+    static compare(a: DateTime, b: DateTime): number;
+    static fromString(data: string): DateTime;
+    static CreateDatetime({ year, month, day, hour, minute, second, }: {
+        year?: int;
+        month?: int;
+        day?: int;
+        hour?: int;
+        minute?: int;
+        second?: int;
+    }): DateTime;
+    addDateOffset({ year, month, day, hour, minute, second, }: {
+        year?: int;
+        month?: int;
+        day?: int;
+        hour?: int;
+        minute?: int;
+        second?: int;
+    }): DateTime;
+    setDate({ year, month, day, hour, minute, second, day_of_the_week, }: {
+        year?: int;
+        month?: int;
+        day?: int;
+        hour?: int;
+        minute?: int;
+        second?: int;
+        day_of_the_week?: int;
+    }): DateTime;
+    toString(): string;
+    getDate(): Date;
+    static Examples: {
+        user_utterance: string;
+        example_parsed: string;
+    }[];
+}