@rnmapbox/maps 10.1.38 → 10.1.39

package/lib/commonjs/specs/RNMBXSymbolLayerNativeComponent.ts

@@ -0,0 +1,37 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import { Double, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+
+import { FilterExpression } from '../utils/MapboxStyles';
+
+import type { UnsafeMixed } from './codegenUtils';
+
+// @{codepart-replace-start(CommonLayerNativeComponentsProps.codepart-ts)}
+// see https://github.com/rnmapbox/maps/wiki/FabricOptionalProp
+type OptionalProp<T> = UnsafeMixed<T>;
+type Slot = 'bottom' | 'middle' | 'top';
+
+type CommonProps = {
+  sourceID?: OptionalProp<string>;
+  existing?: OptionalProp<boolean>;
+  filter?: UnsafeMixed<FilterExpression>;
+
+  aboveLayerID?: OptionalProp<string>;
+  belowLayerID?: OptionalProp<string>;
+  layerIndex?: OptionalProp<Int32>;
+
+  maxZoomLevel?: OptionalProp<Double>;
+  minZoomLevel?: OptionalProp<Double>;
+  sourceLayerID?: OptionalProp<string>;
+  slot?: OptionalProp<Slot>;
+};
+// @{codepart-replace-end}
+
+export interface NativeProps extends ViewProps, CommonProps {
+  id?: OptionalProp<string>;
+  reactStyle: UnsafeMixed<any>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'RNMBXSymbolLayer',
+) as HostComponent<NativeProps>;

package/lib/commonjs/specs/RNMBXTerrainNativeComponent.ts

@@ -0,0 +1,13 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+import type { UnsafeMixed } from './codegenUtils';
+
+export interface NativeProps extends ViewProps {
+  sourceID?: UnsafeMixed<string>;
+  reactStyle: UnsafeMixed<any>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'RNMBXTerrain',
+) as HostComponent<NativeProps>;

package/lib/commonjs/specs/RNMBXVectorSourceNativeComponent.ts

@@ -0,0 +1,28 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import {
+  DirectEventHandler,
+  Double,
+} from 'react-native/Libraries/Types/CodegenTypes';
+
+import type { UnsafeMixed } from './codegenUtils';
+
+type OnMapboxVectorSourcePressEventType = { type: string; payload: string };
+
+export interface NativeProps extends ViewProps {
+  id: UnsafeMixed<string>;
+  existing: UnsafeMixed<boolean>;
+  url: UnsafeMixed<string>;
+  tileUrlTemplates: UnsafeMixed<Array<string>>;
+  attribution: UnsafeMixed<string>;
+  maxZoomLevel: UnsafeMixed<Double>;
+  minZoomLevel: UnsafeMixed<Double>;
+  tms: UnsafeMixed<boolean>;
+  hasPressListener: UnsafeMixed<boolean>;
+  hitbox: UnsafeMixed<any>;
+  onMapboxVectorSourcePress: DirectEventHandler<OnMapboxVectorSourcePressEventType>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'RNMBXVectorSource',
+) as HostComponent<NativeProps>;

package/lib/commonjs/specs/RNMBXViewportNativeComponent.ts

@@ -0,0 +1,117 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+
+import type { UnsafeMixed } from './codegenUtils';
+
+// see https://github.com/rnmapbox/maps/wiki/FabricOptionalProp
+type OptionalProp<T> = UnsafeMixed<T>;
+
+export type FollowPuckOptionsNative = {
+  zoom?: number | 'keep';
+  pitch?: number | 'keep';
+  bearing?: 'course' | 'heading' | number | 'keep';
+  padding?:
+    | {
+        top?: number;
+        left?: number;
+        bottom?: number;
+        right?: number;
+      }
+    | 'keep';
+};
+
+export type ViewportStateNative =
+  | {
+      kind: 'followPuck';
+      options?: FollowPuckOptionsNative;
+    }
+  | {
+      kind: 'overview';
+    };
+
+type ViewportStatus =
+  | {
+      kind: 'idle';
+    }
+  | {
+      kind: 'transition';
+      toState: ViewportStateNative;
+      transition: ViewportTransition;
+    };
+
+type ViewportTransition =
+  | {
+      kind: 'immediate';
+    }
+  | {
+      kind: 'default';
+      maxDurationMs?: number;
+    };
+
+type ViewportStatusChangeReason =
+  | 'TransitionStarted'
+  | 'TransitionSucceeded'
+  | 'IdleRequested'
+  | 'UserInteraction';
+
+//type OnStatusChangedEventType = { __fabric_todo: string };
+
+/*
+type OnStatusChangedEventTypeOk = {
+  from: {
+    kind: string;
+    toState?: {
+      kind: string;
+    };
+    transition?: {
+      kind: string;
+      maxDurationMs?: number;
+    };
+  };
+  to: {
+    kind: string;
+    toState?: {
+      kind: string;
+    };
+    transition?: {
+      kind: string;
+      maxDurationMs?: number;
+    };
+  };
+  reason: string;
+};*/
+
+export type OnStatusChangedEventPayload = {
+  from: ViewportStatus;
+  to: ViewportStatus;
+  reason: ViewportStatusChangeReason;
+};
+
+type OnStatusChangedEventType = {
+  type: string;
+  payload: string;
+  // RN 0.73+:
+  //payload: UnsafeMixed<OnStatusChangedEventPayload>;
+};
+
+export type OnStatusChangedEventTypeReal = {
+  type: 'statuschanged';
+  payload: UnsafeMixed<OnStatusChangedEventPayload>;
+};
+
+export interface NativeProps extends ViewProps {
+  transitionsToIdleUponUserInteraction?: OptionalProp<boolean>;
+  hasStatusChanged: boolean;
+  onStatusChanged?: DirectEventHandler<OnStatusChangedEventType>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'RNMBXViewport',
+) as HostComponent<NativeProps>;
+
+export type NativeViewportReal = HostComponent<
+  Omit<NativeProps, 'onStatusChanged'> & {
+    onStatusChanged?: DirectEventHandler<OnStatusChangedEventTypeReal>;
+  }
+>;

package/lib/commonjs/utils/NativeCommands.ts

@@ -0,0 +1,89 @@
+import { NodeHandle, findNodeHandle } from 'react-native';
+
+export type NativeArg =
+  | string
+  | number
+  | boolean
+  | null
+  | { [k: string]: NativeArg }
+  | NativeArg[]
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | Function
+  | GeoJSON.Geometry
+  | undefined;
+
+type FunctionKeys<T> = keyof {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  [K in keyof T as T[K] extends Function ? K : never]: T[K];
+};
+
+type RefType = React.Component;
+
+export class NativeCommands<Spec extends object> {
+  module: Spec;
+
+  preRefMethodQueue: Array<{
+    method: { name: FunctionKeys<Spec>; args: NativeArg[] };
+    resolver: (value: unknown) => void;
+  }>;
+
+  nativeRef: RefType | undefined;
+
+  constructor(module: Spec) {
+    this.module = module;
+    this.preRefMethodQueue = [];
+  }
+
+  async setNativeRef(nativeRef: RefType) {
+    if (nativeRef) {
+      this.nativeRef = nativeRef;
+      while (this.preRefMethodQueue.length > 0) {
+        const item = this.preRefMethodQueue.pop();
+
+        if (item && item.method && item.resolver) {
+          const res = await this._call(
+            item.method.name,
+            nativeRef,
+            item.method.args,
+          );
+          item.resolver(res);
+        }
+      }
+    }
+  }
+
+  call<T>(name: FunctionKeys<Spec>, args: NativeArg[]): Promise<T> {
+    if (this.nativeRef) {
+      return this._call(name, this.nativeRef, args);
+    } else {
+      return new Promise((resolve) => {
+        this.preRefMethodQueue.push({
+          method: { name, args },
+          resolver: resolve as (args: unknown) => void,
+        });
+      });
+    }
+  }
+
+  _call<T>(
+    name: FunctionKeys<Spec>,
+    nativeRef: RefType,
+    args: NativeArg[],
+  ): Promise<T> {
+    const handle = findNodeHandle(nativeRef);
+    if (handle) {
+      return (
+        this.module[name] as (
+          arg0: NodeHandle,
+          ...args: NativeArg[]
+        ) => Promise<T>
+      )(handle, ...args);
+    } else {
+      throw new Error(
+        `Could not find handle for native ref ${module} when trying to invoke ${String(
+          name,
+        )}`,
+      );
+    }
+  }
+}

package/lib/commonjs/utils/{nativeRef.js → nativeRef.ts}

@@ -1,9 +1,6 @@
-"use strict";
+import { RefObject, type Component, type MutableRefObject } from 'react';
+import { type NativeMethods, type HostComponent } from 'react-native';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = nativeRef;
 /**
  * Helper for useRef and requireNativeComponent:
  * @example
@@ -12,6 +9,9 @@ exports.default = nativeRef;
  * ...
  * <RNMBXCamera ref={ref} ... />
  */
+export type NativeRefType<P> = MutableRefObject<
+  (Component<P> & Readonly<NativeMethods>) | null
+>;
 
 /**
  * Helper for useRef and requireNativeComponent:
@@ -21,7 +21,8 @@ exports.default = nativeRef;
  * ...
  * <RNMBXCamera ref={ref} ... />
  */
-function nativeRef(c) {
-  return c;
+export default function nativeRef<P>(
+  c: RefObject<HostComponent<P> | null>,
+): MutableRefObject<(Component<P> & Readonly<NativeMethods>) | null> {
+  return c as NativeRefType<P>;
 }
-//# sourceMappingURL=nativeRef.js.map

package/lib/module/components/NativeBridgeComponent.tsx

@@ -0,0 +1,67 @@
+import React from 'react';
+import { TurboModule } from 'react-native';
+
+import { type NativeArg, runNativeMethod } from '../utils';
+
+export type RNMBEvent<PayloadType = { [key: string]: string }> = {
+  payload: PayloadType;
+  type: string;
+};
+
+const NativeBridgeComponent = <
+  Props extends object,
+  BaseComponent extends new (...ags: any[]) => React.Component<Props>,
+>(
+  Base: BaseComponent,
+  turboModule: TurboModule,
+) =>
+  class extends Base {
+    _turboModule: TurboModule;
+    _preRefMapMethodQueue: Array<{
+      method: { name: string; args: NativeArg[] };
+      resolver: (value: NativeArg) => void;
+    }>;
+
+    constructor(...args: any[]) {
+      super(...args);
+
+      this._turboModule = turboModule;
+      this._preRefMapMethodQueue = [];
+    }
+
+    async _runPendingNativeMethods<RefType>(nativeRef: RefType) {
+      if (nativeRef) {
+        while (this._preRefMapMethodQueue.length > 0) {
+          const item = this._preRefMapMethodQueue.pop();
+
+          if (item && item.method && item.resolver) {
+            const res = await this._runNativeMethod(
+              item.method.name,
+              nativeRef,
+              item.method.args,
+            );
+            item.resolver(res);
+          }
+        }
+      }
+    }
+
+    _runNativeMethod<RefType, ReturnType = NativeArg>(
+      methodName: string,
+      nativeRef: RefType | undefined,
+      args: NativeArg[] = [],
+    ): Promise<ReturnType> {
+      if (!nativeRef) {
+        return new Promise<ReturnType>((resolve) => {
+          this._preRefMapMethodQueue.push({
+            method: { name: methodName, args },
+            resolver: resolve as (args: NativeArg) => void,
+          });
+        });
+      }
+
+      return runNativeMethod(this._turboModule, methodName, nativeRef, args);
+    }
+  };
+
+export default NativeBridgeComponent;

package/lib/module/specs/NativeMapViewModule.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  takeSnap: (viewRef: Int32 | null, writeToDisk: boolean) => Promise<Object>;
+  queryTerrainElevation: (
+    viewRef: Int32 | null,
+    coordinates: ReadonlyArray<number>,
+  ) => Promise<Object>;
+  setSourceVisibility: (
+    viewRef: Int32 | null,
+    visible: boolean,
+    sourceId: string,
+    sourceLayerId: string,
+  ) => Promise<Object>;
+  getCenter: (viewRef: Int32 | null) => Promise<Object>;
+  getCoordinateFromView: (
+    viewRef: Int32 | null,
+    atPoint: ReadonlyArray<number>,
+  ) => Promise<Object>;
+  getPointInView: (
+    viewRef: Int32 | null,
+    atCoordinate: ReadonlyArray<number>,
+  ) => Promise<Object>;
+  getZoom: (viewRef: Int32 | null) => Promise<Object>;
+  getVisibleBounds: (viewRef: Int32 | null) => Promise<Object>;
+  queryRenderedFeaturesAtPoint: (
+    viewRef: Int32 | null,
+    atPoint: ReadonlyArray<number>,
+    withFilter: ReadonlyArray<Object>,
+    withLayerIDs: ReadonlyArray<string>,
+  ) => Promise<Object>;
+  queryRenderedFeaturesInRect: (
+    viewRef: Int32 | null,
+    withBBox: ReadonlyArray<number>,
+    withFilter: ReadonlyArray<Object>,
+    withLayerIDs: ReadonlyArray<string>,
+  ) => Promise<Object>;
+  setHandledMapChangedEvents: (
+    viewRef: Int32 | null,
+    events: ReadonlyArray<string>,
+  ) => Promise<Object>;
+  clearData: (viewRef: Int32 | null) => Promise<Object>;
+  querySourceFeatures: (
+    viewRef: Int32 | null,
+    sourceId: string,
+    withFilter: ReadonlyArray<Object>,
+    withSourceLayerIDs: ReadonlyArray<string>,
+  ) => Promise<Object>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNMBXMapViewModule');

package/lib/module/specs/NativeRNMBXCameraModule.ts

@@ -0,0 +1,36 @@
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+type ViewRef = Int32 | null;
+
+interface NativeCameraStop {
+  centerCoordinate?: string;
+  bounds?: string;
+  heading?: number;
+  pitch?: number;
+  zoom?: number;
+  paddingLeft?: number;
+  paddingRight?: number;
+  paddingTop?: number;
+  paddingBottom?: number;
+  duration?: number;
+  mode?: NativeAnimationMode;
+}
+
+type Stop =
+  | {
+      stops: NativeCameraStop[];
+    }
+  | NativeCameraStop;
+
+type NativeAnimationMode = 'flight' | 'ease' | 'linear' | 'none' | 'move';
+
+// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-unused-vars
+type ObjectOr<T> = Object;
+
+export interface Spec extends TurboModule {
+  updateCameraStop(viewRef: ViewRef, stop: ObjectOr<Stop>): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNMBXCameraModule');

package/lib/module/specs/NativeRNMBXChangeLineOffsetsShapeAnimatorModule.ts

@@ -0,0 +1,37 @@
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32, Double } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+import { Position } from '@turf/helpers';
+
+//import type { UnsafeMixed } from './codegenUtils';
+
+type AnimatorTag = Int32;
+
+export interface Spec extends TurboModule {
+  create(
+    tag: AnimatorTag,
+    coordinates: Position[],
+    startOffset: Double,
+    endOffset: Double,
+  ): Promise<void>;
+  setLineString(
+    tag: AnimatorTag,
+    coordinates: Position[],
+    startOffset: number,
+    endOffset: number,
+  ): Promise<void>;
+  setStartOffset(
+    tag: AnimatorTag,
+    offset: Double,
+    duration: Double,
+  ): Promise<void>;
+  setEndOffset(
+    tag: AnimatorTag,
+    offset: Double,
+    duration: Double,
+  ): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'RNMBXChangeLineOffsetsShapeAnimatorModule',
+);

package/lib/module/specs/NativeRNMBXImageModule.ts

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  refresh: (viewRef: Int32 | null) => Promise<Object>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNMBXImageModule');

package/lib/module/specs/NativeRNMBXLocationModule.ts

@@ -0,0 +1,32 @@
+import { TurboModule, TurboModuleRegistry} from "react-native";
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+
+type LocationEvent = {
+  type: string //"userlocationdupdated"
+  payload: {
+    coords: {
+      latitude: number
+      longitude: number
+      altitude: number
+      accuracy: number
+      speed: number
+      heading: number
+    }
+    timestamp: number
+  }
+}
+
+export interface Spec extends TurboModule {
+  start(minDisplacement: number): void
+  stop(): void
+  setRequestsAlwaysUse(requestsAlwaysUse: boolean): void
+  setMinDisplacement(minDisplacement: number): void
+  getLastKnownLocation(): Promise<LocationEvent['payload']>
+  simulateHeading(changesPerSecond: number, increment: number): void
+  setLocationEventThrottle(throttle: number): void
+
+  readonly onLocationUpdate: EventEmitter<LocationEvent>
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNMBXLocationModule');
+

package/lib/module/specs/NativeRNMBXMovePointShapeAnimatorModule.ts

@@ -0,0 +1,20 @@
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32, Double } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+//import type { UnsafeMixed } from './codegenUtils';
+
+type AnimatorTag = Int32;
+
+export interface Spec extends TurboModule {
+  create(tag: AnimatorTag, coordinate: ReadonlyArray<Double>): Promise<void>;
+  moveTo(
+    tag: AnimatorTag,
+    coordinate: ReadonlyArray<Double>,
+    duration: Double,
+  ): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'RNMBXMovePointShapeAnimatorModule',
+);

package/lib/module/specs/NativeRNMBXPointAnnotationModule.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  refresh: (viewRef: Int32 | null) => Promise<Object>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'RNMBXPointAnnotationModule',
+);

package/lib/module/specs/NativeRNMBXShapeSourceModule.ts

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  getClusterExpansionZoom: (
+    viewRef: Int32 | null,
+    featureJSON: string,
+  ) => Promise<Object>;
+  getClusterLeaves: (
+    viewRef: Int32 | null,
+    featureJSON: string,
+    number: Int32,
+    offset: Int32,
+  ) => Promise<Object>;
+  getClusterChildren: (
+    viewRef: Int32 | null,
+    featureJSON: string,
+  ) => Promise<Object>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNMBXShapeSourceModule');

package/lib/module/specs/NativeRNMBXTileStoreModule.ts

@@ -0,0 +1,27 @@
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-unused-vars
+type ObjectOr<T> = Object;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type StringOr<_T> = string;
+
+type Domain = 'Maps' | 'Navigation' | 'Search' | 'ADAS';
+
+type Tag = Int32;
+
+type Value = { value: string | number };
+
+export interface Spec extends TurboModule {
+  shared(path?: string): Promise<Tag>;
+  setOption(
+    tag: Tag,
+    key: string,
+    domain: StringOr<Domain>,
+    value: ObjectOr<Value>,
+  ): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNMBXTileStoreModule');