@react-native-kakao/map 2.2.6 → 3.1.0-next.2

package/src/types-shapes.ts

@@ -0,0 +1,244 @@
+import type { Coordinate } from './types';
+
+export type ShapeColor = string;
+/** Model-space meters; not an equal-ground-distance contract. */
+export type ShapePoint = { x: number; y: number };
+export type ShapeLayerPass = 'default' | 'overlay' | 'route';
+export type ShapeInterpolation = 'linear' | 'cubicIn' | 'cubicOut' | 'cubicInOut';
+
+export type ShapePolygonPart<T> = {
+  outer: T[];
+  holes?: T[][];
+  styleIndex?: number;
+  mergeOverlappedHoles?: boolean;
+};
+
+export type ShapeLinePart<T> = { points: T[]; styleIndex?: number };
+
+export type GeographicPolygonGeometry = {
+  type: 'geographicPolygon';
+  parts: ShapePolygonPart<Coordinate>[];
+};
+
+export type ModelPolygonGeometry = {
+  type: 'modelPolygon';
+  base: Coordinate;
+  orientation?: number;
+  parts: ShapePolygonPart<ShapePoint>[];
+};
+
+export type GeographicPolylineGeometry = {
+  type: 'geographicPolyline';
+  parts: ShapeLinePart<Coordinate>[];
+};
+
+export type ModelPolylineGeometry = {
+  type: 'modelPolyline';
+  base: Coordinate;
+  orientation?: number;
+  parts: ShapeLinePart<ShapePoint>[];
+};
+
+export type ShapePrimitiveGeometry =
+  | {
+      type: 'modelCircle';
+      base: Coordinate;
+      /** Model-space meters. */
+      radius: number;
+      pointCount?: number;
+      clockwise?: boolean;
+      orientation?: number;
+      styleIndex?: number;
+    }
+  | {
+      type: 'modelRectangle';
+      base: Coordinate;
+      /** Model-space meters. */
+      width: number;
+      /** Model-space meters. */
+      height: number;
+      clockwise?: boolean;
+      orientation?: number;
+      styleIndex?: number;
+    }
+  | {
+      type: 'geographicCircle';
+      center: Coordinate;
+      /** Meters. */
+      radius: number;
+      pointCount?: number;
+      clockwise?: boolean;
+      styleIndex?: number;
+    }
+  | {
+      type: 'geographicRectangle';
+      center: Coordinate;
+      /** Meters. */
+      width: number;
+      /** Meters. */
+      height: number;
+      clockwise?: boolean;
+      styleIndex?: number;
+    }
+  | {
+      type: 'geographicCurve';
+      start: Coordinate;
+      end: Coordinate;
+      side: 'left' | 'right';
+      styleIndex?: number;
+    }
+  | {
+      type: 'modelArc';
+      base: Coordinate;
+      /** Model-space meters. */
+      radius: number;
+      /** Degrees clockwise from north. */
+      startAngle: number;
+      /** Degrees clockwise from north. */
+      endAngle: number;
+      pointCount?: number;
+      clockwise?: boolean;
+      orientation?: number;
+      styleIndex?: number;
+    }
+  | {
+      type: 'geographicArc';
+      center: Coordinate;
+      /** Meters. */
+      radius: number;
+      /** Degrees clockwise from north. */
+      startAngle: number;
+      /** Degrees clockwise from north. */
+      endAngle: number;
+      pointCount?: number;
+      clockwise?: boolean;
+      styleIndex?: number;
+    };
+
+export type ShapeGeometry =
+  | GeographicPolygonGeometry
+  | ModelPolygonGeometry
+  | GeographicPolylineGeometry
+  | ModelPolylineGeometry
+  | ShapePrimitiveGeometry;
+
+export type PolygonStyleLevel = {
+  level: number;
+  fillColor: ShapeColor;
+  strokeColor?: ShapeColor;
+  /** Density-independent pixels. */
+  strokeWidth?: number;
+};
+
+export type PolylineStyleLevel = {
+  level: number;
+  color: ShapeColor;
+  /** Density-independent pixels. */
+  width: number;
+  strokeColor?: ShapeColor;
+  /** Density-independent pixels. */
+  strokeWidth?: number;
+};
+
+export type PolygonStyleSet = {
+  type: 'polygon';
+  id: string;
+  styles: { levels: PolygonStyleLevel[] }[];
+};
+
+export type PolylineStyleSet = {
+  type: 'polyline';
+  id: string;
+  cap?: 'butt' | 'round' | 'square';
+  styles: { levels: PolylineStyleLevel[] }[];
+};
+
+export type ShapeStyleSet = PolygonStyleSet | PolylineStyleSet;
+
+export type ShapeLayerSpec = {
+  id: string;
+  zIndex?: number;
+  visible?: boolean;
+  /** `route` requires SDK support; capability is reported by the native manager. */
+  pass?: ShapeLayerPass;
+};
+
+export type ShapeSpec = {
+  id: string;
+  layerId: string;
+  styleSetId: string;
+  zIndex?: number;
+  visible?: boolean;
+  geometry: ShapeGeometry;
+};
+
+export type ShapeScene = {
+  styleSets?: ShapeStyleSet[];
+  layers?: ShapeLayerSpec[];
+  shapes?: ShapeSpec[];
+};
+
+export type ShapeWaveAnimation = {
+  animationId: string;
+  shapeIds: string[];
+  duration: number;
+  frames: {
+    level: number;
+    startAlpha: number;
+    endAlpha: number;
+    /** Density-independent pixels. */
+    startRadius: number;
+    /** Density-independent pixels. */
+    endRadius: number;
+  }[];
+  interpolation?: ShapeInterpolation;
+  repeat?: number;
+  hideAtStop?: boolean;
+};
+
+export type ShapeCommand =
+  | { type: 'setVisible'; ids: string[]; visible: boolean }
+  | { type: 'setZIndex'; id: string; zIndex: number }
+  | { type: 'setPosition'; id: string; position: Coordinate }
+  | { type: 'setOrientation'; id: string; orientation: number }
+  | { type: 'changeData'; id: string; styleSetId: string; geometry: ShapeGeometry }
+  | { type: 'startWave'; animation: ShapeWaveAnimation }
+  | { type: 'stopAnimation'; animationId: string }
+  | { type: 'getState'; id: string }
+  | { type: 'getCounts' }
+  | { type: 'getCapabilities' }
+  | { type: 'remove'; ids: string[] };
+
+export type ShapeCounts = { type: 'counts'; layers: number; shapes: number; animations: number };
+
+export type ShapeCommandResult =
+  | { type: 'none' }
+  | {
+      type: 'state';
+      id: string;
+      layerId: string;
+      visible: boolean;
+      zIndex: number;
+      geometryType: ShapeGeometry['type'];
+      position: Coordinate | null;
+      orientation: number | null;
+    }
+  | ShapeCounts
+  | ({ type: 'capabilities' } & ShapeCapabilities);
+
+export type ShapeCapabilities = {
+  layerPasses: ShapeLayerPass[];
+  geographicPrimitives: boolean;
+  modelPrimitives: boolean;
+  geographicPosition: boolean;
+  geographicOrientation: boolean;
+  modelPosition: boolean;
+  modelOrientation: boolean;
+  zIndexMutation: boolean;
+  fractionalStyleWidth: boolean;
+  waveAnimation: boolean;
+  waveTargets: ('polygon' | 'polyline')[];
+  waveNaturalStopEvent: boolean;
+};
+
+export type ShapeAnimationStopEvent = { animationId: string };

