iglooform 2.5.54 → 2.5.56

package/.dumi/tmp/plugin-antd/runtime.tsx

@@ -0,0 +1,65 @@
+// @ts-nocheck
+// This file is generated by Umi automatically
+// DO NOT CHANGE IT MANUALLY!
+import React from 'react';
+import {
+  Modal,
+  ConfigProvider,
+  message,
+  notification,
+} from 'antd';
+import { ApplyPluginsType } from 'umi';
+import { getPluginManager } from '../core/plugin';
+
+let cacheAntdConfig = null;
+
+const getAntdConfig = () => {
+  if(!cacheAntdConfig){
+    cacheAntdConfig = getPluginManager().applyPlugins({
+      key: 'antd',
+      type: ApplyPluginsType.modify,
+      initialValue: {
+        ...{"theme":{"token":{"colorPrimary":"#5858FF","colorError":"#F52209","colorSuccess":"#108043","colorInfo":"#1E90FF","colorWarning":"#CF8909","controlHeight":48,"controlHeightSM":24,"controlOutlineWidth":0,"borderRadius":3,"fontSize":16,"lineHeight":1.2857,"fontFamily":"Roboto"},"components":{"Radio":{"radioSize":22,"dotSize":8,"buttonCheckedBgDisabled":"rgba(0, 0, 0, 0.04)"},"Pagination":{"itemSizeSM":40},"DatePicker":{"pickerPanelCellWidth":36}}}},
+      },
+    });
+  }
+  return cacheAntdConfig;
+}
+
+export function rootContainer(rawContainer) {
+  const {
+    appConfig,
+    ...finalConfigProvider
+  } = getAntdConfig();
+  let container = rawContainer;
+  if (finalConfigProvider.prefixCls) {
+    Modal.config({
+      rootPrefixCls: finalConfigProvider.prefixCls
+    });
+    message.config({
+      prefixCls: `${finalConfigProvider.prefixCls}-message`
+    });
+    notification.config({
+      prefixCls: `${finalConfigProvider.prefixCls}-notification`
+    });
+  }
+
+  if (finalConfigProvider.iconPrefixCls) {
+    // Icons in message need to set iconPrefixCls via ConfigProvider.config()
+    ConfigProvider.config({
+      iconPrefixCls: finalConfigProvider.iconPrefixCls,
+    });
+  };
+
+  if (finalConfigProvider.theme) {
+    // Pass config theme to static method
+    ConfigProvider.config({
+      theme: finalConfigProvider.theme,
+    });
+  }
+
+  container = <ConfigProvider {...finalConfigProvider}>{container}</ConfigProvider>;
+
+
+  return container;
+}

package/.dumi/tmp/plugin-antd/runtimeConfig.d.ts

@@ -0,0 +1,6 @@
+// This file is generated by Umi automatically
+// DO NOT CHANGE IT MANUALLY!
+import type { RuntimeAntdConfig } from './types.d';
+export type IRuntimeConfig = {
+  antd?: RuntimeAntdConfig
+};

package/.dumi/tmp/plugin-antd/types.d.ts

@@ -0,0 +1,14 @@
+// This file is generated by Umi automatically
+// DO NOT CHANGE IT MANUALLY!
+import type { ConfigProviderProps } from 'antd/es/config-provider';
+
+type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+type AntdConfig = Prettify<{}
+  & ConfigProviderProps
+
+>;
+
+export type RuntimeAntdConfig = (memo: AntdConfig) => AntdConfig;

package/.dumi/tmp/plugin-html2sketch/index.ts

@@ -0,0 +1,35 @@
+// @ts-nocheck
+// This file is generated by Umi automatically
+// DO NOT CHANGE IT MANUALLY!
+import type { nodeToGroup, nodeToSymbol, SketchFormat } from 'html2sketch';
+import { ApplyPluginsType } from 'dumi';
+import { getPluginManager } from '@@/core/plugin';
+
+const html2sketch = typeof window !== 'undefined' ? window.html2sketch as {
+  nodeToGroup: typeof nodeToGroup;
+  nodeToSymbol: typeof nodeToSymbol;
+} : null;
+
+async function toSketchJSON(
+  node: HTMLElement,
+  opts: { type: 'group' | 'symbol' },
+) {
+  return opts.type === 'group'
+    ? (await html2sketch.nodeToGroup(node)).toSketchJSON()
+    : (await html2sketch.nodeToSymbol(node)).toSketchJSON();
+}
+
+function runtimeToSketchJSON(
+  target: HTMLElement | Document,
+  opts: Parameters<typeof toSketchJSON>[1],
+): ReturnType<typeof toSketchJSON> | Promise<null> {
+  return getPluginManager().applyPlugins({
+    key: 'toSketchJSON',
+    type: ApplyPluginsType.modify,
+    initialValue: null,
+    args: { target, opts },
+    async: true,
+  });
+}
+
+export const getSketchJSON = null;

