@ohos-ports/react-native-navigation 8.9.0-beta.4 → 8.9.0-beta.5

package/lib/cjs/Mock/mocks/NativeCommandsSender.js

@@ -0,0 +1,181 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NativeCommandsSender_exports = {};
+__export(NativeCommandsSender_exports, {
+  NativeCommandsSender: () => NativeCommandsSender
+});
+module.exports = __toCommonJS(NativeCommandsSender_exports);
+var import_LayoutStore = require("../Stores/LayoutStore.js");
+var import_LayoutNodeFactory = __toESM(require("../Layouts/LayoutNodeFactory.js"), 1);
+var import_EventsStore = require("../Stores/EventsStore.js");
+var import_lodash = __toESM(require("lodash"), 1);
+var import_CommandName = require("../../interfaces/CommandName.js");
+class NativeCommandsSender {
+  constructor() {
+  }
+  setRoot(commandId, layout) {
+    return new Promise((resolve) => {
+      if (import_LayoutStore.LayoutStore.getVisibleLayout()) {
+        import_LayoutStore.LayoutStore.getVisibleLayout().componentDidDisappear();
+        import_LayoutStore.LayoutStore.setRoot({});
+      }
+      const layoutNode = import_LayoutNodeFactory.default.create(layout.root);
+      import_LayoutStore.LayoutStore.setRoot(layoutNode);
+      layoutNode.getVisibleLayout().componentDidAppear();
+      resolve(layout.root.nodeId);
+      this.reportCommandCompletion(import_CommandName.CommandName.SetRoot, commandId);
+    });
+  }
+  setDefaultOptions(options) {
+    import_LayoutStore.LayoutStore.setDefaultOptions(options);
+  }
+  mergeOptions(componentId, options) {
+    import_LayoutStore.LayoutStore.mergeOptions(componentId, options);
+  }
+  push(commandId, onComponentId, layout) {
+    return new Promise((resolve) => {
+      const stack = import_LayoutStore.LayoutStore.getLayoutById(onComponentId).getStack();
+      const layoutNode = import_LayoutNodeFactory.default.create(layout, stack);
+      stack.getVisibleLayout().componentDidDisappear();
+      import_LayoutStore.LayoutStore.push(layoutNode, stack);
+      import_LayoutStore.LayoutStore.applyOptions(layoutNode.nodeId, layoutNode.data.options);
+      stack.getVisibleLayout().componentDidAppear();
+      resolve(stack.getVisibleLayout().nodeId);
+      this.reportCommandCompletion(import_CommandName.CommandName.Push, commandId);
+    });
+  }
+  pop(commandId, componentId, _options) {
+    return new Promise((resolve, reject) => {
+      if (!import_LayoutStore.LayoutStore.getLayoutById(componentId)) {
+        reject(`Popping component failed - componentId '${componentId}' not found`);
+        return;
+      }
+      const poppedChild = import_lodash.default.last(import_LayoutStore.LayoutStore.getLayoutById(componentId).getStack().children);
+      import_LayoutStore.LayoutStore.pop(componentId);
+      import_EventsStore.events.invokeScreenPopped({
+        componentId
+      });
+      resolve(poppedChild.nodeId);
+      this.reportCommandCompletion(import_CommandName.CommandName.Pop, commandId);
+    });
+  }
+  popTo(commandId, componentId, _options) {
+    return new Promise((resolve) => {
+      import_LayoutStore.LayoutStore.popTo(componentId);
+      resolve(componentId);
+      this.reportCommandCompletion(import_CommandName.CommandName.PopTo, commandId);
+    });
+  }
+  popToRoot(commandId, componentId, _options) {
+    import_LayoutStore.LayoutStore.popToRoot(componentId);
+    this.reportCommandCompletion(import_CommandName.CommandName.PopToRoot, commandId);
+  }
+  setStackRoot(commandId, onComponentId, layout) {
+    import_LayoutStore.LayoutStore.setStackRoot(onComponentId, layout);
+    this.reportCommandCompletion(import_CommandName.CommandName.SetStackRoot, commandId);
+  }
+  showModal(commandId, layout) {
+    return new Promise((resolve) => {
+      const layoutNode = import_LayoutNodeFactory.default.create(layout);
+      import_LayoutStore.LayoutStore.getVisibleLayout().componentDidDisappear();
+      import_LayoutStore.LayoutStore.showModal(layoutNode);
+      layoutNode.componentDidAppear();
+      resolve(layoutNode.nodeId);
+      this.reportCommandCompletion(import_CommandName.CommandName.ShowModal, commandId);
+    });
+  }
+  dismissModal(commandId, componentId, _options) {
+    return new Promise((resolve, reject) => {
+      const modal = import_LayoutStore.LayoutStore.getModalById(componentId);
+      if (modal) {
+        const modalTopParent = modal.getTopParent();
+        modalTopParent.componentDidDisappear();
+        import_LayoutStore.LayoutStore.dismissModal(componentId);
+        import_EventsStore.events.invokeModalDismissed({
+          componentName: modalTopParent.data.name,
+          componentId: modalTopParent.nodeId,
+          modalsDismissed: 1
+        });
+        resolve(modalTopParent.nodeId);
+        import_LayoutStore.LayoutStore.getVisibleLayout().componentDidAppear();
+        this.reportCommandCompletion(import_CommandName.CommandName.DismissModal, commandId);
+      } else {
+        reject(`component with id: ${componentId} is not a modal`);
+      }
+    });
+  }
+  dismissAllModals(commandId, _options) {
+    import_LayoutStore.LayoutStore.dismissAllModals();
+    this.reportCommandCompletion(import_CommandName.CommandName.DismissAllModals, commandId);
+  }
+  showOverlay(commandId, layout) {
+    const layoutNode = import_LayoutNodeFactory.default.create(layout);
+    import_LayoutStore.LayoutStore.showOverlay(layoutNode);
+    layoutNode.componentDidAppear();
+    this.reportCommandCompletion(import_CommandName.CommandName.ShowOverlay, commandId);
+  }
+  dismissOverlay(commandId, componentId) {
+    import_LayoutStore.LayoutStore.dismissOverlay(componentId);
+    this.reportCommandCompletion(import_CommandName.CommandName.DismissOverlay, commandId);
+  }
+  dismissAllOverlays(commandId) {
+    import_LayoutStore.LayoutStore.dismissAllOverlays();
+    this.reportCommandCompletion(import_CommandName.CommandName.DismissAllOverlays, commandId);
+  }
+  getLaunchArgs(commandId) {
+    this.reportCommandCompletion(import_CommandName.CommandName.GetLaunchArgs, commandId);
+  }
+  getNavigationConstants() {
+    return Promise.resolve({
+      topBarHeight: 0,
+      backButtonId: "RNN.back",
+      bottomTabsHeight: 0,
+      statusBarHeight: 0
+    });
+  }
+  getNavigationConstantsSync() {
+    return {
+      topBarHeight: 0,
+      backButtonId: "RNN.back",
+      bottomTabsHeight: 0,
+      statusBarHeight: 0
+    };
+  }
+  reportCommandCompletion(commandName, commandId) {
+    import_EventsStore.events.invokeCommandCompleted({
+      commandName,
+      commandId,
+      completionTime: 0
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NativeCommandsSender
+});

package/lib/cjs/Mock/mocks/NativeEventsReceiver.js

@@ -0,0 +1,146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NativeEventsReceiver_exports = {};
+__export(NativeEventsReceiver_exports, {
+  NativeEventsReceiver: () => NativeEventsReceiver
+});
+module.exports = __toCommonJS(NativeEventsReceiver_exports);
+var import_lodash = __toESM(require("lodash"), 1);
+var import_EventsStore = require("../Stores/EventsStore.js");
+class NativeEventsReceiver {
+  registerAppLaunchedListener(callback) {
+    callback();
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerComponentWillAppearListener(callback) {
+    import_EventsStore.events.componentWillAppear.push(callback);
+    return {
+      remove: () => {
+        import_lodash.default.remove(import_EventsStore.events.componentWillAppear, (value) => value === callback);
+      }
+    };
+  }
+  registerComponentDidAppearListener(callback) {
+    import_EventsStore.events.componentDidAppear.push(callback);
+    return {
+      remove: () => {
+        import_lodash.default.remove(import_EventsStore.events.componentDidAppear, (value) => value === callback);
+      }
+    };
+  }
+  registerComponentDidDisappearListener(callback) {
+    import_EventsStore.events.componentDidDisappear.push(callback);
+    return {
+      remove: () => {
+        import_lodash.default.remove(import_EventsStore.events.componentDidDisappear, (value) => value === callback);
+      }
+    };
+  }
+  registerNavigationButtonPressedListener(callback) {
+    import_EventsStore.events.navigationButtonPressed.push(callback);
+    return {
+      remove: () => {
+        import_lodash.default.remove(import_EventsStore.events.navigationButtonPressed, (value) => value === callback);
+      }
+    };
+  }
+  registerBottomTabPressedListener(callback) {
+    import_EventsStore.events.bottomTabPressed.push(callback);
+    return {
+      remove: () => {
+        import_lodash.default.remove(import_EventsStore.events.bottomTabPressed, (value) => value === callback);
+      }
+    };
+  }
+  registerModalDismissedListener(callback) {
+    import_EventsStore.events.modalDismissed.push(callback);
+    return {
+      remove: () => {
+        import_lodash.default.remove(import_EventsStore.events.modalDismissed, (value) => value === callback);
+      }
+    };
+  }
+  registerModalAttemptedToDismissListener(_callback) {
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerSearchBarUpdatedListener(_callback) {
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerSearchBarCancelPressedListener(_callback) {
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerPreviewCompletedListener(_callback) {
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerCommandCompletedListener(callback) {
+    import_EventsStore.events.commandCompleted.push(callback);
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerBottomTabSelectedListener(_callback) {
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerBottomTabLongPressedListener(_callback) {
+    return {
+      remove: () => {
+      }
+    };
+  }
+  registerScreenPoppedListener(callback) {
+    import_EventsStore.events.screenPopped.push(callback);
+    return {
+      remove: () => {
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NativeEventsReceiver
+});

package/lib/cjs/Navigation.js

@@ -0,0 +1,259 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Navigation_exports = {};
+__export(Navigation_exports, {
+  NavigationRoot: () => NavigationRoot
+});
+module.exports = __toCommonJS(Navigation_exports);
+var import_isArray = __toESM(require("lodash/isArray.js"), 1);
+var import_UniqueIdProvider = require("./adapters/UniqueIdProvider.js");
+var import_Store = require("./components/Store.js");
+var import_OptionProcessorsStore = require("./processors/OptionProcessorsStore.js");
+var import_ComponentRegistry = require("./components/ComponentRegistry.js");
+var import_Commands = require("./commands/Commands.js");
+var import_LayoutTreeParser = require("./commands/LayoutTreeParser.js");
+var import_LayoutTreeCrawler = require("./commands/LayoutTreeCrawler.js");
+var import_EventsRegistry = require("./events/EventsRegistry.js");
+var import_CommandsObserver = require("./events/CommandsObserver.js");
+var import_Constants = require("./adapters/Constants.js");
+var import_ComponentEventsObserver = require("./events/ComponentEventsObserver.js");
+var import_TouchablePreview = require("./adapters/TouchablePreview.js");
+var import_ComponentWrapper = require("./components/ComponentWrapper.js");
+var import_OptionsProcessor = require("./commands/OptionsProcessor.js");
+var import_ColorService = require("./adapters/ColorService.js");
+var import_AssetResolver = require("./adapters/AssetResolver.js");
+var import_Deprecations = require("./commands/Deprecations.js");
+var import_LayoutProcessor = require("./processors/LayoutProcessor.js");
+var import_LayoutProcessorsStore = require("./processors/LayoutProcessorsStore.js");
+var import_OptionsCrawler = require("./commands/OptionsCrawler.js");
+var import_LinkingHandler = require("./linking/LinkingHandler.js");
+class NavigationRoot {
+  TouchablePreview = import_TouchablePreview.TouchablePreview;
+  constructor(nativeCommandsSender, nativeEventsReceiver, appRegistryService) {
+    this.nativeCommandsSender = nativeCommandsSender;
+    this.nativeEventsReceiver = nativeEventsReceiver;
+    this.appRegistryService = appRegistryService;
+    this.componentWrapper = new import_ComponentWrapper.ComponentWrapper();
+    this.store = new import_Store.Store();
+    this.optionProcessorsStore = new import_OptionProcessorsStore.OptionProcessorsStore();
+    this.layoutProcessorsStore = new import_LayoutProcessorsStore.LayoutProcessorsStore();
+    this.uniqueIdProvider = new import_UniqueIdProvider.UniqueIdProvider();
+    this.componentEventsObserver = new import_ComponentEventsObserver.ComponentEventsObserver(this.nativeEventsReceiver, this.store);
+    this.componentRegistry = new import_ComponentRegistry.ComponentRegistry(this.store, this.componentEventsObserver, this.componentWrapper, this.appRegistryService);
+    this.layoutTreeParser = new import_LayoutTreeParser.LayoutTreeParser(this.uniqueIdProvider);
+    const optionsProcessor = new import_OptionsProcessor.OptionsProcessor(this.store, this.uniqueIdProvider, this.optionProcessorsStore, new import_ColorService.ColorService(), new import_AssetResolver.AssetService(), new import_Deprecations.Deprecations());
+    const layoutProcessor = new import_LayoutProcessor.LayoutProcessor(this.layoutProcessorsStore);
+    this.layoutTreeCrawler = new import_LayoutTreeCrawler.LayoutTreeCrawler(this.store, optionsProcessor);
+    this.commandsObserver = new import_CommandsObserver.CommandsObserver(this.uniqueIdProvider);
+    this.optionsCrawler = new import_OptionsCrawler.OptionsCrawler(this.store, this.uniqueIdProvider);
+    this.commands = new import_Commands.Commands(this.store, this.nativeCommandsSender, this.layoutTreeParser, this.layoutTreeCrawler, this.commandsObserver, this.uniqueIdProvider, optionsProcessor, layoutProcessor, this.optionsCrawler);
+    this.eventsRegistry = new import_EventsRegistry.EventsRegistry(this.nativeEventsReceiver, this.commandsObserver, this.componentEventsObserver);
+    this.linkingHandler = new import_LinkingHandler.LinkingHandler((layout) => this.commands.showModal(layout));
+    this.componentEventsObserver.registerOnceForAllComponentEvents();
+  }
+  /**
+   * Every navigation component in your app must be registered with a unique name.
+   * The component itself is a traditional React component extending React.Component.
+   */
+  registerComponent(componentName, componentProvider, concreteComponentProvider) {
+    return this.componentRegistry.registerComponent(componentName, componentProvider, concreteComponentProvider);
+  }
+  /**
+   * Adds an option processor which allows option interpolation by optionPath.
+   */
+  addOptionProcessor(optionPath, processor) {
+    return this.optionProcessorsStore.addProcessor(optionPath, processor);
+  }
+  /**
+   * Method to be invoked when a layout is processed and is about to be created. This can be used to change layout options or even inject props to components.
+   */
+  addLayoutProcessor(processor) {
+    return this.layoutProcessorsStore.addProcessor(processor);
+  }
+  setLazyComponentRegistrator(lazyRegistratorFn) {
+    this.store.setLazyComponentRegistrator(lazyRegistratorFn);
+  }
+  /**
+   * Utility helper function like registerComponent,
+   * wraps the provided component with a react-redux Provider with the passed redux store
+   * @deprecated
+   */
+  registerComponentWithRedux(componentName, getComponentClassFunc, ReduxProvider, reduxStore) {
+    console.warn("registerComponentWithRedux is deprecated and will be removed in the next version! Please use Navigation.registerComponent instead. Visit the docs for more information https://wix.github.io/react-native-navigation/api/component#registering-a-component-wrapped-with-providers");
+    return this.componentRegistry.registerComponent(componentName, getComponentClassFunc, void 0, ReduxProvider, reduxStore);
+  }
+  /**
+   * Reset the app to a new layout
+   */
+  setRoot(layout) {
+    const result = this.commands.setRoot(layout);
+    result.then(() => this.linkingHandler.setRootReady()).catch(() => {
+    });
+    return result;
+  }
+  /**
+   * Set default options to all screens. Useful for declaring a consistent style across the app.
+   */
+  setDefaultOptions(options) {
+    this.commands.setDefaultOptions(options);
+  }
+  /**
+   * Change a component's navigation options
+   */
+  mergeOptions(componentId, options) {
+    this.commands.mergeOptions(componentId, options);
+  }
+  /**
+   * Update a mounted component's props
+   */
+  updateProps(componentId, props, callback) {
+    this.commands.updateProps(componentId, props, callback);
+  }
+  /**
+   * Show a screen as a modal.
+   */
+  showModal(layout) {
+    return this.commands.showModal(layout);
+  }
+  /**
+   * Dismiss a modal by componentId. The dismissed modal can be anywhere in the stack.
+   */
+  dismissModal(componentId, mergeOptions) {
+    return this.commands.dismissModal(componentId, mergeOptions);
+  }
+  /**
+   * Dismiss all Modals
+   */
+  dismissAllModals(mergeOptions) {
+    return this.commands.dismissAllModals(mergeOptions);
+  }
+  /**
+   * Push a new layout into this screen's navigation stack.
+   */
+  push(componentId, layout) {
+    return this.commands.push(componentId, layout);
+  }
+  /**
+   * Pop a component from the stack, regardless of it's position.
+   */
+  pop(componentId, mergeOptions) {
+    return this.commands.pop(componentId, mergeOptions);
+  }
+  /**
+   * Pop the stack to a given component
+   */
+  popTo(componentId, mergeOptions) {
+    return this.commands.popTo(componentId, mergeOptions);
+  }
+  /**
+   * Pop the component's stack to root.
+   */
+  popToRoot(componentId, mergeOptions) {
+    return this.commands.popToRoot(componentId, mergeOptions);
+  }
+  /**
+   * Sets new root component to stack.
+   */
+  setStackRoot(componentId, layout) {
+    const children = (0, import_isArray.default)(layout) ? layout : [layout];
+    return this.commands.setStackRoot(componentId, children);
+  }
+  /**
+   * Show overlay on top of the entire app
+   */
+  showOverlay(layout) {
+    return this.commands.showOverlay(layout);
+  }
+  /**
+   * dismiss overlay by componentId
+   */
+  dismissOverlay(componentId) {
+    return this.commands.dismissOverlay(componentId);
+  }
+  /**
+   * dismiss all overlays
+   */
+  dismissAllOverlays() {
+    return this.commands.dismissAllOverlays();
+  }
+  /**
+   * Resolves arguments passed on launch
+   */
+  getLaunchArgs() {
+    return this.commands.getLaunchArgs();
+  }
+  /**
+   * Configure deep link handling. Maps URL prefixes and path patterns to
+   * RNN components. By default each matched link is presented as a modal
+   * (wrapped in a stack so a topBar close button can be configured); supply
+   * `getModal` to customize the modal layout or `onLink` to bypass the
+   * default behavior entirely.
+   */
+  setLinking(config) {
+    this.linkingHandler.configure(config);
+  }
+  /**
+   * Manually run a URL through the deep link pipeline as if it had been
+   * delivered by the OS. Useful for URLs received from push notifications
+   * or other non-`Linking` sources.
+   */
+  handleDeepLink(url) {
+    this.linkingHandler.handleURL(url);
+  }
+  /**
+   * Signal that the app is ready to process deep links (e.g. after the
+   * user has authenticated). When set to `true`, any links that were
+   * queued while not ready are replayed in order.
+   */
+  setLinkingReady(ready) {
+    this.linkingHandler.setLinkingReady(ready);
+  }
+  /**
+   * Obtain the events registry instance
+   */
+  events() {
+    return this.eventsRegistry;
+  }
+  /**
+   * Constants coming from native
+   */
+  async constants() {
+    return await import_Constants.Constants.get(this.nativeCommandsSender);
+  }
+  /**
+   * Constants coming from native (synchronized call)
+   */
+  constantsSync() {
+    return import_Constants.Constants.getSync(this.nativeCommandsSender);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NavigationRoot
+});