package/src/types-utilities.ts

@@ -0,0 +1,115 @@
+import type { MapViewport } from './types';
+
+export type MapPoiCategory =
+  | 'policyCategory'
+  | 'address'
+  | 'district'
+  | 'busStop'
+  | 'railroadPlatform'
+  | 'railroadEntrance'
+  | 'railroadLine'
+  | 'brand'
+  | 'place'
+  | 'climb'
+  | 'climbWave'
+  | 'road'
+  | 'roadNumber'
+  | 'roadInfo'
+  | 'facilities'
+  | 'publicFacilities'
+  | 'apartNumber'
+  | 'apartDetail'
+  | 'houseNumber'
+  | 'land'
+  | 'indoor'
+  | 'indoorPlace'
+  | 'detailCategory';
+
+export type MapCoordinateSystem = 'wgs84' | 'wtm' | 'wcong' | 'kakao';
+export type MapCoordinateValue = { x: number; y: number };
+export type MapCacheKind = 'disk' | 'memory' | 'viewInfo' | 'all';
+export type MapPoiScale = 'small' | 'regular' | 'large' | 'xLarge';
+export type MapPoiState = {
+  visible: boolean;
+  clickable: boolean;
+  scale: MapPoiScale;
+  language: string | null;
+};
+
+export type MapUtilityCommand =
+  | { type: 'getCapabilities' }
+  | { type: 'getState' }
+  | { type: 'setPoiVisible'; visible: boolean }
+  | { type: 'setPoiCategoryVisible'; category: MapPoiCategory; visible: boolean }
+  | { type: 'setPoiCategoryMaxCount'; category: MapPoiCategory; count: number }
+  | { type: 'resetPoiCategoryMaxCount'; category: MapPoiCategory }
+  | { type: 'setTapInterval'; milliseconds: number }
+  | { type: 'setCameraAnimationEnabled'; enabled: boolean }
+  | { type: 'setEnabled'; enabled: boolean }
+  | { type: 'setVisible'; visible: boolean }
+  | { type: 'setKeepLevelOnResize'; enabled: boolean }
+  | { type: 'getViewport' }
+  | { type: 'setViewport'; viewport: MapViewport }
+  | { type: 'refresh' }
+  | { type: 'registerFont'; resourceName: string; name?: string }
+  | { type: 'getVersion'; component: 'sdk' | 'engine' }
+  | {
+      type: 'convertCoordinate';
+      from: MapCoordinateSystem;
+      to: MapCoordinateSystem;
+      coordinate: MapCoordinateValue;
+    }
+  | { type: 'clearCache'; kind: MapCacheKind };
+
+export type MapUtilityCapabilities = {
+  type: 'capabilities';
+  poi: {
+    visibility: boolean;
+    visibilityReadable: boolean;
+    categoryVisibility: boolean;
+    categoryMaxCount: boolean;
+    stateRequest: boolean;
+    categories: MapPoiCategory[];
+  };
+  settings: {
+    tapInterval: boolean;
+    cameraAnimationEnabled: boolean;
+    cameraAnimationEnabledReadable: boolean;
+    enabled: boolean;
+    visible: boolean;
+    keepLevelOnResize: boolean;
+    refresh: boolean;
+    focusedReadable: boolean;
+  };
+  viewport: { readable: boolean; writable: boolean };
+  fontRegistration: boolean;
+  versionComponents: ('sdk' | 'engine')[];
+  coordinateSystems: MapCoordinateSystem[];
+  coordinateConversions: `${MapCoordinateSystem}:${MapCoordinateSystem}`[];
+  cacheKinds: MapCacheKind[];
+};
+
+export type MapUtilityState = {
+  type: 'state';
+  tapInterval: number;
+  cameraAnimationEnabled?: boolean;
+  poiVisible?: boolean;
+  enabled?: boolean;
+  visible?: boolean;
+  keepLevelOnResize?: boolean;
+  focused?: boolean;
+};
+
+export type MapUtilityResult =
+  | { type: 'none' }
+  | MapUtilityCapabilities
+  | MapUtilityState
+  | { type: 'version'; component: 'sdk' | 'engine'; version: string }
+  | { type: 'viewport'; viewport: MapViewport }
+  | {
+      type: 'coordinate';
+      system: MapCoordinateSystem;
+      coordinate: MapCoordinateValue;
+    };
+
+export type MapPoiStateResult = { type: 'poiState'; state: MapPoiState };