package/.dumi/tmp/testBrowser.tsx

@@ -0,0 +1,90 @@
+// @ts-nocheck
+// This file is generated by Umi automatically
+// DO NOT CHANGE IT MANUALLY!
+import React, { useEffect, useState } from 'react';
+import { ApplyPluginsType } from 'umi';
+import { renderClient, RenderClientOpts } from '/Users/lei/iglooform/node_modules/@umijs/renderer-react';
+import { createHistory } from './core/history';
+import { createPluginManager } from './core/plugin';
+import { getRoutes } from './core/route';
+import type { Location } from 'history';
+
+import '/Users/lei/iglooform/.dumi/global.less';
+import { getPluginManager as getDumiPluginManager } from './core/plugin';
+import { setPluginManager as setDumiPluginManager } from '/Users/lei/iglooform/node_modules/dumi/dist/client/theme-api/utils.js';
+import 'antd/dist/reset.css';
+const publicPath = '/';
+const runtimePublicPath = false;
+
+type TestBrowserProps = {
+  location?: Partial<Location>;
+  historyRef?: React.MutableRefObject<Location>;
+};
+
+export function TestBrowser(props: TestBrowserProps) {
+  const pluginManager = createPluginManager();
+  const [context, setContext] = useState<RenderClientOpts | undefined>(
+    undefined
+  );
+  useEffect(() => {
+    const genContext = async () => {
+      const { routes, routeComponents } = await getRoutes(pluginManager);
+      // allow user to extend routes
+      await pluginManager.applyPlugins({
+        key: 'patchRoutes',
+        type: ApplyPluginsType.event,
+        args: {
+          routes,
+          routeComponents,
+        },
+      });
+      const contextOpts = pluginManager.applyPlugins({
+        key: 'modifyContextOpts',
+        type: ApplyPluginsType.modify,
+        initialValue: {},
+      });
+      const basename = contextOpts.basename || '/';
+      const history = createHistory({
+        type: 'memory',
+        basename,
+      });
+      const context = {
+        routes,
+        routeComponents,
+        pluginManager,
+        rootElement: contextOpts.rootElement || document.getElementById('root'),
+        publicPath,
+        runtimePublicPath,
+        history,
+        basename,
+        components: true,
+      };
+      const modifiedContext = pluginManager.applyPlugins({
+        key: 'modifyClientRenderOpts',
+        type: ApplyPluginsType.modify,
+        initialValue: context,
+      });
+      return modifiedContext;
+    };
+    genContext().then((context) => {
+      setContext(context);
+      if (props.location) {
+        context?.history?.push(props.location);
+      }
+      if (props.historyRef) {
+        props.historyRef.current = context?.history;
+      }
+    });
+  }, []);
+
+  if (context === undefined) {
+    return <div id="loading" />;
+  }
+
+  const Children = renderClient(context);
+  return (
+    <React.Fragment>
+      <Children />
+    </React.Fragment>
+  );
+}

package/.dumi/tmp/umi.ts

