tagworks-sdk-v1-react 1.1.0

package/android/src/main/java/com/tagworkssdkv1/TagWorksModule.kt

@@ -0,0 +1,317 @@
+package com.tagworkssdkv1
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.obzen.tagworks.TagWorks
+import com.obzen.tagworks.TagWorksConfig
+import com.obzen.tagworks.data.DataBundle
+import com.obzen.tagworks.data.Dimension
+import com.obzen.tagworks.data.DimensionType
+import com.obzen.tagworks.util.Logger
+import com.obzen.tagworks.util.Logger.Companion.d
+import com.obzen.tagworks.util.WebAppInterface.Companion.MessageHandlerName
+import org.json.JSONArray
+import org.json.JSONObject
+
+class TagWorksModule(reactContext: ReactApplicationContext):ReactContextBaseJavaModule(reactContext) {
+
+    /**
+     * js에서 호출하는 TagWorksModule 네이밍
+     */
+    override fun getName(): String {
+        return "TagWorksModule"
+    }
+
+    /**
+     * config SDK 초기화 함수
+     */
+    @ReactMethod
+    fun initializeTagWorks(
+        siteId:String,
+        baseUrl:String,
+        isUseIntervals:Boolean,
+        dispatchInterval:Double,
+        sessionTimeout:Double,
+        isManualDispatch:Boolean,
+        appVersion:String?,
+        appName:String?
+    ) {
+        val config = TagWorksConfig.Builder()
+            .setSiteId(siteId)
+            .setBaseUrl(baseUrl)
+            .setDispatchInterval(dispatchInterval.toLong())
+            .setSessionTimeOut(sessionTimeout.toLong())
+            .setAppVersion(appVersion)
+            .setAppName(appName)
+            .setManualDispatch(isManualDispatch)
+            .setIsUseIntervals(isUseIntervals)
+            .build()
+
+        TagWorks.initializeSdk(reactApplicationContext, config)
+
+    }
+
+
+    /**
+     * siteId, baseUrl SDK 초기화 함수
+     */
+    @ReactMethod
+    fun initTagWorksWithSiteIdAndBaseUrl(siteId: String,baseUrl: String) {
+        TagWorks.initializeSdk(reactApplicationContext,siteId,baseUrl)
+    }
+
+
+    @ReactMethod
+    fun setLogLevel(level:Int) {
+        TagWorks.getInstance().setLogLevel(level)
+    }
+
+    @ReactMethod
+    fun setOptOut(isOptOut:Boolean) {
+        TagWorks.getInstance().optOut = isOptOut
+    }
+
+    @ReactMethod
+    fun setUserId(userId:String) {
+        TagWorks.getInstance().userId = userId
+    }
+
+    @ReactMethod
+    fun setVisitorId(visitorId:String) {
+        TagWorks.getInstance().setVisitorId(visitorId)
+    }
+
+    @ReactMethod
+    fun getVisitorId(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().getVisitorId())
+        }catch (e:Exception) {
+            callback.invoke("error :",e.message)
+        }
+    }
+
+    @ReactMethod
+    fun getSiteId(callback: Callback) {
+        try {
+            callback.invoke(TagWorks.getInstance().getSiteId())
+        } catch (e:Exception) {
+            callback.invoke("error :",e.message)
+        }
+    }
+
+
+    /**
+     * 공용 dimension 설정
+     */
+
+
+    @ReactMethod
+    fun setCommonDimensionWithDouble(index: Int,numValue:Double) {
+        TagWorks.getInstance().setCommonDimension(index,numValue)
+    }
+
+    @ReactMethod
+    fun setCommonDimensionWithString(index: Int,value:String) {
+        TagWorks.getInstance().setCommonDimension(index,value)
+    }
+
+
+
+    @ReactMethod
+    fun getCommonDimensions(callback: Callback) {
+
+        try {
+            val commonDimensions = TagWorks.getInstance().getDimensions()
+
+            val generalMap = Arguments.createMap()
+            val factMap = Arguments.createMap()
+
+            commonDimensions.forEach { dimension ->
+                when (dimension.type) {
+                    DimensionType.GENERAL_TYPE -> generalMap.putString(dimension.index.toString(),dimension.value)
+                    DimensionType.FACT_TYPE -> factMap.putDouble(dimension.index.toString(),dimension.numValue)
+                }
+            }
+
+            val generalWrapper = Arguments.createMap()
+            generalWrapper.putMap("General",generalMap)
+
+            val factWrapper = Arguments.createMap()
+            factWrapper.putMap("Fact",factMap)
+
+            val dimensionsArray = Arguments.createArray()
+            dimensionsArray.pushMap(generalWrapper)
+            dimensionsArray.pushMap(factWrapper)
+
+
+            val result = Arguments.createMap()
+            result.putArray("Dimensions", dimensionsArray)
+
+            callback.invoke(result)
+        } catch (e: Exception) {
+            // 오류 처리
+            e.printStackTrace()
+            callback.invoke(null)
+        }
+
+
+    }
+
+    @ReactMethod
+    fun getCommonDimensionsOfArrayIndex(callback: Callback) {
+        try {
+            val commonDimensions = TagWorks.getInstance().getDimensions()
+            Log.d(TAG, "getCommonDimensionsOfArrayIndex: ${commonDimensions}")
+            val dimensions = JSONArray()
+
+            commonDimensions.forEach { dimension ->
+                val dimensionObject = JSONObject()
+                if (dimension.type == DimensionType.FACT_TYPE) {
+                    dimensionObject.put("Fact_${dimension.index}", dimension.numValue)
+                } else if (dimension.type == DimensionType.GENERAL_TYPE) {
+                    dimensionObject.put("General_${dimension.index}", dimension.value)
+                }
+                dimensions.put(dimensionObject)
+            }
+            val jsonString = dimensions.toString(4)
+            callback.invoke(jsonString)
+        }catch (e:Exception) {
+            callback.invoke(null)
+        }
+    }
+
+    @ReactMethod
+    fun getCommonDimensionWithString(index: Int,callback: Callback) {
+        val mCommonDimension = TagWorks.getInstance().getCommonDimension(DimensionType.GENERAL_TYPE,index)
+        if (mCommonDimension != null) callback.invoke(mCommonDimension.value)
+        else callback.invoke(null)
+    }
+
+    @ReactMethod
+    fun getCommonDimensionWithDouble(index: Int,callback: Callback) {
+        val mCommonDimension = TagWorks.getInstance().getCommonDimension(DimensionType.FACT_TYPE,index)
+        if (mCommonDimension != null) callback.invoke(mCommonDimension.numValue)
+        else callback.invoke(null)
+    }
+
+    @ReactMethod
+    fun removeDimensionInGeneralType(index: Int) {
+        TagWorks.getInstance().removeCommonDimension(DimensionType.GENERAL_TYPE,index)
+    }
+
+    @ReactMethod
+    fun removeDimensionInFactType(index: Int) {
+        TagWorks.getInstance().removeCommonDimension(DimensionType.FACT_TYPE,index)
+    }
+
+    @ReactMethod
+    fun removeAllCommonDimension() {
+        TagWorks.getInstance().removeAllCommonDimension()
+    }
+
+    @ReactMethod
+    fun removeCommonDimensionWithArrayIndex(index:Int) {
+        TagWorks.getInstance().removeCommonDimensionWithArrayIndex(index)
+    }
+
+
+    @ReactMethod
+    fun dispatch(callback: Callback) {
+        val result = TagWorks.getInstance().dispatch()
+        callback.invoke(result)
+    }
+
+    @ReactMethod
+    fun sendReferrerEventWithOpenUrlString(openUrl: String) {
+        TagWorks.getInstance().sendReferrerEvent(openUrl)
+    }
+
+
+    @ReactMethod
+    fun logEvent(eventType:String,data:ReadableMap,callback: Callback) {
+
+        val bundle = DataBundle()
+
+        val dataBundleMap = data.getMap("dataBundle")
+        dataBundleMap?.let {
+            val keySetIterator = it.keySetIterator()
+            while (keySetIterator.hasNextKey()) {
+                val key = keySetIterator.nextKey()
+                bundle.putString(key,it.getString(key))
+            }
+        }
+
+        val dimensionsArray = data.getArray("dimensions")
+        dimensionsArray?.let {
+            for (i in 0 until it.size()) {
+                val dimensionMap = it.getMap(i)
+                val type = dimensionMap.getString("type")
+                val index = dimensionMap.getInt("index")
+                val value = dimensionMap.getString("value")
+                val numValue = dimensionMap.getDouble("numValue")
+
+                bundle.setDimension(Dimension(DimensionType.valueOf(type!!),index,value,numValue))
+            }
+        }
+
+        Log.d(TAG, "logEvent: ${bundle.dataBundle} + ${bundle.dimensions}")
+        try {
+
+            val result = TagWorks.getInstance().logEvent(eventType, bundle)
+            callback.invoke(result)
+
+        }catch (e:Exception) {
+            Log.d(TAG, "log event error: ${e.message}")
+        }
+
+
+    }
+
+    @ReactMethod
+    fun webInterfaceDidReceive(jsonEventString: String) {
+        d(MessageHandlerName,jsonEventString)
+        Log.d("TAG", "TagWorksWebEvent: ${jsonEventString}")
+        try {
+            d(name, jsonEventString)
+            val jsonObj = JSONObject(jsonEventString)
+
+            val idSite = if (jsonObj.isNull("idsite")) null else jsonObj.getString("idsite")
+            val url = if (jsonObj.isNull("url")) null else jsonObj.getString("url")
+            val urlref = if (jsonObj.isNull("urlref")) null else jsonObj.getString("urlref")
+            var eventCategory = if (jsonObj.isNull("e_c")) null else jsonObj.getString("e_c")
+
+            if (eventCategory != null) {
+                eventCategory =
+                    eventCategory.replace("{{vstor_id}}", TagWorks.getInstance().getVisitorId())
+            }
+
+            if (idSite != null && idSite != TagWorks.getInstance().getSiteId()) {
+                Logger.i(MessageHandlerName, "WebView siteid is not equal App siteid!!")
+            }
+
+            TagWorks.getInstance().webInterfaceLogEventPush(
+                idSite, url, urlref, eventCategory
+            )
+
+        } catch (t: Throwable) {
+            Logger.e(MessageHandlerName,t.message);
+            Logger.e(MessageHandlerName, "Could not parse malformed JSON: \"$jsonEventString\"");
+        }
+    }
+
+    override fun getConstants(): MutableMap<String, Any> {
+        return mutableMapOf(
+            "EVENT_TYPE_PAGE" to TagWorks.EVENT_TYPE_PAGE,
+            "EVENT_TYPE_USER_EVENT" to TagWorks.EVENT_TYPE_USER_EVENT,
+        )
+    }
+
+    companion object {
+        const val TAG = "TagWorksModule"
+    }
+}