package/src/types.ts

@@ -0,0 +1,223 @@
+import type { ViewProps } from 'react-native';
+
+import type {
+  AdvancedCameraCommand,
+  AdvancedCameraCommandResult,
+  AdvancedCameraOperationEvent,
+} from './types-camera';
+import type { DimScreenEvent, DimScreenOptions, DimScreenStatus } from './types-dim';
+import type {
+  AnimatedImageAction,
+  MapGuiEvent,
+  MapGuiScene,
+  MapGuiStatus,
+  MoveInfoWindowOptions,
+  ShowInfoWindowOptions,
+} from './types-gui';
+import type {
+  LabelAnimationEvent,
+  LabelCapabilities,
+  LabelClickEvent,
+  LabelCommand,
+  LabelRuntimeState,
+  LabelScene,
+} from './types-labels';
+import type {
+  RouteAnimationStopEvent,
+  RouteCommand,
+  RouteCommandResult,
+  RouteCounts,
+  RouteProgressEvent,
+  RouteScene,
+} from './types-routes';
+import type {
+  ShapeAnimationStopEvent,
+  ShapeCommand,
+  ShapeCommandResult,
+  ShapeCounts,
+  ShapeScene,
+} from './types-shapes';
+import type { MapPoiStateResult, MapUtilityCommand, MapUtilityResult } from './types-utilities';
+
+export type Coordinate = {
+  latitude: number;
+  longitude: number;
+};
+
+export type ScreenPoint = { x: number; y: number };
+export type MapViewport = ScreenPoint & { width: number; height: number };
+export type MapPadding = { top: number; right: number; bottom: number; left: number };
+export type MapType = 'normal' | 'skyview';
+export type MapOverlay = 'roadviewLine' | 'hillShading' | 'bicycleRoad' | 'hybrid';
+export type MapGesture =
+  | 'doubleTapZoomIn'
+  | 'twoFingerTapZoomOut'
+  | 'pan'
+  | 'rotate'
+  | 'zoom'
+  | 'tilt'
+  | 'longTapAndDrag'
+  | 'rotateZoom'
+  | 'oneFingerZoom';
+export type MapWidgetPosition = ScreenPoint & {
+  gravity:
+    | 'topLeft'
+    | 'topCenter'
+    | 'topRight'
+    | 'centerLeft'
+    | 'center'
+    | 'centerRight'
+    | 'bottomLeft'
+    | 'bottomCenter'
+    | 'bottomRight';
+};
+export type MapOptions = {
+  mapType?: MapType;
+  /** Mutually exclusive with mapType. Custom configurations may require a Kakao agreement. */
+  viewInfo?: { name: string; appName?: string };
+  overlays?: MapOverlay[];
+  /** Raw SDK overlay IDs for separately licensed map data. */
+  customOverlays?: string[];
+  language?: string;
+  poi?: {
+    visible?: boolean;
+    clickable?: boolean;
+    scale?: 'small' | 'regular' | 'large' | 'xLarge';
+  };
+  buildingScale?: number;
+  padding?: MapPadding;
+  zoomRange?: { min: number; max: number };
+  gestures?: Partial<Record<MapGesture, boolean>>;
+  compass?: { visible?: boolean; position?: MapWidgetPosition };
+  scaleBar?: {
+    visible?: boolean;
+    position?: MapWidgetPosition;
+    autoHide?: boolean;
+    fade?: { inDuration: number; outDuration: number; retentionDuration: number };
+  };
+  logo?: MapWidgetPosition;
+};
+
+export type MapInfo = {
+  mapType: MapType;
+  viewInfoName: string;
+  zoomRange: { min: number; max: number };
+  padding: MapPadding;
+  size: { width: number; height: number };
+  viewport: MapViewport;
+  language: string;
+  supportedLanguages: string[];
+  capabilities: { coordinateToScreen: boolean };
+};
+
+export type CameraUpdate =
+  | { type: 'position'; position: Coordinate }
+  | { type: 'zoom'; zoomLevel: number }
+  | { type: 'orientation'; rotation: number; tilt: number }
+  | { type: 'fit'; coordinates: Coordinate[] };
+
+export type CameraPosition = Coordinate & {
+  zoomLevel: number;
+  /** Degrees from the vertical. The SDK may limit tilt at the current zoom. */
+  tilt: number;
+  /** Counterclockwise camera angle from north in degrees; returned as [0, 360). */
+  rotation: number;
+};
+
+export type CameraOptions = Omit<CameraPosition, 'tilt' | 'rotation'> & {
+  tilt?: number;
+  rotation?: number;
+};
+
+export type KakaoMapError = { code: string; message: string };
+export type CameraMoveEvent = { reason: 'gesture' | 'developer' };
+export type MapClickEvent = { latitude: number; longitude: number; x: number; y: number };
+export type PoiClickEvent = Coordinate & { id: string; layerId: string };
+
+export type KakaoMapViewProps = ViewProps & {
+  initialCamera?: CameraOptions;
+  camera?: CameraOptions;
+  /** Applies the supplied fields; omitted fields retain their current SDK values. */
+  options?: MapOptions;
+  labels?: LabelScene;
+  shapes?: ShapeScene;
+  routes?: RouteScene;
+  onMapReady?: () => void;
+  onError?: (error: KakaoMapError) => void;
+  onCameraMoveStart?: (event: CameraMoveEvent) => void;
+  onCameraIdle?: (event: CameraMoveEvent & { camera: CameraPosition }) => void;
+  onMapClick?: (event: MapClickEvent) => void;
+  onMapLongClick?: (event: Coordinate) => void;
+  onTerrainClick?: (event: Coordinate) => void;
+  /** Android only: receives SDK viewport taps, including object taps. */
+  onViewportClick?: (event: MapClickEvent) => void;
+  /** Android only. */
+  onVisibilityChanged?: (event: { visible: boolean }) => void;
+  /** iOS only. */
+  onFocusChanged?: (event: { focused: boolean }) => void;
+  onPoiClick?: (event: PoiClickEvent) => void;
+  onCompassClick?: () => void;
+  onMapTypeChanged?: (event: { viewInfoName: string }) => void;
+  onPaddingChanged?: (event: MapPadding) => void;
+  onViewportChanged?: (event: MapViewport) => void;
+  onLabelClick?: (event: LabelClickEvent) => void;
+  onLabelAnimationStopped?: (event: LabelAnimationEvent) => void;
+  onLabelsChanged?: (event: LabelRuntimeState) => void;
+  onShapeAnimationStop?: (event: ShapeAnimationStopEvent) => void;
+  onShapesChanged?: (event: ShapeCounts) => void;
+  onRoutesChanged?: (event: RouteCounts) => void;
+  onRouteProgress?: (event: RouteProgressEvent) => void;
+  onRouteAnimationStop?: (event: RouteAnimationStopEvent) => void;
+  onGuiEvent?: (event: MapGuiEvent) => void;
+  onDimScreenEvent?: (event: DimScreenEvent) => void;
+  onCameraOperation?: (event: AdvancedCameraOperationEvent) => void;
+};
+
+export type KakaoMapViewRef = {
+  /** Resolves on command dispatch. Duration is milliseconds; omitted means immediate. */
+  moveCamera: (camera: CameraOptions, options?: { duration?: number }) => Promise<void>;
+  getCamera: () => Promise<CameraPosition>;
+  updateCamera: (update: CameraUpdate, options?: { duration?: number }) => Promise<void>;
+  getMapInfo: () => Promise<MapInfo>;
+  screenToCoordinate: (point: ScreenPoint) => Promise<Coordinate>;
+  /** Android only: iOS SDK does not expose this projection. */
+  coordinateToScreen: (coordinate: Coordinate) => Promise<ScreenPoint>;
+  clearCache: () => Promise<void>;
+  runLabelCommand: (command: LabelCommand) => Promise<void>;
+  getLabelCapabilities: () => Promise<LabelCapabilities>;
+  getLabelState: () => Promise<LabelRuntimeState>;
+  applyShapes: (scene: ShapeScene) => Promise<ShapeCounts>;
+  executeShapeCommand: (command: ShapeCommand) => Promise<ShapeCommandResult>;
+  applyRoutes: (scene: RouteScene) => Promise<RouteCounts>;
+  executeRouteCommand: (command: RouteCommand) => Promise<RouteCommandResult>;
+  applyGui: (scene: MapGuiScene) => Promise<void>;
+  showInfoWindow: (id: string, options?: ShowInfoWindowOptions) => Promise<void>;
+  hideInfoWindow: (id: string) => Promise<void>;
+  moveInfoWindow: (
+    id: string,
+    position: Coordinate,
+    options?: MoveInfoWindowOptions,
+  ) => Promise<void>;
+  showWidget: (id: string) => Promise<void>;
+  hideWidget: (id: string) => Promise<void>;
+  positionWidget: (id: string, position: MapWidgetPosition) => Promise<void>;
+  rotateWidget: (id: string, rotation: number) => Promise<void>;
+  startGuiAnimation: (id: string) => Promise<void>;
+  stopGuiAnimation: (id: string) => Promise<void>;
+  controlAnimatedImage: (
+    ownerType: 'infoWindow' | 'widget',
+    ownerId: string,
+    componentId: string,
+    action: AnimatedImageAction,
+  ) => Promise<void>;
+  getGuiStatus: () => Promise<MapGuiStatus>;
+  applyDimScreen: (options: DimScreenOptions) => Promise<void>;
+  setDimHighlightVisible: (id: string, visible: boolean) => Promise<void>;
+  startDimAnimation: (id: string) => Promise<void>;
+  stopDimAnimation: (id: string) => Promise<void>;
+  getDimScreenStatus: () => Promise<DimScreenStatus>;
+  executeUtilityCommand: (command: MapUtilityCommand) => Promise<MapUtilityResult>;
+  /** Android only: resolves with the SDK's asynchronous POI state response. */
+  requestPoiState: () => Promise<MapPoiStateResult>;
+  executeCameraCommand: (command: AdvancedCameraCommand) => Promise<AdvancedCameraCommandResult>;
+};

