@sumsub/cordova-idensic-mobile-sdk-plugin 1.18.1

package/src/android/src/main/java/com/sumsub/msdk/plugins/cordova/SNSMobileSdkCordovaPlugin.java

@@ -0,0 +1,339 @@
+package com.sumsub.msdk.plugins.cordova;
+
+import android.content.Intent;
+import android.text.TextUtils;
+import android.util.Log;
+import android.webkit.ValueCallback;
+
+import com.google.gson.Gson;
+import com.sumsub.sns.R;
+import com.sumsub.sns.core.SNSActionResult;
+import com.sumsub.sns.core.SNSMobileSDK;
+import com.sumsub.sns.core.data.listener.SNSActionResultHandler;
+import com.sumsub.sns.core.data.listener.SNSCompleteHandler;
+import com.sumsub.sns.core.data.listener.SNSErrorHandler;
+import com.sumsub.sns.core.data.listener.SNSEvent;
+import com.sumsub.sns.core.data.listener.SNSEventHandler;
+import com.sumsub.sns.core.data.listener.SNSStateChangedHandler;
+import com.sumsub.sns.core.data.listener.TokenExpirationHandler;
+import com.sumsub.sns.core.data.model.SNSCompletionResult;
+import com.sumsub.sns.core.data.model.SNSException;
+import com.sumsub.sns.core.data.model.SNSSDKState;
+import com.sumsub.sns.core.data.model.SNSSupportItem;
+import com.sumsub.sns.prooface.SNSProoface;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import androidx.annotation.Nullable;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import timber.log.Timber;
+
+public class SNSMobileSdkCordovaPlugin extends CordovaPlugin {
+    private static final String LAUNCH_ACTION = "launchSNSMobileSDK";
+    private static final String NEW_TOKEN_ACTION = "setNewAccessToken";
+    private static final String ACTION_COMPLETED_ACTION = "onActionResultCompleted";
+    private static final String DISMISS_ACTION = "dismiss";
+
+    private static volatile String newAccessToken = null;
+    private static SNSMobileSDK.SDK snsSdk;
+    private volatile static SNSActionResult actionResultHandlerComplete;
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+        Timber.d("execute: " + action + " args: " + args);
+        if (action.equals(LAUNCH_ACTION)) {
+            if (args.isNull(0)) {
+                callbackContext.error("Error: SDK Config object must be provided");
+                return false;
+            }
+
+            JSONObject conf = args.getJSONObject(0);
+            String apiUrl = conf.optString("apiUrl");
+            String flowName = conf.optString("flowName");
+            String accessToken = conf.optString("accessToken");
+            String supportEmail = conf.optString("supportEmail");
+            String locale = conf.optString("locale");
+            boolean isDebug = conf.optBoolean("debug", false);
+            JSONObject hasHandlers = conf.getJSONObject("hasHandlers");
+
+            if (TextUtils.isEmpty(supportEmail)) {
+                supportEmail = "support@sumsub.com";
+            }
+
+            if (TextUtils.isEmpty(accessToken)) {
+                callbackContext.error("Error: Access token must be provided");
+                return false;
+            }
+            if (TextUtils.isEmpty(locale)) {
+                locale = Locale.getDefault().getLanguage();
+            }
+            this.launchSNSMobileSDK(apiUrl, flowName, accessToken, supportEmail, locale, isDebug, hasHandlers, callbackContext);
+            return true;
+        } else if (action.equals(NEW_TOKEN_ACTION)) {
+            newAccessToken = args.getString(0);
+            return true;
+        } else if (action.equals(DISMISS_ACTION)) {
+            cordova.getActivity().runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    snsSdk.dismiss();
+                }
+            });
+            return true;
+        } else if (ACTION_COMPLETED_ACTION.equalsIgnoreCase(action)) {
+            String result = args.getJSONObject(0).getString("result");
+            actionResultHandlerComplete = "cancel".equalsIgnoreCase(result) ? SNSActionResult.Cancel : SNSActionResult.Continue;
+            return true;
+        } else {
+            callbackContext.error("Method not implemented");
+            return false;
+        }
+    }
+
+    private void requestNewAccessToken() {
+        cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                webView.getEngine().evaluateJavascript("window.SNSMobileSDK.getNewAccessToken()", new ValueCallback<String>() {
+                    @Override
+                    public void onReceiveValue(String s) {
+                        // no op
+                    }
+                });
+            }
+        });
+    }
+
+    private void requestActionResult(String actionId, String answer, String actionType, Boolean allowContinuing) {
+        cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+
+                final String func = "window.SNSMobileSDK.sendEvent('onActionResult', { actionId: '" + actionId + "', answer: '" + answer + "', actionType: '" + actionType + ", allowContinuing: '" + allowContinuing + "})";
+
+                webView.getEngine().evaluateJavascript(func, new ValueCallback<String>() {
+                    @Override
+                    public void onReceiveValue(String s) {
+                        // no op
+                    }
+                });
+            }
+        });
+    }
+
+    private void launchSNSMobileSDK(final String apiUrl, final String flowName, final String accessToken, String supportEmail, final String locale, final boolean isDebug, final JSONObject hasHandlers, CallbackContext callbackContext) {
+        final SNSSupportItem supportItem = new SNSSupportItem(
+                R.string.sns_support_EMAIL_title,
+                R.string.sns_support_EMAIL_description,
+                R.drawable.sns_ic_email,
+                SNSSupportItem.Type.Email,
+                supportEmail, null);
+
+
+        cordova.getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+
+                try {
+
+                    final SNSActionResultHandler actionResultHandler = hasHandlers.optBoolean("onActionResult") ?
+                            (actionId, actionType, answer, allowContinuing) -> {
+                                Timber.d("Calling onActionResult(" + actionId + ", " + answer + ")");
+                                actionResultHandlerComplete = null;
+                                requestActionResult(actionId, answer, actionType, allowContinuing);
+                                int cnt = 0;
+                                while (actionResultHandlerComplete == null) {
+                                    try {
+                                        Thread.sleep(100);
+                                    } catch (InterruptedException e) {
+                                        //no op
+                                    }
+                                    if (++cnt > 100) {
+                                        return SNSActionResult.Continue;
+                                    }
+                                }
+                                Timber.d("SumSub: Received: " + actionResultHandlerComplete + ' ' + Thread.currentThread().getName());
+                                return actionResultHandlerComplete;
+                            } : null;
+
+                    final SNSErrorHandler errorHandler = e -> Timber.d(Log.getStackTraceString(e));
+
+                    final SNSStateChangedHandler stateChangedHandler = (oldState, newState) -> {
+                        final String newStatus = newState.getClass().getSimpleName();
+                        final String prevStatus = oldState.getClass().getSimpleName();
+                        final String func = "window.SNSMobileSDK.sendEvent('onStatusChanged', { newStatus: '" + newStatus + "', prevStatus: '" + prevStatus + "' })";
+                        cordova.getActivity().runOnUiThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                webView.getEngine().evaluateJavascript(func, new ValueCallback<String>() {
+                                    @Override
+                                    public void onReceiveValue(String s) {
+                                        // no op
+                                    }
+                                });
+                            }
+                        });
+                    };
+
+                    final SNSCompleteHandler completeHandler = (snsCompletionResult, snssdkState) -> getResultToTheClient(snsCompletionResult, snssdkState, callbackContext);
+
+                    final SNSEventHandler eventHandler = snsEvent -> {
+                        Map<String, Object> params = new HashMap<>();
+                        final Map<String, Object> payload = snsEvent.getPayload();
+                        for (String key: payload.keySet()) {
+                            if (key.equals("isCanceled") || key.equals("isCancelled")) {
+                                params.put("isCancelled", (Boolean) payload.get(key));
+                            } else {
+                                params.put(key, payload.get(key).toString());
+                            }
+                        }
+                        final String func = "window.SNSMobileSDK.sendEvent('onEvent', { 'eventType': '" + upperCaseFirstLetter(snsEvent.getEventType()) + "', 'payload': " + mapToString(params) + " })";
+                        cordova.getActivity().runOnUiThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                webView.getEngine().evaluateJavascript(func, new ValueCallback<String>() {
+                                    @Override
+                                    public void onReceiveValue(String s) {
+                                        // no op
+                                    }
+                                });
+                            }
+                        });
+                    };
+
+                    SNSMobileSDK.Builder snsSdkBuilder;
+                    if (flowName.isEmpty()) {
+                        snsSdkBuilder = new SNSMobileSDK.Builder(cordova.getActivity());
+                    } else {
+                        snsSdkBuilder = new SNSMobileSDK.Builder(cordova.getActivity(), null, flowName);
+                    }
+
+                    if (!apiUrl.isEmpty()) {
+                        snsSdkBuilder.withBaseUrl(apiUrl);
+                    }
+
+                    snsSdk = snsSdkBuilder
+                            .withAccessToken(accessToken, () -> {
+                                Timber.d("SumSub: calling onTokenExpired!");
+                                newAccessToken = null;
+                                requestNewAccessToken();
+                                int cnt = 0;
+                                while (newAccessToken == null) {
+                                    try {
+                                        Thread.sleep(100);
+                                    } catch (InterruptedException e) {
+                                        //no op
+                                    }
+                                    if (++cnt > 100) {
+                                        return null;
+                                    }
+                                }
+                                Timber.d("SumSub: Received new token: " + newAccessToken + ' ' + Thread.currentThread().getName());
+                                return newAccessToken;
+                            })
+                            .withDebug(isDebug)
+                            .withModules(Arrays.asList(new SNSProoface()))
+                            .withErrorHandler(errorHandler)
+                            .withStateChangedHandler(stateChangedHandler)
+                            .withCompleteHandler(completeHandler)
+                            .withActionResultHandler(actionResultHandler)
+                            .withEventHandler(eventHandler)
+                            .withSupportItems(Collections.singletonList(supportItem))
+                            .withLocale(new Locale(locale))
+                            .build();
+                    snsSdk.launch();
+                } catch (Exception e) {
+                    Timber.e(e);
+                }
+
+            }
+        });
+
+        cordova.setActivityResultCallback(this);
+    }
+
+    private String upperCaseFirstLetter(String s) {
+        return s.substring(0, 1).toUpperCase() + s.substring(1);
+    }
+
+    private void getResultToTheClient(SNSCompletionResult snsCompletionResult, SNSSDKState snssdkState, CallbackContext callbackContext) {
+        if (snsCompletionResult instanceof SNSCompletionResult.SuccessTermination) {
+            callbackContext.success(getResult(true, snssdkState, null, null));
+        } else if (snsCompletionResult instanceof SNSCompletionResult.AbnormalTermination) {
+            SNSCompletionResult.AbnormalTermination abnormalTermination = (SNSCompletionResult.AbnormalTermination) snsCompletionResult;
+            String message = abnormalTermination.getException() != null ? abnormalTermination.getException().getMessage() : null;
+            if (snssdkState instanceof SNSSDKState.Failed) {
+                callbackContext.success(getResult(false, snssdkState, message, snssdkState.getClass().getSimpleName()));
+            } else {
+                callbackContext.success(getResult(false, new SNSSDKState.Failed.Unknown(new Exception()), message, "Unknown"));
+            }
+        } else {
+            callbackContext.error("Unknown completion result: " + snsCompletionResult.getClass().getName());
+        }
+    }
+
+    private JSONObject getResult(boolean success, SNSSDKState state, String errorMsg, String errorType) {
+        final JSONObject result = new JSONObject();
+        try {
+            result.put("success", success);
+            result.put("status", state != null ? getSDKStateName(state) : "Unknown");
+            result.put("errorType", errorType);
+            result.put("errorMsg", errorMsg);
+            if (state instanceof SNSSDKState.ActionCompleted) {
+                final SNSSDKState.ActionCompleted action = (SNSSDKState.ActionCompleted) state;
+                final JSONObject actionResult = new JSONObject();
+                actionResult.put("actionId", action.getActionId());
+                actionResult.put("answer", action.getAnswer() != null ? action.getAnswer().getValue() : null);
+                result.put("actionResult", actionResult);
+            }
+        } catch (JSONException e) {
+            throw new RuntimeException(e);
+        }
+        return result;
+    }
+
+    private String getSDKStateName(SNSSDKState state) {
+        if (state instanceof SNSSDKState.Failed) {
+            return "Failed";
+        } else {
+            return state.getClass().getSimpleName();
+        }
+    }
+
+    private String mapToString(Map<String, Object> values) {
+        StringBuilder sb = new StringBuilder();
+        sb.append('{');
+        for (String key: values.keySet()) {
+            Object value = values.get(key);
+            sb.append("'");
+            sb.append(key);
+            sb.append("':  ");
+            if (value instanceof String) sb.append("'");
+            sb.append(value);
+            if (value instanceof String) sb.append("'");
+            sb.append(",");
+        }
+        sb.setLength(sb.length() - 1); // strip last comma
+        sb.append('}');
+        return sb.toString();
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+    }
+
+}

