@lacagnottedesproches/lcdp-js-lite 1.6.0

package/dist/index.mjs

@@ -0,0 +1,588 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return p;
+}
+function _createClass(e, r, t) {
+  return Object.defineProperty(e, "prototype", {
+    writable: false
+  }), e;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var LCDPRequest = /*#__PURE__*/_createClass(function LCDPRequest(secret, apiUrl) {
+  var _this = this;
+  _classCallCheck(this, LCDPRequest);
+  _defineProperty(this, "_apiToken", void 0);
+  _defineProperty(this, "_apiUrl", void 0);
+  _defineProperty(this, "requestLCDPApi", function (endpoint, payload, authToken) {
+    var customMethod = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "POST";
+    if (typeof window !== "undefined") {
+      throw new Error("Must be used server side");
+    }
+    return new Promise(/*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(resolve, reject) {
+        var url, response, status, _yield$response$json, detail, data, _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              url = "".concat(_this._apiUrl, "/").concat(endpoint);
+              _context.p = 1;
+              _context.n = 2;
+              return fetch(url, {
+                method: customMethod,
+                headers: {
+                  "Content-Type": "application/json",
+                  "User-Agent": "lcdp/v1",
+                  Authorization: "Bearer ".concat(authToken)
+                },
+                body: JSON.stringify(payload)
+              });
+            case 2:
+              response = _context.v;
+              status = response.status;
+              if (!(status >= 400)) {
+                _context.n = 4;
+                break;
+              }
+              _context.n = 3;
+              return response.json();
+            case 3:
+              _yield$response$json = _context.v;
+              detail = _yield$response$json.detail;
+              reject(detail);
+              _context.n = 7;
+              break;
+            case 4:
+              if (!(status === 204)) {
+                _context.n = 5;
+                break;
+              }
+              resolve();
+              _context.n = 7;
+              break;
+            case 5:
+              _context.n = 6;
+              return response.json();
+            case 6:
+              data = _context.v;
+              resolve(data);
+            case 7:
+              _context.n = 9;
+              break;
+            case 8:
+              _context.p = 8;
+              _t = _context.v;
+              reject(_t);
+            case 9:
+              return _context.a(2);
+          }
+        }, _callee, null, [[1, 8]]);
+      }));
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+  });
+  _defineProperty(this, "createAccount", /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(payload) {
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.n) {
+          case 0:
+            return _context3.a(2, new Promise(/*#__PURE__*/function () {
+              var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(resolve, reject) {
+                var responsePromise;
+                return _regenerator().w(function (_context2) {
+                  while (1) switch (_context2.n) {
+                    case 0:
+                      responsePromise = _this.requestLCDPApi("accounts", payload, _this._apiToken);
+                      return _context2.a(2, responsePromise.then(function (data) {
+                        try {
+                          // TODO: may be improved
+                          resolve(data);
+                        } catch (error) {
+                          reject(error);
+                        }
+                      })["catch"](function (reason) {
+                        return reject(reason);
+                      }));
+                  }
+                }, _callee2);
+              }));
+              return function (_x4, _x5) {
+                return _ref3.apply(this, arguments);
+              };
+            }()));
+        }
+      }, _callee3);
+    }));
+    return function (_x3) {
+      return _ref2.apply(this, arguments);
+    };
+  }());
+  _defineProperty(this, "createPot", /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(payload) {
+      return _regenerator().w(function (_context5) {
+        while (1) switch (_context5.n) {
+          case 0:
+            return _context5.a(2, new Promise(/*#__PURE__*/function () {
+              var _ref5 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(resolve, reject) {
+                var responsePromise;
+                return _regenerator().w(function (_context4) {
+                  while (1) switch (_context4.n) {
+                    case 0:
+                      responsePromise = _this.requestLCDPApi("pots", payload, _this._apiToken);
+                      return _context4.a(2, responsePromise.then(function (data) {
+                        try {
+                          // TODO: may be improved
+                          resolve(data);
+                        } catch (error) {
+                          reject(error);
+                        }
+                      })["catch"](function (reason) {
+                        return reject(reason);
+                      }));
+                  }
+                }, _callee4);
+              }));
+              return function (_x7, _x8) {
+                return _ref5.apply(this, arguments);
+              };
+            }()));
+        }
+      }, _callee5);
+    }));
+    return function (_x6) {
+      return _ref4.apply(this, arguments);
+    };
+  }());
+  _defineProperty(this, "createAccountAndPot", /*#__PURE__*/function () {
+    var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(payload) {
+      return _regenerator().w(function (_context7) {
+        while (1) switch (_context7.n) {
+          case 0:
+            return _context7.a(2, new Promise(/*#__PURE__*/function () {
+              var _ref7 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(resolve, reject) {
+                var responsePromise;
+                return _regenerator().w(function (_context6) {
+                  while (1) switch (_context6.n) {
+                    case 0:
+                      responsePromise = _this.requestLCDPApi("wizards", payload, _this._apiToken);
+                      return _context6.a(2, responsePromise.then(function (data) {
+                        try {
+                          // TODO: may be improved
+                          resolve(data);
+                        } catch (error) {
+                          reject(error);
+                        }
+                      })["catch"](function (reason) {
+                        return reject(reason);
+                      }));
+                  }
+                }, _callee6);
+              }));
+              return function (_x0, _x1) {
+                return _ref7.apply(this, arguments);
+              };
+            }()));
+        }
+      }, _callee7);
+    }));
+    return function (_x9) {
+      return _ref6.apply(this, arguments);
+    };
+  }());
+  _defineProperty(this, "updatePot", /*#__PURE__*/function () {
+    var _ref8 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(payload) {
+      return _regenerator().w(function (_context9) {
+        while (1) switch (_context9.n) {
+          case 0:
+            return _context9.a(2, new Promise(/*#__PURE__*/function () {
+              var _ref9 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(resolve, reject) {
+                var responsePromise;
+                return _regenerator().w(function (_context8) {
+                  while (1) switch (_context8.n) {
+                    case 0:
+                      responsePromise = _this.requestLCDPApi("pots", payload, _this._apiToken, "PATCH");
+                      return _context8.a(2, responsePromise.then(function (_) {
+                        try {
+                          resolve();
+                        } catch (error) {
+                          reject(error);
+                        }
+                      })["catch"](function (reason) {
+                        return reject(reason);
+                      }));
+                  }
+                }, _callee8);
+              }));
+              return function (_x11, _x12) {
+                return _ref9.apply(this, arguments);
+              };
+            }()));
+        }
+      }, _callee9);
+    }));
+    return function (_x10) {
+      return _ref8.apply(this, arguments);
+    };
+  }());
+  if (typeof window !== "undefined") {
+    throw new Error("Must be used server side");
+  }
+  this._apiToken = secret;
+  this._apiUrl = apiUrl;
+});
+
+var AfinaError;
+(function (AfinaError) {
+  AfinaError["Verify"] = "Fail to verify origin request";
+  AfinaError["Stripe"] = "Stripe is not available";
+  AfinaError["ClientSide"] = "Should be on Client Side";
+  AfinaError["Key"] = "A publishable key is mandatory";
+})(AfinaError || (AfinaError = {}));
+var TokenObjectType;
+(function (TokenObjectType) {
+  TokenObjectType["Account"] = "account";
+  TokenObjectType["Pot"] = "pot";
+  TokenObjectType["Wizard"] = "wizard";
+})(TokenObjectType || (TokenObjectType = {}));
+
+var lcdpPromise = null;
+var API_URL = "https://api.lacagnottedesproches.fr";
+var API_URL_REGEX = function API_URL_REGEX(url) {
+  return new RegExp("/^".concat(url, "?(.*)$/"));
+};
+var onErrorListener = null;
+var onLoadListener = null;
+var onError = function onError(reject) {
+  return function () {
+    reject(new Error("Failed to load lcdp.js"));
+  };
+};
+var onLoad = function onLoad(resolve, reject) {
+  return function () {
+    var _window$lcdp;
+    if ((_window$lcdp = window.lcdp) !== null && _window$lcdp !== void 0 && _window$lcdp.Afina) {
+      resolve(window.lcdp.Afina);
+    } else {
+      reject(new Error("lcdp.js not available"));
+    }
+  };
+};
+var findScript = function findScript(url, url_regex) {
+  var scripts = document.querySelectorAll("script[src^=\"".concat(url, "\"]"));
+  for (var i = 0; i < scripts.length; i++) {
+    var script = scripts[i];
+    if (!url_regex.test(script.src)) {
+      continue;
+    }
+    return script;
+  }
+  return null;
+};
+var injectScript = function injectScript(url) {
+  var script = document.createElement("script");
+  script.src = "".concat(url, "/js");
+  var headOrBody = document.head || document.body;
+  if (!headOrBody) {
+    throw new Error("Expected document.body not to be null. Stripe.js requires a <body> element.");
+  }
+  headOrBody.appendChild(script);
+  var divModalRoot = document.createElement("div");
+  divModalRoot.id = "lcdp-modal-root";
+  document.body.appendChild(divModalRoot);
+  return script;
+};
+var getLCDPPromise = function getLCDPPromise(args) {
+  if (lcdpPromise) {
+    return lcdpPromise;
+  }
+  lcdpPromise = new Promise(function (resolve, reject) {
+    var _window$lcdp2;
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      resolve(null);
+      return;
+    }
+    if ((_window$lcdp2 = window.lcdp) !== null && _window$lcdp2 !== void 0 && _window$lcdp2.Afina) {
+      resolve(window.lcdp.Afina);
+      return;
+    }
+    var url = API_URL;
+    var url_regex = API_URL_REGEX(url);
+    if (args && args.length >= 2) {
+      var opts = args[1];
+      if (opts !== null && opts !== void 0 && opts.api_url) {
+        url = opts.api_url;
+        url_regex = API_URL_REGEX(url);
+      }
+    }
+    try {
+      var script = findScript(url, url_regex);
+      if (script) {
+        console.warn("it seems a lcdp script already exists.");
+      } else if (!script) {
+        script = injectScript(url);
+      } else if (script && onLoadListener !== null && onErrorListener !== null) {
+        var _script$parentNode;
+        // remove event listeners
+        script.removeEventListener("load", onLoadListener);
+        script.removeEventListener("error", onErrorListener);
+        // if script exists, but we are reloading due to an error,
+        // reload script to trigger 'load' event
+        (_script$parentNode = script.parentNode) === null || _script$parentNode === void 0 || _script$parentNode.removeChild(script);
+        script = injectScript(url);
+      }
+      onLoadListener = onLoad(resolve, reject);
+      onErrorListener = onError(reject);
+      script.addEventListener("load", onLoadListener);
+      script.addEventListener("error", onErrorListener);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+  });
+  return lcdpPromise;
+};
+var initLCDP = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(maybeLCDP, args) {
+    var lcdp;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          if (!(maybeLCDP === null)) {
+            _context.n = 1;
+            break;
+          }
+          return _context.a(2, Promise.resolve(null));
+        case 1:
+          lcdp = _construct(maybeLCDP, _toConsumableArray(args));
+          return _context.a(2, lcdp.init().then(function (lcdpReady) {
+            return lcdpReady;
+          }));
+      }
+    }, _callee);
+  }));
+  return function initLCDP(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var loadLCDP = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+    var _len,
+      args,
+      _key,
+      _args2 = arguments;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          for (_len = _args2.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = _args2[_key];
+          }
+          return _context2.a(2, getLCDPPromise(args).then(function (lcdp) {
+            return initLCDP(lcdp, args);
+          }));
+      }
+    }, _callee2);
+  }));
+  return function loadLCDP() {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var requestLCDP = function requestLCDP(secret) {
+  var apiUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : API_URL;
+  return new LCDPRequest(secret, apiUrl);
+};
+
+export { AfinaError, TokenObjectType, loadLCDP, requestLCDP };