package/android/gradle.properties

@@ -1 +0,0 @@
-Kakao_kotlinVersion=1.7.0

package/android/src/main/AndroidManifestNew.xml

@@ -1,2 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-</manifest>

package/android/src/main/java/net/mjstudio/rnkakao/map/RNCKakaoMapModule.kt

@@ -1,25 +0,0 @@
-package net.mjstudio.rnkakao.map
-
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.kakao.vectormap.KakaoMapSdk
-
-class RNCKakaoMapModule internal constructor(
-  context: ReactApplicationContext,
-) : KakaoMapSpec(context) {
-  override fun getName(): String = NAME
-
-  @ReactMethod
-  override fun initializeKakaoMapSDK(
-    appKey: String,
-    promise: Promise,
-  ) {
-    KakaoMapSdk.init(reactApplicationContext, appKey)
-    promise.resolve(42)
-  }
-
-  companion object {
-    const val NAME = "RNCKakaoMap"
-  }
-}

package/android/src/main/java/net/mjstudio/rnkakao/map/RNCKakaoMapPackage.kt

@@ -1,35 +0,0 @@
-package net.mjstudio.rnkakao.map
-
-import com.facebook.react.TurboReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.model.ReactModuleInfo
-import com.facebook.react.module.model.ReactModuleInfoProvider
-
-class RNCKakaoMapPackage : TurboReactPackage() {
-  override fun getModule(
-    name: String,
-    reactContext: ReactApplicationContext,
-  ): NativeModule? =
-    if (name == RNCKakaoMapModule.NAME) {
-      RNCKakaoMapModule(reactContext)
-    } else {
-      null
-    }
-
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
-    ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-      moduleInfos[RNCKakaoMapModule.NAME] =
-        ReactModuleInfo(
-          RNCKakaoMapModule.NAME,
-          RNCKakaoMapModule.NAME,
-          false, // canOverrideExistingModule
-          false, // needsEagerInit
-          false, // isCxxModule
-          isTurboModule, // isTurboModule
-        )
-      moduleInfos
-    }
-}

