smartcomply-web-sdk 1.0.93 → 1.0.95

package/dist/flow/SmartComplyFlow.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartComplyFlow = void 0;
+exports.isChannelDocumentFlow = isChannelDocumentFlow;
+exports.selectIdTypesForScreen = selectIdTypesForScreen;
 exports.isResumeLinkErrorMessage = isResumeLinkErrorMessage;
 exports.resolveIdTypeInfo = resolveIdTypeInfo;
 const Smartcomply_1 = require("../client/Smartcomply");
@@ -72,6 +74,49 @@ const COUNTRY_LABELS = {
 function isUploadFieldType(type) {
     return type === "upload" || type === "image" || type === "file";
 }
+/**
+ * Whether a SPECIFIC channel is a document-scan item, vs. a plain
+ * number-entry one. channels[country] is a flat list that can mix
+ * data_verification channels (e.g. bare "Passport", a number-entry lookup)
+ * with document_verification channels (e.g. "Document Verification -
+ * Passport", a scan) whenever an SDK config's verification_type covers
+ * both modes — a real, valid dual-mode setup, not a misconfiguration.
+ *
+ * Reported live: with both modes enabled, every channel rendered and
+ * routed as a document scan, including number-entry ones — because the
+ * per-channel decision fell back to the config's overall
+ * globalDocFlow/verification_type the moment document_verification was
+ * enabled ANYWHERE in the config, instead of checking whether THIS
+ * channel actually has an upload field. A legacy string-only channel
+ * (typeof idType === "string") carries no fields array to check at all,
+ * so that's the only case the global flow mode is still used for.
+ */
+function isChannelDocumentFlow(idType, globalDocFlow) {
+    if (typeof idType === "string")
+        return globalDocFlow;
+    return (idType.fields || []).some((f) => isUploadFieldType(f.type));
+}
+/**
+ * Picks the channel list for the "Select document type" / "Select ID type"
+ * screen — the one list that actually matches this screen's mode, not a
+ * flat list mixing both categories.
+ *
+ * Reported live: the deployed widget's document-scan screen showed a bare
+ * "Passport" (data_verification, number-entry) right next to "Document
+ * Verification - Passport" (document_verification, scan) as if they were
+ * the same kind of option — because channels[country] used to be one flat
+ * list with no category split at all. Splitting the backend response
+ * (SDKSecureLoaderView, adhere-backend) into {data_verification,
+ * document_verification} only helps if this screen then reads the ONE
+ * list matching globalDocFlow, instead of still flattening both — that's
+ * what actually removes the duplicate, not just how each entry displays
+ * (see isChannelDocumentFlow above, which only decides that).
+ */
+function selectIdTypesForScreen(byCategory, globalDocFlow) {
+    if (!byCategory)
+        return [];
+    return (globalDocFlow ? byCategory.document_verification : byCategory.data_verification) || [];
+}
 /**
  * Whether a showErrorStep() message is about an expired/invalid resume or
  * resubmit link (RESUME_TARGET_UNAVAILABLE / NOT_A_RESUME_TOKEN — see
@@ -740,8 +785,11 @@ class SmartComplyFlow {
                 return "liveness";
             }
             if (info.failure_stage === "document" && info.country && info.identifier_type) {
+                // A document-stage resume always references a document_verification
+                // channel by its doc code — channels[country] is now split by
+                // category (see ChannelsByCategory), so search that list directly.
                 const channels = this.sdkConfig?.channels || {};
-                const idTypes = channels[info.country] || [];
+                const idTypes = channels[info.country]?.document_verification || [];
                 const match = idTypes.find((idType) => {
                     const code = typeof idType === "string" ? idType : (idType.code || idType.name);
                     return code === info.identifier_type;
@@ -1117,7 +1165,9 @@ class SmartComplyFlow {
         subtitle.textContent = "Choose the country that issued your ID";
         container.appendChild(subtitle);
         for (const country of countries) {
-            const card = this.createOptionCard(COUNTRY_LABELS[country] || country, `${channels[country].length} ID type${channels[country].length > 1 ? "s" : ""} available`, () => {
+            const count = channels[country].data_verification.length
+                + channels[country].document_verification.length;
+            const card = this.createOptionCard(COUNTRY_LABELS[country] || country, `${count} ID type${count > 1 ? "s" : ""} available`, () => {
                 this.selectedCountry = country;
                 this.showStep("id_type");
             });
@@ -1137,14 +1187,14 @@ class SmartComplyFlow {
             : "Choose the ID you want to verify";
         container.appendChild(subtitle);
         const channels = this.sdkConfig?.channels || {};
-        const idTypes = channels[this.selectedCountry] || [];
+        const idTypes = selectIdTypesForScreen(channels[this.selectedCountry], globalDocFlow);
         for (const idType of idTypes) {
             const typeName = typeof idType === "string" ? idType : idType.name;
             // Use code (canonical) for API calls, fallback to name for backward compatibility
             const typeCode = typeof idType === "string" ? idType : (idType.code || idType.name);
-            // Detect per-channel: does THIS specific channel have upload fields?
-            const channelFields = typeof idType !== "string" ? (idType.fields || []) : [];
-            const isThisDocFlow = channelFields.some((f) => isUploadFieldType(f.type)) || globalDocFlow;
+            // Detect per-channel, not from the config's overall mode — see
+            // isChannelDocumentFlow's docstring for why.
+            const isThisDocFlow = isChannelDocumentFlow(idType, globalDocFlow);
             const info = resolveIdTypeInfo(typeName, isThisDocFlow);
             // Prefer the backend-provided back-side flag; fall back to local heuristics only when absent.
             const requiresBackFromBackend = typeof idType !== "string" ? idType.requires_back_side : undefined;
@@ -1182,12 +1232,9 @@ class SmartComplyFlow {
                     this.selectedChannelId = idType.id;
                     this.selectedChannelFields = idType.fields || []; // guard null/undefined from backend
                 }
-                // Route: use explicit verification_type when set (more reliable than inspecting all channels)
-                // Fallback to per-channel upload field check for mixed / unconfigured setups
-                const hasUpload = (this.selectedChannelFields).some((f) => isUploadFieldType(f.type));
-                const vType = this.sdkConfig?.verification_type;
-                const vTypes = vType ? (Array.isArray(vType) ? vType : [vType]) : [];
-                const isDocChannel = hasUpload || (vTypes.length > 0 && vTypes.includes("document_verification"));
+                // Route on THIS channel, same as isThisDocFlow above — see
+                // isChannelDocumentFlow's docstring.
+                const isDocChannel = isChannelDocumentFlow(idType, globalDocFlow);
                 this.showStep(isDocChannel ? "document_capture" : "id_input");
             });
             container.appendChild(card);
@@ -2733,10 +2780,16 @@ class SmartComplyFlow {
             if (types.includes("data_verification"))
                 return false;
         }
-        // 2. Fallback: inspect channel fields — any upload field = document flow
+        // 2. Fallback: inspect channel fields — any upload field = document flow.
+        // channels[country] is now split {data_verification, document_verification}
+        // (see ChannelsByCategory) — flatten both sub-lists per country, not the
+        // per-country objects themselves.
         const channels = this.sdkConfig?.channels || {};
         const allFields = Object.values(channels)
-            .flat()
+            .flatMap((byCategory) => [
+            ...(byCategory.data_verification || []),
+            ...(byCategory.document_verification || []),
+        ])
             .flatMap((ch) => ch.fields || []);
         return allFields.some((f) => isUploadFieldType(f.type));
     }