package/src/ios/SNSMobileSdkCordovaPlugin.h

@@ -0,0 +1,12 @@
+#import <Cordova/CDV.h>
+
+@interface SNSMobileSdkCordovaPlugin : CDVPlugin
+
+- (void)launchSNSMobileSDK:(CDVInvokedUrlCommand*)command;
+- (void)setNewAccessToken:(CDVInvokedUrlCommand*)command;
+- (void)onActionResultCompleted:(CDVInvokedUrlCommand*)command;
+- (void)dismiss:(CDVInvokedUrlCommand*)command;
+
+
+
+@end

package/src/ios/SNSMobileSdkCordovaPlugin.m

@@ -0,0 +1,263 @@
+#import "SNSMobileSdkCordovaPlugin.h"
+#import <Cordova/CDV.h>
+#import <IdensicMobileSDK/IdensicMobileSDK.h>
+
+@interface SNSMobileSdkCordovaPlugin ()
+@property (nonatomic, copy) void(^tokenExpirationOnComplete)(NSString * _Nullable newAccessToken);
+@property (nonatomic, copy) void(^actionResultHandlerOnComplete)(SNSActionResultHandlerReaction);
+@property (nonatomic, weak) SNSMobileSDK *sdk;
+@end
+
+@implementation SNSMobileSdkCordovaPlugin
+
+- (void)launchSNSMobileSDK:(CDVInvokedUrlCommand *)command {
+    
+    NSDictionary *params = command.arguments.firstObject;
+    
+    if (![params isKindOfClass:NSDictionary.class]) {
+        return [self complete:command withInvalidParameters:@"No params detected"];
+    }
+    
+    NSString *apiUrl = params[@"apiUrl"];
+    NSString *flowName = params[@"flowName"];
+    NSString *accessToken = params[@"accessToken"];
+    NSString *locale = params[@"locale"];
+    
+    SNSMobileSDK *sdk;
+    
+    if (!flowName || flowName.length <= 0) {
+        
+        SNSEnvironment environment = (apiUrl && apiUrl.length > 0) ? apiUrl : SNSEnvironmentProduction;
+    
+        sdk = [SNSMobileSDK setupWithAccessToken:accessToken
+                                     environment:environment];
+        sdk.locale = locale;
+
+    } else {
+    
+        sdk = [SNSMobileSDK setupWithBaseUrl:apiUrl
+                                    flowName:flowName
+                                 accessToken:accessToken
+                                      locale:locale
+                                supportEmail:params[@"supportEmail"]];
+    }
+    
+    if (!sdk.isReady) {
+        [self complete:command withSDK:sdk];
+        return;
+    }
+    
+    self.sdk = sdk;
+
+    if ([params[@"debug"] boolValue]) {
+        sdk.logLevel = SNSLogLevel_Debug;
+    }
+    
+    __weak SNSMobileSdkCordovaPlugin *weakSelf = self;
+    
+    [sdk tokenExpirationHandler:^(void (^ _Nonnull onComplete)(NSString * _Nullable)) {
+        
+        weakSelf.tokenExpirationOnComplete = onComplete;
+        
+        [weakSelf.commandDelegate evalJs:@"SNSMobileSDK.getNewAccessToken();" scheduledOnRunLoop:NO];
+    }];
+
+    [sdk onDidDismiss:^(SNSMobileSDK * _Nonnull sdk) {
+        
+        [weakSelf complete:command withSDK:sdk];
+    }];
+    
+    if (params[@"hasHandlers"][@"onStatusChanged"]) {
+
+        [sdk setOnStatusDidChange:^(SNSMobileSDK * _Nonnull sdk, SNSMobileSDKStatus prevStatus) {
+            
+            [weakSelf sendEventWithName:@"onStatusChanged" body:@{
+                @"newStatus": [sdk descriptionForStatus:sdk.status] ?: @"",
+                @"prevStatus": [sdk descriptionForStatus:prevStatus] ?: @"",
+            }];
+        }];
+    }
+    
+    if (params[@"hasHandlers"][@"onEvent"]) {
+        
+        [sdk onEvent:^(SNSMobileSDK * _Nonnull sdk, SNSEvent * _Nonnull event) {
+
+            [weakSelf sendEventWithName:@"onEvent" body:@{
+                @"eventType": [event descriptionForEventType:event.eventType] ?: @"",
+                @"payload": event.payload ?: @{},
+            }];
+        }];
+    }
+
+    if (params[@"hasHandlers"][@"onActionResult"]) {
+
+        [sdk actionResultHandler:^(SNSMobileSDK * _Nonnull sdk, SNSActionResult * _Nonnull result, void (^ _Nonnull onComplete)(SNSActionResultHandlerReaction)) {
+            
+            weakSelf.actionResultHandlerOnComplete = onComplete;
+
+            [weakSelf sendEventWithName:@"onActionResult" body:@{
+                @"actionId": result.actionId ?: @"",
+                @"actionType": result.actionType ?: @"",
+                @"answer": result.answer ?: @"",
+                @"allowContinuing": @(result.allowContinuing),
+            }];
+        }];
+    }
+
+    [self applyCustomizationIfAny];
+
+    [sdk presentFrom:self.viewController];
+}
+
+- (void)setNewAccessToken:(CDVInvokedUrlCommand*)command {
+    
+    NSString *newAccessToken = command.arguments.firstObject;
+    
+//    NSLog(@"got new token: %@", newAccessToken);
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (self.tokenExpirationOnComplete) {
+            self.tokenExpirationOnComplete(newAccessToken);
+            self.tokenExpirationOnComplete = nil;
+        }
+    });
+}
+
+- (void)onActionResultCompleted:(CDVInvokedUrlCommand*)command {
+
+    NSDictionary *params = command.arguments.firstObject;
+
+    SNSActionResultHandlerReaction reaction = SNSActionResultHandlerReaction_Continue;
+    if ([params[@"result"] isEqualToString:@"cancel"]) {
+        reaction = SNSActionResultHandlerReaction_Cancel;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (self.actionResultHandlerOnComplete) {
+            self.actionResultHandlerOnComplete(reaction);
+            self.actionResultHandlerOnComplete = nil;
+        }
+    });
+}
+
+- (void)dismiss:(CDVInvokedUrlCommand*)command {
+
+    [self.sdk dismiss];
+}
+
+#pragma mark - Customization
+
+/**
+ * Usage:
+ *
+ * Add a class named `IdensicMobileSDKCustomization` into the main project
+ * and define a static method named `apply:` that will take an instance of `SNSMobileSDK`
+ *
+ * For example, in Swift:
+ *
+ * import IdensicMobileSDK
+ *
+ * class IdensicMobileSDKCustomization: NSObject {
+ *
+ *   @objc static func apply(_ sdk: SNSMobileSDK) {
+ *   }
+ * }
+ *
+ */
+- (void)applyCustomizationIfAny {
+    
+    NSString *className = @"IdensicMobileSDKCustomization";
+    
+    Class customization = [NSBundle.mainBundle classNamed:className];
+    if (!customization) {
+        NSString *classPrefix = [NSBundle.mainBundle objectForInfoDictionaryKey:(__bridge NSString *)kCFBundleExecutableKey];
+        if (classPrefix) {
+            customization = [NSBundle.mainBundle classNamed:[NSString stringWithFormat:@"%@.%@", classPrefix, className]];
+        }
+    }
+    
+    if (customization && [customization respondsToSelector:@selector(apply:)]) {
+        [customization performSelector:@selector(apply:) withObject:self.sdk];
+    }
+}
+
+#pragma mark - Helpers
+
+- (NSString *)stringFromJSON:(NSDictionary *)dict {
+    
+    NSError *error;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:dict
+                                                       options:0
+                                                         error:&error];
+    
+    if (!jsonData) {
+        return @"{}";
+    } else {
+        return [NSString.alloc initWithData:jsonData encoding:NSUTF8StringEncoding];
+    }
+}
+
+- (void)sendEventWithName:(NSString *)name body:(NSDictionary *)body {
+
+    NSString *jsonString = body ? [self stringFromJSON:body] : @"{}"; 
+
+    NSString *command = [NSString stringWithFormat:@"SNSMobileSDK.sendEvent('%@', %@);", name, jsonString];
+
+    if (NSThread.isMainThread) {
+        [self.commandDelegate evalJs:command scheduledOnRunLoop:NO];
+    } else{
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self.commandDelegate evalJs:command scheduledOnRunLoop:NO];
+        });
+    }
+}
+
+- (void)complete:(CDVInvokedUrlCommand *)command withSDK:(SNSMobileSDK *)sdk {
+
+    NSMutableDictionary *result = NSMutableDictionary.new;
+    
+    result[@"success"] = @(sdk.status != SNSMobileSDKStatus_Failed);
+    result[@"status"] = [sdk descriptionForStatus:sdk.status];
+    
+    if (sdk.status == SNSMobileSDKStatus_Failed) {
+        result[@"errorType"] = [sdk descriptionForFailReason:sdk.failReason];
+        result[@"errorMsg"] = sdk.verboseStatus;
+    }
+    
+    if (sdk.status == SNSMobileSDKStatus_ActionCompleted && sdk.actionResult) {
+        NSMutableDictionary *actionResult = NSMutableDictionary.new;
+        
+        actionResult[@"actionId"] = sdk.actionResult.actionId;
+        actionResult[@"actionType"] = sdk.actionResult.actionType;
+        actionResult[@"answer"] = sdk.actionResult.answer;
+        actionResult[@"allowContinuing"] = @(sdk.actionResult.allowContinuing);
+
+        result[@"actionResult"] = actionResult.copy;
+    }
+
+    [self complete:command withResult:result.copy];
+}
+
+- (void)complete:(CDVInvokedUrlCommand *)command withInvalidParameters:(NSString *)message {
+
+    NSDictionary *result = @{
+        @"success": @NO,
+        @"status": @"Failed",
+        @"errorType": @"InvalidParameters",
+        @"errorMsg": message ?: @"",
+    };
+    
+    [self complete:command withResult:result];
+}
+
+- (void)complete:(CDVInvokedUrlCommand *)command withResult:(NSDictionary *)result {
+    
+    CDVCommandStatus commandStatus = CDVCommandStatus_OK; //[result[@"success"] boolValue] ? CDVCommandStatus_OK : CDVCommandStatus_ERROR;
+    
+    CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:commandStatus
+                                                  messageAsDictionary:result];
+    
+    [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+}
+
+@end

package/webpack.config.js

@@ -0,0 +1,42 @@
+//const webpack = require('webpack');
+const path = require('path');
+
+const MAIN_FILE = './www/SNSMobileSDK.js';
+const BUILD_PATH = '/dist/';
+const FILE_NAME = 'SNSMobileSDK';
+const LIBRARY_NAME = 'SNSMobileSDK';
+
+module.exports = {
+	entry: {
+		wrapper: MAIN_FILE,
+	},
+	output: {
+		path: path.join(__dirname, BUILD_PATH),
+		filename: `${FILE_NAME}.js`,
+		publicPath: '/',
+		libraryTarget: 'umd',
+		library: LIBRARY_NAME,
+	},
+	externals: {
+		'cordova/exec': 'cordova/exec',
+	},
+	// production
+	/*
+    plugins: [
+        new webpack.DefinePlugin({
+            'process.env': {
+                'NODE_ENV': JSON.stringify('production')
+            }
+        })
+    ],
+    */
+	module: {
+		rules: [
+			{
+				test: /\.(js)$/,
+				exclude: /node_modules/,
+				use: ['babel-loader', 'eslint-loader'],
+			},
+		],
+	},
+};