package/android/src/newarch/KakaoMapSpec.kt

@@ -1,7 +0,0 @@
-package net.mjstudio.rnkakao.map
-
-import com.facebook.react.bridge.ReactApplicationContext
-
-abstract class KakaoMapSpec internal constructor(
-  context: ReactApplicationContext,
-) : NativeKakaoMapSpec(context)

package/android/src/oldarch/KakaoMapSpec.kt

@@ -1,14 +0,0 @@
-package net.mjstudio.rnkakao.map
-
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-
-abstract class KakaoMapSpec internal constructor(
-  context: ReactApplicationContext,
-) : ReactContextBaseJavaModule(context) {
-  abstract fun initializeKakaoMapSDK(
-    appKey: String,
-    promise: Promise,
-  )
-}

package/ios/Component/Map/RNCKakaoMapView.h

@@ -1,23 +0,0 @@
-//
-//  RNCKakaoMapView.h
-//  RNCKakaoMap
-//
-//  Created by mj on 5/5/24.
-//
-
-#import "RCTFabricComponentsPlugins.h"
-#import <KakaoMapsSDK/KakaoMapsSDK-Swift.h>
-#import <KakaoMapsSDK/KakaoMapsSDK.h>
-#import <React/RCTViewComponentView.h>
-#import <React/UIView+ComponentViewProtocol.h>
-#import <UIKit/UIKit.h>
-#import <react/renderer/components/RNCKakaoMapSpec/ComponentDescriptors.h>
-#import <react/renderer/components/RNCKakaoMapSpec/EventEmitters.h>
-#import <react/renderer/components/RNCKakaoMapSpec/Props.h>
-#import <react/renderer/components/RNCKakaoMapSpec/RCTComponentViewHelpers.h>
-
-@interface RNCKakaoMapView : RCTViewComponentView
-
-@property(nonatomic, assign) double cameraAnimationDuration;
-
-@end