package/android/src/main/java/com/tagworkssdkv1/TagworksSdkV1Module.kt

@@ -0,0 +1,25 @@
+package com.tagworkssdkv1
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+
+class TagworksSdkV1Module(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  @ReactMethod
+  fun multiply(a: Double, b: Double, promise: Promise) {
+    promise.resolve(a * b)
+  }
+
+  companion object {
+    const val NAME = "TagworksSdkV1"
+  }
+}

package/android/src/main/java/com/tagworkssdkv1/TagworksSdkV1Package.kt

@@ -0,0 +1,18 @@
+package com.tagworkssdkv1
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class TagworksSdkV1Package : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+  //  return listOf(TagworksSdkV1Module(reactContext))
+  return listOf(DataBundleModule(reactContext), TagWorksModule(reactContext), StandardEventModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/ios/DataBundleModule.swift

@@ -0,0 +1,271 @@
+//
+//  DataBundleModule.swift
+//  TagWorks_SDK_React
+//
+//  Created by obzen on 11/29/24.
+//
+
+import Foundation
+import React
+import TagWorks_SDK_iOS
+
+@objc(DataBundleModule)
+class DataBundleModule: NSObject, RCTBridgeModule {
+    
+    var dataDictionary: [String: String] = [:]
+    var eventDimensions: [TagWorks_SDK_iOS.Dimension] = []
+    
+    static func moduleName() -> String {
+        return "DataBundleModule"
+    }
+    
+    // 네이티브 모듈에서 사용할 상수값을 반환하는 함수
+    @objc static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    @objc func getConstants() -> [AnyHashable: Any]! {
+        // 상수값을 반환합니다. JavaScript로 전달됩니다.
+        return [
+            "EVENT_TAG_NAME": "OBZEN_EVENT_NAME",
+            "EVENT_TAG_PARAM_PAGE_PATH": "EVENT_TAG_PARAM_PAGE_PATH",
+            "EVENT_TAG_PARAM_TITLE": "EVENT_TAG_PARAM_TITLE",
+            "EVENT_TAG_PARAM_KEYWORD": "EVENT_TAG_PARAM_KEYWORD",
+            "EVENT_TAG_PARAM_CUSTOM_PATH": "EVENT_TAG_PARAM_CUSTOM_PATH",
+            "EVENT_TAG_PARAM_ERROR_MSG": "EVENT_TAG_PARAM_ERROR_MSG",
+        ]
+    }
+    
+    @objc func initialize() {
+        if !dataDictionary.isEmpty {
+            dataDictionary.removeAll()
+        }
+        if !eventDimensions.isEmpty {
+            eventDimensions.removeAll()
+        }
+    }
+    
+    @objc func initDataBundle(_ jsonString: String) {
+        initialize()
+        
+        // JSON 문자열을 Data로 변환
+        if let data = jsonString.data(using: .utf8) {
+            do {
+                // Data를 Dictionary로 변환
+                if let bundleDictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
+                    var dataDictionary: [String: Any] = [:]
+                    var eventDemensionsArray: [[String: Any]] = []
+                    var genericDimensions: [String: String] = [:]
+                    var factDimensions: [String: Any] = [:]
+                    
+                    // 기존 번들 내용을 복사
+                    if bundleDictionary["dataDictionary"] != nil {
+                        dataDictionary = bundleDictionary["dataDictionary"] as! [String: String]
+                        
+                        for (key, value) in dataDictionary {
+                            self.dataDictionary[key] = value as? String
+                        }
+                    }
+                    if bundleDictionary["eventDimensions"] != nil {
+                        eventDemensionsArray = bundleDictionary["eventDimensions"] as! [[String: Any]]
+                        
+                        for dimension in eventDemensionsArray {
+                            if dimension["General"] != nil {
+                                genericDimensions = dimension["General"] as! [String: String]
+                                
+                                for (key, value) in genericDimensions {
+                                    self.eventDimensions.append(TagWorks_SDK_iOS.Dimension(index: Int(key)!, stringValue: value))
+                                }
+                            }
+                            if dimension["Fact"] != nil {
+                                factDimensions = dimension["Fact"] as! [String: Any]
+                                
+                                for (key, value) in factDimensions {
+                                    self.eventDimensions.append(TagWorks_SDK_iOS.Dimension(index: Int(key)!, numValue: Double(value as! String) ?? 0.0))
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch {
+                print("JSON 변환 오류: \(error)")
+            }
+        }
+    }
+    
+    @objc func getDataBundle(_ callback: @escaping RCTResponseSenderBlock) {
+        // DataBundle을 Dictionary 형태로 변환
+        var result: [String: Any] = [:]
+        result["dataDictionary"] = self.dataDictionary
+        
+        var generalDimensions: [String: String] = [:]
+        var factDimensions: [String: Any] = [:]
+        for dimension in self.eventDimensions {
+            if dimension.type == Dimension.generalType {
+                generalDimensions[String(dimension.index)] = dimension.value
+            } else if dimension.type == Dimension.factType {
+                factDimensions[String(dimension.index)] = String(dimension.numValue)
+            }
+        }
+        let gDimension = ["General": generalDimensions]
+        let fDimension = ["Fact": factDimensions]
+        result["eventDimensions"] = [gDimension, fDimension]
+        
+        do {
+            // Dictionary Array를 JSON으로 변환
+            let jsonData = try JSONSerialization.data(withJSONObject: result, options: .prettyPrinted)
+            
+            // JSON 데이터를 문자열로 변환하여 반환
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                callback([jsonString])  // JSON 문자열을 JavaScript로 전달
+            }
+        } catch {
+            print("JSON 변환 오류: \(error)")
+            callback([NSNull()])
+        }
+    }
+    
+    ///
+    /// 파라미터 추가
+    /// 이벤트에 필요한 파라미터 항목들을, Key, Value의 String 형태로 Dictionary에 추가
+    ///
+    @objc func putString(_ key: String, value: String) {
+        dataDictionary[key] = value
+    }
+    
+    ///
+    /// 이벤트에 필요한 Dimension 항목을 Array에 추가
+    /// 단, 추가하기 전 중복 항목 체크..
+    ///
+    @objc func putDimensionWithString(_ index: Int, value: String) {
+        removeDimensionInGeneralType(index)
+        eventDimensions.append(Dimension(index: index, stringValue: value))
+    }
+    
+    @objc func putDimensionWithDouble(_ index: Int, value: Double) {
+        removeDimensionInFactType(index)
+        eventDimensions.append(Dimension(index: index, numValue: value))
+    }
+    
+    /// General 과 Fact 별로 저장되어 있는 인덱스와 값들을 리턴i
+    @objc func getDimensions(_ callback: @escaping RCTResponseSenderBlock) {
+        var dictDimensions: [String: Any] = [:]
+        var generalDimensions: [String: String] = [:]
+        var factDimensions: [String: Any] = [:]
+        
+        for dimension in self.eventDimensions {
+            if dimension.type == Dimension.generalType {
+                generalDimensions[String(dimension.index)] = dimension.value
+            } else if dimension.type == Dimension.factType {
+                factDimensions[String(dimension.index)] = String(dimension.numValue)
+            }
+        }
+        let gDimension = ["General": generalDimensions]
+        let fDimension = ["Fact": factDimensions]
+        dictDimensions["Dimensions"] = [gDimension, fDimension]
+        
+        do {
+            // Dictionary Array를 JSON으로 변환
+            let jsonData = try JSONSerialization.data(withJSONObject: dictDimensions, options: .prettyPrinted)
+            
+            // JSON 데이터를 문자열로 변환하여 반환
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                callback([jsonString])  // JSON 문자열을 JavaScript로 전달
+            }
+        } catch {
+            print("JSON 변환 오류: \(error)")
+            callback([NSNull()])
+        }
+    }
+    
+    /// ArrayIndex에 맞춰서 리턴
+    @objc func getDimensionsOfArrayIndex(_ callback: @escaping RCTResponseSenderBlock) {
+        var dimensionsArray: [[String:String]] = []
+        
+        for dimension in self.eventDimensions {
+            if dimension.type == Dimension.generalType {
+                var dim: [String: String] = [:]
+                dim["General_\(dimension.index)"] = dimension.value
+                dimensionsArray.append(dim)
+            } else if dimension.type == Dimension.factType {
+                var dim: [String: String] = [:]
+                dim["Fact_\(dimension.index)"] = String(dimension.numValue)
+                dimensionsArray.append(dim)
+            }
+        }
+
+        do {
+            // Dictionary Array를 JSON으로 변환
+            let jsonData = try JSONSerialization.data(withJSONObject: dimensionsArray, options: .prettyPrinted)
+            
+            // JSON 데이터를 문자열로 변환하여 반환
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                callback([jsonString])  // JSON 문자열을 JavaScript로 전달
+            }
+        } catch {
+            print("JSON 변환 오류: \(error)")
+            callback([NSNull()])
+        }
+    }
+    
+    @objc func getDimensionWithString(_ index: Int, callback: @escaping RCTResponseSenderBlock) {
+        let dimension: TagWorks_SDK_iOS.Dimension? = self.eventDimensions.filter {$0.index == index && $0.type == Dimension.generalType}.first
+        if let dimension {
+            callback([dimension.value])
+        } else {
+            callback([])
+        }
+    }
+    
+    @objc func getDimensionWithDouble(_ index: Int, callback: @escaping RCTResponseSenderBlock) {
+        let dimension: TagWorks_SDK_iOS.Dimension? = self.eventDimensions.filter {$0.index == index && $0.type == Dimension.factType}.first
+        if let dimension {
+            callback([String(dimension.numValue)])
+        } else {
+            callback([])
+        }
+    }
+    
+    @objc func removeDimensionInGeneralType(_ index: Int) {
+        eventDimensions.removeAll(where: {$0.index == index && $0.type == Dimension.generalType})
+    }
+    
+    @objc func removeDimensionInFactType(_ index: Int) {
+        eventDimensions.removeAll(where: {$0.index == index && $0.type == Dimension.factType})
+    }
+    
+    @objc func removeDimensionWithArrayIndex(_ index: Int) {
+        eventDimensions.remove(at: index)
+    }
+    
+    @objc func removeAllDimension() {
+        eventDimensions.removeAll()
+    }
+    
+    
+    /// 이벤트에 필요한 파라미터 항목들이 비어 있는지 체크
+    @objc public func isParameterEmpty() -> Bool {
+        if dataDictionary.isEmpty {
+            return true
+        }
+        return false
+    }
+    
+    /// 이벤트에 필요한 Dimension 항목들이 비어 있는지 체크
+    @objc public func isDimensionEmpty() -> Bool {
+        if eventDimensions.isEmpty {
+            return true
+        }
+        return false
+    }
+    
+    /// 이벤트에 필요한 파라미터 항목들의 갯수를 리턴
+    @objc public func parameterCount() -> Int {
+        return dataDictionary.count
+    }
+    
+    /// 이벤트에 필요한 Dimension 항목들의 갯수를 리턴
+    @objc public func dimensionCount() -> Int {
+        return eventDimensions.count
+    }
+}

package/ios/DataBundleModuleBridge.m

@@ -0,0 +1,29 @@
+//
+//  DataBundleModuleBridge.m
+//  TagWorks_SDK_React
+//
+//  Created by obzen on 11/29/24.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(DataBundleModule, NSObject)
+
+RCT_EXTERN_METHOD(initialize)
+RCT_EXTERN_METHOD(initDataBundle:(NSString *) jsonString)
+RCT_EXTERN_METHOD(getDataBundle:(RCTResponseSenderBlock) callback)
+
+RCT_EXTERN_METHOD(putString:(NSString *)key value:(NSString *)value)
+RCT_EXTERN_METHOD(putDimensionWithString:(int)index value:(NSString *)value)
+RCT_EXTERN_METHOD(putDimensionWithDouble:(int)index value:(double)value)
+RCT_EXTERN_METHOD(getDimensions:(RCTResponseSenderBlock) callback)
+RCT_EXTERN_METHOD(getDimensionsOfArrayIndex:(RCTResponseSenderBlock) callback)
+RCT_EXTERN_METHOD(getDimensionWithString:(int)index callback:(RCTResponseSenderBlock) callback)
+RCT_EXTERN_METHOD(getDimensionWithDouble:(int)index callback:(RCTResponseSenderBlock) callback)
+RCT_EXTERN_METHOD(removeDimensionInGeneralType:(int)index)
+RCT_EXTERN_METHOD(removeDimensionInFactType:(int)index)
+RCT_EXTERN_METHOD(removeDimensionWithArrayIndex:(int)index)
+RCT_EXTERN_METHOD(removeAllDimension)
+
+@end