@agilemotion/oui-react-js 2.0.11 → 2.0.13

package/dist/components/Turnstile.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _Utils = _interopRequireDefault(require("../Utils"));
+var _Observable = _interopRequireDefault(require("../event/Observable"));
+var _Event = _interopRequireDefault(require("../event/Event"));
+var _EventType = _interopRequireDefault(require("../event/EventType"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * CDUI-wrapped Cloudflare Turnstile widget. Drops the widget into a
+ * layout the same way any other CDUI component does and exposes the
+ * resolved challenge token through {@code handle.api.value}, so view
+ * authors can reference it from other components / service calls via
+ * {@code @#{turnstile}.value} when wiring up an httpParameterType.
+ *
+ * <p>Loads Cloudflare's vendor script lazily on first mount. The script
+ * defines {@code window.turnstile} which exposes {@code render()} —
+ * we render explicitly (not auto-render via class="cf-turnstile") so
+ * the React lifecycle can issue a {@code reset} when the parent view
+ * re-mounts.
+ *
+ * <p>Site key is sourced from {@code REACT_APP_TURNSTILE_SITE_KEY} at
+ * build time (matches the project's existing REACT_APP_* convention),
+ * NOT from CDUI JSON — view authors shouldn't have to know the key.
+ * For dev, hostname {@code localhost} is explicitly supported by
+ * Cloudflare so the same env var can be used unchanged.
+ */
+const TURNSTILE_SCRIPT_URL = 'https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit';
+
+// Cloudflare Turnstile's "site key" is intentionally public (it's the
+// publishable identifier, analogous to Stripe's publishable key) and
+// is hostname-bound on the Cloudflare side, so leaking it can't be
+// used against other domains. Even so, sourcing it from an env var
+// keeps dev/staging/prod swappable without a code change — same shape
+// the codebase already uses for REACT_APP_DOCS_API_HOST etc. Set
+// REACT_APP_TURNSTILE_SITE_KEY per environment.
+const SITE_KEY = process.env.REACT_APP_TURNSTILE_SITE_KEY;
+let scriptLoadPromise = null;
+const loadTurnstileScript = () => {
+  if (scriptLoadPromise) {
+    return scriptLoadPromise;
+  }
+  if (typeof window !== 'undefined' && window.turnstile) {
+    scriptLoadPromise = Promise.resolve();
+    return scriptLoadPromise;
+  }
+  scriptLoadPromise = new Promise((resolve, reject) => {
+    const script = document.createElement('script');
+    script.src = TURNSTILE_SCRIPT_URL;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = e => {
+      scriptLoadPromise = null; // allow retry next mount
+      reject(e);
+    };
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise;
+};
+const Turnstile = /*#__PURE__*/_react.default.memo(props => {
+  const containerRef = _react.default.useRef(null);
+  const widgetIdRef = _react.default.useRef(null);
+  const [token, setToken] = _react.default.useState(null);
+  _react.default.useEffect(() => {
+    props.handle.api = api();
+  });
+  _react.default.useEffect(() => {
+    const parsedConfig = _Utils.default.parseConfig(props.config, props.viewId);
+    _Observable.default.addSubscriptions(parsedConfig.eventHandlingConfig, props.handle, props.viewId);
+    _Observable.default.addSystemSubscriptions(props.viewId, parsedConfig);
+    if (!SITE_KEY) {
+      console.error('Turnstile: REACT_APP_TURNSTILE_SITE_KEY env var is not set — the widget will not render');
+      return;
+    }
+    let cancelled = false;
+    loadTurnstileScript().then(() => {
+      if (cancelled || !containerRef.current || !window.turnstile) {
+        return;
+      }
+      widgetIdRef.current = window.turnstile.render(containerRef.current, {
+        sitekey: SITE_KEY,
+        callback: newToken => {
+          setToken(newToken);
+          const event = new _Event.default(props.handle, props.viewId, newToken);
+          _Observable.default.fireEvent(_EventType.default.VALUE_CHANGE, event);
+        },
+        'error-callback': () => {
+          setToken(null);
+        },
+        'expired-callback': () => {
+          setToken(null);
+        }
+      });
+    }).catch(e => console.error('Turnstile: failed to load vendor script', e));
+
+    // Fire COMPONENT_LOAD so any view-level eventHandlingConfig keyed
+    // on the turnstile component's load can hook in (mirrors the
+    // pattern used by HtmlPanel / other CDUI components).
+    const loadEvent = new _Event.default(props.handle, props.viewId, null);
+    _Observable.default.fireEvent(_EventType.default.COMPONENT_LOAD, loadEvent);
+    return () => {
+      cancelled = true;
+      if (widgetIdRef.current && window.turnstile) {
+        try {
+          window.turnstile.remove(widgetIdRef.current);
+        } catch (e) {
+          // turnstile.remove throws if the widget id is unknown
+          // (e.g. script unloaded mid-cleanup) — safe to ignore.
+        }
+        widgetIdRef.current = null;
+      }
+      _Observable.default.clearComponentEventListeners(props.handle);
+    };
+  }, []);
+  const api = () => ({
+    get id() {
+      return props.config.id;
+    },
+    // The challenge token the backend siteverifies against. Null
+    // before the widget resolves; CDUI service-call wiring should
+    // guard with `nullable: false` so submit can't fire pre-solve.
+    get value() {
+      return token;
+    },
+    getChildren: () => [],
+    // Allows callers to manually reset the widget after a backend
+    // rejection — e.g. a 403 from siteverify. Token is consumed per
+    // call; resetting re-issues a fresh one.
+    reset: () => {
+      if (widgetIdRef.current && window.turnstile) {
+        window.turnstile.reset(widgetIdRef.current);
+        setToken(null);
+      }
+    },
+    refresh: () => {}
+  });
+  return /*#__PURE__*/_react.default.createElement("div", {
+    style: _Utils.default.mergeStyles({
+      margin: '8px 0'
+    }, props.config)
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    ref: containerRef
+  }));
+});
+var _default = exports.default = Turnstile;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_Utils","_Observable","_Event","_EventType","e","__esModule","default","TURNSTILE_SCRIPT_URL","SITE_KEY","process","env","REACT_APP_TURNSTILE_SITE_KEY","scriptLoadPromise","loadTurnstileScript","window","turnstile","Promise","resolve","reject","script","document","createElement","src","async","defer","onload","onerror","head","appendChild","Turnstile","React","memo","props","containerRef","useRef","widgetIdRef","token","setToken","useState","useEffect","handle","api","parsedConfig","Utils","parseConfig","config","viewId","eventManager","addSubscriptions","eventHandlingConfig","addSystemSubscriptions","console","error","cancelled","then","current","render","sitekey","callback","newToken","event","Event","fireEvent","EventType","VALUE_CHANGE","error-callback","expired-callback","catch","loadEvent","COMPONENT_LOAD","remove","clearComponentEventListeners","id","value","getChildren","reset","refresh","style","mergeStyles","margin","ref","_default","exports"],"sources":["../../src/lib/components/Turnstile.jsx"],"sourcesContent":["import React from 'react';\nimport Utils from '../Utils';\nimport eventManager from '../event/Observable';\nimport Event from '../event/Event';\nimport EventType from '../event/EventType';\n\n/**\n * CDUI-wrapped Cloudflare Turnstile widget. Drops the widget into a\n * layout the same way any other CDUI component does and exposes the\n * resolved challenge token through {@code handle.api.value}, so view\n * authors can reference it from other components / service calls via\n * {@code @#{turnstile}.value} when wiring up an httpParameterType.\n *\n * <p>Loads Cloudflare's vendor script lazily on first mount. The script\n * defines {@code window.turnstile} which exposes {@code render()} —\n * we render explicitly (not auto-render via class=\"cf-turnstile\") so\n * the React lifecycle can issue a {@code reset} when the parent view\n * re-mounts.\n *\n * <p>Site key is sourced from {@code REACT_APP_TURNSTILE_SITE_KEY} at\n * build time (matches the project's existing REACT_APP_* convention),\n * NOT from CDUI JSON — view authors shouldn't have to know the key.\n * For dev, hostname {@code localhost} is explicitly supported by\n * Cloudflare so the same env var can be used unchanged.\n */\nconst TURNSTILE_SCRIPT_URL = 'https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit';\n\n// Cloudflare Turnstile's \"site key\" is intentionally public (it's the\n// publishable identifier, analogous to Stripe's publishable key) and\n// is hostname-bound on the Cloudflare side, so leaking it can't be\n// used against other domains. Even so, sourcing it from an env var\n// keeps dev/staging/prod swappable without a code change — same shape\n// the codebase already uses for REACT_APP_DOCS_API_HOST etc. Set\n// REACT_APP_TURNSTILE_SITE_KEY per environment.\nconst SITE_KEY = process.env.REACT_APP_TURNSTILE_SITE_KEY;\n\nlet scriptLoadPromise = null;\nconst loadTurnstileScript = () => {\n    if (scriptLoadPromise) {\n        return scriptLoadPromise;\n    }\n    if (typeof window !== 'undefined' && window.turnstile) {\n        scriptLoadPromise = Promise.resolve();\n        return scriptLoadPromise;\n    }\n    scriptLoadPromise = new Promise((resolve, reject) => {\n        const script = document.createElement('script');\n        script.src = TURNSTILE_SCRIPT_URL;\n        script.async = true;\n        script.defer = true;\n        script.onload = () => resolve();\n        script.onerror = (e) => {\n            scriptLoadPromise = null; // allow retry next mount\n            reject(e);\n        };\n        document.head.appendChild(script);\n    });\n    return scriptLoadPromise;\n};\n\nconst Turnstile = React.memo((props) => {\n    const containerRef = React.useRef(null);\n    const widgetIdRef = React.useRef(null);\n    const [token, setToken] = React.useState(null);\n\n    React.useEffect(() => {\n        props.handle.api = api();\n    });\n\n    React.useEffect(() => {\n        const parsedConfig = Utils.parseConfig(props.config, props.viewId);\n        eventManager.addSubscriptions(parsedConfig.eventHandlingConfig, props.handle, props.viewId);\n        eventManager.addSystemSubscriptions(props.viewId, parsedConfig);\n\n        if (!SITE_KEY) {\n            console.error('Turnstile: REACT_APP_TURNSTILE_SITE_KEY env var is not set — the widget will not render');\n            return;\n        }\n\n        let cancelled = false;\n        loadTurnstileScript()\n            .then(() => {\n                if (cancelled || !containerRef.current || !window.turnstile) {\n                    return;\n                }\n                widgetIdRef.current = window.turnstile.render(containerRef.current, {\n                    sitekey: SITE_KEY,\n                    callback: (newToken) => {\n                        setToken(newToken);\n                        const event = new Event(props.handle, props.viewId, newToken);\n                        eventManager.fireEvent(EventType.VALUE_CHANGE, event);\n                    },\n                    'error-callback': () => {\n                        setToken(null);\n                    },\n                    'expired-callback': () => {\n                        setToken(null);\n                    },\n                });\n            })\n            .catch((e) => console.error('Turnstile: failed to load vendor script', e));\n\n        // Fire COMPONENT_LOAD so any view-level eventHandlingConfig keyed\n        // on the turnstile component's load can hook in (mirrors the\n        // pattern used by HtmlPanel / other CDUI components).\n        const loadEvent = new Event(props.handle, props.viewId, null);\n        eventManager.fireEvent(EventType.COMPONENT_LOAD, loadEvent);\n\n        return () => {\n            cancelled = true;\n            if (widgetIdRef.current && window.turnstile) {\n                try {\n                    window.turnstile.remove(widgetIdRef.current);\n                } catch (e) {\n                    // turnstile.remove throws if the widget id is unknown\n                    // (e.g. script unloaded mid-cleanup) — safe to ignore.\n                }\n                widgetIdRef.current = null;\n            }\n            eventManager.clearComponentEventListeners(props.handle);\n        };\n    }, []);\n\n    const api = () => ({\n        get id() {\n            return props.config.id;\n        },\n        // The challenge token the backend siteverifies against. Null\n        // before the widget resolves; CDUI service-call wiring should\n        // guard with `nullable: false` so submit can't fire pre-solve.\n        get value() {\n            return token;\n        },\n        getChildren: () => [],\n        // Allows callers to manually reset the widget after a backend\n        // rejection — e.g. a 403 from siteverify. Token is consumed per\n        // call; resetting re-issues a fresh one.\n        reset: () => {\n            if (widgetIdRef.current && window.turnstile) {\n                window.turnstile.reset(widgetIdRef.current);\n                setToken(null);\n            }\n        },\n        refresh: () => {},\n    });\n\n    return (\n        <div style={Utils.mergeStyles({margin: '8px 0'}, props.config)}>\n            <div ref={containerRef}/>\n        </div>\n    );\n});\n\nexport default Turnstile;"],"mappings":"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","ignoreList":[]}