@@ -0,0 +1,108 @@
+// @ts-nocheck
+// This file is generated by Umi automatically
+// DO NOT CHANGE IT MANUALLY!
+import './core/polyfill';
+import '/Users/lei/iglooform/.dumi/global.less';
+import { getPluginManager as getDumiPluginManager } from './core/plugin';
+import { setPluginManager as setDumiPluginManager } from '/Users/lei/iglooform/node_modules/dumi/dist/client/theme-api/utils.js';
+import 'antd/dist/reset.css';
+import { renderClient } from '/Users/lei/iglooform/node_modules/@umijs/renderer-react';
+import { getRoutes } from './core/route';
+import { createPluginManager } from './core/plugin';
+import { createHistory } from './core/history';
+import Loading from '@@/dumi/theme/loading';
+import { ApplyPluginsType } from 'umi';
+import '/Users/lei/iglooform/.dumi/overrides.less';
+
+const publicPath = "/";
+const runtimePublicPath = false;
+
+async function render() {
+  const pluginManager = createPluginManager();
+  const { routes, routeComponents } = await getRoutes(pluginManager);
+
+  // allow user to extend routes
+  await pluginManager.applyPlugins({
+    key: 'patchRoutes',
+    type: ApplyPluginsType.event,
+    args: {
+      routes,
+      routeComponents,
+    },
+  });
+
+  const contextOpts = pluginManager.applyPlugins({
+    key: 'modifyContextOpts',
+    type: ApplyPluginsType.modify,
+    initialValue: {},
+  });
+
+  const basename = contextOpts.basename || '/';
+  const historyType = contextOpts.historyType || 'browser';
+
+  const history = createHistory({
+    type: historyType,
+    basename,
+    ...contextOpts.historyOpts,
+  });
+
+  return (pluginManager.applyPlugins({
+    key: 'render',
+    type: ApplyPluginsType.compose,
+    initialValue() {
+      const context = {
+        routes,
+        routeComponents,
+        pluginManager,
+        rootElement: contextOpts.rootElement || document.getElementById('root'),
+        loadingComponent: Loading,
+        publicPath,
+        runtimePublicPath,
+        history,
+        historyType,
+        basename,
+        callback: contextOpts.callback,
+      };
+      const modifiedContext = pluginManager.applyPlugins({
+        key: 'modifyClientRenderOpts',
+        type: ApplyPluginsType.modify,
+        initialValue: context,
+      });
+      return renderClient(modifiedContext);
+    },
+  }))();
+}
+
+
+// always remove trailing slash from location.pathname
+if (
+  typeof history !== 'undefined' &&
+  location.pathname.length > 1 &&
+  location.pathname.endsWith('/')
+) {
+  history.replaceState(
+    {},
+    '',
+    location.pathname.slice(0, -1) + location.search + location.hash,
+  );
+}
+
+(function () {
+  var cache = typeof navigator !== 'undefined' && navigator.cookieEnabled && typeof window.localStorage !== 'undefined' && localStorage.getItem('dumi:prefers-color') || 'light';
+  var isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+  var enums = ['light', 'dark', 'auto'];
+
+  document.documentElement.setAttribute(
+    'data-prefers-color',
+    cache === enums[2]
+      ? (isDark ? enums[1] : enums[0])
+      : (enums.indexOf(cache) > -1 ? cache : enums[0])
+  );
+})();
+render();
+
+window.g_umi = {
+  version: '4.0.75',
+};
+  
+setDumiPluginManager(getDumiPluginManager());

package/es/form/elements.js

@@ -13,6 +13,7 @@ import UploadPhoto from '../upload-photo';
 import RenderElement from './render';
 import Typography from '../typography';
 import SearchBox from '../search-box';
