@circle-dna/react-context-provider 1.0.2

package/dist/react-context-provider.esm.js

@@ -0,0 +1,3059 @@
+import React, { useState, useCallback, useContext, useRef, useEffect } from 'react';
+import axios from 'axios';
+import jwt from 'jwt-decode';
+import moment from 'moment';
+import { v4 } from 'uuid';
+import equal from 'fast-deep-equal';
+
+function _regeneratorRuntime() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+
+  var exports = {},
+      Op = Object.prototype,
+      hasOwn = Op.hasOwnProperty,
+      $Symbol = "function" == typeof Symbol ? Symbol : {},
+      iteratorSymbol = $Symbol.iterator || "@@iterator",
+      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+        generator = Object.create(protoGenerator.prototype),
+        context = new Context(tryLocsList || []);
+    return generator._invoke = function (innerFn, self, context) {
+      var state = "suspendedStart";
+      return function (method, arg) {
+        if ("executing" === state) throw new Error("Generator is already running");
+
+        if ("completed" === state) {
+          if ("throw" === method) throw arg;
+          return doneResult();
+        }
+
+        for (context.method = method, context.arg = arg;;) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+            if ("suspendedStart" === state) throw state = "completed", context.arg;
+            context.dispatchException(context.arg);
+          } else "return" === context.method && context.abrupt("return", context.arg);
+          state = "executing";
+          var record = tryCatch(innerFn, self, context);
+
+          if ("normal" === record.type) {
+            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          }
+
+          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        }
+      };
+    }(innerFn, self, context), generator;
+  }
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if ("throw" !== record.type) {
+        var result = record.arg,
+            value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+
+      reject(record.arg);
+    }
+
+    var previousPromise;
+
+    this._invoke = function (method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (undefined === method) {
+      if (context.delegate = null, "throw" === context.method) {
+        if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+
+          return next.value = undefined, next.done = !0, next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) keys.push(key);
+
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+            record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+              hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+
+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);
+    });
+  };
+}
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+/* istanbul ignore next */
+
+var AuthContext = /*#__PURE__*/React.createContext({
+  token: undefined,
+  requestOtp: function requestOtp() {
+    return Promise.resolve('');
+  },
+  verifyOtp: function verifyOtp() {
+    return Promise.resolve('');
+  },
+  register: function register() {
+    return Promise.resolve('');
+  },
+  login: function login() {
+    return Promise.resolve('');
+  },
+  logout: function logout() {
+    return Promise.resolve();
+  },
+  updatePassword: function updatePassword() {
+    return Promise.resolve();
+  }
+});
+
+var AuthHeader = function AuthHeader(token) {
+  return {
+    Authorization: "Bearer " + token
+  };
+}; // axios.defaults.baseURL = getEnvironment.baseUrl;
+
+var replaceUriParams = function replaceUriParams(obj, url) {
+  var updatedUrl = url;
+  Object.entries(obj).forEach(function (_ref) {
+    var key = _ref[0],
+        value = _ref[1];
+    updatedUrl = updatedUrl.replace(":" + key, value.toString());
+  });
+  return updatedUrl;
+};
+
+var request = function request(config, errorHandler, uriParams) {
+  if (uriParams === void 0) {
+    uriParams = {};
+  }
+
+  var url = config.url;
+  if (url) url = replaceUriParams(uriParams, url);
+
+  var options = _extends({}, config, {
+    url: url
+  });
+
+  return axios(options)["catch"](function (error) {
+    return errorHandler(error, config);
+  });
+};
+
+var baseURL$2 = undefined;
+var application$2 = '/authentication';
+var postOtpRequest = function postOtpRequest(context, handler) {
+  return request({
+    baseURL: baseURL$2,
+    url: application$2 + '/v1.0/otp',
+    method: 'POST',
+    data: {
+      username: context.username,
+      type: context.type,
+      lang: context.lang
+    },
+    params: context.verify ? {
+      verify: context.verify
+    } : undefined
+  }, handler).then(function () {
+    return context.username;
+  });
+};
+var postOtpVerification = function postOtpVerification(context, handler) {
+  return request({
+    baseURL: baseURL$2,
+    url: application$2 + '/v1.0/token/otp',
+    method: 'POST',
+    data: context
+  }, handler).then(function (response) {
+    return response == null ? void 0 : response.data.token;
+  });
+};
+var postCreateToken = function postCreateToken(context, handler) {
+  return request({
+    baseURL: baseURL$2,
+    url: application$2 + '/v1.0/token/user',
+    method: 'POST',
+    data: context
+  }, handler).then(function (response) {
+    return response == null ? void 0 : response.data.token;
+  });
+};
+var putUpdateUser = function putUpdateUser(context, token, handler) {
+  return request({
+    baseURL: baseURL$2,
+    url: application$2 + '/v1.0/user/:userid',
+    method: 'PUT',
+    data: context.info,
+    headers: AuthHeader(token)
+  }, handler, {
+    userid: context.userid
+  });
+};
+
+// import { Identity } from '../../type/Customer';
+var baseURL$1 = undefined;
+var application$1 = 'customer';
+var postCreateAccount = function postCreateAccount(context, token, handler) {
+  return request({
+    baseURL: baseURL$1,
+    url: application$1 + '/v1.0/customer',
+    method: 'POST',
+    data: {
+      customer: {
+        name: {
+          nickName: context.nickname
+        }
+      },
+      userName: context.username,
+      loginType: 'email',
+      password: context.password,
+      locale: context.locale,
+      location: context.location
+    },
+    headers: AuthHeader(token)
+  }, handler).then(function (response) {
+    return {
+      customerId: response == null ? void 0 : response.data.customerId,
+      profileId: response == null ? void 0 : response.data.profileId,
+      emailIdentity: response == null ? void 0 : response.data.emailIdentity
+    };
+  });
+};
+
+var capture = function capture(e, cb) {
+  if (cb) cb(e);
+};
+
+var Role;
+
+(function (Role) {
+  Role["CustomerUser"] = "customer_user";
+  Role["OtpVerified"] = "otp_verified";
+})(Role || (Role = {}));
+
+var LoginType;
+
+(function (LoginType) {
+  LoginType["Basic"] = "basic";
+  LoginType["Mobile"] = "mobile";
+  LoginType["WeChat"] = "wechat";
+  LoginType["Email"] = "email";
+})(LoginType || (LoginType = {}));
+
+var capturing = function capturing(e) {
+  if (e instanceof Error) {
+    console.warn("Invalid jwt: " + e.message);
+  } else {
+    console.warn("Invalid jwt: " + e);
+  }
+};
+
+var getUserId = function getUserId(input) {
+  try {
+    var decoded = jwt(input);
+    var token = decoded;
+    return token.uid;
+  } catch (error) {
+    capture(error, capturing);
+    return;
+  }
+};
+var getRoles = function getRoles(input) {
+  try {
+    var decoded = jwt(input);
+    var token = decoded;
+    return token.roles;
+  } catch (error) {
+    capture(error, capturing);
+    return;
+  }
+};
+var isActive = function isActive(input) {
+  try {
+    var decoded = jwt(input);
+    if (decoded.exp === undefined) return undefined;
+    var now = moment(); // https://www.rfc-editor.org/rfc/rfc7519#section-2
+    // jwt exp is defined as the number of seconds (not milliseconds) since Epoch
+
+    var exp = moment(decoded.exp * 1000);
+    if (!moment(exp).isAfter(now)) return false;
+    return true;
+  } catch (error) {
+    capture(error);
+    return;
+  }
+};
+
+var AuthorizationErrorReason;
+
+(function (AuthorizationErrorReason) {
+  AuthorizationErrorReason["Expired"] = "ERR_EXPIRED";
+  AuthorizationErrorReason["Unauthroized"] = "ERR_UNAUTHORIZED";
+})(AuthorizationErrorReason || (AuthorizationErrorReason = {}));
+
+var AuthorizationError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(AuthorizationError, _Error);
+
+  function AuthorizationError(m, r) {
+    var _this;
+
+    if (r === void 0) {
+      r = AuthorizationErrorReason.Expired;
+    }
+
+    _this = _Error.call(this, m) || this;
+    _this.reason = void 0;
+    _this.name = 'AuthorizationError';
+    _this.reason = r; // Set the prototype explicitly.
+
+    Object.setPrototypeOf(_assertThisInitialized(_this), AuthorizationError.prototype);
+    return _this;
+  }
+
+  return AuthorizationError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var UnexpectedError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(UnexpectedError, _Error);
+
+  function UnexpectedError(m) {
+    var _this;
+
+    _this = _Error.call(this, m) || this;
+    _this.name = 'UnexpectedError'; // Set the prototype explicitly.
+
+    Object.setPrototypeOf(_assertThisInitialized(_this), UnexpectedError.prototype);
+    return _this;
+  }
+
+  return UnexpectedError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var ApiErrorHandler = function ApiErrorHandler(error) {
+  if (error instanceof Error) {
+    console.log('[ApiErrorHandler] ' + error.name + ': ' + error.message);
+  } else {
+    console.log('[ApiErrorHandler] Unknown Error: ' + error);
+  }
+
+  if (axios.isAxiosError(error)) {
+    var _error$response;
+
+    if (((_error$response = error.response) == null ? void 0 : _error$response.status) === 401) {
+      var _error$config, _error$config$headers;
+
+      if ((_error$config = error.config) != null && (_error$config$headers = _error$config.headers) != null && _error$config$headers.Authorization && typeof error.config.headers.Authorization === 'string' && error.config.headers.Authorization.startsWith('Bearer ')) {
+        var token = error.config.headers.Authorization.substring(7); // Remove `Bearer `
+
+        var active = isActive(token);
+
+        if (active !== undefined && !active) {
+          throw new AuthorizationError('Session Expired', AuthorizationErrorReason.Expired);
+        }
+      }
+    }
+
+    throw error;
+  }
+
+  throw new UnexpectedError('Unexpected API Error');
+};
+
+var AuthenticationErrorReason;
+
+(function (AuthenticationErrorReason) {
+  AuthenticationErrorReason["TooMany"] = "ERR_AUTH_TOO_MANY";
+  AuthenticationErrorReason["NotExists"] = "ERR_AUTH_NOT_EXISTS";
+  AuthenticationErrorReason["AlreadyExists"] = "ERR_AUTH_ALREADY_EXISTS";
+  AuthenticationErrorReason["General"] = "ERR_AUTH_GENERAL";
+  AuthenticationErrorReason["InvalidCredential"] = "ERR_AUTH_INVALID_CRED";
+})(AuthenticationErrorReason || (AuthenticationErrorReason = {}));
+
+var AuthenticationError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(AuthenticationError, _Error);
+
+  function AuthenticationError(r, m) {
+    var _this;
+
+    if (r === void 0) {
+      r = AuthenticationErrorReason.General;
+    }
+
+    _this = _Error.call(this, m || r) || this;
+    _this.reason = void 0;
+    _this.name = 'AuthenticationError';
+    _this.reason = r; // Set the prototype explicitly.
+
+    Object.setPrototypeOf(_assertThisInitialized(_this), AuthenticationError.prototype);
+    return _this;
+  }
+
+  return AuthenticationError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var AuthProvider = function AuthProvider(_ref) {
+  var children = _ref.children,
+      defaults = _ref.defaults,
+      _ref$locale = _ref.locale,
+      locale = _ref$locale === void 0 ? 'en-HK' : _ref$locale;
+
+  var _useState = useState(defaults == null ? void 0 : defaults.token),
+      authToken = _useState[0],
+      setAuthToken = _useState[1];
+
+  var requestOtp = useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(email, verify) {
+      var _e$response, status, _e$response2, _e$response3, hasErrorMessage, errMsg;
+
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              console.log("Requesting OTP for " + email + "; Verify: " + verify);
+              _context.next = 4;
+              return postOtpRequest({
+                username: email,
+                type: 'email',
+                lang: locale,
+                verify: verify
+              }, ApiErrorHandler);
+
+            case 4:
+              return _context.abrupt("return", _context.sent);
+
+            case 7:
+              _context.prev = 7;
+              _context.t0 = _context["catch"](0);
+
+              if (!axios.isAxiosError(_context.t0)) {
+                _context.next = 20;
+                break;
+              }
+
+              status = (_e$response = _context.t0.response) == null ? void 0 : _e$response.status;
+
+              if (!(status === 429)) {
+                _context.next = 15;
+                break;
+              }
+
+              throw new AuthenticationError(AuthenticationErrorReason.TooMany);
+
+            case 15:
+              if (!(status === 400)) {
+                _context.next = 20;
+                break;
+              }
+
+              hasErrorMessage = function hasErrorMessage(data) {
+                if (data && typeof data === 'object') {
+                  if ('error_message' in data) {
+                    return true;
+                  }
+                }
+
+                return false;
+              };
+
+              errMsg = hasErrorMessage((_e$response2 = _context.t0.response) == null ? void 0 : _e$response2.data) && ((_e$response3 = _context.t0.response) == null ? void 0 : _e$response3.data.error_message);
+
+              if (!(errMsg && errMsg.match(/^.+does not exist$/))) {
+                _context.next = 20;
+                break;
+              }
+
+              throw new AuthenticationError(AuthenticationErrorReason.NotExists, errMsg);
+
+            case 20:
+              throw new AuthenticationError(AuthenticationErrorReason.General);
+
+            case 21:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, null, [[0, 7]]);
+    }));
+
+    return function (_x, _x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [locale]);
+
+  var verifyOtp = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(email, otp) {
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              console.log("Verifying OTP for " + email);
+              _context2.next = 3;
+              return postOtpVerification({
+                username: email,
+                password: otp,
+                type: 'email'
+              }, ApiErrorHandler);
+
+            case 3:
+              return _context2.abrupt("return", _context2.sent);
+
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function verifyOtp(_x3, _x4) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
+  var register = useCallback( /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(email, password, token, location) {
+      var roles, result;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              console.log("Creating user for " + email + "; Location: " + location);
+              roles = getRoles(token);
+
+              if (!(token && roles)) {
+                _context3.next = 7;
+                break;
+              }
+
+              if (!roles.some(function (role) {
+                return role === Role.CustomerUser;
+              })) {
+                _context3.next = 5;
+                break;
+              }
+
+              throw new AuthenticationError(AuthenticationErrorReason.AlreadyExists);
+
+            case 5:
+              _context3.next = 8;
+              break;
+
+            case 7:
+              throw new Error('Cannot create account: Invalid OTP token');
+
+            case 8:
+              _context3.next = 10;
+              return postCreateAccount({
+                username: email,
+                password: password,
+                nickname: email,
+                locale: locale,
+                location: location
+              }, token, ApiErrorHandler);
+
+            case 10:
+              result = _context3.sent;
+              setAuthToken(result.emailIdentity);
+              return _context3.abrupt("return", result.emailIdentity);
+
+            case 13:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+
+    return function (_x5, _x6, _x7, _x8) {
+      return _ref4.apply(this, arguments);
+    };
+  }(), [locale]);
+  var login = useCallback( /*#__PURE__*/function () {
+    var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(username, password) {
+      var token, _error$response, _error$response2;
+
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              console.log("Login as " + username);
+              _context4.prev = 1;
+              _context4.next = 4;
+              return postCreateToken({
+                username: username,
+                password: password,
+                locale: 'en-HK'
+              }, ApiErrorHandler);
+
+            case 4:
+              token = _context4.sent;
+              setAuthToken(token);
+              return _context4.abrupt("return", token);
+
+            case 9:
+              _context4.prev = 9;
+              _context4.t0 = _context4["catch"](1);
+
+              if (!axios.isAxiosError(_context4.t0)) {
+                _context4.next = 18;
+                break;
+              }
+
+              if (!(((_error$response = _context4.t0.response) == null ? void 0 : _error$response.status) === 401)) {
+                _context4.next = 16;
+                break;
+              }
+
+              throw new AuthenticationError(AuthenticationErrorReason.InvalidCredential);
+
+            case 16:
+              if (!(((_error$response2 = _context4.t0.response) == null ? void 0 : _error$response2.status) === 429)) {
+                _context4.next = 18;
+                break;
+              }
+
+              throw new AuthenticationError(AuthenticationErrorReason.TooMany);
+
+            case 18:
+              throw _context4.t0;
+
+            case 19:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, null, [[1, 9]]);
+    }));
+
+    return function (_x9, _x10) {
+      return _ref5.apply(this, arguments);
+    };
+  }(), []);
+  var logout = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            console.log('Logout');
+            setAuthToken(undefined);
+
+          case 2:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  })), []);
+  var updatePassword = useCallback( /*#__PURE__*/function () {
+    var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(password, jwt) {
+      var uid;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              console.log('Updating password');
+              uid = getUserId(jwt);
+
+              if (uid) {
+                _context6.next = 4;
+                break;
+              }
+
+              throw new Error('Missing user ID');
+
+            case 4:
+              _context6.prev = 4;
+              _context6.next = 7;
+              return putUpdateUser({
+                userid: uid,
+                info: {
+                  password: password
+                }
+              }, jwt, ApiErrorHandler);
+
+            case 7:
+              _context6.next = 12;
+              break;
+
+            case 9:
+              _context6.prev = 9;
+              _context6.t0 = _context6["catch"](4);
+              throw _context6.t0;
+
+            case 12:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, null, [[4, 9]]);
+    }));
+
+    return function (_x11, _x12) {
+      return _ref7.apply(this, arguments);
+    };
+  }(), []);
+  var authContext = React.useMemo(function () {
+    return {
+      token: authToken,
+      requestOtp: requestOtp,
+      verifyOtp: verifyOtp,
+      register: register,
+      login: login,
+      logout: logout,
+      updatePassword: updatePassword
+    };
+  }, [authToken, login, logout, register, requestOtp, updatePassword]);
+  return React.createElement(AuthContext.Provider, {
+    value: authContext
+  }, children);
+};
+var useAuth = function useAuth() {
+  return useContext(AuthContext);
+};
+
+/* istanbul ignore next */
+
+var ProfileContext = /*#__PURE__*/React.createContext({
+  isProfileReady: false,
+  userProfiles: undefined,
+  rootProfile: undefined,
+  currentProfile: undefined,
+  setCurrentProfile: function setCurrentProfile() {
+    return undefined;
+  },
+  createProfile: /*#__PURE__*/function () {
+    var _createProfile = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", {
+                profileId: '',
+                owner: '',
+                root: false,
+                name: {}
+              });
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    function createProfile() {
+      return _createProfile.apply(this, arguments);
+    }
+
+    return createProfile;
+  }(),
+  updateProfile: /*#__PURE__*/function () {
+    var _updateProfile = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    function updateProfile() {
+      return _updateProfile.apply(this, arguments);
+    }
+
+    return updateProfile;
+  }(),
+  deleteProfile: /*#__PURE__*/function () {
+    var _deleteProfile = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+
+    function deleteProfile() {
+      return _deleteProfile.apply(this, arguments);
+    }
+
+    return deleteProfile;
+  }(),
+  createTag: /*#__PURE__*/function () {
+    var _createTag = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+
+    function createTag() {
+      return _createTag.apply(this, arguments);
+    }
+
+    return createTag;
+  }(),
+  updateTag: /*#__PURE__*/function () {
+    var _updateTag = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    }));
+
+    function updateTag() {
+      return _updateTag.apply(this, arguments);
+    }
+
+    return updateTag;
+  }(),
+  deleteTag: /*#__PURE__*/function () {
+    var _deleteTag = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              return _context6.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6);
+    }));
+
+    function deleteTag() {
+      return _deleteTag.apply(this, arguments);
+    }
+
+    return deleteTag;
+  }(),
+  createIdentity: /*#__PURE__*/function () {
+    var _createIdentity = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              return _context7.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7);
+    }));
+
+    function createIdentity() {
+      return _createIdentity.apply(this, arguments);
+    }
+
+    return createIdentity;
+  }(),
+  updateIdentity: /*#__PURE__*/function () {
+    var _updateIdentity = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8);
+    }));
+
+    function updateIdentity() {
+      return _updateIdentity.apply(this, arguments);
+    }
+
+    return updateIdentity;
+  }(),
+  deleteIdentity: /*#__PURE__*/function () {
+    var _deleteIdentity = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) {
+          switch (_context9.prev = _context9.next) {
+            case 0:
+              return _context9.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }
+      }, _callee9);
+    }));
+
+    function deleteIdentity() {
+      return _deleteIdentity.apply(this, arguments);
+    }
+
+    return deleteIdentity;
+  }(),
+  createAddress: /*#__PURE__*/function () {
+    var _createAddress = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) {
+          switch (_context10.prev = _context10.next) {
+            case 0:
+              return _context10.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context10.stop();
+          }
+        }
+      }, _callee10);
+    }));
+
+    function createAddress() {
+      return _createAddress.apply(this, arguments);
+    }
+
+    return createAddress;
+  }(),
+  updateQuestionnaire: /*#__PURE__*/function () {
+    var _updateQuestionnaire = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) {
+          switch (_context11.prev = _context11.next) {
+            case 0:
+              return _context11.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context11.stop();
+          }
+        }
+      }, _callee11);
+    }));
+
+    function updateQuestionnaire() {
+      return _updateQuestionnaire.apply(this, arguments);
+    }
+
+    return updateQuestionnaire;
+  }(),
+  createAvatar: /*#__PURE__*/function () {
+    var _createAvatar = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+      return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+        while (1) {
+          switch (_context12.prev = _context12.next) {
+            case 0:
+              return _context12.abrupt("return");
+
+            case 1:
+            case "end":
+              return _context12.stop();
+          }
+        }
+      }, _callee12);
+    }));
+
+    function createAvatar() {
+      return _createAvatar.apply(this, arguments);
+    }
+
+    return createAvatar;
+  }()
+});
+
+var PARTNER = 'circle';
+
+var hasKeys = function hasKeys(obj, keys) {
+  return typeof obj === 'object' && keys.every(function (k) {
+    return k in obj;
+  });
+};
+function validateString(string) {
+  if (typeof string === 'string') {
+    return string;
+  } else {
+    throw new Error("Validation for string failed " + string);
+  }
+}
+function validateNumber(number) {
+  if (typeof number === 'number') {
+    return number;
+  } else {
+    throw new Error('Validation for number failed');
+  }
+}
+function validateBoolean(_boolean) {
+  if (typeof _boolean === 'boolean') {
+    return _boolean;
+  } else {
+    throw new Error('Validation for boolean failed');
+  }
+}
+function validateOptionalString(string) {
+  if (typeof string === 'string') {
+    return string;
+  } else {
+    return undefined;
+  }
+}
+function validateEnum(value, accepted) {
+  if (typeof value === 'string' && accepted.includes(value)) {
+    return value;
+  } else {
+    throw new Error("Validation for enum(" + value + ") failed");
+  }
+}
+function validateArray(value, validationFunction) {
+  if (Array.isArray(value)) {
+    return value.map(validationFunction);
+  } else {
+    throw new Error('Validation for array failed');
+  }
+} // export function parseUnixTimestampToMoment(value: unknown) {
+//     if (typeof value !== 'number') {
+//         throw new Error('Validation for unix timestamp failed');
+//     }
+//     const date = moment(value * 1000);
+//     if (date.isValid()) {
+//         return date;
+//     } else {
+//         throw new Error('Validation for unix timestamp failed');
+//     }
+// }
+// export function validateAndTransformDateTimeString(value: string) {
+//     const date = moment(value);
+//     if (date.isValid()) {
+//         return date.format('LLL');
+//     } else {
+//         throw new Error('Validation for unix timestamp failed');
+//     }
+// }
+// export function validateMoment(value: unknown) {
+//     const date = moment(validateString(value));
+//     if (date.isValid()) {
+//         return date;
+//     } else {
+//         throw new Error('Validation for string data failed');
+//     }
+// }
+
+var Ethnicity;
+
+(function (Ethnicity) {
+  Ethnicity["eastAsian"] = "eastasian";
+  Ethnicity["southAsian"] = "southasian";
+  Ethnicity["middleEastern"] = "middleeastern";
+  Ethnicity["pacificIslander"] = "pacificislander";
+  Ethnicity["nativeAmerican"] = "nativeamerican";
+  Ethnicity["african"] = "african";
+  Ethnicity["caucasian"] = "caucasian";
+  Ethnicity["southEastAsian"] = "southeastasian";
+  Ethnicity["hispanic"] = "hispanic";
+  Ethnicity["eastAsianSouthEastAsian"] = "eastasiansoutheastasian";
+  Ethnicity["other"] = "other";
+})(Ethnicity || (Ethnicity = {}));
+
+var Ethnicities = /*#__PURE__*/Object.values(Ethnicity);
+var Gender;
+
+(function (Gender) {
+  Gender["male"] = "male";
+  Gender["female"] = "female";
+})(Gender || (Gender = {}));
+
+var IdentityType;
+
+(function (IdentityType) {
+  IdentityType["hkid"] = "hkid";
+  IdentityType["hkidpassport"] = "hkidpassport";
+  IdentityType["hkreturnhomepermit"] = "hkreturnhomepermit";
+  IdentityType["passport"] = "passport";
+  IdentityType["traveldocument"] = "traveldocument";
+  IdentityType["externaluserid"] = "externaluserid";
+  IdentityType["participantid"] = "participantid";
+  IdentityType["castawayclubid"] = "castawayclubid";
+  IdentityType["nhsnumber"] = "nhsnumber";
+  IdentityType["microchipid"] = "microchipid";
+})(IdentityType || (IdentityType = {}));
+
+var parseProfiles = function parseProfiles(profiles) {
+  try {
+    return profiles ? validateArray(profiles, parseProfile) : [];
+  } catch (error) {
+    console.log(error.stack);
+    throw new Error("Failed to parse profiles: " + error);
+  }
+};
+var parseProfile = function parseProfile(profile) {
+  var expectedKeys = ['profileId', 'owner', 'name'];
+
+  if (!hasKeys(profile, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var profileId = profile.profileId,
+      owner = profile.owner,
+      name = profile.name;
+  var validIdentityTypes = Object.values(IdentityType);
+  return {
+    profileId: validateString(profileId),
+    owner: validateString(owner),
+    root: hasKeys(profile, ['root']) && profile.root ? validateBoolean(profile.root) : false,
+    name: parseProfileName(name),
+    email: hasKeys(profile, ['email']) ? validateArray(profile.email, parseProfileEmail) : undefined,
+    health: hasKeys(profile, ['health']) && isHealth(profile.health) ? parseProfileHealth(profile.health) : undefined,
+    tag: hasKeys(profile, ['tag']) ? validateArray(profile.tag, parseProfileTag) : undefined,
+    preference: hasKeys(profile, ['preference']) && isPreference(profile.preference) ? parseProfilePreference(profile.preference) : undefined,
+    identity: hasKeys(profile, ['identity']) && Array.isArray(profile.identity) ? validateArray(profile.identity.filter(function (identity) {
+      return typeof identity === 'object' && validIdentityTypes.includes(identity.identityType);
+    }), parseProfileIdentity) : undefined,
+    address: hasKeys(profile, ['address']) ? profile.address : undefined,
+    phone: hasKeys(profile, ['phone']) ? profile.phone : undefined,
+    species: hasKeys(profile, ['species']) ? profile.species : undefined,
+    avatar: hasKeys(profile, ['avatar']) && isAvatar(profile.avatar) ? parseProfileAvatar(profile.avatar) : undefined
+  };
+};
+var parseCreateProfile = function parseCreateProfile(profile) {
+  var expectedKeys = ['profileId', 'owner', 'name'];
+
+  if (!hasKeys(profile, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var profileId = profile.profileId,
+      owner = profile.owner,
+      name = profile.name;
+  return {
+    profileId: validateString(profileId),
+    owner: validateString(owner),
+    root: hasKeys(profile, ['root']) && profile.root ? validateBoolean(profile.root) : false,
+    name: parseProfileName(name)
+  };
+};
+
+var parseProfileName = function parseProfileName(profileName) {
+  var expectedKeys = ['nameId'];
+
+  if (!hasKeys(profileName, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var nameId = profileName.nameId;
+  return {
+    nameId: validateString(nameId),
+    lastName: hasKeys(profileName, ['lastName']) ? validateOptionalString(profileName.lastName) : undefined,
+    firstName: hasKeys(profileName, ['firstName']) ? validateOptionalString(profileName.firstName) : undefined
+  };
+};
+
+var parseProfileHealth = function parseProfileHealth(profileHealth) {
+  var expectedKeys = ['healthId', 'dob', 'gender', 'ethnicity', 'weight', 'weightUnit', 'height', 'heightUnit', 'questionnaire'];
+
+  if (!hasKeys(profileHealth, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var healthId = profileHealth.healthId,
+      dob = profileHealth.dob,
+      gender = profileHealth.gender,
+      ethnicity = profileHealth.ethnicity,
+      weight = profileHealth.weight,
+      weightUnit = profileHealth.weightUnit,
+      height = profileHealth.height,
+      heightUnit = profileHealth.heightUnit,
+      questionnaire = profileHealth.questionnaire;
+  return {
+    healthId: validateString(healthId),
+    dob: validateString(dob),
+    gender: validateEnum(gender, Object.values(Gender)),
+    ethnicity: Object.values(Ethnicity).includes(ethnicity) ? ethnicity : undefined,
+    weight: weight ? {
+      value: Number(validateString(weight)),
+      unit: validateString(weightUnit)
+    } : undefined,
+    height: height ? {
+      value: validateNumber(height),
+      unit: validateString(heightUnit)
+    } : undefined,
+    questionnaire: questionnaire
+  };
+};
+
+var isHealth = function isHealth(health) {
+  if (typeof health !== 'object' || !health) {
+    return false;
+  }
+
+  return Object.keys(health).includes('healthId');
+};
+
+var isAvatar = function isAvatar(avatar) {
+  if (typeof avatar !== 'object' || !avatar) {
+    return false;
+  }
+
+  return Object.keys(avatar).includes('avatarId');
+};
+
+var isPreference = function isPreference(preference) {
+  if (typeof preference !== 'object' || !preference) {
+    return false;
+  }
+
+  return Object.keys(preference).includes('preferenceId');
+};
+
+var parseProfilePreference = function parseProfilePreference(profilePreference) {
+  var expectedKeys = ['preferenceId', 'language'];
+
+  if (!hasKeys(profilePreference, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var preferenceId = profilePreference.preferenceId,
+      language = profilePreference.language;
+  var location = hasKeys(profilePreference, ['location']) && profilePreference.location ? validateString(profilePreference.location) : undefined;
+  return {
+    preferenceId: validateString(preferenceId),
+    language: validateString(language),
+    location: location
+  };
+};
+
+var parseProfileEmail = function parseProfileEmail(profileEmail) {
+  var expectedKeys = ['emailId', 'datetime', 'primary', 'name', 'email'];
+
+  if (!hasKeys(profileEmail, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var emailId = profileEmail.emailId,
+      datetime = profileEmail.datetime,
+      primary = profileEmail.primary,
+      name = profileEmail.name,
+      email = profileEmail.email;
+  return {
+    emailId: validateString(emailId),
+    datetime: validateString(datetime),
+    primary: validateBoolean(primary),
+    name: validateString(name),
+    email: validateString(email)
+  };
+};
+
+var parseDeleteProfile = function parseDeleteProfile(deleteProfile) {
+  var expectedKeys = ['profileId', 'active'];
+
+  if (!hasKeys(deleteProfile, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var profileId = deleteProfile.profileId,
+      active = deleteProfile.active;
+  return {
+    profileId: validateString(profileId),
+    active: validateBoolean(active)
+  };
+};
+
+function parseProfileTag(profileTag) {
+  var expectedKeys = ['tagId', 'tag', 'active', 'modified'];
+
+  if (!hasKeys(profileTag, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var tagId = profileTag.tagId,
+      tag = profileTag.tag,
+      active = profileTag.active,
+      modified = profileTag.modified;
+  return {
+    tagId: validateString(tagId),
+    tag: validateString(tag),
+    active: validateBoolean(active),
+    modified: validateString(modified)
+  };
+}
+
+function parseProfileIdentity(profileIdentity) {
+  var expectedKeys = ['identityId', 'identityType', 'identityValue'];
+
+  if (!hasKeys(profileIdentity, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var identityId = profileIdentity.identityId,
+      identityType = profileIdentity.identityType,
+      identityValue = profileIdentity.identityValue;
+  return {
+    identityId: validateString(identityId),
+    identityType: validateEnum(identityType, Object.values(IdentityType)),
+    identityValue: validateString(identityValue)
+  };
+}
+
+function parseProfileAvatar(profileAvatar) {
+  var expectedKeys = ['url', 'avatarId', 'status'];
+
+  if (!hasKeys(profileAvatar, expectedKeys)) {
+    throw new Error("Missing keys " + expectedKeys.join(', '));
+  }
+
+  var url = profileAvatar.url,
+      avatarId = profileAvatar.avatarId,
+      status = profileAvatar.status;
+  return {
+    url: validateString(url),
+    avatarId: validateString(avatarId),
+    status: validateString(status)
+  };
+}
+
+var baseURL = undefined;
+var application = 'profile'; // Get Profiles
+
+var getProfiles = function getProfiles(token, species, handler) {
+  if (species === void 0) {
+    species = 'all';
+  }
+
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile',
+    method: 'GET',
+    headers: AuthHeader(token),
+    params: {
+      species: species
+    }
+  }, handler).then(function (response) {
+    return parseProfiles(response == null ? void 0 : response.data);
+  })["catch"](function (e) {
+    console.warn("Invalid profile: " + e);
+    throw e;
+  });
+};
+var postCreateProfile = function postCreateProfile(context, token, handler) {
+  var _context$health, _context$health$weigh, _context$health2, _context$health2$weig;
+
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile',
+    params: {
+      health: !!context.health,
+      email: !!context.email,
+      preference: true,
+      identity: !!context.identities && context.identities.length > 0,
+      species: !!context.species
+    },
+    method: 'POST',
+    data: {
+      profile: {
+        name: {
+          firstName: context.firstName,
+          lastName: context.lastName
+        },
+        email: {
+          name: v4(),
+          primary: true,
+          detail: {
+            email: context.email
+          }
+        },
+        health: _extends({}, context.health, {
+          weight: {
+            value: (_context$health = context.health) == null ? void 0 : (_context$health$weigh = _context$health.weight) == null ? void 0 : _context$health$weigh.value.toFixed(1),
+            unit: (_context$health2 = context.health) == null ? void 0 : (_context$health2$weig = _context$health2.weight) == null ? void 0 : _context$health2$weig.unit
+          }
+        }),
+        preference: {
+          language: context.locale
+        },
+        identities: context.identities,
+        species: context.species || undefined
+      }
+    },
+    headers: AuthHeader(token)
+  }, handler).then(function (response) {
+    return parseCreateProfile(response == null ? void 0 : response.data);
+  });
+};
+var putUpdateProfilePreference = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(context, token, handler) {
+    var response;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid/preference',
+              method: 'PUT',
+              data: {
+                preference: {
+                  language: context.language,
+                  location: context.location
+                }
+              },
+              headers: AuthHeader(token)
+            }, handler, {
+              profileid: context.profileId
+            });
+
+          case 2:
+            response = _context.sent;
+            return _context.abrupt("return", response);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function putUpdateProfilePreference(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var putUpdateProfileName = /*#__PURE__*/function () {
+  var _ref2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context, token, handler) {
+    var response;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid/name',
+              method: 'PUT',
+              data: {
+                name: {
+                  firstName: context.firstName,
+                  lastName: context.lastName
+                }
+              },
+              headers: AuthHeader(token)
+            }, handler, {
+              profileid: context.profileId
+            });
+
+          case 2:
+            response = _context2.sent;
+            return _context2.abrupt("return", response);
+
+          case 4:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function putUpdateProfileName(_x4, _x5, _x6) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var putUpdateProfileHealth = /*#__PURE__*/function () {
+  var _ref3 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(context, token, handler) {
+    var _context$weight, _context$weight2;
+
+    var response;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid/health',
+              method: 'PUT',
+              data: {
+                health: {
+                  weight: context.weight ? {
+                    unit: (_context$weight = context.weight) == null ? void 0 : _context$weight.unit,
+                    value: (_context$weight2 = context.weight) == null ? void 0 : _context$weight2.value.toFixed(1)
+                  } : undefined,
+                  height: context.height,
+                  gender: context.gender,
+                  dob: context.dob,
+                  ethnicity: context.ethnicity
+                }
+              },
+              headers: AuthHeader(token)
+            }, handler, {
+              profileid: context.profileId
+            });
+
+          case 2:
+            response = _context3.sent;
+            return _context3.abrupt("return", response);
+
+          case 4:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+
+  return function putUpdateProfileHealth(_x7, _x8, _x9) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+var postCreateProfileAddress = /*#__PURE__*/function () {
+  var _ref4 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(context, token, handler) {
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid/address',
+              method: 'POST',
+              data: {
+                address: {
+                  name: v4(),
+                  primary: true,
+                  detail: context.address
+                }
+              },
+              headers: AuthHeader(token)
+            }, handler, {
+              profileid: context.profileId
+            });
+
+          case 2:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 3:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+
+  return function postCreateProfileAddress(_x10, _x11, _x12) {
+    return _ref4.apply(this, arguments);
+  };
+}(); // FIXME: We should support the rest of field and move the all update profile call to use this one.
+//        Currently we are only doing phone update.
+
+var patchUpdateProfile = /*#__PURE__*/function () {
+  var _ref5 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(context, token, handler) {
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 2;
+            return request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid',
+              method: 'PATCH',
+              data: {
+                profile: {
+                  phone: {
+                    name: v4(),
+                    primary: true,
+                    detail: context.phone
+                  },
+                  species: context.species
+                }
+              },
+              params: {
+                phone: !!context.phone,
+                species: !!context.species
+              },
+              headers: AuthHeader(token)
+            }, handler, {
+              profileid: context.profileId
+            });
+
+          case 2:
+            return _context5.abrupt("return", _context5.sent);
+
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+
+  return function patchUpdateProfile(_x13, _x14, _x15) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+var deleteRemoveProfile = /*#__PURE__*/function () {
+  var _ref6 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(context, token, handler) {
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            return _context6.abrupt("return", request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid',
+              method: 'DELETE',
+              headers: AuthHeader(token)
+            }, handler, {
+              profileid: context.profileId
+            }).then(function (response) {
+              return parseDeleteProfile(response == null ? void 0 : response.data);
+            }));
+
+          case 1:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+
+  return function deleteRemoveProfile(_x16, _x17, _x18) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+var postCreateTag = function postCreateTag(context, token, handler) {
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile/:profileid/tag',
+    method: 'POST',
+    data: {
+      tag: {
+        tag: context.tag
+      }
+    },
+    headers: AuthHeader(token)
+  }, handler, {
+    profileid: context.profileId
+  });
+};
+var putUpdateTag = function putUpdateTag(context, token, handler) {
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile/:profileid/tag',
+    method: 'PUT',
+    data: {
+      tag: {
+        tag: context.tag
+      }
+    },
+    headers: AuthHeader(token)
+  }, handler, {
+    profileid: context.profileId
+  });
+};
+var deleteTag = function deleteTag(context, token, handler) {
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile/:profileid/tag/:tagId',
+    method: 'DELETE',
+    data: {},
+    headers: AuthHeader(token)
+  }, handler, {
+    profileid: context.profileId,
+    tagId: context.tagId
+  });
+};
+var postProfileIdentity = function postProfileIdentity(context, token, handler) {
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile/:profileid/identity',
+    method: 'POST',
+    data: {
+      identity: {
+        identityType: context.identityType,
+        identityValue: context.identityValue
+      }
+    },
+    headers: AuthHeader(token)
+  }, handler, {
+    profileid: context.profileId
+  });
+};
+var putUpdateProfileIdentity = function putUpdateProfileIdentity(context, token, handler) {
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile/:profileid/identity/:identityId',
+    method: 'PATCH',
+    data: {
+      identityType: context.identityType,
+      identityValue: context.identityValue
+    },
+    headers: AuthHeader(token)
+  }, handler, {
+    profileid: context.profileId,
+    identityId: context.identityId
+  });
+};
+var deleteProfileIdentity = function deleteProfileIdentity(context, token, handler) {
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/profile/:profileid/identity/:identityId',
+    method: 'DELETE',
+    headers: AuthHeader(token)
+  }, handler, {
+    profileid: context.profileId,
+    identityId: context.identityId
+  });
+};
+var putUpdateQuestionnaire = function putUpdateQuestionnaire(context, token, handler) {
+  var _answers;
+
+  return request({
+    baseURL: baseURL,
+    url: application + '/v1.0/health/:healthid/questionnaire',
+    method: 'PUT',
+    data: {
+      answers: (_answers = {}, _answers[PARTNER] = context.answers, _answers)
+    },
+    headers: _extends({}, AuthHeader(token), {
+      'x-owner': context.owner
+    })
+  }, handler, {
+    healthid: context.healthId
+  });
+};
+var postProfileAvatar = /*#__PURE__*/function () {
+  var _ref7 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(context, token, handler) {
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return request({
+              baseURL: baseURL,
+              url: application + '/v1.0/profile/:profileid/avatar',
+              method: 'POST',
+              data: context.formData,
+              headers: _extends({}, AuthHeader(token), {
+                'content-type': 'multipart/form-data'
+              })
+            }, handler, {
+              profileid: context.profileId
+            });
+
+          case 2:
+            return _context7.abrupt("return", _context7.sent);
+
+          case 3:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7);
+  }));
+
+  return function postProfileAvatar(_x19, _x20, _x21) {
+    return _ref7.apply(this, arguments);
+  };
+}();
+
+var getProfileDateTime = function getProfileDateTime(profile) {
+  var _profile$email;
+
+  var profileEmail = (_profile$email = profile.email) == null ? void 0 : _profile$email.find(function (email) {
+    return email.datetime;
+  });
+  if (!profileEmail) return;
+  var date = moment(validateString(profileEmail.datetime));
+
+  if (date.isValid()) {
+    return date;
+  }
+};
+
+var getRootProfile = function getRootProfile(profiles) {
+  return profiles.find(function (item) {
+    return item.root;
+  });
+};
+var getUserProfile = function getUserProfile(profiles) {
+  return profiles.filter(function (profile) {
+    return !profile.root;
+  }).sort(function (a, b) {
+    var aDate = getProfileDateTime(a);
+    var bDate = getProfileDateTime(b);
+
+    if (!aDate || !bDate) {
+      return 1;
+    }
+
+    return bDate.diff(aDate);
+  });
+};
+
+var usePrevious = function usePrevious(value) {
+  var ref = useRef();
+  useEffect(function () {
+    ref.current = value;
+  });
+  return ref.current;
+};
+
+var ProfileProvider = function ProfileProvider(_ref) {
+  var children = _ref.children,
+      _ref$locale = _ref.locale,
+      locale = _ref$locale === void 0 ? 'en-HK' : _ref$locale,
+      defaults = _ref.defaults,
+      capturing = _ref.capturing;
+
+  // Provider
+  var _useAuth = useAuth(),
+      token = _useAuth.token; // State
+
+
+  var _useState = useState(false),
+      isReady = _useState[0],
+      setReady = _useState[1];
+
+  var _useState2 = useState(),
+      profiles = _useState2[0],
+      setProfiles = _useState2[1];
+
+  var _useState3 = useState(),
+      userProfiles = _useState3[0],
+      setUserProfiles = _useState3[1];
+
+  var _useState4 = useState(),
+      rootProfile = _useState4[0],
+      setRootProfile = _useState4[1];
+
+  var _useState5 = useState(),
+      currentProfile = _useState5[0],
+      _setCurrentProfile = _useState5[1];
+
+  var prevRootProfile = usePrevious(rootProfile);
+  var prevCurrentProfile = usePrevious(currentProfile);
+  var refreshProfiles = useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(token) {
+      var profiles;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (token) {
+                _context.next = 2;
+                break;
+              }
+
+              return _context.abrupt("return");
+
+            case 2:
+              _context.next = 4;
+              return getProfiles(token, 'all', ApiErrorHandler);
+
+            case 4:
+              profiles = _context.sent;
+              setProfiles(profiles);
+              setUserProfiles(getUserProfile(profiles));
+              setRootProfile(getRootProfile(profiles));
+
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), []);
+  var createProfile = useCallback( /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+      var newProfie;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+
+              if (token) {
+                _context2.next = 3;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 3:
+              console.log("Creating profile " + context.firstName + " " + context.lastName);
+              _context2.next = 6;
+              return postCreateProfile(context, token, ApiErrorHandler);
+
+            case 6:
+              newProfie = _context2.sent;
+              _context2.next = 9;
+              return refreshProfiles(token);
+
+            case 9:
+              console.log('Set default profile to new profile:', newProfie.profileId);
+
+              _setCurrentProfile(newProfie);
+
+              return _context2.abrupt("return", newProfie);
+
+            case 14:
+              _context2.prev = 14;
+              _context2.t0 = _context2["catch"](0);
+              throw _context2.t0;
+
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[0, 14]]);
+    }));
+
+    return function (_x2) {
+      return _ref3.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var updateProfile = useCallback( /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(profileId, category, refresh) {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (refresh === void 0) {
+                refresh = true;
+              }
+
+              _context3.prev = 1;
+
+              if (token) {
+                _context3.next = 4;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 4:
+              _context3.t0 = category.preference;
+
+              if (!_context3.t0) {
+                _context3.next = 8;
+                break;
+              }
+
+              _context3.next = 8;
+              return putUpdateProfilePreference({
+                profileId: profileId,
+                language: category.preference.language,
+                location: category.preference.location || undefined
+              }, token, ApiErrorHandler);
+
+            case 8:
+              _context3.t1 = category.name;
+
+              if (!_context3.t1) {
+                _context3.next = 12;
+                break;
+              }
+
+              _context3.next = 12;
+              return putUpdateProfileName({
+                profileId: profileId,
+                firstName: category.name.firstName,
+                lastName: category.name.lastName
+              }, token, ApiErrorHandler);
+
+            case 12:
+              _context3.t2 = category.health && category.health.dob && category.health.ethnicity;
+
+              if (!_context3.t2) {
+                _context3.next = 16;
+                break;
+              }
+
+              _context3.next = 16;
+              return putUpdateProfileHealth({
+                profileId: profileId,
+                gender: category.health.gender,
+                dob: category.health.dob,
+                ethnicity: category.health.ethnicity,
+                height: category.health.height ? {
+                  value: category.health.height.value,
+                  unit: category.health.height.unit
+                } : undefined,
+                weight: category.health.weight ? {
+                  value: category.health.weight.value,
+                  unit: category.health.weight.unit
+                } : undefined
+              }, token, ApiErrorHandler);
+
+            case 16:
+              _context3.t3 = category.phone || category.species;
+
+              if (!_context3.t3) {
+                _context3.next = 20;
+                break;
+              }
+
+              _context3.next = 20;
+              return patchUpdateProfile({
+                profileId: profileId,
+                phone: category.phone,
+                species: category.species
+              }, token, ApiErrorHandler);
+
+            case 20:
+              if (!refresh) {
+                _context3.next = 24;
+                break;
+              }
+
+              console.log('Refresh after profile update');
+              _context3.next = 24;
+              return refreshProfiles(token);
+
+            case 24:
+              _context3.next = 29;
+              break;
+
+            case 26:
+              _context3.prev = 26;
+              _context3.t4 = _context3["catch"](1);
+              throw _context3.t4;
+
+            case 29:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, null, [[1, 26]]);
+    }));
+
+    return function (_x3, _x4, _x5) {
+      return _ref4.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var deleteProfile = useCallback( /*#__PURE__*/function () {
+    var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(profileId) {
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.prev = 0;
+
+              if (token) {
+                _context4.next = 3;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 3:
+              _context4.next = 5;
+              return deleteRemoveProfile({
+                profileId: profileId
+              }, token, ApiErrorHandler);
+
+            case 5:
+              _context4.next = 7;
+              return refreshProfiles(token);
+
+            case 7:
+              _context4.next = 12;
+              break;
+
+            case 9:
+              _context4.prev = 9;
+              _context4.t0 = _context4["catch"](0);
+              throw _context4.t0;
+
+            case 12:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, null, [[0, 9]]);
+    }));
+
+    return function (_x6) {
+      return _ref5.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var createTag = useCallback( /*#__PURE__*/function () {
+    var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(profileId, tag) {
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              if (token) {
+                _context5.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context5.next = 4;
+              return postCreateTag({
+                profileId: profileId,
+                tag: tag
+              }, token, ApiErrorHandler);
+
+            case 4:
+              _context5.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    }));
+
+    return function (_x7, _x8) {
+      return _ref6.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var updateTag = useCallback( /*#__PURE__*/function () {
+    var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(profileId, tag) {
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              if (token) {
+                _context6.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context6.next = 4;
+              return putUpdateTag({
+                profileId: profileId,
+                tag: tag
+              }, token, ApiErrorHandler);
+
+            case 4:
+              _context6.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6);
+    }));
+
+    return function (_x9, _x10) {
+      return _ref7.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var deleteTag$1 = useCallback( /*#__PURE__*/function () {
+    var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(profileId, tagId) {
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              if (token) {
+                _context7.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context7.next = 4;
+              return deleteTag({
+                profileId: profileId,
+                tagId: tagId
+              }, token, ApiErrorHandler);
+
+            case 4:
+              _context7.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7);
+    }));
+
+    return function (_x11, _x12) {
+      return _ref8.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var createIdentity = useCallback( /*#__PURE__*/function () {
+    var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(profileId, identity) {
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              if (token) {
+                _context8.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context8.next = 4;
+              return postProfileIdentity(_extends({
+                profileId: profileId
+              }, identity), token, ApiErrorHandler);
+
+            case 4:
+              _context8.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8);
+    }));
+
+    return function (_x13, _x14) {
+      return _ref9.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var updateIdentity = useCallback( /*#__PURE__*/function () {
+    var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(profileId, profileIdentity) {
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) {
+          switch (_context9.prev = _context9.next) {
+            case 0:
+              if (token) {
+                _context9.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context9.next = 4;
+              return putUpdateProfileIdentity(_extends({
+                profileId: profileId
+              }, profileIdentity), token, ApiErrorHandler);
+
+            case 4:
+              _context9.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context9.stop();
+          }
+        }
+      }, _callee9);
+    }));
+
+    return function (_x15, _x16) {
+      return _ref10.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var deleteIdentity = useCallback( /*#__PURE__*/function () {
+    var _ref11 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(profileId, identityId) {
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) {
+          switch (_context10.prev = _context10.next) {
+            case 0:
+              if (token) {
+                _context10.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context10.next = 4;
+              return deleteProfileIdentity({
+                profileId: profileId,
+                identityId: identityId
+              }, token, ApiErrorHandler);
+
+            case 4:
+              _context10.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context10.stop();
+          }
+        }
+      }, _callee10);
+    }));
+
+    return function (_x17, _x18) {
+      return _ref11.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var createAddress = useCallback( /*#__PURE__*/function () {
+    var _ref12 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(profileId, address) {
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) {
+          switch (_context11.prev = _context11.next) {
+            case 0:
+              if (token) {
+                _context11.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context11.next = 4;
+              return postCreateProfileAddress({
+                profileId: profileId,
+                address: address
+              }, token, ApiErrorHandler);
+
+            case 4:
+              _context11.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context11.stop();
+          }
+        }
+      }, _callee11);
+    }));
+
+    return function (_x19, _x20) {
+      return _ref12.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var updateQuestionnaire = useCallback( /*#__PURE__*/function () {
+    var _ref13 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(profile, questionnaire) {
+      var _profile$health;
+
+      var healthId;
+      return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+        while (1) {
+          switch (_context12.prev = _context12.next) {
+            case 0:
+              if (token) {
+                _context12.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              healthId = profile == null ? void 0 : (_profile$health = profile.health) == null ? void 0 : _profile$health.healthId;
+
+              if (healthId) {
+                _context12.next = 5;
+                break;
+              }
+
+              throw new Error("Missing health record in profile " + profile.profileId);
+
+            case 5:
+              _context12.next = 7;
+              return putUpdateQuestionnaire({
+                healthId: healthId,
+                owner: profile.owner,
+                answers: questionnaire
+              }, token, ApiErrorHandler);
+
+            case 7:
+              _context12.next = 9;
+              return refreshProfiles(token);
+
+            case 9:
+            case "end":
+              return _context12.stop();
+          }
+        }
+      }, _callee12);
+    }));
+
+    return function (_x21, _x22) {
+      return _ref13.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]);
+  var createAvatar = useCallback( /*#__PURE__*/function () {
+    var _ref14 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(profileId, formData) {
+      return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+        while (1) {
+          switch (_context13.prev = _context13.next) {
+            case 0:
+              if (token) {
+                _context13.next = 2;
+                break;
+              }
+
+              throw new AuthorizationError('Unauthorized', AuthorizationErrorReason.Unauthroized);
+
+            case 2:
+              _context13.next = 4;
+              return postProfileAvatar({
+                profileId: profileId,
+                formData: formData
+              }, token, ApiErrorHandler);
+
+            case 4:
+              _context13.next = 6;
+              return refreshProfiles(token);
+
+            case 6:
+            case "end":
+              return _context13.stop();
+          }
+        }
+      }, _callee13);
+    }));
+
+    return function (_x23, _x24) {
+      return _ref14.apply(this, arguments);
+    };
+  }(), [refreshProfiles, token]); // Init Profile Provider
+
+  useEffect(function () {
+    if (token) {
+      refreshProfiles(token)["catch"](function (e) {
+        return capture(e, capturing);
+      })["finally"]( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
+        return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+          while (1) {
+            switch (_context14.prev = _context14.next) {
+              case 0:
+                setReady(true);
+
+              case 1:
+              case "end":
+                return _context14.stop();
+            }
+          }
+        }, _callee14);
+      })));
+    } else {
+      setReady(true);
+    }
+  }, [capturing, refreshProfiles, token]); // Init/Update Current Profile
+
+  useEffect(function () {
+    var setDefaultProfile = function setDefaultProfile(profiles, defaultProfileId) {
+      _setCurrentProfile(function (current) {
+        var latestCurrent = profiles.find(function (p) {
+          return p.profileId === (current == null ? void 0 : current.profileId);
+        });
+
+        if (current && latestCurrent && !equal(current, latestCurrent)) {
+          return _extends({}, latestCurrent);
+        }
+
+        if (!current) {
+          if (defaultProfileId) {
+            // if defaults profile is cached/set by called use it
+            var found = profiles.find(function (p) {
+              return p.profileId === defaultProfileId;
+            }); // use the latest one if caller preferred profile does not exist
+
+            var target = found || profiles[0];
+            console.log('Set default profile:', target.profileId);
+            return _extends({}, target);
+          } else {
+            // otherwise go for whatever is latest
+            console.log('Set defeault profile to latest:', profiles[0].profileId);
+            return _extends({}, profiles[0]);
+          }
+        }
+
+        return current;
+      });
+    };
+
+    var mounted = true;
+
+    if (profiles) {
+      var _userProfiles = getUserProfile(profiles);
+
+      if (_userProfiles.length === 0) {
+        console.log('Reset default profile');
+        if (mounted) _setCurrentProfile(undefined);
+      } else {
+        if (defaults != null && defaults.pid) {
+          var _rootProfile = getRootProfile(profiles);
+
+          defaults.pid(_rootProfile == null ? void 0 : _rootProfile.profileId).then(function (defaultProfileId) {
+            if (mounted) setDefaultProfile(_userProfiles, defaultProfileId);
+          });
+        } else {
+          if (mounted) setDefaultProfile(_userProfiles);
+        }
+      }
+    }
+
+    return function () {
+      mounted = false;
+    };
+  }, [defaults, profiles]); // Update locale for root profile whenever switch/login to an account
+
+  useEffect(function () {
+    if (rootProfile && (prevRootProfile == null ? void 0 : prevRootProfile.profileId) !== rootProfile.profileId) {
+      var _rootProfile$preferen;
+
+      if (((_rootProfile$preferen = rootProfile.preference) == null ? void 0 : _rootProfile$preferen.language) !== locale) {
+        console.log("Update account language to " + locale); // Don't really care if it fails
+
+        updateProfile(rootProfile.profileId, {
+          preference: {
+            language: locale
+          }
+        })["catch"](function (error) {
+          return capture(error, capturing);
+        });
+      }
+    }
+  }, [capturing, locale, prevRootProfile == null ? void 0 : prevRootProfile.profileId, rootProfile, updateProfile]); // Update locale for user profile whenever switching/creating a new profile
+
+  useEffect(function () {
+    if (currentProfile && (prevCurrentProfile == null ? void 0 : prevCurrentProfile.profileId) !== currentProfile.profileId) {
+      var _currentProfile$prefe;
+
+      if (((_currentProfile$prefe = currentProfile.preference) == null ? void 0 : _currentProfile$prefe.language) !== locale) {
+        console.log("Update profile language to " + locale); // Don't really care if it fails
+
+        updateProfile(currentProfile.profileId, {
+          preference: {
+            language: locale
+          }
+        }, false)["catch"](function (error) {
+          return capture(error, capturing);
+        });
+      }
+    }
+  }, [locale, prevCurrentProfile, currentProfile, updateProfile, capturing]); // Clean up (Basically logout)
+
+  useEffect(function () {
+    if (!token) {
+      console.log('ProfileProvider cleanup');
+      setProfiles(undefined);
+      setRootProfile(undefined);
+      setUserProfiles(undefined);
+
+      _setCurrentProfile(undefined);
+    }
+  }, [token]);
+  var profileContext = React.useMemo(function () {
+    return {
+      isProfileReady: isReady,
+      userProfiles: userProfiles,
+      rootProfile: rootProfile,
+      currentProfile: currentProfile,
+      setCurrentProfile: function () {
+        var _setCurrentProfile2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(profile) {
+          var target;
+          return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+            while (1) {
+              switch (_context15.prev = _context15.next) {
+                case 0:
+                  if (rootProfile && profile && userProfiles) {
+                    target = userProfiles.find(function (p) {
+                      return p.profileId === profile.profileId;
+                    });
+
+                    if (target) {
+                      console.log('Set curent profile:', target.profileId);
+
+                      _setCurrentProfile(target);
+                    }
+                  }
+
+                case 1:
+                case "end":
+                  return _context15.stop();
+              }
+            }
+          }, _callee15);
+        }));
+
+        function setCurrentProfile(_x25) {
+          return _setCurrentProfile2.apply(this, arguments);
+        }
+
+        return setCurrentProfile;
+      }(),
+      createProfile: createProfile,
+      updateProfile: updateProfile,
+      deleteProfile: deleteProfile,
+      createTag: createTag,
+      updateTag: updateTag,
+      deleteTag: deleteTag$1,
+      createIdentity: createIdentity,
+      updateIdentity: updateIdentity,
+      deleteIdentity: deleteIdentity,
+      createAddress: createAddress,
+      updateQuestionnaire: updateQuestionnaire,
+      createAvatar: createAvatar
+    };
+  }, [isReady, userProfiles, rootProfile, currentProfile, createProfile, updateProfile, deleteProfile, createTag, updateTag, deleteTag$1, createIdentity, updateIdentity, deleteIdentity, createAddress, updateQuestionnaire, createAvatar]);
+  return React.createElement(ProfileContext.Provider, {
+    value: profileContext
+  }, children);
+};
+var useProfile = function useProfile() {
+  return useContext(ProfileContext);
+};
+
+export { AuthProvider, AuthenticationError, AuthenticationErrorReason, AuthorizationError, AuthorizationErrorReason, Ethnicities, Ethnicity, Gender, IdentityType, ProfileProvider, UnexpectedError, useAuth, useProfile };
+//# sourceMappingURL=react-context-provider.esm.js.map