@garrix82/reactgenie-lib 1.3.0

package/dist/react-decorators.js

@@ -0,0 +1,368 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AllGenieObjectInterfaces = exports.AllGenieDisplayedInstances = exports.AllGenieDisplayedInstanceRefreshers = void 0;
+Object.defineProperty(exports, "AllGenieObjects", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.AllGenieObjects;
+  }
+});
+Object.defineProperty(exports, "ClassDescriptor", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.ClassDescriptor;
+  }
+});
+exports.CurrentSelectionBlockedRects = exports.ClickPoints = void 0;
+Object.defineProperty(exports, "DataClass", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.DataClass;
+  }
+});
+Object.defineProperty(exports, "FieldDescriptor", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.FieldDescriptor;
+  }
+});
+Object.defineProperty(exports, "FuncDescriptor", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.FuncDescriptor;
+  }
+});
+Object.defineProperty(exports, "GenieClass", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.GenieClass;
+  }
+});
+exports.GenieClassInterface = GenieClassInterface;
+Object.defineProperty(exports, "GenieFunction", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.GenieFunction;
+  }
+});
+Object.defineProperty(exports, "GenieKey", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.GenieKey;
+  }
+});
+Object.defineProperty(exports, "GenieProperty", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.GenieProperty;
+  }
+});
+Object.defineProperty(exports, "HelperClass", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.HelperClass;
+  }
+});
+exports.InstantiateGenieObject = InstantiateGenieObject;
+Object.defineProperty(exports, "ParamDescriptor", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.ParamDescriptor;
+  }
+});
+exports.RefreshDisplayedInstanceRects = RefreshDisplayedInstanceRects;
+exports.RetrieveInterfaces = RetrieveInterfaces;
+exports.RetrieveInterfacesSnapshot = RetrieveInterfacesSnapshot;
+Object.defineProperty(exports, "float", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.float;
+  }
+});
+exports.hasSameFunctionSignature = hasSameFunctionSignature;
+exports.initReactGenie = initReactGenie;
+Object.defineProperty(exports, "int", {
+  enumerable: true,
+  get: function () {
+    return _reactgenieDsl.int;
+  }
+});
+exports.mergeUniqueExamples = mergeUniqueExamples;
+exports.upsertFunctionDescriptor = upsertFunctionDescriptor;
+var _genieViewWrapper = require("./genie-view-wrapper");
+var _reactNative = require("react-native");
+var _reactgenieDsl = require("@garrix82/reactgenie-dsl");
+var _react = _interopRequireDefault(require("react"));
+var _currentSelection = require("./current-selection");
+var _nativeVisibility = require("./native-visibility");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // dictionary of genie object names to genie objects
+class GenieInterfacesStore {
+  constructor() {
+    this.supportedTypes = new Set();
+    this.interfaces = {};
+  }
+  addInterface(element) {
+    if (!this.interfaces[element.objectClassName]) {
+      this.interfaces[element.objectClassName] = [];
+    }
+    this.interfaces[element.objectClassName].push(element);
+    this.supportedTypes.add(element.objectClassName);
+  }
+  getObjectClassName(object) {
+    if (object.constructor.name === "Array") {
+      return this.getObjectClassName(object[0]) + "[]";
+    }
+    return object.constructor.name;
+  }
+  getInterfaces(object) {
+    const className = this.getObjectClassName(object);
+    if (this.interfaces[className]) {
+      const sortedInterfaces = this.interfaces[className].sort((a, b) => {
+        return b.displayPriority(object) - a.displayPriority(object);
+      });
+      return sortedInterfaces[0];
+    }
+    return null;
+  }
+
+  // key is the class name of the GenieInterfaceStoreElement, not the GenieObject
+  allInterfaces() {
+    const allInterfaces = {};
+    for (const key in this.interfaces) {
+      for (const element of this.interfaces[key]) {
+        allInterfaces[element.viewClassName] = element;
+      }
+    }
+    return allInterfaces;
+  }
+}
+const AllGenieObjectInterfaces = exports.AllGenieObjectInterfaces = new GenieInterfacesStore();
+const AllGenieDisplayedInstances = exports.AllGenieDisplayedInstances = {};
+const AllGenieDisplayedInstanceRefreshers = exports.AllGenieDisplayedInstanceRefreshers = {};
+const ClickPoints = exports.ClickPoints = [];
+const CurrentSelectionBlockedRects = exports.CurrentSelectionBlockedRects = [];
+function toStringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function exampleKey(example) {
+  return `${toStringOrEmpty(example?.user_utterance)}\n${toStringOrEmpty(example?.example_parsed)}`;
+}
+function normalizeParams(params) {
+  return Array.isArray(params) ? params : [];
+}
+function hasSameFunctionSignature(left, right) {
+  if (left?.func_name !== right?.func_name) return false;
+  if (left?.isStatic !== right?.isStatic) return false;
+  if (left?.returnType !== right?.returnType) return false;
+  const leftParams = normalizeParams(left?.parameters);
+  const rightParams = normalizeParams(right?.parameters);
+  if (leftParams.length !== rightParams.length) return false;
+  for (let i = 0; i < leftParams.length; i += 1) {
+    const a = leftParams[i];
+    const b = rightParams[i];
+    if (a?.name !== b?.name) return false;
+    if (a?.type !== b?.type) return false;
+    if (a?.required !== b?.required) return false;
+  }
+  return true;
+}
+function upsertFunctionDescriptor(functions, candidate) {
+  for (const existing of functions) {
+    if (hasSameFunctionSignature(existing, candidate)) {
+      return false;
+    }
+  }
+  functions.add(candidate);
+  return true;
+}
+function mergeUniqueExamples(existing, incoming) {
+  const merged = [...(existing || [])];
+  const seen = new Set(merged.map(example => exampleKey(example)));
+  for (const candidate of incoming || []) {
+    const key = exampleKey(candidate);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(candidate);
+  }
+  return merged;
+}
+function InstantiateGenieObject(objectSpec) {
+  const objectKey = objectSpec && objectSpec.key;
+  if (objectKey && Object.hasOwn(objectKey, "localStore")) {
+    if (objectKey["localStore"]["__genieObjectType"] == "HelperClass") {
+      return objectKey;
+    }
+  }
+  const objectClass = _reactgenieDsl.AllGenieObjects[objectSpec.className];
+  return objectClass.GetObject(objectSpec.key);
+}
+
+/**
+ * Get all genie class interfaces within modality provider and their rects
+ * @returns {GenieInterfaceSpec[]} Retrieve all the Genie object components on the interface and their rects
+ */
+function RetrieveInterfaces() {
+  return RetrieveInterfacesSnapshot().interfaces;
+}
+function RetrieveInterfacesSnapshot() {
+  // scan through values of AllGenieObject and get the displayedInstances
+  console.log(`AllGenieObjectInterfaces ${JSON.stringify(AllGenieDisplayedInstances)}`);
+  const displayedInstances = [];
+  for (const key in AllGenieDisplayedInstances) {
+    displayedInstances.push(AllGenieDisplayedInstances[key]());
+  }
+  const resolution = (0, _nativeVisibility.resolveVisibleInterfacesForPlatform)(_reactNative.Platform.OS, displayedInstances);
+  return {
+    interfaces: resolution.interfaces,
+    visibilityState: resolution.state
+  };
+}
+function RefreshDisplayedInstanceRects() {
+  // Re-measure every visible interface just before geometric resolution so
+  // Current() uses the latest on-screen bounds after scrolling.
+  for (const key in AllGenieDisplayedInstanceRefreshers) {
+    AllGenieDisplayedInstanceRefreshers[key]?.();
+  }
+}
+const reactGenieClassModifier = target => {
+  // append method `current()` to the class
+  /**
+   * Retrieves the most relevant instance of GenieObject in this context
+   * @returns {any} the GenieObject
+   */
+  function Current() {
+    const currentClassName = target.ClassDescriptor.className;
+    const interfaceSnapshot = RetrieveInterfacesSnapshot();
+    const genieInterfaces = interfaceSnapshot.interfaces;
+    console.log(`[Current] start ${currentClassName}; visibleInterfaces=${genieInterfaces.length}; taps=${ClickPoints.length}`);
+    if (interfaceSnapshot.visibilityState === "transition_unstable") {
+      throw new _currentSelection.CurrentContextError(`Visible ${currentClassName} context is temporarily unavailable while navigation is transitioning.`);
+    }
+    const currentInterface = (0, _currentSelection.pickCurrentInterface)(currentClassName, genieInterfaces, ClickPoints, {
+      blockedRects: CurrentSelectionBlockedRects
+    });
+    console.log(`[Current] resolved ${currentClassName} -> ${currentInterface.className} ${JSON.stringify(currentInterface.key)}`);
+    return InstantiateGenieObject(currentInterface);
+  }
+
+  // @ts-ignore
+  target.Current = Current;
+
+  // append additional function descriptor to class descriptor
+  upsertFunctionDescriptor(target.ClassDescriptor.functions, new _reactgenieDsl.FuncDescriptor("Current", [], target.ClassDescriptor.className, true, "The single object that the user is referring to. Usually either the object that is closest to the mouse click, or the object that is the largest on screen."));
+  function AllCurrent() {
+    const currentClassName = target.ClassDescriptor.className;
+    const interfaceSnapshot = RetrieveInterfacesSnapshot();
+    const genieInterfaces = interfaceSnapshot.interfaces;
+    const candidates = genieInterfaces.filter(genieInterface => genieInterface.className === currentClassName);
+    console.log(`[AllCurrent] start ${currentClassName}; visibleInterfaces=${genieInterfaces.length}; candidates=${candidates.length}; taps=${ClickPoints.length}`);
+    const objects = [];
+    if (candidates.length === 0) {
+      return objects;
+    }
+    if (ClickPoints.length > 1) {
+      for (const clickPoint of ClickPoints) {
+        const closest = (0, _currentSelection.pickNearestInterface)(candidates, clickPoint);
+        objects.push(InstantiateGenieObject(closest));
+      }
+      return objects;
+    } else {
+      for (const genieInterface of candidates) {
+        objects.push(InstantiateGenieObject(genieInterface));
+      }
+      return objects;
+    }
+  }
+
+  // @ts-ignore
+  target.AllCurrent = AllCurrent;
+
+  // append additional function descriptor to class descriptor
+  upsertFunctionDescriptor(target.ClassDescriptor.functions, new _reactgenieDsl.FuncDescriptor("AllCurrent", [], target.ClassDescriptor.className + "[]", true, "All objects that the user is referring to. Usually either the objects that are closest to the mouse clicks (if multiple), or all objects of that type on screeen."));
+  (0, _reactgenieDsl.genieDispatch)(() => {
+    const newExamples = mergeUniqueExamples(_reactgenieDsl.sharedState["__EXAMPLES__"] || [], target.Examples || []);
+    (0, _reactgenieDsl.setSharedState)(_objectSpread(_objectSpread({}, _reactgenieDsl.sharedState), {}, {
+      ["__EXAMPLES__"]: newExamples
+    }));
+  });
+};
+function initReactGenie() {
+  const reactGenieStore = (0, _reactgenieDsl.initGenie)({
+    initGenieClassModifier: reactGenieClassModifier
+  });
+  (0, _reactgenieDsl.genieDispatch)(() => {
+    const reactGenieState = _reactgenieDsl.sharedState;
+    reactGenieState.navState = {
+      objectViewClassName: null,
+      objectConstructorParams: null,
+      queryIntent: null,
+      resultRef: null,
+      resultObjectType: null
+    };
+    reactGenieState.navStack = 0;
+    reactGenieState.message = {
+      minimalText: "",
+      fullText: "",
+      type: "info",
+      shouldSpeak: false,
+      origin: "system",
+      message: ""
+    };
+    reactGenieState.resultWindowByRef = {};
+    reactGenieState.resultWindowOrder = [];
+    reactGenieState.resultWindowMax = 40;
+    reactGenieState.resultWindowTtlMs = 5 * 60 * 1000;
+    reactGenieState.resultWindowSequence = 0;
+  });
+  return reactGenieStore;
+}
+
+/**
+ *
+ * @param type the type of the object being rendered by the interface
+ * @param displayTitle the title of the interface, can be a function that takes in the object and returns a string
+ * @param displayPriority the priority of the interface, can be a function that takes in the object and returns a number
+ * @constructor
+ */
+function GenieClassInterface(type, displayTitle = undefined, displayPriority = 0) {
+  return function (target) {
+    // create a function with a list of parameters
+    const newTarget = (...args) => {
+      return (0, _genieViewWrapper.GenieViewWrapper)(type, target, args)();
+    };
+    if (displayTitle === undefined) {
+      displayTitle = type;
+    }
+    const titleFunction = typeof displayTitle === "string" ? () => displayTitle : displayTitle;
+    const displayPriorityFunction = typeof displayPriority === "number" ? () => displayPriority : displayPriority;
+    const newGenieInterfaceSpec = {
+      objectClassName: type,
+      viewClassName: target.name,
+      title: titleFunction,
+      function: newTarget,
+      displayPriority: displayPriorityFunction
+    };
+    AllGenieObjectInterfaces.addInterface(newGenieInterfaceSpec);
+
+    /**
+     * Note: Automatic route registration based on convention (optional, can be overridden by explicit registration in components) 
+     * - for example, we can automatically register an interface for a GenieObject class named "Email" with a component named "EmailInterface". This allows for more seamless integration of new components and interfaces without needing to worry about registration order. 
+     * However, explicit registration is still supported and can be used instead if desired.
+     * We can have multiple interfaces for the same object type without worrying about registration order.
+     */
+
+    // add callback function with shared data structure which contains whether the element is on/off screen
+    return /*#__PURE__*/_react.default.memo(newTarget);
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_genieViewWrapper","require","_reactNative","_reactgenieDsl","_react","_interopRequireDefault","_currentSelection","_nativeVisibility","e","__esModule","default","ownKeys","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","GenieInterfacesStore","constructor","supportedTypes","Set","interfaces","addInterface","element","objectClassName","add","getObjectClassName","object","name","getInterfaces","className","sortedInterfaces","sort","a","b","displayPriority","allInterfaces","key","viewClassName","AllGenieObjectInterfaces","exports","AllGenieDisplayedInstances","AllGenieDisplayedInstanceRefreshers","ClickPoints","CurrentSelectionBlockedRects","toStringOrEmpty","exampleKey","example","user_utterance","example_parsed","normalizeParams","params","Array","isArray","hasSameFunctionSignature","left","right","func_name","isStatic","returnType","leftParams","parameters","rightParams","type","required","upsertFunctionDescriptor","functions","candidate","existing","mergeUniqueExamples","incoming","merged","seen","map","has","InstantiateGenieObject","objectSpec","objectKey","hasOwn","objectClass","AllGenieObjects","GetObject","RetrieveInterfaces","RetrieveInterfacesSnapshot","console","log","JSON","stringify","displayedInstances","resolution","resolveVisibleInterfacesForPlatform","Platform","OS","visibilityState","state","RefreshDisplayedInstanceRects","reactGenieClassModifier","target","Current","currentClassName","ClassDescriptor","interfaceSnapshot","genieInterfaces","CurrentContextError","currentInterface","pickCurrentInterface","blockedRects","FuncDescriptor","AllCurrent","candidates","genieInterface","objects","clickPoint","closest","pickNearestInterface","genieDispatch","newExamples","sharedState","Examples","setSharedState","initReactGenie","reactGenieStore","initGenie","initGenieClassModifier","reactGenieState","navState","objectViewClassName","objectConstructorParams","queryIntent","resultRef","resultObjectType","navStack","message","minimalText","fullText","shouldSpeak","origin","resultWindowByRef","resultWindowOrder","resultWindowMax","resultWindowTtlMs","resultWindowSequence","GenieClassInterface","displayTitle","undefined","newTarget","args","GenieViewWrapper","titleFunction","displayPriorityFunction","newGenieInterfaceSpec","title","function","React","memo"],"sources":["../src/react-decorators.ts"],"sourcesContent":["// dictionary of genie object names to genie objects\nimport { GenieViewWrapper } from \"./genie-view-wrapper\";\nimport { Platform } from \"react-native\";\nimport {\n  FuncDescriptor,\n  GenieClassModifier,\n  GenieObject,\n  initGenie,\n  genieDispatch,\n  AllGenieObjects,\n  sharedState,\n  sharedStore,\n  setSharedState,\n} from \"@garrix82/reactgenie-dsl\";\nimport {\n  GenieClass,\n  GenieFunction,\n  GenieKey,\n  GenieProperty,\n  DataClass,\n  HelperClass,\n  int,\n  float,\n  ClassDescriptor,\n  FieldDescriptor,\n  ParamDescriptor,\n} from \"@garrix82/reactgenie-dsl\";\n\nexport {\n  GenieClass,\n  GenieFunction,\n  GenieKey,\n  GenieProperty,\n  DataClass,\n  HelperClass,\n  int,\n  float,\n  ClassDescriptor,\n  FieldDescriptor,\n  FuncDescriptor,\n  ParamDescriptor,\n} from \"@garrix82/reactgenie-dsl\";\nimport React from \"react\";\nimport { ReactGenieState } from \"./shared-store\";\nimport { Store } from 'redux';\nimport {\n  CurrentContextError,\n  pickCurrentInterface,\n  pickNearestInterface,\n} from \"./current-selection\";\nimport {\n  type NativeVisibilityState,\n  resolveVisibleInterfacesForPlatform,\n} from \"./native-visibility\";\n\nexport { AllGenieObjects } from \"@garrix82/reactgenie-dsl\";\n\nexport interface GenieInterfaceStoreElement {\n  objectClassName: string;\n  viewClassName: string;\n  title: (any) => string;\n  function: any;\n  displayPriority: (target: any) => number;\n}\n\nclass GenieInterfacesStore {\n  supportedTypes: Set<string> = new Set<string>();\n  interfaces: { [key: string]: GenieInterfaceStoreElement[] } = {};\n\n  addInterface(element: GenieInterfaceStoreElement) {\n    if (!this.interfaces[element.objectClassName]) {\n      this.interfaces[element.objectClassName] = [];\n    }\n    this.interfaces[element.objectClassName].push(element);\n    this.supportedTypes.add(element.objectClassName);\n  }\n\n  getObjectClassName(object: GenieObject): string {\n    if (object.constructor.name === \"Array\") {\n      return this.getObjectClassName(object[0]) + \"[]\";\n    }\n    return object.constructor.name;\n  }\n\n  getInterfaces(object: GenieObject): GenieInterfaceStoreElement {\n    const className = this.getObjectClassName(object);\n    if (this.interfaces[className]) {\n      const sortedInterfaces = this.interfaces[className].sort((a, b) => {\n        return b.displayPriority(object) - a.displayPriority(object);\n      });\n      return sortedInterfaces[0];\n    }\n    return null;\n  }\n\n  // key is the class name of the GenieInterfaceStoreElement, not the GenieObject\n  allInterfaces(): { [key: string]: GenieInterfaceStoreElement } {\n    const allInterfaces: { [key: string]: GenieInterfaceStoreElement } = {};\n    for (const key in this.interfaces) {\n      for (const element of this.interfaces[key]) {\n        allInterfaces[element.viewClassName] = element;\n      }\n    }\n    return allInterfaces;\n  }\n}\n\nexport const AllGenieObjectInterfaces: GenieInterfacesStore =\n  new GenieInterfacesStore();\n\nexport const AllGenieDisplayedInstances: {\n  [key: string]: () => GenieInterfaceSpec;\n} = {};\n\nexport const AllGenieDisplayedInstanceRefreshers: {\n  [key: string]: () => void;\n} = {};\n\nexport const ClickPoints: { x: number; y: number }[] = [];\nexport const CurrentSelectionBlockedRects: Array<{\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}> = [];\n\nexport type ExampleLike = {\n  user_utterance?: unknown;\n  example_parsed?: unknown;\n};\n\nexport type FuncParamLike = {\n  name?: unknown;\n  type?: unknown;\n  required?: unknown;\n};\n\nexport type FuncDescriptorLike = {\n  func_name?: unknown;\n  isStatic?: unknown;\n  returnType?: unknown;\n  parameters?: unknown;\n};\n\nfunction toStringOrEmpty(value: unknown): string {\n  return typeof value === \"string\" ? value : \"\";\n}\n\nfunction exampleKey(example: ExampleLike): string {\n  return `${toStringOrEmpty(example?.user_utterance)}\\n${toStringOrEmpty(\n    example?.example_parsed,\n  )}`;\n}\n\nfunction normalizeParams(params: unknown): FuncParamLike[] {\n  return Array.isArray(params) ? (params as FuncParamLike[]) : [];\n}\n\nexport function hasSameFunctionSignature(\n  left: FuncDescriptorLike,\n  right: FuncDescriptorLike,\n): boolean {\n  if (left?.func_name !== right?.func_name) return false;\n  if (left?.isStatic !== right?.isStatic) return false;\n  if (left?.returnType !== right?.returnType) return false;\n\n  const leftParams = normalizeParams(left?.parameters);\n  const rightParams = normalizeParams(right?.parameters);\n\n  if (leftParams.length !== rightParams.length) return false;\n\n  for (let i = 0; i < leftParams.length; i += 1) {\n    const a = leftParams[i];\n    const b = rightParams[i];\n    if (a?.name !== b?.name) return false;\n    if (a?.type !== b?.type) return false;\n    if (a?.required !== b?.required) return false;\n  }\n\n  return true;\n}\n\nexport function upsertFunctionDescriptor(\n  functions: Set<FuncDescriptorLike>,\n  candidate: FuncDescriptorLike,\n): boolean {\n  for (const existing of functions) {\n    if (hasSameFunctionSignature(existing, candidate)) {\n      return false;\n    }\n  }\n  functions.add(candidate);\n  return true;\n}\n\nexport function mergeUniqueExamples<T extends ExampleLike>(\n  existing: T[] | null | undefined,\n  incoming: T[] | null | undefined,\n): T[] {\n  const merged = [...(existing || [])];\n  const seen = new Set(merged.map((example) => exampleKey(example)));\n\n  for (const candidate of incoming || []) {\n    const key = exampleKey(candidate);\n    if (seen.has(key)) {\n      continue;\n    }\n    seen.add(key);\n    merged.push(candidate);\n  }\n\n  return merged;\n}\n\ninterface GenieObjectSpec {\n  className: string;\n  key: any;\n}\n\ninterface GenieRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n  top: number;\n  left: number;\n  bottom: number;\n  right: number;\n}\n\nexport interface GenieInterfaceSpec extends GenieObjectSpec {\n  rect: GenieRect;\n  isFocusedScreen?: boolean;\n}\n\nexport interface RetrieveInterfacesResult {\n  interfaces: GenieInterfaceSpec[];\n  visibilityState: NativeVisibilityState;\n}\n\nexport function InstantiateGenieObject(objectSpec: GenieObjectSpec): any {\n  const objectKey = objectSpec && objectSpec.key;\n  if (objectKey && Object.hasOwn(objectKey, \"localStore\")) {\n    if (objectKey[\"localStore\"][\"__genieObjectType\"] == \"HelperClass\") {\n      return objectKey;\n    }\n  }\n  const objectClass = AllGenieObjects[objectSpec.className] as typeof DataClass;\n  return objectClass.GetObject(objectSpec.key);\n}\n\n/**\n * Get all genie class interfaces within modality provider and their rects\n * @returns {GenieInterfaceSpec[]} Retrieve all the Genie object components on the interface and their rects\n */\nexport function RetrieveInterfaces(): GenieInterfaceSpec[] {\n  return RetrieveInterfacesSnapshot().interfaces;\n}\n\nexport function RetrieveInterfacesSnapshot(): RetrieveInterfacesResult {\n  // scan through values of AllGenieObject and get the displayedInstances\n  console.log(\n    `AllGenieObjectInterfaces ${JSON.stringify(AllGenieDisplayedInstances)}`,\n  );\n  const displayedInstances: GenieInterfaceSpec[] = [];\n  for (const key in AllGenieDisplayedInstances) {\n    displayedInstances.push(AllGenieDisplayedInstances[key]());\n  }\n  const resolution = resolveVisibleInterfacesForPlatform(\n    Platform.OS,\n    displayedInstances,\n  );\n  return {\n    interfaces: resolution.interfaces as GenieInterfaceSpec[],\n    visibilityState: resolution.state,\n  };\n}\n\nexport function RefreshDisplayedInstanceRects(): void {\n  // Re-measure every visible interface just before geometric resolution so\n  // Current() uses the latest on-screen bounds after scrolling.\n  for (const key in AllGenieDisplayedInstanceRefreshers) {\n    AllGenieDisplayedInstanceRefreshers[key]?.();\n  }\n}\n\nconst reactGenieClassModifier: GenieClassModifier = (\n  target: typeof GenieObject,\n) => {\n  // append method `current()` to the class\n  /**\n   * Retrieves the most relevant instance of GenieObject in this context\n   * @returns {any} the GenieObject\n   */\n  function Current() {\n    const currentClassName = target.ClassDescriptor.className;\n    const interfaceSnapshot = RetrieveInterfacesSnapshot();\n    const genieInterfaces = interfaceSnapshot.interfaces;\n    console.log(\n      `[Current] start ${currentClassName}; visibleInterfaces=${genieInterfaces.length}; taps=${ClickPoints.length}`,\n    );\n    if (interfaceSnapshot.visibilityState === \"transition_unstable\") {\n      throw new CurrentContextError(\n        `Visible ${currentClassName} context is temporarily unavailable while navigation is transitioning.`,\n      );\n    }\n    const currentInterface = pickCurrentInterface(\n      currentClassName,\n      genieInterfaces,\n      ClickPoints,\n      {\n        blockedRects: CurrentSelectionBlockedRects,\n      },\n    );\n    console.log(\n      `[Current] resolved ${currentClassName} -> ${currentInterface.className} ${JSON.stringify(currentInterface.key)}`,\n    );\n    return InstantiateGenieObject(currentInterface);\n  }\n\n  // @ts-ignore\n  target.Current = Current;\n\n  // append additional function descriptor to class descriptor\n  upsertFunctionDescriptor(\n    target.ClassDescriptor.functions as unknown as Set<any>,\n    new FuncDescriptor(\n        \"Current\",\n        [],\n        target.ClassDescriptor.className,\n        true,\n        \"The single object that the user is referring to. Usually either the object that is closest to the mouse click, or the object that is the largest on screen.\",\n      ),\n  );\n\n  function AllCurrent() {\n    const currentClassName = target.ClassDescriptor.className;\n    const interfaceSnapshot = RetrieveInterfacesSnapshot();\n    const genieInterfaces = interfaceSnapshot.interfaces;\n    const candidates = genieInterfaces.filter(\n      (genieInterface) => genieInterface.className === currentClassName,\n    );\n    console.log(\n      `[AllCurrent] start ${currentClassName}; visibleInterfaces=${genieInterfaces.length}; candidates=${candidates.length}; taps=${ClickPoints.length}`,\n    );\n\n    const objects: any[] = [];\n\n    if (candidates.length === 0) {\n      return objects;\n    }\n\n    if (ClickPoints.length > 1) {\n      for (const clickPoint of ClickPoints) {\n        const closest = pickNearestInterface(candidates, clickPoint);\n        objects.push(InstantiateGenieObject(closest));\n      }\n      return objects;\n    } else {\n      for (const genieInterface of candidates) {\n        objects.push(InstantiateGenieObject(genieInterface));\n      }\n      return objects;\n    }\n  }\n\n  // @ts-ignore\n  target.AllCurrent = AllCurrent;\n\n  // append additional function descriptor to class descriptor\n  upsertFunctionDescriptor(\n    target.ClassDescriptor.functions as unknown as Set<any>,\n    new FuncDescriptor(\n        \"AllCurrent\",\n        [],\n        target.ClassDescriptor.className + \"[]\",\n        true,\n        \"All objects that the user is referring to. Usually either the objects that are closest to the mouse clicks (if multiple), or all objects of that type on screeen.\",\n      ),\n  );\n\n  genieDispatch(() => {\n    const newExamples = mergeUniqueExamples(\n      sharedState[\"__EXAMPLES__\"] || [],\n      target.Examples || [],\n    );\n    setSharedState({\n      ...sharedState,\n      [\"__EXAMPLES__\"]: newExamples,\n    });\n  });\n};\n\nexport function initReactGenie(): Store<any, any> {\n  const reactGenieStore = initGenie({\n    initGenieClassModifier: reactGenieClassModifier,\n  });\n  genieDispatch(() => {\n    const reactGenieState = sharedState as ReactGenieState;\n    reactGenieState.navState = {\n      objectViewClassName: null,\n      objectConstructorParams: null,\n      queryIntent: null,\n      resultRef: null,\n      resultObjectType: null,\n    };\n    reactGenieState.navStack = 0;\n    reactGenieState.message = {\n      minimalText: \"\",\n      fullText: \"\",\n      type: \"info\",\n      shouldSpeak: false,\n      origin: \"system\",\n      message: \"\",\n    };\n    reactGenieState.resultWindowByRef = {};\n    reactGenieState.resultWindowOrder = [];\n    reactGenieState.resultWindowMax = 40;\n    reactGenieState.resultWindowTtlMs = 5 * 60 * 1000;\n    reactGenieState.resultWindowSequence = 0;\n  });\n  return reactGenieStore;\n}\n\n/**\n *\n * @param type the type of the object being rendered by the interface\n * @param displayTitle the title of the interface, can be a function that takes in the object and returns a string\n * @param displayPriority the priority of the interface, can be a function that takes in the object and returns a number\n * @constructor\n */\nexport function GenieClassInterface(\n  type: string,\n  displayTitle: string | ((any) => string) | undefined = undefined,\n  displayPriority: number | ((target: any) => number) = 0,\n) {\n  return function (target: any) {\n    // create a function with a list of parameters\n    const newTarget = (...args) => {\n      return GenieViewWrapper(type, target, args)();\n    };\n    if (displayTitle === undefined) {\n      displayTitle = type;\n    }\n    const titleFunction =\n      typeof displayTitle === \"string\" ? () => displayTitle : displayTitle;\n    const displayPriorityFunction =\n      typeof displayPriority === \"number\"\n        ? () => displayPriority\n        : displayPriority;\n    const newGenieInterfaceSpec: GenieInterfaceStoreElement = {\n      objectClassName: type,\n      viewClassName: target.name,\n      title: titleFunction as (any: any) => string,\n      function: newTarget,\n      displayPriority: displayPriorityFunction,\n    };\n    AllGenieObjectInterfaces.addInterface(newGenieInterfaceSpec);\n    \n    /**\n     * Note: Automatic route registration based on convention (optional, can be overridden by explicit registration in components) \n     * - for example, we can automatically register an interface for a GenieObject class named \"Email\" with a component named \"EmailInterface\". This allows for more seamless integration of new components and interfaces without needing to worry about registration order. \n     * However, explicit registration is still supported and can be used instead if desired.\n     * We can have multiple interfaces for the same object type without worrying about registration order.\n     */ \n\n    // add callback function with shared data structure which contains whether the element is on/off screen\n    return React.memo(newTarget);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAAA,iBAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AACA,IAAAE,cAAA,GAAAF,OAAA;AAuCA,IAAAG,MAAA,GAAAC,sBAAA,CAAAJ,OAAA;AAGA,IAAAK,iBAAA,GAAAL,OAAA;AAKA,IAAAM,iBAAA,GAAAN,OAAA;AAG6B,SAAAI,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,SAAAG,QAAAH,CAAA,EAAAI,CAAA,QAAAC,CAAA,GAAAC,MAAA,CAAAC,IAAA,CAAAP,CAAA,OAAAM,MAAA,CAAAE,qBAAA,QAAAC,CAAA,GAAAH,MAAA,CAAAE,qBAAA,CAAAR,CAAA,GAAAI,CAAA,KAAAK,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAAN,CAAA,WAAAE,MAAA,CAAAK,wBAAA,CAAAX,CAAA,EAAAI,CAAA,EAAAQ,UAAA,OAAAP,CAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,CAAA,EAAAI,CAAA,YAAAJ,CAAA;AAAA,SAAAU,cAAAf,CAAA,aAAAI,CAAA,MAAAA,CAAA,GAAAY,SAAA,CAAAC,MAAA,EAAAb,CAAA,UAAAC,CAAA,WAAAW,SAAA,CAAAZ,CAAA,IAAAY,SAAA,CAAAZ,CAAA,QAAAA,CAAA,OAAAD,OAAA,CAAAG,MAAA,CAAAD,CAAA,OAAAa,OAAA,WAAAd,CAAA,IAAAe,eAAA,CAAAnB,CAAA,EAAAI,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAE,MAAA,CAAAc,yBAAA,GAAAd,MAAA,CAAAe,gBAAA,CAAArB,CAAA,EAAAM,MAAA,CAAAc,yBAAA,CAAAf,CAAA,KAAAF,OAAA,CAAAG,MAAA,CAAAD,CAAA,GAAAa,OAAA,WAAAd,CAAA,IAAAE,MAAA,CAAAgB,cAAA,CAAAtB,CAAA,EAAAI,CAAA,EAAAE,MAAA,CAAAK,wBAAA,CAAAN,CAAA,EAAAD,CAAA,iBAAAJ,CAAA;AAAA,SAAAmB,gBAAAnB,CAAA,EAAAI,CAAA,EAAAC,CAAA,YAAAD,CAAA,GAAAmB,cAAA,CAAAnB,CAAA,MAAAJ,CAAA,GAAAM,MAAA,CAAAgB,cAAA,CAAAtB,CAAA,EAAAI,CAAA,IAAAoB,KAAA,EAAAnB,CAAA,EAAAO,UAAA,MAAAa,YAAA,MAAAC,QAAA,UAAA1B,CAAA,CAAAI,CAAA,IAAAC,CAAA,EAAAL,CAAA;AAAA,SAAAuB,eAAAlB,CAAA,QAAAsB,CAAA,GAAAC,YAAA,CAAAvB,CAAA,uCAAAsB,CAAA,GAAAA,CAAA,GAAAA,CAAA;AAAA,SAAAC,aAAAvB,CAAA,EAAAD,CAAA,2BAAAC,CAAA,KAAAA,CAAA,SAAAA,CAAA,MAAAL,CAAA,GAAAK,CAAA,CAAAwB,MAAA,CAAAC,WAAA,kBAAA9B,CAAA,QAAA2B,CAAA,GAAA3B,CAAA,CAAA+B,IAAA,CAAA1B,CAAA,EAAAD,CAAA,uCAAAuB,CAAA,SAAAA,CAAA,YAAAK,SAAA,yEAAA5B,CAAA,GAAA6B,MAAA,GAAAC,MAAA,EAAA7B,CAAA,KArD7B;AAiEA,MAAM8B,oBAAoB,CAAC;EAAAC,YAAA;IAAA,KACzBC,cAAc,GAAgB,IAAIC,GAAG,CAAS,CAAC;IAAA,KAC/CC,UAAU,GAAoD,CAAC,CAAC;EAAA;EAEhEC,YAAYA,CAACC,OAAmC,EAAE;IAChD,IAAI,CAAC,IAAI,CAACF,UAAU,CAACE,OAAO,CAACC,eAAe,CAAC,EAAE;MAC7C,IAAI,CAACH,UAAU,CAACE,OAAO,CAACC,eAAe,CAAC,GAAG,EAAE;IAC/C;IACA,IAAI,CAACH,UAAU,CAACE,OAAO,CAACC,eAAe,CAAC,CAAC7B,IAAI,CAAC4B,OAAO,CAAC;IACtD,IAAI,CAACJ,cAAc,CAACM,GAAG,CAACF,OAAO,CAACC,eAAe,CAAC;EAClD;EAEAE,kBAAkBA,CAACC,MAAmB,EAAU;IAC9C,IAAIA,MAAM,CAACT,WAAW,CAACU,IAAI,KAAK,OAAO,EAAE;MACvC,OAAO,IAAI,CAACF,kBAAkB,CAACC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAClD;IACA,OAAOA,MAAM,CAACT,WAAW,CAACU,IAAI;EAChC;EAEAC,aAAaA,CAACF,MAAmB,EAA8B;IAC7D,MAAMG,SAAS,GAAG,IAAI,CAACJ,kBAAkB,CAACC,MAAM,CAAC;IACjD,IAAI,IAAI,CAACN,UAAU,CAACS,SAAS,CAAC,EAAE;MAC9B,MAAMC,gBAAgB,GAAG,IAAI,CAACV,UAAU,CAACS,SAAS,CAAC,CAACE,IAAI,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAK;QACjE,OAAOA,CAAC,CAACC,eAAe,CAACR,MAAM,CAAC,GAAGM,CAAC,CAACE,eAAe,CAACR,MAAM,CAAC;MAC9D,CAAC,CAAC;MACF,OAAOI,gBAAgB,CAAC,CAAC,CAAC;IAC5B;IACA,OAAO,IAAI;EACb;;EAEA;EACAK,aAAaA,CAAA,EAAkD;IAC7D,MAAMA,aAA4D,GAAG,CAAC,CAAC;IACvE,KAAK,MAAMC,GAAG,IAAI,IAAI,CAAChB,UAAU,EAAE;MACjC,KAAK,MAAME,OAAO,IAAI,IAAI,CAACF,UAAU,CAACgB,GAAG,CAAC,EAAE;QAC1CD,aAAa,CAACb,OAAO,CAACe,aAAa,CAAC,GAAGf,OAAO;MAChD;IACF;IACA,OAAOa,aAAa;EACtB;AACF;AAEO,MAAMG,wBAA8C,GAAAC,OAAA,CAAAD,wBAAA,GACzD,IAAItB,oBAAoB,CAAC,CAAC;AAErB,MAAMwB,0BAEZ,GAAAD,OAAA,CAAAC,0BAAA,GAAG,CAAC,CAAC;AAEC,MAAMC,mCAEZ,GAAAF,OAAA,CAAAE,mCAAA,GAAG,CAAC,CAAC;AAEC,MAAMC,WAAuC,GAAAH,OAAA,CAAAG,WAAA,GAAG,EAAE;AAClD,MAAMC,4BAKX,GAAAJ,OAAA,CAAAI,4BAAA,GAAG,EAAE;AAoBP,SAASC,eAAeA,CAACvC,KAAc,EAAU;EAC/C,OAAO,OAAOA,KAAK,KAAK,QAAQ,GAAGA,KAAK,GAAG,EAAE;AAC/C;AAEA,SAASwC,UAAUA,CAACC,OAAoB,EAAU;EAChD,OAAO,GAAGF,eAAe,CAACE,OAAO,EAAEC,cAAc,CAAC,KAAKH,eAAe,CACpEE,OAAO,EAAEE,cACX,CAAC,EAAE;AACL;AAEA,SAASC,eAAeA,CAACC,MAAe,EAAmB;EACzD,OAAOC,KAAK,CAACC,OAAO,CAACF,MAAM,CAAC,GAAIA,MAAM,GAAuB,EAAE;AACjE;AAEO,SAASG,wBAAwBA,CACtCC,IAAwB,EACxBC,KAAyB,EAChB;EACT,IAAID,IAAI,EAAEE,SAAS,KAAKD,KAAK,EAAEC,SAAS,EAAE,OAAO,KAAK;EACtD,IAAIF,IAAI,EAAEG,QAAQ,KAAKF,KAAK,EAAEE,QAAQ,EAAE,OAAO,KAAK;EACpD,IAAIH,IAAI,EAAEI,UAAU,KAAKH,KAAK,EAAEG,UAAU,EAAE,OAAO,KAAK;EAExD,MAAMC,UAAU,GAAGV,eAAe,CAACK,IAAI,EAAEM,UAAU,CAAC;EACpD,MAAMC,WAAW,GAAGZ,eAAe,CAACM,KAAK,EAAEK,UAAU,CAAC;EAEtD,IAAID,UAAU,CAAC7D,MAAM,KAAK+D,WAAW,CAAC/D,MAAM,EAAE,OAAO,KAAK;EAE1D,KAAK,IAAIU,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGmD,UAAU,CAAC7D,MAAM,EAAEU,CAAC,IAAI,CAAC,EAAE;IAC7C,MAAMwB,CAAC,GAAG2B,UAAU,CAACnD,CAAC,CAAC;IACvB,MAAMyB,CAAC,GAAG4B,WAAW,CAACrD,CAAC,CAAC;IACxB,IAAIwB,CAAC,EAAEL,IAAI,KAAKM,CAAC,EAAEN,IAAI,EAAE,OAAO,KAAK;IACrC,IAAIK,CAAC,EAAE8B,IAAI,KAAK7B,CAAC,EAAE6B,IAAI,EAAE,OAAO,KAAK;IACrC,IAAI9B,CAAC,EAAE+B,QAAQ,KAAK9B,CAAC,EAAE8B,QAAQ,EAAE,OAAO,KAAK;EAC/C;EAEA,OAAO,IAAI;AACb;AAEO,SAASC,wBAAwBA,CACtCC,SAAkC,EAClCC,SAA6B,EACpB;EACT,KAAK,MAAMC,QAAQ,IAAIF,SAAS,EAAE;IAChC,IAAIZ,wBAAwB,CAACc,QAAQ,EAAED,SAAS,CAAC,EAAE;MACjD,OAAO,KAAK;IACd;EACF;EACAD,SAAS,CAACzC,GAAG,CAAC0C,SAAS,CAAC;EACxB,OAAO,IAAI;AACb;AAEO,SAASE,mBAAmBA,CACjCD,QAAgC,EAChCE,QAAgC,EAC3B;EACL,MAAMC,MAAM,GAAG,CAAC,IAAIH,QAAQ,IAAI,EAAE,CAAC,CAAC;EACpC,MAAMI,IAAI,GAAG,IAAIpD,GAAG,CAACmD,MAAM,CAACE,GAAG,CAAE1B,OAAO,IAAKD,UAAU,CAACC,OAAO,CAAC,CAAC,CAAC;EAElE,KAAK,MAAMoB,SAAS,IAAIG,QAAQ,IAAI,EAAE,EAAE;IACtC,MAAMjC,GAAG,GAAGS,UAAU,CAACqB,SAAS,CAAC;IACjC,IAAIK,IAAI,CAACE,GAAG,CAACrC,GAAG,CAAC,EAAE;MACjB;IACF;IACAmC,IAAI,CAAC/C,GAAG,CAACY,GAAG,CAAC;IACbkC,MAAM,CAAC5E,IAAI,CAACwE,SAAS,CAAC;EACxB;EAEA,OAAOI,MAAM;AACf;AA4BO,SAASI,sBAAsBA,CAACC,UAA2B,EAAO;EACvE,MAAMC,SAAS,GAAGD,UAAU,IAAIA,UAAU,CAACvC,GAAG;EAC9C,IAAIwC,SAAS,IAAIzF,MAAM,CAAC0F,MAAM,CAACD,SAAS,EAAE,YAAY,CAAC,EAAE;IACvD,IAAIA,SAAS,CAAC,YAAY,CAAC,CAAC,mBAAmB,CAAC,IAAI,aAAa,EAAE;MACjE,OAAOA,SAAS;IAClB;EACF;EACA,MAAME,WAAW,GAAGC,8BAAe,CAACJ,UAAU,CAAC9C,SAAS,CAAqB;EAC7E,OAAOiD,WAAW,CAACE,SAAS,CAACL,UAAU,CAACvC,GAAG,CAAC;AAC9C;;AAEA;AACA;AACA;AACA;AACO,SAAS6C,kBAAkBA,CAAA,EAAyB;EACzD,OAAOC,0BAA0B,CAAC,CAAC,CAAC9D,UAAU;AAChD;AAEO,SAAS8D,0BAA0BA,CAAA,EAA6B;EACrE;EACAC,OAAO,CAACC,GAAG,CACT,4BAA4BC,IAAI,CAACC,SAAS,CAAC9C,0BAA0B,CAAC,EACxE,CAAC;EACD,MAAM+C,kBAAwC,GAAG,EAAE;EACnD,KAAK,MAAMnD,GAAG,IAAII,0BAA0B,EAAE;IAC5C+C,kBAAkB,CAAC7F,IAAI,CAAC8C,0BAA0B,CAACJ,GAAG,CAAC,CAAC,CAAC,CAAC;EAC5D;EACA,MAAMoD,UAAU,GAAG,IAAAC,qDAAmC,EACpDC,qBAAQ,CAACC,EAAE,EACXJ,kBACF,CAAC;EACD,OAAO;IACLnE,UAAU,EAAEoE,UAAU,CAACpE,UAAkC;IACzDwE,eAAe,EAAEJ,UAAU,CAACK;EAC9B,CAAC;AACH;AAEO,SAASC,6BAA6BA,CAAA,EAAS;EACpD;EACA;EACA,KAAK,MAAM1D,GAAG,IAAIK,mCAAmC,EAAE;IACrDA,mCAAmC,CAACL,GAAG,CAAC,GAAG,CAAC;EAC9C;AACF;AAEA,MAAM2D,uBAA2C,GAC/CC,MAA0B,IACvB;EACH;EACA;AACF;AACA;AACA;EACE,SAASC,OAAOA,CAAA,EAAG;IACjB,MAAMC,gBAAgB,GAAGF,MAAM,CAACG,eAAe,CAACtE,SAAS;IACzD,MAAMuE,iBAAiB,GAAGlB,0BAA0B,CAAC,CAAC;IACtD,MAAMmB,eAAe,GAAGD,iBAAiB,CAAChF,UAAU;IACpD+D,OAAO,CAACC,GAAG,CACT,mBAAmBc,gBAAgB,uBAAuBG,eAAe,CAACvG,MAAM,UAAU4C,WAAW,CAAC5C,MAAM,EAC9G,CAAC;IACD,IAAIsG,iBAAiB,CAACR,eAAe,KAAK,qBAAqB,EAAE;MAC/D,MAAM,IAAIU,qCAAmB,CAC3B,WAAWJ,gBAAgB,wEAC7B,CAAC;IACH;IACA,MAAMK,gBAAgB,GAAG,IAAAC,sCAAoB,EAC3CN,gBAAgB,EAChBG,eAAe,EACf3D,WAAW,EACX;MACE+D,YAAY,EAAE9D;IAChB,CACF,CAAC;IACDwC,OAAO,CAACC,GAAG,CACT,sBAAsBc,gBAAgB,OAAOK,gBAAgB,CAAC1E,SAAS,IAAIwD,IAAI,CAACC,SAAS,CAACiB,gBAAgB,CAACnE,GAAG,CAAC,EACjH,CAAC;IACD,OAAOsC,sBAAsB,CAAC6B,gBAAgB,CAAC;EACjD;;EAEA;EACAP,MAAM,CAACC,OAAO,GAAGA,OAAO;;EAExB;EACAjC,wBAAwB,CACtBgC,MAAM,CAACG,eAAe,CAAClC,SAAS,EAChC,IAAIyC,6BAAc,CACd,SAAS,EACT,EAAE,EACFV,MAAM,CAACG,eAAe,CAACtE,SAAS,EAChC,IAAI,EACJ,6JACF,CACJ,CAAC;EAED,SAAS8E,UAAUA,CAAA,EAAG;IACpB,MAAMT,gBAAgB,GAAGF,MAAM,CAACG,eAAe,CAACtE,SAAS;IACzD,MAAMuE,iBAAiB,GAAGlB,0BAA0B,CAAC,CAAC;IACtD,MAAMmB,eAAe,GAAGD,iBAAiB,CAAChF,UAAU;IACpD,MAAMwF,UAAU,GAAGP,eAAe,CAAC9G,MAAM,CACtCsH,cAAc,IAAKA,cAAc,CAAChF,SAAS,KAAKqE,gBACnD,CAAC;IACDf,OAAO,CAACC,GAAG,CACT,sBAAsBc,gBAAgB,uBAAuBG,eAAe,CAACvG,MAAM,gBAAgB8G,UAAU,CAAC9G,MAAM,UAAU4C,WAAW,CAAC5C,MAAM,EAClJ,CAAC;IAED,MAAMgH,OAAc,GAAG,EAAE;IAEzB,IAAIF,UAAU,CAAC9G,MAAM,KAAK,CAAC,EAAE;MAC3B,OAAOgH,OAAO;IAChB;IAEA,IAAIpE,WAAW,CAAC5C,MAAM,GAAG,CAAC,EAAE;MAC1B,KAAK,MAAMiH,UAAU,IAAIrE,WAAW,EAAE;QACpC,MAAMsE,OAAO,GAAG,IAAAC,sCAAoB,EAACL,UAAU,EAAEG,UAAU,CAAC;QAC5DD,OAAO,CAACpH,IAAI,CAACgF,sBAAsB,CAACsC,OAAO,CAAC,CAAC;MAC/C;MACA,OAAOF,OAAO;IAChB,CAAC,MAAM;MACL,KAAK,MAAMD,cAAc,IAAID,UAAU,EAAE;QACvCE,OAAO,CAACpH,IAAI,CAACgF,sBAAsB,CAACmC,cAAc,CAAC,CAAC;MACtD;MACA,OAAOC,OAAO;IAChB;EACF;;EAEA;EACAd,MAAM,CAACW,UAAU,GAAGA,UAAU;;EAE9B;EACA3C,wBAAwB,CACtBgC,MAAM,CAACG,eAAe,CAAClC,SAAS,EAChC,IAAIyC,6BAAc,CACd,YAAY,EACZ,EAAE,EACFV,MAAM,CAACG,eAAe,CAACtE,SAAS,GAAG,IAAI,EACvC,IAAI,EACJ,mKACF,CACJ,CAAC;EAED,IAAAqF,4BAAa,EAAC,MAAM;IAClB,MAAMC,WAAW,GAAG/C,mBAAmB,CACrCgD,0BAAW,CAAC,cAAc,CAAC,IAAI,EAAE,EACjCpB,MAAM,CAACqB,QAAQ,IAAI,EACrB,CAAC;IACD,IAAAC,6BAAc,EAAA1H,aAAA,CAAAA,aAAA,KACTwH,0BAAW;MACd,CAAC,cAAc,GAAGD;IAAW,EAC9B,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC;AAEM,SAASI,cAAcA,CAAA,EAAoB;EAChD,MAAMC,eAAe,GAAG,IAAAC,wBAAS,EAAC;IAChCC,sBAAsB,EAAE3B;EAC1B,CAAC,CAAC;EACF,IAAAmB,4BAAa,EAAC,MAAM;IAClB,MAAMS,eAAe,GAAGP,0BAA8B;IACtDO,eAAe,CAACC,QAAQ,GAAG;MACzBC,mBAAmB,EAAE,IAAI;MACzBC,uBAAuB,EAAE,IAAI;MAC7BC,WAAW,EAAE,IAAI;MACjBC,SAAS,EAAE,IAAI;MACfC,gBAAgB,EAAE;IACpB,CAAC;IACDN,eAAe,CAACO,QAAQ,GAAG,CAAC;IAC5BP,eAAe,CAACQ,OAAO,GAAG;MACxBC,WAAW,EAAE,EAAE;MACfC,QAAQ,EAAE,EAAE;MACZvE,IAAI,EAAE,MAAM;MACZwE,WAAW,EAAE,KAAK;MAClBC,MAAM,EAAE,QAAQ;MAChBJ,OAAO,EAAE;IACX,CAAC;IACDR,eAAe,CAACa,iBAAiB,GAAG,CAAC,CAAC;IACtCb,eAAe,CAACc,iBAAiB,GAAG,EAAE;IACtCd,eAAe,CAACe,eAAe,GAAG,EAAE;IACpCf,eAAe,CAACgB,iBAAiB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI;IACjDhB,eAAe,CAACiB,oBAAoB,GAAG,CAAC;EAC1C,CAAC,CAAC;EACF,OAAOpB,eAAe;AACxB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASqB,mBAAmBA,CACjC/E,IAAY,EACZgF,YAAoD,GAAGC,SAAS,EAChE7G,eAAmD,GAAG,CAAC,EACvD;EACA,OAAO,UAAU8D,MAAW,EAAE;IAC5B;IACA,MAAMgD,SAAS,GAAGA,CAAC,GAAGC,IAAI,KAAK;MAC7B,OAAO,IAAAC,kCAAgB,EAACpF,IAAI,EAAEkC,MAAM,EAAEiD,IAAI,CAAC,CAAC,CAAC;IAC/C,CAAC;IACD,IAAIH,YAAY,KAAKC,SAAS,EAAE;MAC9BD,YAAY,GAAGhF,IAAI;IACrB;IACA,MAAMqF,aAAa,GACjB,OAAOL,YAAY,KAAK,QAAQ,GAAG,MAAMA,YAAY,GAAGA,YAAY;IACtE,MAAMM,uBAAuB,GAC3B,OAAOlH,eAAe,KAAK,QAAQ,GAC/B,MAAMA,eAAe,GACrBA,eAAe;IACrB,MAAMmH,qBAAiD,GAAG;MACxD9H,eAAe,EAAEuC,IAAI;MACrBzB,aAAa,EAAE2D,MAAM,CAACrE,IAAI;MAC1B2H,KAAK,EAAEH,aAAqC;MAC5CI,QAAQ,EAAEP,SAAS;MACnB9G,eAAe,EAAEkH;IACnB,CAAC;IACD9G,wBAAwB,CAACjB,YAAY,CAACgI,qBAAqB,CAAC;;IAE5D;AACJ;AACA;AACA;AACA;AACA;;IAEI;IACA,oBAAOG,cAAK,CAACC,IAAI,CAACT,SAAS,CAAC;EAC9B,CAAC;AACH","ignoreList":[]}

package/dist/shared-store.d.ts

@@ -0,0 +1,74 @@
+import { GenieInterfaceSpec } from "./react-decorators";
+export type ReactGenieState = {
+    message: ReactGenieMessage;
+    navState: NavigatorState;
+    navStack: number;
+    resultWindowByRef: Record<string, ResultWindowEntry>;
+    resultWindowOrder: string[];
+    resultWindowMax: number;
+    resultWindowTtlMs: number;
+    resultWindowSequence: number;
+};
+export type ReactGenieMessage = AgentResponsePayload & {
+    origin: "voice" | "system";
+    message?: string;
+};
+export type QueryIntentOperation = {
+    kind: "matching" | "contains" | "equals";
+    field: string;
+    value: string | number | boolean;
+} | {
+    kind: "between";
+    field: string;
+    from?: string | number | boolean;
+    to?: string | number | boolean;
+} | {
+    kind: "sort";
+    field: string;
+    ascending: boolean;
+} | {
+    kind: "index";
+    value: number;
+} | {
+    kind: "length";
+};
+export type QueryIntent = {
+    ops: QueryIntentOperation[];
+    hash: string;
+};
+export type ResultWindowEntry = {
+    resultRef: string;
+    eventId: number;
+    resultObjectType: string;
+    orderedConstructorParams: Record<string, any>[];
+    createdAt: number;
+};
+type AgentResponsePayload = {
+    minimalText: string;
+    fullText: string;
+    type: "info" | "error" | "success" | "warning";
+    shouldSpeak: boolean;
+};
+export declare let uiActive: boolean;
+export interface NavigatorState {
+    objectViewClassName: string | null;
+    objectConstructorParams: any;
+    queryIntent?: QueryIntent | null;
+    resultRef?: string | null;
+    resultObjectType?: string | null;
+}
+export declare function createImmutableConstructorParamsSnapshot(value: any): Record<string, any> | null;
+export declare function extractQueryIntentFromAst(ast: any): QueryIntent | null;
+export declare const useGenieCodeSelector: (command: string) => (state: any) => Promise<any>;
+export declare const useGenieSelector: (selector: any) => any;
+type GenieCodeResult = {
+    success: boolean;
+    results: any[];
+};
+export declare function executeGenieCode(command: unknown, options?: {
+    origin?: ReactGenieMessage["origin"];
+    shouldSpeakErrors?: boolean;
+}): Promise<GenieCodeResult>;
+export declare function displayResult(executionResult: GenieCodeResult, transcript: string, parsed: string, genieInterfaces: GenieInterfaceSpec[]): void;
+export declare function resetGenieNavigation(): void;
+export {};