PageSourceSearch

https://visitcloud.com/wp-content/plugins/conditional-fields-for-e…/js/atomic-form-condition.js?ver=1.8.5

js visitcloud.com collected 2026-10-02 04:42:19 UTC 20,376 bytes, 564 lines download raw bytes

1(function ($) {
2    "use strict";
3
4    function decodeHTMLEntities(text) {
5        var textArea = document.createElement("textarea");
6        textArea.innerHTML = text == null ? "" : String(text);
7        return textArea.value;
8    }
9
10    function checkFieldLogic(compareFieldValue, conditionOperation, compareValue) {
11        conditionOperation = decodeHTMLEntities(conditionOperation);
12        compareValue = compareValue === null
13            ? decodeHTMLEntities(compareValue)
14            : decodeHTMLEntities(compareValue).trim();
15        compareFieldValue = compareFieldValue === null
16            ? decodeHTMLEntities(compareFieldValue)
17            : decodeHTMLEntities(compareFieldValue).trim();
18
19        var values = compareFieldValue.split(",");
20
21        var matchFound = values.some(function (value) {
22            return value.trim() === compareValue;
23        });
24
25        switch (conditionOperation) {
26            case "==":
27                return matchFound && "" !== compareFieldValue;
28            case "!=":
29                return !matchFound && compareFieldValue !== "";
30            case "e":
31                return compareFieldValue == "";
32            case "!e":
33                return compareFieldValue != "";
34            case "c":
35                return compareFieldValue.includes(compareValue);
36            case "!c":
37                return (
38                    compareFieldValue != "" && !compareFieldValue.includes(compareValue)
39                );
40            case "^":
41                return compareFieldValue.startsWith(compareValue);
42            case "~":
43                return compareFieldValue.endsWith(compareValue);
44            case ">":
45                return parseInt(compareFieldValue, 10) > parseInt(compareValue, 10);
46            case "<":
47                return parseInt(compareFieldValue, 10) < parseInt(compareValue, 10);
48            case ">=":
49                return parseInt(compareFieldValue, 10) >= parseInt(compareValue, 10);
50            case "<=":
51                return parseInt(compareFieldValue, 10) <= parseInt(compareValue, 10);
52            default:
53                return false;
54        }
55    }
56
57    function getFieldGroup(form, fieldId) {
58        let targetINput= $(form).find(`#${fieldId}`);
59        return targetINput;
60    }
61
62    function getFieldContainer(targetField) {
63        var fieldContainer = targetField.closest(".cfef-atomic-field-group");
64        return fieldContainer.length ? fieldContainer : targetField;
65    }
66
67    function getFieldControls(targetField) {
68        var fieldContainer = getFieldContainer(targetField);
69        var controls = fieldContainer.find("input, select, textarea");
70        if (!controls.length && targetField.is("input, select, textarea")) {
71            controls = targetField;
72        }
73        return controls;
74    }
75
76    function isRequiredControl(control) {
77        return control.prop("required") || control.attr("required") !== undefined || control.attr("aria-required") === "true";
78    }
79
80    function getDemoValueForControl(control) {
81        var nodeName = (control.prop("nodeName") || "").toLowerCase();
82        var type = (control.attr("type") || "").toLowerCase();
83
84        if (nodeName === "textarea") {
85            return "cool_plugins";
86        }
87        if (nodeName === "select") {
88            return null;
89        }
90        if (type === "email") {
91            return "[email protected]";
92        }
93        if (type === "url") {
94            return "https://testing.com";
95        }
96        if (type === "tel") {
97            return "+1234567890";
98        }
99        if (type === "number") {
100            return "000";
101        }
102        if (type === "date") {
103            return "1003-01-01";
104        }
105        if (type === "time") {
106            return "11:59";
107        }
108        return "cool23plugins";
109    }
110
111    function setDemoValueOnHide(targetField) {
112        var controls = getFieldControls(targetField);
113
114        controls.each(function () {
115            var control = $(this);
116            var nodeName = (control.prop("nodeName") || "").toLowerCase();
117            var type = (control.attr("type") || "").toLowerCase();
118
119            if (!isRequiredControl(control)) {
120                return;
121            }
122
123            if (type === "checkbox" || type === "radio") {
124                var groupControls = controls.filter('[type="' + type + '"][name="' + control.attr("name") + '"]');
125                var checkedControl = groupControls.filter(":checked");
126                if (typeof control.data("cfefOriginalCheckedValue") === "undefined") {
127                    control.data("cfefOriginalCheckedValue", checkedControl.length ? checkedControl.val() : "");
128                }
129                if (!checkedControl.length && groupControls.length) {
130                    var firstControl = groupControls.first();
131                    firstControl.prop("checked", true);
132                    firstControl.data("cfefDemoApplied", true);
133                } else if (checkedControl.length) {
134                    groupControls.prop("checked", false);
135                    var firstChecked = groupControls.first();
136                    firstChecked.prop("checked", true);
137                    firstChecked.data("cfefDemoApplied", true);
138                }
139                return;
140            }
141
142            if (nodeName === "select") {
143                if (typeof control.data("cfefOriginalValue") === "undefined") {
144                    control.data("cfefOriginalValue", control.val() || "");
145                }
146                var firstOption = control.find("option[value!='']").first();
147                if (!firstOption.length) {
148                    firstOption = control.find("option").first();
149                }
150                if (firstOption.length) {
151                    control.val(firstOption.val());
152                    control.data("cfefDemoApplied", true);
153                }
154                return;
155            }
156
157            if (isFileUploadControl(control)) {
158                var accept = control.attr("accept") || "";
159                var firstType = accept.split(",")[0].trim().replace(/^\./, "") || "png";
160                var pluginConstant = typeof my_script_vars !== "undefined" && my_script_vars.pluginConstant
161                    ? my_script_vars.pluginConstant
162                    : "";
163                var fileName = pluginConstant + "assets/images/placeholder." + firstType;
164                var defaultImage = new File([], fileName, { type: "image/png" });
165                var container = new DataTransfer();
166                container.items.add(defaultImage);
167                control[0].files = container.files;
168                control.data("cfefDemoApplied", true);
169                return;
170            }
171
172            if (typeof control.data("cfefOriginalValue") === "undefined") {
173                control.data("cfefOriginalValue", control.val() || "");
174            }
175            control.val(getDemoValueForControl(control));
176            control.data("cfefDemoApplied", true);
177        });
178    }
179
180    function isFileUploadControl(control) {
181        var type = (control.attr("type") || "").toLowerCase();
182        return type === "file" || control.hasClass("e-form-file-upload-base");
183    }
184
185    function clearDemoValueOnShow(targetField) {
186        var controls = getFieldControls(targetField);
187
188        controls.each(function () {
189            var control = $(this);
190
191            if (isFileUploadControl(control)) {
192                if (control.data("cfefDemoApplied") === true) {
193                    control.val("");
194                    control.removeData("cfefDemoApplied");
195                }
196                return;
197            }
198
199            if (control.data("cfefDemoApplied") !== true) {
200                return;
201            }
202
203            var type = (control.attr("type") || "").toLowerCase();
204            if (type === "checkbox" || type === "radio") {
205                var groupName = control.attr("name");
206                if (groupName) {
207                    var groupControls = controls.filter('[type="' + type + '"][name="' + groupName + '"]');
208                    var originalCheckedValue = control.data("cfefOriginalCheckedValue");
209                    groupControls.prop("checked", false);
210                    if (originalCheckedValue) {
211                        groupControls.filter('[value="' + originalCheckedValue + '"]').first().prop("checked", true);
212                    }
213                } else {
214                    control.prop("checked", false);
215                }
216                control.removeData("cfefOriginalCheckedValue");
217            } else {
218                var originalValue = control.data("cfefOriginalValue");
219                control.val(typeof originalValue === "undefined" ? "" : originalValue);
220                control.removeData("cfefOriginalValue");
221            }
222            control.removeData("cfefDemoApplied");
223        });
224    }
225
226    function formatToMDY(dateStr) {
227        if (!dateStr) {
228            return "";
229        }
230        var parts = dateStr.split("-");
231        if (parts.length !== 3) {
232            return dateStr;
233        }
234        return parts[1] + "/" + parts[2] + "/" + parts[0];
235    }
236
237    function convertTo12Hour(time) {
238        if (!time) {
239            return "";
240        }
241        var segments = time.split(":");
242        var hours = parseInt(segments[0], 10);
243        var minutes = segments[1] || "00";
244        var period = hours >= 12 ? "PM" : "AM";
245        var hours12 = hours % 12 || 12;
246        return hours12.toString().padStart(2, "0") + ":" + minutes + " " + period;
247    }
248
249    function getFieldValue(form, fieldId) {
250        var fieldINput = getFieldGroup(form, fieldId);
251        var value = "";
252
253        if (fieldINput.length === 0) {
254            return value;
255        }
256
257        var fieldType = (fieldINput.attr("type") || "").toLowerCase();
258        var nodeName = (fieldINput.prop("nodeName") || "").toLowerCase();
259
260        if (fieldType === "checkbox") {
261            return fieldINput.is(":checked") ? fieldINput.val() : "";
262        }
263
264        if (fieldType === "radio") {
265            var radioName = fieldINput.attr("name");
266            if (radioName) {
267                var checkedRadio = $(form).find('input[type="radio"][name="' + radioName + '"]:checked');
268                return checkedRadio.length ? checkedRadio.val() : "";
269            }
270            return fieldINput.is(":checked") ? fieldINput.val() : "";
271        }
272
273        if (fieldType === "date") {
274            return formatToMDY(fieldINput.val());
275        }
276
277        if (fieldType === "time") {
278            return convertTo12Hour(fieldINput.val());
279        }
280
281        if (nodeName === "select") {
282            value = fieldINput.val();
283            if (fieldINput.prop("multiple") && Array.isArray(value)) {
284                return value.join(", ");
285            }
286            return value || "";
287        }
288
289        value = fieldINput.val();
290        return value == null ? "" : value;
291    }
292
293    function evaluateConditionResult(form, logicValue) {
294        var fireAction = logicValue.fire_action || "All";
295        var logicData = Array.isArray(logicValue.logic_data) ? logicValue.logic_data : [];
296        var checks = [];
297
298        $.each(logicData, function (_idx, rule) {
299            if (!rule || !rule.cfef_logic_field_id) {
300                return;
301            }
302            var currentValue = getFieldValue(form, rule.cfef_logic_field_id);
303            checks.push(checkFieldLogic(currentValue, rule.cfef_logic_field_is, rule.cfef_logic_compare_value));
304        });
305
306        if (!checks.length) {
307            return false;
308        }
309
310        return fireAction === "All"
311            ? checks.every(function (v) { return v === true; })
312            : checks.some(function (v) { return v === true; });
313    }
314
315    function evaluateLogic(form, logicValue) {
316        var displayMode = logicValue.display_mode || "show";
317        var result = evaluateConditionResult(form, logicValue);
318        return displayMode === "show" ? result : !result;
319    }
320
321    function isSubmitButton(targetField) {
322        return targetField.is("button[type='submit']");
323    }
324
325    function getSubmitButton(targetField) {
326        if (isSubmitButton(targetField)) {
327            return targetField;
328        }
329        return getFieldContainer(targetField).find("button[type='submit']").first();
330    }
331
332    function setSubmitButtonEnabled(button, enabled) {
333        if (!button.length) {
334            return;
335        }
336        if (enabled) {
337            button.prop("disabled", false).css({ "pointer-events": "unset", opacity: "1.0" });
338        } else {
339            button.prop("disabled", true).css({ "pointer-events": "none", opacity: "0.3" });
340        }
341    }
342
343    function applySubmitButtonLogic(form, targetFieldId, logicValue) {
344        var targetField = getFieldGroup(form, targetFieldId);
345        if (!targetField.length) {
346            return;
347        }
348
349        var displayMode = logicValue.display_mode || "show";
350        var conditionResult = evaluateConditionResult(form, logicValue);
351        var fieldContainer = getFieldContainer(targetField);
352        var button = getSubmitButton(targetField);
353
354        if (displayMode === "show") {
355            if (conditionResult) {
356                setSubmitButtonEnabled(button, true);
357                fieldContainer.removeClass("cfef-hidden");
358            } else {
359                fieldContainer.addClass("cfef-hidden");
360            }
361            return;
362        }
363
364        if (displayMode === "hide") {
365            if (conditionResult) {
366                fieldContainer.addClass("cfef-hidden");
367            } else {
368                setSubmitButtonEnabled(button, true);
369                fieldContainer.removeClass("cfef-hidden");
370            }
371            return;
372        }
373
374        fieldContainer.removeClass("cfef-hidden");
375
376        if (displayMode === "enable") {
377            setSubmitButtonEnabled(button, conditionResult);
378            return;
379        }
380
381        if (displayMode === "disable") {
382            setSubmitButtonEnabled(button, !conditionResult);
383        }
384    }
385
386    function applyFieldLogic(form, targetFieldId, logicValue) {
387        var targetField = getFieldGroup(form, targetFieldId);
388        if (!targetField.length) {
389            return;
390        }
391
392        if (isSubmitButton(targetField)) {
393            applySubmitButtonLogic(form, targetFieldId, logicValue);
394            return;
395        }
396
397        var shouldShowField = evaluateLogic(form, logicValue);
398        var fieldContainer = getFieldContainer(targetField);
399
400        if (shouldShowField) {
401            clearDemoValueOnShow(targetField);
402            showFieldLabel(form, targetFieldId);
403            fieldContainer.removeClass("cfef-hidden");
404        } else {
405            setDemoValueOnHide(targetField);
406            hideFieldLabel(form, targetFieldId);
407            fieldContainer.addClass("cfef-hidden");
408        }
409    }
410
411    function showFieldLabel(form, targetFieldId) {
412        let label_widget = $(form).find(`label[for="${targetFieldId}"]`);
413        if(label_widget.length > 0) {
414            label_widget.removeClass('cfef-hidden');
415        }
416    }
417
418    function hideFieldLabel(form, targetFieldId) {
419        let label_widget = $(form).find(`label[for="${targetFieldId}"]`);
420        if(label_widget.length > 0) {
421            label_widget.addClass('cfef-hidden');
422        }
423    }
424
425    function readAtomicLogic(form) {
426        var merged = {};
427        $(form).find(".cfef-atomic-field-logic").each(function () {
428            var raw = $(this).html();
429            if (!raw) {
430                return;
431            }
432            try {
433                var data = JSON.parse(raw);
434                merged = $.extend(true, {}, merged, data);
435            } catch (e) {
436                // Ignore invalid field payloads so one bad rule does not break the form.
437            }
438        });
439        return merged;
440    }
441
442    function runAtomicLogic(form) {
443        var logicMap = readAtomicLogic(form);
444        $.each(logicMap, function (index, singleLogic) {
445            $.each(singleLogic, function (targetFieldId, logicValue) {
446                applyFieldLogic(form, targetFieldId, logicValue);
447            });
448        });
449    }
450
451    function getAtomicFormContainerFromElement(el) {
452        return $(el).closest(".e-form-base");
453    }
454
455    function initAtomicForms() {
456
457        $(".e-form-base").each(function () {
458            var form = (this);
459            filterTemplateLogic(form);
460            if (form.length) {
461                runAtomicLogic(form);
462            }
463        });
464    }
465
466    function filterTemplateLogic(form) {
467
468        var $form = $(form);
469        var all_fields_logic = [];
470
471        if ($form.attr("template-extracted") === "true") {
472            return;
473        }
474
475        $form.find(".cfef-atomic-field-group").each(function () {
476            var field = $(this);
477            var template = field.find("template").first();
478
479            if (template.length) {
480                try {
481                    all_fields_logic.push(JSON.parse(template.html()));
482                } catch (e) {
483                    // Ignore malformed template payloads.
484                }
485            }
486        });
487
488        $form.find(".cfef-atomic-field-group").each(function () {
489            var fieldGroup = $(this);
490            var fieldControl = fieldGroup.find("input[data-e-type='widget'], select[data-e-type='widget'], textarea[data-e-type='widget']").first();
491
492            // Fallback: keep compatibility if data-e-type is absent on some controls.
493            if (!fieldControl.length) {
494                fieldControl = fieldGroup.find("input, select, textarea").first();
495            }
496
497            if (!fieldControl.length) {
498                return;
499            }
500
501            var country_wrapper = fieldControl.closest("div.ccfef-wrapper");
502            var mask_wrapper = fieldControl.closest("div.ccfef-mask-wrapper");
503
504            if (country_wrapper.length === 0 && mask_wrapper.length === 0) {
505                fieldGroup.replaceWith(fieldControl);
506            }
507        });
508
509        var template_tag_logic = $("<template>", {
510            class: "cfef_logic_data_js cfef-atomic-field-logic cfef-hidden",
511            html: JSON.stringify(all_fields_logic)
512        });
513        $form.find("template.cfef_logic_data_js").remove();
514        $form.append(template_tag_logic);
515        $form.attr("template-extracted", "true");
516    }
517
518    $(document).ready(function () {
519        initAtomicForms();
520    });
521
522    $(document).on("elementor/popup/show", function () {
523        initAtomicForms();
524    });
525
526    window.addEventListener("elementor/frontend/init", function () {
527        initAtomicForms();
528    });
529
530    $("body").on("input change", ".e-form-base input, .e-form-base select, .e-form-base textarea", function () {
531        var form = getAtomicFormContainerFromElement(this);
532        if (form.length) {
533            runAtomicLogic(form);
534        }
535    });
536
537    $("body").on("click", ".e-form-base button[type='submit']", function (e) {
538        var form = getAtomicFormContainerFromElement(this);
539        if (form.length) {
540            runAtomicLogic(form);
541            if ($(this).prop("disabled")) {
542                e.preventDefault();
543                e.stopImmediatePropagation();
544                return false;
545            }
546        }
547    });
548
549    $("body").on("keydown", ".e-form-base input, .e-form-base textarea", function (e) {
550        if (e.key !== "Enter" && e.keyCode !== 13) {
551            return;
552        }
553        var form = getAtomicFormContainerFromElement(this);
554        if (!form.length) {
555            return;
556        }
557        var submitButton = form.find("button[type='submit']");
558        if (submitButton.length && submitButton.prop("disabled")) {
559            e.preventDefault();
560            e.stopImmediatePropagation();
561            return false;
562        }
563    });
564})(jQuery);

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.