@prosopo/procaptcha-frictionless 2.5.5 → 2.6.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @prosopo/procaptcha-frictionless
+
+## 2.6.1
+
+### Patch Changes
+
+- Updated dependencies [52feffc]
+  - @prosopo/types@2.6.1
+  - @prosopo/procaptcha-pow@2.6.1
+  - @prosopo/procaptcha-react@2.6.1
+
+## 2.6.0
+
+### Minor Changes
+
+- a0bfc8a: bump all pkg versions since independent versioning applied
+
+### Patch Changes
+
+- Updated dependencies [a0bfc8a]
+  - @prosopo/detector@2.6.0
+  - @prosopo/locale@2.6.0
+  - @prosopo/procaptcha-pow@2.6.0
+  - @prosopo/procaptcha-react@2.6.0
+  - @prosopo/types@2.6.0
+  - @prosopo/widget-skeleton@2.6.0

package/dist/cjs/ProcaptchaFrictionless.cjs

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const locale = require("@prosopo/locale");
+const procaptchaCommon = require("@prosopo/procaptcha-common");
+const procaptchaPow = require("@prosopo/procaptcha-pow");
+const procaptchaReact = require("@prosopo/procaptcha-react");
+const types = require("@prosopo/types");
+const widgetSkeleton = require("@prosopo/widget-skeleton");
+const react = require("react");
+const customDetectBot = require("./customDetectBot.cjs");
+const renderPlaceholder = (theme, mode, errorMessage, translationFn, loading) => {
+  const checkboxTheme = "light" === theme ? widgetSkeleton.lightTheme : widgetSkeleton.darkTheme;
+  if (mode === "invisible") {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    procaptchaCommon.Checkbox,
+    {
+      theme: checkboxTheme,
+      onChange: async () => {
+      },
+      checked: false,
+      labelText: translationFn("WIDGET.I_AM_HUMAN"),
+      error: errorMessage,
+      "aria-label": "human checkbox",
+      loading
+    }
+  );
+};
+const defaultLoadingState = (attemptCount) => ({
+  loading: false,
+  attemptCount: attemptCount || 0
+});
+const ProcaptchaFrictionless = ({
+  config,
+  callbacks,
+  restart,
+  i18n,
+  detectBot = customDetectBot
+}) => {
+  const stateRef = react.useRef(defaultLoadingState(0));
+  const events = procaptchaCommon.getDefaultEvents(callbacks);
+  react.useEffect(() => {
+    if (config.language) {
+      if (i18n) {
+        if (i18n.language !== config.language) {
+          i18n.changeLanguage(config.language).then((r) => r);
+        }
+      } else {
+        locale.loadI18next(false).then((i18n2) => {
+          if (i18n2.language !== config.language)
+            i18n2.changeLanguage(config.language).then((r) => r);
+        });
+      }
+    }
+  }, [i18n, config.language]);
+  const [componentToRender, setComponentToRender] = react.useState(
+    renderPlaceholder(
+      config.theme,
+      config.mode,
+      stateRef.current.errorMessage,
+      i18n.t,
+      true
+    )
+  );
+  const resetState = (attemptCount) => {
+    stateRef.current = defaultLoadingState(
+      attemptCount || stateRef.current.attemptCount
+    );
+  };
+  const fallOverWithStyle = (errorMessage, errorKey) => {
+    if (errorKey === "CAPTCHA.NO_SESSION_FOUND") {
+      setTimeout(() => {
+        restartComponentTimeout();
+      }, 0);
+    }
+    setComponentToRender(
+      renderPlaceholder(
+        config.theme,
+        config.mode,
+        errorMessage || "Cannot load CAPTCHA",
+        i18n.t,
+        false
+      )
+    );
+  };
+  const restartComponentTimeout = () => {
+    setTimeout(() => {
+      resetState(0);
+      events.onReset();
+      restart();
+    }, 1e4);
+  };
+  const start = async () => {
+    await procaptchaCommon.providerRetry(
+      async () => {
+        stateRef.current.attemptCount += 1;
+        const configOutput = types.ProcaptchaConfigSchema.parse(config);
+        const result = await detectBot(configOutput);
+        if (result.error?.message) {
+          stateRef.current = {
+            ...stateRef.current,
+            loading: false,
+            errorMessage: result.error?.message
+          };
+          events.onError(new Error(result.error?.message));
+          fallOverWithStyle(result.error?.message, result.error?.key);
+          return;
+        }
+        const frictionlessState = {
+          provider: result.provider,
+          sessionId: result.sessionId,
+          userAccount: result.userAccount,
+          restart
+          // Pass restart function
+        };
+        if (result.captchaType === "image") {
+          setComponentToRender(
+            /* @__PURE__ */ jsxRuntime.jsx(
+              procaptchaReact.Procaptcha,
+              {
+                config,
+                callbacks,
+                frictionlessState,
+                i18n
+              }
+            )
+          );
+        } else {
+          setComponentToRender(
+            /* @__PURE__ */ jsxRuntime.jsx(
+              procaptchaPow.ProcaptchaPow,
+              {
+                config,
+                callbacks,
+                frictionlessState,
+                i18n
+              }
+            )
+          );
+          stateRef.current = {
+            ...stateRef.current,
+            loading: false
+          };
+        }
+      },
+      start,
+      resetState,
+      stateRef.current.attemptCount,
+      5
+    ).finally(() => {
+      if (stateRef.current.attemptCount >= 5) {
+        fallOverWithStyle();
+        restartComponentTimeout();
+      }
+    });
+  };
+  react.useEffect(() => {
+    const detectAndSetComponent = async () => {
+      await start();
+    };
+    detectAndSetComponent();
+  }, [config, callbacks, detectBot, config.language]);
+  return componentToRender;
+};
+exports.ProcaptchaFrictionless = ProcaptchaFrictionless;

package/dist/cjs/customDetectBot.cjs

@@ -0,0 +1,33 @@
+"use strict";
+const api = require("@prosopo/api");
+const common = require("@prosopo/common");
+const procaptchaCommon = require("@prosopo/procaptcha-common");
+const detectorLoader = require("./detectorLoader.cjs");
+const customDetectBot = async (config) => {
+  const detect = await detectorLoader.DetectorLoader();
+  const botScore = await detect();
+  const ext = new (await procaptchaCommon.ExtensionLoader(config.web2))();
+  const userAccount = await ext.getAccount(config);
+  if (!config.account.address) {
+    throw new common.ProsopoEnvError("GENERAL.SITE_KEY_MISSING");
+  }
+  const provider = await procaptchaCommon.getRandomActiveProvider(config);
+  const providerApi = new api.ProviderApi(
+    provider.provider.url,
+    config.account.address
+  );
+  const captcha = await providerApi.getFrictionlessCaptcha(
+    botScore.token,
+    config.account.address,
+    userAccount.account.address
+  );
+  return {
+    captchaType: captcha.captchaType,
+    sessionId: captcha.sessionId,
+    provider,
+    status: captcha.status,
+    userAccount,
+    error: captcha.error
+  };
+};
+module.exports = customDetectBot;