@twinmatrix/spatialverse-sdk-rn 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinmatrix/spatialverse-sdk-rn",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "SpatialVerse map engine SDK for React Native",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
@@ -29,7 +29,8 @@
     "build": "npm-run-all -l clean -p build:esm build:cjs declarations",
     "build:all": "npm-run-all -l clean -p build:esm build:cjs build:bundles declarations",
     "prepublishOnly": "npm run build",
-    "test": "jest"
+    "test": "cross-env BABEL_ENV=test jest --config jest.config.cjs",
+    "test:live-multi-where": "cross-env BABEL_ENV=test jest --config jest.config.cjs src/meta-atlas-sdk-rn/MetaAtlasCore/__tests__/scenario/live-multi-where-nav.test.ts --testTimeout=180000"
   },
   "repository": {
     "type": "git",
@@ -81,27 +82,29 @@
   },
   "dependencies": {
     "@dagrejs/graphlib": "^2.2.4",
+    "@turf/along": "6.5.0",
     "@turf/area": "6.5.0",
+    "@turf/bbox": "6.5.0",
     "@turf/bearing": "6.5.0",
+    "@turf/boolean-disjoint": "6.5.0",
     "@turf/boolean-point-in-polygon": "6.5.0",
     "@turf/center": "6.5.0",
     "@turf/distance": "6.5.0",
     "@turf/helpers": "6.5.0",
     "@turf/invariant": "6.5.0",
     "@turf/length": "6.5.0",
+    "@turf/line-intersect": "6.5.0",
+    "@turf/line-slice": "6.5.0",
     "@turf/line-slice-along": "6.5.0",
     "@turf/meta": "6.5.0",
     "@turf/nearest-point-on-line": "6.5.0",
     "@turf/rhumb-bearing": "6.5.0",
     "@turf/transform-translate": "6.5.0",
-    "@turf/boolean-disjoint": "6.5.0",
-    "@turf/line-slice": "6.5.0",
-    "@turf/line-intersect": "6.5.0",
-    "@turf/bbox": "6.5.0",
     "@types/mapbox__mapbox-gl-draw": "^1.3.3",
     "base-64": "^1.0.0",
     "geojson": "^0.5.0",
     "geojson-path-finder": "^2.0.1",
+    "geojson-rbush": "^3.2.0",
     "lodash": "git+https://github.com/TwinMatrixOrg/lodash.git#4cf78bf2e3c982a3ad6f4236bf45a958210bb6ee",
     "ngraph.graph": "^20.0.1",
     "ngraph.path": "^1.3.1",
@@ -121,7 +124,9 @@
     "react-native-aes-crypto": "3.2.1",
     "@react-native-community/netinfo": "11.4.1",
     "react-native-geolocation-service": "5.3.1",
-    "react-native-gesture-handler": "2.28.0"
+    "react-native-compass-heading": "2.0.2",
+    "react-native-gesture-handler": "2.28.0",
+    "expo-sensors": "15.0.8"
   },
   "overrides": {
     "chalk@2": {

package/typings/index.d.ts

@@ -1,68 +1,475 @@
-/**
- * Public TypeScript surface for `@twinmatrix/spatialverse-sdk-rn` package consumers (e.g. UI SDK).
- * Runtime entry is the built `lib/` output; types ship from this file.
- */
-import type { ReactNode, Ref } from 'react';
-
-export type StatusUpdateCallbackType = (loaded: boolean) => void;
-export type NetworkModeUpdateCallbackType = (mode: string) => void;
-
-export type FocusNode = {
-  name: string;
-  taxonomyPath: string;
-  depth?: number;
-  cameraConfigs?: unknown;
-  bounds?: unknown;
-  defaultFloorPath?: string;
-  children?: FocusNode[];
-  [key: string]: unknown;
-};
-
-export type FocusTree = Record<string, FocusNode>;
-
-export type MetaAtlasSDKProps = {
-  ref?: Ref<any>;
-  onPress?: (data: any) => void;
-  onMoveStart?: (data: any) => void;
-  onMove?: (data: any) => void;
-  onMoveEnd?: (data: any) => void;
-  onLoad?: () => void;
-  onLoadFail?: (errorMessage: string) => void;
-  onRoutingStatusUpdate?: StatusUpdateCallbackType;
-  onSearchStatusUpdate?: StatusUpdateCallbackType;
-  onNetworkModeUpdate?: NetworkModeUpdateCallbackType;
-  onOfflineMapsStatusUpdate?: StatusUpdateCallbackType;
-  tileserverRoleName: string;
-  accessToken: string;
-  secretKey: string;
-  maxMapHeight?: number | string;
-  isFullHeight?: boolean;
-  children?: ReactNode;
-};
-
-/** Function component; return typed as `any` to avoid React 18/19 JSX element mismatches across peers. */
-export declare function MetaAtlasSDK(props: MetaAtlasSDKProps): any;
-
-export type MetaFeatureUiProperties = {
-  imageUrl?: string;
-  priceLabel?: string;
-  badgeLabel?: string;
-  address?: string;
-  hoursLabel?: string;
-  distanceLabel?: string;
-  subtitle?: string;
-  areaName?: string;
-  [key: string]: unknown;
-};
-
-export type metaFeature = {
-  mapObjectId?: string | number | null;
-  name?: string | null;
-  coordinates?: number[] | null;
-  whereDimension?: string | null;
-  whatDimension?: string | null;
-  geometry?: { type?: string; coordinates?: unknown };
-  properties?: MetaFeatureUiProperties & Record<string, unknown>;
-};
-
-export type MetaFeature = metaFeature;
+/**
+ * Public TypeScript surface for `@twinmatrix/spatialverse-sdk-rn` package consumers (e.g. UI SDK).
+ * Runtime entry is the built `lib/` output; types ship from this file.
+ */
+import type { ReactElement, ReactNode, Ref } from 'react';
+
+export type StatusUpdateCallbackType = (loaded: boolean) => void;
+export type NetworkModeUpdateCallbackType = (mode: string) => void;
+
+export type FocusNode = {
+  name: string;
+  taxonomyPath: string;
+  depth?: number;
+  cameraConfigs?: unknown;
+  bounds?: unknown;
+  defaultFloorPath?: string;
+  children?: FocusNode[];
+  [key: string]: unknown;
+};
+
+export type FocusTree = Record<string, FocusNode>;
+
+export type FocusNodeInfo = {
+  name: string;
+  whereTaxonomy: string;
+  depth: number;
+  hasChildren: boolean;
+  isLeaf: boolean;
+};
+
+export enum FilterType {
+  Name = 'title',
+  LocalRef = 'localRef',
+  WhatTaxonomy = 'dimension_what',
+}
+
+export enum LocationType {
+  MapObject = 'map-object',
+  Coordinate = 'coordinate',
+}
+
+export interface MapObjectLocation {
+  type: LocationType.MapObject;
+  mapObjectId: string;
+}
+
+export interface CoordinateLocation {
+  type: LocationType.Coordinate;
+  /** Public nav coordinates are `[lng, lat]`. */
+  coordinates: [number, number];
+  whereDimension: string;
+}
+
+export type MapLocation = MapObjectLocation | CoordinateLocation;
+
+export enum RouteMode {
+  WithinTerminal = 'WithinTerminal',
+  ToTerminal = 'ToTerminal',
+  FromTerminal = 'FromTerminal',
+  Airside = 'Airside',
+}
+
+export type NavigationSensorKind = 'gps' | 'compass' | 'motion';
+
+export declare const ROUTE_MODE_REQUIRED_SENSORS: Record<
+  RouteMode,
+  readonly NavigationSensorKind[]
+>;
+
+export declare function resolveRequiredSensors(
+  mode: RouteMode,
+  config?: Pick<BaseRouteConfig, 'requiredSensors'> | null,
+): readonly NavigationSensorKind[];
+
+export interface BaseRouteConfig {
+  shouldAddOverviewSegment?: boolean;
+  shouldAddStartSegment?: boolean;
+  shouldAddEndSegment?: boolean;
+  /** When true, realtime navigation trims trailing edge-connector geometry (and its link cost) from path features. */
+  forRealtime?: boolean;
+  /**
+   * Sensors this live-nav session must request. When omitted, the SDK uses
+   * {@link ROUTE_MODE_REQUIRED_SENSORS} for the current {@link RouteMode}.
+   */
+  requiredSensors?: readonly NavigationSensorKind[];
+}
+
+export interface WithinTerminalConfig extends BaseRouteConfig {
+  wheelChairAccessible?: boolean;
+}
+
+export interface ToTerminalConfig extends BaseRouteConfig {
+  departureDate: string;
+  departureTime: string;
+  wheelChairAccessible?: boolean;
+}
+
+export interface FromTerminalConfig extends BaseRouteConfig {
+  departureDate: string;
+  departureTime: string;
+  wheelChairAccessible?: boolean;
+}
+
+export interface VehicleType {
+  id: string;
+  name: string;
+  navigationTemplateType: string;
+  allowedRoadwayCategories: string[];
+  customProperties: Record<string, string>;
+  defaults?: unknown;
+}
+
+export interface AirsideConfig extends BaseRouteConfig {
+  vehicleType: VehicleType;
+  distanceThreshold?: number;
+}
+
+export type RoutingConfig =
+  | WithinTerminalConfig
+  | ToTerminalConfig
+  | FromTerminalConfig
+  | AirsideConfig;
+
+export interface RouteSegment {
+  maneuverType: string;
+  coordinates: number[][];
+  distance: number;
+  time: number;
+  [key: string]: unknown;
+}
+
+export interface Route {
+  segments: RouteSegment[];
+  walkingDistance: number;
+  transportDistance: number;
+  walkingTime: number;
+  transportTime: number;
+  distanceUnit: string;
+  speed: number;
+}
+
+export type NavigationLocMode = 'gps' | 'pdr';
+
+export type NavigationUIHandlers = {
+  onSegmentIndexChange?: (index: number) => void;
+  onNavigationStart?: () => void;
+  onNavigationStop?: () => void;
+  onNavigationLocModeChange?: (mode: NavigationLocMode, deadZoneId?: string) => void;
+  onAnchorGpsBlendChange?: (active: boolean, blendW: number) => void;
+  onProgressUpdate?: (data: {
+    remainingTime: number;
+    remainingDistance: number;
+    segmentRemainingDistance?: number;
+  }) => void;
+  onBearingUpdate?: (bearing: number) => void;
+  onReroute?: (route: Route) => void;
+  onSnapStateChange?: (snapped: boolean) => void;
+  onNavigationComplete?: () => void;
+};
+
+export type RecenterCameraOptions = {
+  /** When true, reset to the default navigation camera zoom instead of the map's current zoom. */
+  useDefaultZoom?: boolean;
+};
+
+export type SdkMode = 'normal' | 'navigation';
+export type CameraFollowOwner = 'gps' | 'navigation';
+
+/** Mode-aware camera-follow state for UI. */
+export type CameraFollowState = {
+  mode: SdkMode;
+  owner: CameraFollowOwner;
+  isFollowing: boolean;
+  /** Normal GPS mode only: map camera is rotating to device heading. */
+  followsHeading?: boolean;
+};
+
+export type NavigationStartErrorCode =
+  | 'UNSUPPORTED_ROUTE_MODE'
+  | 'MISSING_ROUTING_DATA'
+  | 'NOT_READY';
+
+export declare class NavigationStartError extends Error {
+  readonly code: NavigationStartErrorCode;
+  readonly mode: RouteMode;
+  readonly missing: readonly string[];
+  constructor(
+    code: NavigationStartErrorCode,
+    mode: RouteMode,
+    message?: string,
+    missing?: readonly string[],
+  );
+}
+
+export type StartNavigationOptions = {
+  userWhereDimension: string;
+  useInternalGPS?: boolean;
+  /**
+   * Explicit `[lng, lat]` seed for start-anchor PDR. Wins over
+   * {@link useStartPositionAsAnchor}.
+   */
+  startAnchorLngLat?: [number, number];
+  /**
+   * When true and {@link startAnchorLngLat} is omitted, seed start-anchor PDR from the
+   * live GPS start fix. When false/omitted, start in GPS mode (no start-anchor PDR).
+   */
+  useStartPositionAsAnchor?: boolean;
+};
+
+export type StartNavigationFromCoordinatesOptions = {
+  startWhereDimension: string;
+  useInternalGPS?: boolean;
+  startAnchorLngLat?: [number, number];
+  /** Same semantics as {@link StartNavigationOptions.useStartPositionAsAnchor}. */
+  useStartPositionAsAnchor?: boolean;
+};
+
+export type GPSPosition = {
+  coordinates: [number, number];
+  accuracy: number;
+  timestamp: number;
+  heading?: number;
+  speed?: number;
+  altitude?: number;
+  altitudeAccuracy?: number;
+};
+
+export type WhereTaxonomyProposal =
+  | {
+      kind: 'altitude';
+      whereTaxonomyPath: string;
+      id: string;
+      autoAcceptCooldownMs: number;
+    }
+  | {
+      kind: 'portal';
+      whereTaxonomyPath: string;
+      id: string;
+      autoAcceptCooldownMs: number;
+      portal: {
+        segmentIndex?: number;
+        instructionLine?: string;
+        portalName?: string;
+        description?: string;
+      };
+    };
+
+export type AutoFocusManager = {
+  start: () => void;
+  stop: () => void;
+  acceptProposal: (id: string) => void;
+  rejectProposal: (id: string) => void;
+  manualOverride: (id: string, whereTaxonomyPath: string) => void;
+  notifyManualFloorChange: (
+    whereTaxonomyPath: string,
+    shouldMoveCamera?: boolean,
+  ) => void;
+  resetPortalProposalSuppression: () => void;
+  proposeFromNavigation: (params: {
+    whereTaxonomyPath: string;
+    portalDedupeKey: string;
+    portal: {
+      segmentIndex?: number;
+      instructionLine?: string;
+      portalName?: string | null;
+      description?: string | null;
+    };
+  }) => boolean;
+  getLastAcceptedTaxonomyPath: () => string | null;
+};
+
+export type TaxonomyUpdatePortalMeta = Extract<
+  WhereTaxonomyProposal,
+  { kind: 'portal' }
+>['portal'];
+
+export type TaxonomyUpdateStoreState = {
+  pendingWhere: string;
+  proposalId: string | null;
+  proposalKind: 'altitude' | 'portal' | null;
+  portalMeta: TaxonomyUpdatePortalMeta | null;
+  isAwaitingDecision: boolean;
+  showTaxonomyUpdatePopup: boolean;
+  autoAcceptCooldownMs: number;
+  openProposal: (proposal: WhereTaxonomyProposal) => void;
+  clearProposal: () => void;
+  acceptProposal: () => void;
+  rejectProposal: () => void;
+  manualOverride: (whereTaxonomyPath: string) => void;
+};
+
+/** Vanilla Zustand store (`getState` / `subscribe` / `setState`). One per map instance. */
+export type TaxonomyUpdateStore = {
+  getState: () => TaxonomyUpdateStoreState;
+  setState: (
+    partial:
+      | TaxonomyUpdateStoreState
+      | Partial<TaxonomyUpdateStoreState>
+      | ((
+          state: TaxonomyUpdateStoreState,
+        ) => TaxonomyUpdateStoreState | Partial<TaxonomyUpdateStoreState>),
+    replace?: boolean,
+  ) => void;
+  subscribe: (
+    listener: (
+      state: TaxonomyUpdateStoreState,
+      prevState: TaxonomyUpdateStoreState,
+    ) => void,
+  ) => () => void;
+};
+
+export type MetaAtlasSDKHandle = {
+  getZoom: () => Promise<number | null>;
+  getCenter: () => Promise<number[] | null>;
+  getBearing: () => Promise<number | null>;
+  moveTo: (coordinates: number[], animationDuration: number) => void;
+  zoomTo: (zoomLevel: number, animationDuration: number) => void;
+  /** Focus a where-taxonomy. Pass `moveCamera: false` to filter layers without a camera move. */
+  focusTo: (dimensionWhere: string, moveCamera?: boolean) => void;
+  /**
+   * Focus the building currently in the viewport. Keys are building taxonomyPath or
+   * name; values are the default floor where-taxonomy to commit without moving the camera.
+   */
+  changeTerminalInFocusToUserViewpoint: (
+    defaultFloors?: Record<string, string>,
+  ) => Promise<void>;
+  subscribeToFocusChange: (
+    callback: (whereTaxonomyPath: string) => void,
+  ) => () => void;
+  flyTo: (
+    config: {
+      center: number[] | null;
+      zoomLevel?: number | null;
+      bearing?: number | null;
+    },
+    persistPins?: boolean,
+  ) => Promise<void>;
+  getFocusTree: () => FocusTree;
+  getWhatTaxonomies: () => string[];
+  getCurrentFocus: () => string;
+  getCurrentFocusBuilding: () => FocusNode | null;
+  getCurrentFocusFloor: () => FocusNode | null;
+  getLastClickedFeature: () => unknown;
+  getAllMapObjects: (...args: unknown[]) => unknown;
+  getMapObjectsByName: (...args: unknown[]) => unknown;
+  getMapObjectById: (...args: unknown[]) => unknown;
+  dropPin: (
+    feature: unknown,
+    element: ReactElement,
+    replaceLast?: boolean,
+  ) => Promise<string>;
+  clearPins: () => void;
+  enableGPS: (options?: unknown) => Promise<unknown> | unknown;
+  disableGPS: () => void;
+  isGPSEnabled: () => boolean | undefined;
+  /** Whether the camera is currently tracking the user. */
+  isFollowing: () => boolean | undefined;
+  getCameraFollowState: () => CameraFollowState;
+  setNormalModeHeadingCameraFollow: (enabled: boolean) => void;
+  isNormalModeHeadingCameraFollowEnabled: () => boolean;
+  isCompassEnabled: () => boolean | undefined;
+  triggerGPSUpdate: (position: GPSPosition) => void;
+
+  notifyManualFloorChange: (whereTaxonomyPath: string) => void;
+  isNavigating: () => boolean;
+  getTaxonomyUpdateStore: () => TaxonomyUpdateStore | null;
+
+  setRoutingMode: (mode: RouteMode) => void;
+  computeRoute: (
+    startMapObjectId: string,
+    endMapObjectId: string,
+    config: RoutingConfig,
+  ) => Promise<Route | undefined>;
+  computeRoutes: (
+    mapObjectIdentifiers: string[],
+    config: RoutingConfig,
+  ) => Promise<Route | undefined>;
+  computeRoutesFromLocation: (
+    startLngLat: [number, number],
+    startWhereDimension: string,
+    mapObjectIds: string[],
+    wheelChairAccessibleRouting?: boolean,
+  ) => Promise<Route | undefined>;
+  computeRouteFromCoordinates: (
+    startLngLat: [number, number],
+    endLngLat: [number, number],
+    config: AirsideConfig,
+  ) => Promise<Route | undefined>;
+
+  startNavigation: (
+    endMapObjectId: string,
+    config?: RoutingConfig,
+    handlers?: NavigationUIHandlers,
+    options: StartNavigationOptions,
+  ) => Promise<Route>;
+  startNavigationFromCoordinates: (
+    endLocation: CoordinateLocation,
+    config?: RoutingConfig,
+    handlers?: NavigationUIHandlers,
+    options: StartNavigationFromCoordinatesOptions,
+  ) => Promise<Route>;
+  stopNavigation: () => void;
+  recenter: (options?: RecenterCameraOptions) => Promise<void> | void;
+  /**
+   * Highlight a route segment for preview / live step focus.
+   * Requires an active route (e.g. after compute or navigation start).
+   */
+  highlightRouteSegment: (
+    segmentNumberToHighlight: number,
+  ) => Promise<void>;
+  /**
+   * Whether `[lng, lat]` is inside any focus-tree site bounds
+   * (SW/NE pair or polygon ring). Authoritative outside-venue check.
+   */
+  isPositionWithinBounds: (coordinates: [number, number]) => boolean;
+
+  getRootNodes: () => FocusNode[];
+  getChildNodes: (parentTaxonomyPath: string) => FocusNode[];
+  getNodesAtDepth: (
+    parentTaxonomyPath: string | null,
+    depth: number,
+  ) => FocusNode[];
+  getNodeDepth: (taxonomyPath: string) => number | null;
+  getSubtreeMaxRelativeDepth: (rootTaxonomyPath: string) => number;
+  getSelectorTierCount: (rootTaxonomyPath: string) => number;
+  findNodeByTaxonomy: (taxonomyPath: string) => FocusNode | null;
+  getAncestors: (taxonomyPath: string) => FocusNode[];
+};
+
+export type MetaAtlasSDKProps = {
+  ref?: Ref<MetaAtlasSDKHandle>;
+  onPress?: (data: any) => void;
+  onMoveStart?: (data: any) => void;
+  onMove?: (data: any) => void;
+  onMoveEnd?: (data: any) => void;
+  onLoad?: () => void;
+  onLoadFail?: (errorMessage: string) => void;
+  onRoutingStatusUpdate?: StatusUpdateCallbackType;
+  onSearchStatusUpdate?: StatusUpdateCallbackType;
+  onNetworkModeUpdate?: NetworkModeUpdateCallbackType;
+  onOfflineMapsStatusUpdate?: StatusUpdateCallbackType;
+  tileserverRoleName: string;
+  accessToken: string;
+  secretKey: string;
+  maxMapHeight?: number | string;
+  isFullHeight?: boolean;
+  children?: ReactNode;
+};
+
+/** Function component; return typed as `any` to avoid React 18/19 JSX element mismatches across peers. */
+export declare function MetaAtlasSDK(props: MetaAtlasSDKProps): any;
+
+export type MetaFeatureUiProperties = {
+  imageUrl?: string;
+  priceLabel?: string;
+  badgeLabel?: string;
+  address?: string;
+  hoursLabel?: string;
+  distanceLabel?: string;
+  subtitle?: string;
+  areaName?: string;
+  [key: string]: unknown;
+};
+
+export type metaFeature = {
+  mapObjectId?: string | number | null;
+  name?: string | null;
+  coordinates?: number[] | null;
+  whereDimension?: string | null;
+  whatDimension?: string | null;
+  geometry?: { type?: string; coordinates?: unknown };
+  properties?: MetaFeatureUiProperties & Record<string, unknown>;
+};
+
+export type MetaFeature = metaFeature;