iglooform 2.5.54 → 2.5.55

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

@@ -0,0 +1,189 @@
+import "antd/es/upload/style";
+import _Upload from "antd/es/upload";
+
+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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext } from 'react';
+import { UploadOutlined } from 'iglooicon';
+import { colors } from 'iglootheme';
+import invariant from 'invariant';
+import * as lodash from 'lodash';
+import moment from 'moment';
+import fromContext from '../../form-context';
+import Typography from '../../typography';
+import { LocaleContext } from '../../locale';
+import message from '../../global-message';
+import './style';
+
+function getOcrDate(result, format) {
+  var successfullyParsed = lodash.get(result, ['dateOfBirth', 'successfullyParsed']);
+
+  if (successfullyParsed) {
+    var year = lodash.get(result, ['dateOfBirth', 'year']);
+    var month = lodash.get(result, ['dateOfBirth', 'month']);
+    var day = lodash.get(result, ['dateOfBirth', 'day']);
+    var date = new Date("".concat(year, "-").concat(month, "-").concat(day));
+    return format ? moment(date).format(format) : moment(date);
+  }
+
+  return undefined;
+}
+
+var MicroBlink = function MicroBlink(props) {
+  var outputMap = props.outputMap,
+      disabled = props.disabled;
+  var Dragger = _Upload.Dragger;
+
+  var _useContext = useContext(fromContext),
+      ocrHooks = _useContext.ocrHooks,
+      form = _useContext.form;
+
+  var _useContext2 = useContext(LocaleContext),
+      formatMessage = _useContext2.formatMessage;
+
+  var _ref = ocrHooks || {},
+      microBlink = _ref.microBlink;
+
+  var _ref2 = microBlink || {},
+      recognize = _ref2.recognize;
+
+  invariant(Boolean(microBlink) && Boolean(recognize), 'Must Config Micro Blink licenseKey');
+
+  var onUpload = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(file) {
+      var microBlinkResult, state, formSet;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!recognize) {
+                _context.next = 15;
+                break;
+              }
+
+              _context.next = 3;
+              return recognize(file);
+
+            case 3:
+              microBlinkResult = _context.sent;
+
+              if (microBlinkResult) {
+                _context.next = 6;
+                break;
+              }
+
+              return _context.abrupt("return");
+
+            case 6:
+              state = microBlinkResult.state;
+              _context.t0 = state;
+              _context.next = _context.t0 === 0 ? 10 : 12;
+              break;
+
+            case 10:
+              message.error(formatMessage({
+                id: 'Nothing has been recognized.'
+              }));
+              return _context.abrupt("return");
+
+            case 12:
+              return _context.abrupt("break", 13);
+
+            case 13:
+              formSet = (outputMap || []).reduce(function (pre, cur) {
+                var field = cur.field,
+                    source = cur.source,
+                    format = cur.format,
+                    formatType = cur.formatType;
+
+                switch (formatType) {
+                  case 'date':
+                    pre.push({
+                      name: field,
+                      value: getOcrDate(microBlinkResult, format),
+                      errors: []
+                    });
+                    break;
+
+                  default:
+                    pre.push({
+                      name: field,
+                      value: lodash.get(microBlinkResult || {}, source),
+                      errors: []
+                    });
+                    break;
+                }
+
+                return pre;
+              }, []);
+              form === null || form === void 0 ? void 0 : form.setFields(formSet);
+
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function onUpload(_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  return _jsx("div", {
+    className: 'igloo-micro-blink',
+    children: _jsx(Dragger, {
+      action: function action(file) {
+        onUpload(file);
+        return '';
+      },
+      showUploadList: false,
+      className: "igloo-upload-box",
+      customRequest: function customRequest() {},
+      //@ts-ignore
+      disabled: disabled,
+      multiple: true,
+      children: _jsxs("div", {
+        className: "igloo-upload-box-center",
+        children: [_jsx(UploadOutlined, {
+          style: {
+            marginRight: 16,
+            fontSize: 24,
+            color: '#666666'
+          }
+        }), _jsxs("span", {
+          className: "igloo-upload-placeholder",
+          children: [_jsx(Typography, {
+            level: "body1",
+            children: formatMessage({
+              id: 'Drag and drop a file here'
+            })
+          }), _jsx(Typography, {
+            level: "body1",
+            style: {
+              marginLeft: 4
+            },
+            children: formatMessage({
+              id: 'or'
+            })
+          }), _jsx(Typography, {
+            level: "body1",
+            style: {
+              color: colors.purpleMain,
+              marginLeft: 4
+            },
+            children: formatMessage({
+              id: 'browse'
+            })
+          })]
+        })]
+      })
+    })
+  });
+};
+
+export default MicroBlink;

package/es/ocr/micro-blink/style/index.d.ts

@@ -0,0 +1 @@
+import './index.less';

package/es/ocr/micro-blink/style/index.js

@@ -0,0 +1 @@
+import './index.less';

package/es/ocr/micro-blink/style/index.less

@@ -0,0 +1,30 @@
+.igloo-micro-blink {
+  .igloo-upload-box {
+    &:hover {
+      border-color: #d9d9d9 !important;
+    }
+
+    & > .ant-upload {
+      background: #ffffff !important;
+
+      .ant-upload-btn {
+        padding: 24px 24px;
+      }
+    }
+
+    .igloo-upload-box-center {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      white-space: nowrap;
+
+      .igloo-upload-placeholder {
+        white-space: pre-wrap;
+
+        .igloo-upload-box-center-upload-icon {
+          margin-right: 16px;
+        }
+      }
+    }
+  }
+}

package/es/types.d.ts

@@ -4,8 +4,19 @@ import { ReactNode } from 'react';
 import { NamePath } from 'rc-field-form/lib/interface';
 import { CheckboxOptionType } from 'antd/es/checkbox';
 import { SelectProps } from 'antd/es/select';
+import { BlinkIdSingleSideRecognizerResult } from '@microblink/blinkid-in-browser-sdk';
 export { Rule } from 'rc-field-form/lib/interface';
 export declare type FormItemName = NamePath;
+export interface OCRHooks {
+    microBlink?: {
+        recognize: ((file: File) => Promise<BlinkIdSingleSideRecognizerResult | null>) | null;
+    };
+}
+export interface OCRConfig {
+    microBlink?: {
+        licenseKey: string;
+    };
+}
 export interface FormBasicConfig {
     className?: string;
     config: FormItemConfig;
@@ -31,6 +42,7 @@ export interface FormBasicConfig {
     validationRule?: string;
     getRuleValidationApi?: string;
     stepDirection?: 'vertical' | 'horizontal';
+    ocr?: OCRConfig;
 }
 export declare type FormItemAssert = {
     field: NamePath;

package/es/utils/form-utils.js

@@ -210,7 +210,7 @@ export var calcFormItemProps = function calcFormItemProps(config, extraProps, fo
       shouldRenderCode = config.shouldRenderCode,
       rest = _objectWithoutProperties(config, _excluded);
 
-  invariant(nameProp !== undefined || type === 'Divider' || type === 'Section' || type === 'Typography' || !type, "name property is required for form item config (type: ".concat(type, ")"));
+  invariant(nameProp !== undefined || type === 'Divider' || type === 'Section' || type === 'Typography' || type === 'OCR' || !type, "name property is required for form item config (type: ".concat(type, ")"));
   invariant(!previewFormater || typeof previewFormater === 'function', 'previewFormater property should be a function');
   invariant(!shouldRender || typeof shouldRender === 'function', 'shouldRender property should be a function');
 

package/lib/form/elements.js

@@ -37,6 +37,8 @@ var _typography = _interopRequireDefault(require("../typography"));
 
 var _searchBox = _interopRequireDefault(require("../search-box"));
 
+var _ocr = _interopRequireDefault(require("../ocr"));
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -75,7 +77,8 @@ var elementMap = {
   Confirmation: _confirmation.default,
   ExpiryDate: _input.ExpiryDate,
   Typography: _typography.default,
-  SearchBox: _searchBox.default
+  SearchBox: _searchBox.default,
+  OCR: _ocr.default
 };
 
 var Unknown = function Unknown() {

package/lib/form/index.js

@@ -37,6 +37,8 @@ var _locale = require("../locale");
 
 var _formUtils = require("./../utils/form-utils");
 
+var _ocr = _interopRequireDefault(require("../hooks/ocr"));
+
 var _excluded = ["validateMessages"];
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -91,7 +93,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.default.useForm(),
       _Form$useForm2 = _slicedToArray(_Form$useForm, 1),
@@ -119,6 +122,13 @@ var IglooForm = function IglooForm(props, ref) {
       currentLang = _useContext.currentLang;
 
   var validationRule = props.validationRule || config.validationRule;
+  var createHooks = (0, _ocr.default)();
+  var ocrHooks = undefined;
+
+  if (ocr) {
+    ocrHooks = createHooks(ocr);
+  }
+
   (0, _invariant.default)(type, "Contianer type should be one of ['Pages', 'Page', 'Steps', 'Login']");
   (0, _invariant.default)(!validationRule || getRuleValidationApi, 'Please provide getRuleValidationApi in Form props');
 
@@ -302,7 +312,8 @@ var IglooForm = function IglooForm(props, ref) {
         uploadApi: uploadApi,
         selectDatasourceApi: selectDatasourceApi,
         getRuleValidationApi: getRuleValidationApi,
-        handleValuesChange: handleValuesChange
+        handleValuesChange: handleValuesChange,
+        ocrHooks: ocrHooks
       }, locales),
       children: (0, _jsxRuntime.jsxs)(_form.default, {
         form: form,

package/lib/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/lib/form-context.js

@@ -14,7 +14,8 @@ var _default = /*#__PURE__*/_react.default.createContext({
     return window;
   },
   registerDependencies: function registerDependencies() {},
-  handleValuesChange: function handleValuesChange() {}
+  handleValuesChange: function handleValuesChange() {},
+  ocrHooks: {}
 });
 
 exports.default = _default;

package/lib/hooks/index.d.ts

@@ -0,0 +1 @@
+

package/lib/hooks/index.js

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

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

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

package/lib/hooks/ocr/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _invariant = _interopRequireDefault(require("invariant"));
+
+var _microBlink = _interopRequireDefault(require("./micro-blink"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var useOCR = function useOCR() {
+  var createRecognize = (0, _microBlink.default)();
+  return function (config) {
+    var microBlink = config.microBlink;
+
+    var _ref = microBlink || {},
+        licenseKey = _ref.licenseKey;
+
+    var hooks = {};
+    (0, _invariant.default)(Boolean(microBlink) === Boolean(licenseKey), 'Must Config licenseKey of Micro Blink');
+
+    if (microBlink && licenseKey) {
+      hooks['microBlink'] = {
+        recognize: createRecognize(licenseKey)
+      };
+    }
+
+    return hooks;
+  };
+};
+
+var _default = useOCR;
+exports.default = _default;

package/lib/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/lib/hooks/ocr/micro-blink.js

@@ -0,0 +1,251 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = require("react");
+
+var BlinkIDSDK = _interopRequireWildcard(require("@microblink/blinkid-in-browser-sdk"));
+
+var _globalMessage = _interopRequireDefault(require("../../global-message"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); }); }; }
+
+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 = (0, _react.useState)(''),
+      _useState2 = _slicedToArray(_useState, 2),
+      currentKey = _useState2[0],
+      setCurrentKey = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(null),
+      _useState4 = _slicedToArray(_useState3, 2),
+      recognizer = _useState4[0],
+      setRecognizer = _useState4[1];
+
+  var _useState5 = (0, _react.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:
+              _globalMessage.default.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 = (0, _react.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:
+                  _globalMessage.default.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();
+  };
+};
+
+var _default = useMicroBlink;
+exports.default = _default;

package/lib/input/phone-number.d.ts

@@ -1,6 +1,6 @@
 import { CSSProperties } from 'react';
 import { FC, IglooComponentProps } from '../types';
-import './style/index';
+import './style/index.less';
 export interface PhoneNumberProps extends IglooComponentProps {
     areaCode?: string | string[];
     phoneNumber?: number;