+import OCR from '../ocr';
 var elementMap = {
   Input: Input,
   PhoneNumber: PhoneNumber,
@@ -45,7 +46,8 @@ var elementMap = {
   Confirmation: Confirmation,
   ExpiryDate: ExpiryDate,
   Typography: Typography,
-  SearchBox: SearchBox
+  SearchBox: SearchBox,
+  OCR: OCR
 };
 
 var Unknown = function Unknown() {

package/es/form/index.js

@@ -42,6 +42,7 @@ import classNames from 'classnames';
 import invariant from 'invariant';
 import { LocaleContext } from '../locale';
 import { getRuleValidation } from './../utils/form-utils';
+import useOCR from '../hooks/ocr';
 
 var IglooForm = function IglooForm(props, ref) {
   var config = props.config,
@@ -67,7 +68,8 @@ var IglooForm = function IglooForm(props, ref) {
       selectDatasourceApi = props.selectDatasourceApi,
       getRuleValidationApi = props.getRuleValidationApi,
       _props$stepDirection = props.stepDirection,
-      stepDirection = _props$stepDirection === void 0 ? 'vertical' : _props$stepDirection;
+      stepDirection = _props$stepDirection === void 0 ? 'vertical' : _props$stepDirection,
+      ocr = props.ocr;
 
   var _Form$useForm = _Form.useForm(),
       _Form$useForm2 = _slicedToArray(_Form$useForm, 1),
@@ -95,6 +97,13 @@ var IglooForm = function IglooForm(props, ref) {
       currentLang = _useContext.currentLang;
 
   var validationRule = props.validationRule || config.validationRule;
+  var createHooks = useOCR();
+  var ocrHooks = undefined;
+
+  if (ocr) {
+    ocrHooks = createHooks(ocr);
+  }
+
   invariant(type, "Contianer type should be one of ['Pages', 'Page', 'Steps', 'Login']");
   invariant(!validationRule || getRuleValidationApi, 'Please provide getRuleValidationApi in Form props');
 
@@ -278,7 +287,8 @@ var IglooForm = function IglooForm(props, ref) {
         uploadApi: uploadApi,
         selectDatasourceApi: selectDatasourceApi,
         getRuleValidationApi: getRuleValidationApi,
-        handleValuesChange: handleValuesChange
+        handleValuesChange: handleValuesChange,
+        ocrHooks: ocrHooks
       }, locales),
       children: _jsxs(_Form, {
         form: form,

package/es/form-context.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { FormInstance } from 'antd/es/form';
-import { FormItemName } from '@/types';
+import { FormItemName, OCRHooks } from './types';
 declare const _default: React.Context<{
     form?: FormInstance<any> | undefined;
     onCancel?(): void;
@@ -19,5 +19,6 @@ declare const _default: React.Context<{
     selectDatasourceApi?: string | undefined;
     getRuleValidationApi?: string | undefined;
     handleValuesChange(changedFields: any): any;
+    ocrHooks?: OCRHooks | undefined;
 }>;
 export default _default;

package/es/form-context.js

@@ -4,5 +4,6 @@ export default /*#__PURE__*/React.createContext({
     return window;
   },
   registerDependencies: function registerDependencies() {},
-  handleValuesChange: function handleValuesChange() {}
+  handleValuesChange: function handleValuesChange() {},
+  ocrHooks: {}
 });

package/es/hooks/index.d.ts

@@ -0,0 +1 @@
+

package/es/hooks/index.js

@@ -0,0 +1 @@
+"use strict";

package/es/hooks/ocr/index.d.ts

@@ -0,0 +1,3 @@
+import { OCRConfig, OCRHooks } from '../../types';
+declare const useOCR: () => (config: OCRConfig) => OCRHooks;
+export default useOCR;

package/es/hooks/ocr/index.js

@@ -0,0 +1,25 @@
+import invariant from 'invariant';
+import useMicroBlink from './micro-blink';
+
+var useOCR = function useOCR() {
+  var createRecognize = useMicroBlink();
+  return function (config) {
+    var microBlink = config.microBlink;
+
+    var _ref = microBlink || {},
+        licenseKey = _ref.licenseKey;
+
+    var hooks = {};
+    invariant(Boolean(microBlink) === Boolean(licenseKey), 'Must Config licenseKey of Micro Blink');
+
+    if (microBlink && licenseKey) {
+      hooks['microBlink'] = {
+        recognize: createRecognize(licenseKey)
+      };
+    }
+
+    return hooks;
+  };
+};
+
+export default useOCR;

package/es/hooks/ocr/micro-blink.d.ts

@@ -0,0 +1,3 @@
+import * as BlinkIDSDK from '@microblink/blinkid-in-browser-sdk';
+declare const useMicroBlink: () => (licenseKey: string) => (file: File) => Promise<BlinkIDSDK.BlinkIdSingleSideRecognizerResult | null>;
+export default useMicroBlink;

package/es/hooks/ocr/micro-blink.js

@@ -0,0 +1,231 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+import { useState, useCallback } from 'react';
+import * as BlinkIDSDK from '@microblink/blinkid-in-browser-sdk';
+import message from '../../global-message';
+var MICRO_BLINK_SERVICE_PATH = 'https://static.iglooinsure.com/microblink/in-browser';
+
+function getWorkerLocation(_x) {
+  return _getWorkerLocation.apply(this, arguments);
+}
+
+function _getWorkerLocation() {
+  _getWorkerLocation = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(path) {
+    return regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            return _context5.abrupt("return", new Promise(function (resolve) {
+              window.fetch(path).then(function (response) {
+                return response.text();
+              }).then(function (data) {
+                var blob = new Blob([data], {
+                  type: 'application/javascript'
+                });
+                var url = URL.createObjectURL(blob);
+                resolve(url);
+              });
+            }));
+
+          case 1:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getWorkerLocation.apply(this, arguments);
+}
+
+var useMicroBlink = function useMicroBlink() {
+  var _useState = useState(''),
+      _useState2 = _slicedToArray(_useState, 2),
+      currentKey = _useState2[0],
+      setCurrentKey = _useState2[1];
+
+  var _useState3 = useState(null),
+      _useState4 = _slicedToArray(_useState3, 2),
+      recognizer = _useState4[0],
+      setRecognizer = _useState4[1];
+
+  var _useState5 = useState(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      recognizerRunner = _useState6[0],
+      setRecognizerRunner = _useState6[1];
+
+  var initSdk = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(licenseKey) {
+      var loadSettings;
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!BlinkIDSDK.isBrowserSupported()) {
+                _context2.next = 9;
+                break;
+              }
+
+              loadSettings = new BlinkIDSDK.WasmSDKLoadSettings(licenseKey);
+              loadSettings.engineLocation = MICRO_BLINK_SERVICE_PATH;
+              _context2.next = 5;
+              return getWorkerLocation("".concat(MICRO_BLINK_SERVICE_PATH, "/BlinkIDWasmSDK.worker.min.js"));
+
+            case 5:
+              loadSettings.workerLocation = _context2.sent;
+              BlinkIDSDK.loadWasmModule(loadSettings).then( /*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(wasmSDK) {
+                  var recognizer, recognizerRunner;
+                  return regeneratorRuntime.wrap(function _callee$(_context) {
+                    while (1) {
+                      switch (_context.prev = _context.next) {
+                        case 0:
+                          _context.next = 2;
+                          return BlinkIDSDK.createBlinkIdSingleSideRecognizer(wasmSDK);
+
+                        case 2:
+                          recognizer = _context.sent;
+                          _context.next = 5;
+                          return BlinkIDSDK.createRecognizerRunner(wasmSDK, [recognizer], true);
+
+                        case 5:
+                          recognizerRunner = _context.sent;
+                          setRecognizer(recognizer);
+                          setRecognizerRunner(recognizerRunner);
+
+                        case 8:
+                        case "end":
+                          return _context.stop();
+                      }
+                    }
+                  }, _callee);
+                }));
+
+                return function (_x3) {
+                  return _ref2.apply(this, arguments);
+                };
+              }(), function (error) {
+                console.log('Error during the initialization of the SDK!', error);
+              });
+              _context2.next = 10;
+              break;
+
+            case 9:
+              message.error('This browser is not supported by the SDK!');
+
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function initSdk(_x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  var recognize = useCallback(function () {
+    if (recognizer && recognizerRunner) {
+      return /*#__PURE__*/function () {
+        var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(file) {
+          var ele, frame, processResult, recognitionResult;
+          return regeneratorRuntime.wrap(function _callee3$(_context3) {
+            while (1) {
+              switch (_context3.prev = _context3.next) {
+                case 0:
+                  ele = document.createElement('img');
+                  ele.src = URL.createObjectURL(file);
+                  _context3.next = 4;
+                  return ele.decode();
+
+                case 4:
+                  frame = BlinkIDSDK.captureFrame(ele);
+                  _context3.next = 7;
+                  return recognizerRunner.processImage(frame);
+
+                case 7:
+                  processResult = _context3.sent;
+
+                  if (!(processResult !== BlinkIDSDK.RecognizerResultState.Empty)) {
+                    _context3.next = 15;
+                    break;
+                  }
+
+                  _context3.next = 11;
+                  return recognizer.getResult();
+
+                case 11:
+                  recognitionResult = _context3.sent;
+                  return _context3.abrupt("return", recognitionResult);
+
+                case 15:
+                  message.error('Recognition was not successful!');
+                  return _context3.abrupt("return", null);
+
+                case 17:
+                case "end":
+                  return _context3.stop();
+              }
+            }
+          }, _callee3);
+        }));
+
+        return function (_x4) {
+          return _ref3.apply(this, arguments);
+        };
+      }();
+    } else {
+      return /*#__PURE__*/function () {
+        var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(file) {
+          return regeneratorRuntime.wrap(function _callee4$(_context4) {
+            while (1) {
+              switch (_context4.prev = _context4.next) {
+                case 0:
+                  return _context4.abrupt("return", null);
+
+                case 1:
+                case "end":
+                  return _context4.stop();
+              }
+            }
+          }, _callee4);
+        }));
+
+        return function (_x5) {
+          return _ref4.apply(this, arguments);
+        };
+      }();
+    }
+  }, [recognizer, recognizerRunner]);
+
+  var dealRepeatSendRequest = function dealRepeatSendRequest(licenseKey) {
+    if (currentKey !== '' && currentKey === licenseKey) {
+      return;
+    } else {
+      setCurrentKey(licenseKey);
+      initSdk(licenseKey);
+    }
+  };
+
+  return function (licenseKey) {
+    dealRepeatSendRequest(licenseKey);
+    return recognize();
+  };
+};
+
+export default useMicroBlink;