@verbb/formie-browser 1.0.2 → 1.0.3

package/src/js/modules/address/google-address.ts

@@ -8,6 +8,7 @@ type GoogleMaps = typeof google;
 type GoogleAddressProviderOptions = {
     apiKey?: string;
     options?: Record<string, unknown>;
+    countryDefaultValue?: string;
 };
 
 const SCRIPT_ID = 'FORMIE_GOOGLE_ADDRESS_SCRIPT';
@@ -194,6 +195,37 @@ function buildAddressFromComponents(formData: Record<string, string>): {
     };
 }
 
+function hasCountryRestriction(options: Record<string, unknown>): boolean {
+    const componentRestrictions = options.componentRestrictions;
+
+    if (componentRestrictions && typeof componentRestrictions === 'object') {
+        const country = (componentRestrictions as { country?: unknown }).country;
+
+        if (Array.isArray(country) ? country.length > 0 : Boolean(country)) {
+            return true;
+        }
+    }
+
+    const includedRegionCodes = options.includedRegionCodes;
+
+    return Array.isArray(includedRegionCodes) && includedRegionCodes.length > 0;
+}
+
+export function buildGoogleAutocompleteOptions(provider: GoogleAddressProviderOptions): Record<string, unknown> {
+    const options = { types: ['geocode'], ...(provider.options || {}) };
+    const country = provider.countryDefaultValue?.trim().toLowerCase();
+
+    if (!country || hasCountryRestriction(options)) {
+        return options;
+    }
+
+    return {
+        ...options,
+        componentRestrictions: { country },
+        includedRegionCodes: [country.toUpperCase()],
+    };
+}
+
 export const googleAddressModule = defineAddressModule<
     GoogleAddressProviderOptions,
     GoogleMaps,
@@ -218,7 +250,7 @@ export const googleAddressModule = defineAddressModule<
             return null;
         }
 
-        const options = { types: ['geocode'], ...(provider.options || {}) };
+        const options = buildGoogleAutocompleteOptions(provider);
         const autocomplete = new PlaceAutocompleteElement(options);
         const inputHeight = window.getComputedStyle(input).height;
 

package/src/js/modules/fields/conditions/effects.ts

@@ -3,6 +3,9 @@ const PRESERVED_DISABLED_ATTR = 'data-formie-preserve-disabled';
 const CONDITIONAL_HIDDEN_ATTR = 'data-formie-conditionally-hidden';
 const PAGE_HIDDEN_ATTR = 'data-formie-page-hidden';
 const CONDITIONAL_HIDDEN_CLASS = 'formie-conditionally-hidden';
+const CP_MUTED_CLASS = 'fui-cp-muted-conditional-field';
+const CP_MUTED_EXPANDED_CLASS = 'fui-cp-muted-conditional-field--expanded';
+const CP_MUTED_ATTR = 'data-formie-cp-muted';
 const PAGE_HIDDEN_CLASS = 'formie-page-hidden';
 const ROW_HIDDEN_ATTR = 'data-formie-row-hidden';
 const ROW_HIDDEN_CLASS = 'formie-row-hidden';
@@ -143,6 +146,19 @@ function syncRowState(row: Element): void {
     }
 }
 
+function clearCpMutedState(node: Element): void {
+    node.removeAttribute(CP_MUTED_ATTR);
+    node.classList.remove(CP_MUTED_CLASS);
+    node.classList.remove(CP_MUTED_EXPANDED_CLASS);
+}
+
+function clearHideState(node: Element): void {
+    node.removeAttribute(CONDITIONAL_HIDDEN_ATTR);
+    node.removeAttribute(PAGE_HIDDEN_ATTR);
+    node.classList.remove(CONDITIONAL_HIDDEN_CLASS);
+    node.classList.remove(PAGE_HIDDEN_CLASS);
+}
+
 function syncAncestorRows(node: Element): void {
     let currentRow = node.closest(ROW_SELECTOR);
 
@@ -152,8 +168,26 @@ function syncAncestorRows(node: Element): void {
     }
 }
 
-export function applyConditionVisibility(node: Element, hidden: boolean, clearOnHide: boolean): boolean {
-    const stateChanged = setVisibilityState(node, hidden);
+export function applyConditionVisibility(
+    node: Element,
+    hidden: boolean,
+    clearOnHide: boolean,
+    options: { displayMode?: 'hide' | 'muted' } = {},
+): boolean {
+    if (options.displayMode === 'muted') {
+        return applyMutedConditionVisibility(node, hidden);
+    }
+
+    let stateChanged = false;
+
+    if (node.hasAttribute(CP_MUTED_ATTR)
+        || node.classList.contains(CP_MUTED_CLASS)
+        || node.classList.contains(CP_MUTED_EXPANDED_CLASS)) {
+        clearCpMutedState(node);
+        stateChanged = true;
+    }
+
+    stateChanged = setVisibilityState(node, hidden) || stateChanged;
 
     syncDisabledState(node, hidden);
     syncAncestorRows(node);
@@ -164,3 +198,46 @@ export function applyConditionVisibility(node: Element, hidden: boolean, clearOn
 
     return stateChanged;
 }
+
+function applyMutedConditionVisibility(node: Element, hidden: boolean): boolean {
+    let stateChanged = false;
+
+    if (hidden) {
+        if (node.hasAttribute(CONDITIONAL_HIDDEN_ATTR)
+            || node.hasAttribute(PAGE_HIDDEN_ATTR)
+            || node.classList.contains(CONDITIONAL_HIDDEN_CLASS)
+            || node.classList.contains(PAGE_HIDDEN_CLASS)) {
+            clearHideState(node);
+            stateChanged = true;
+        }
+
+        if (!node.hasAttribute(CP_MUTED_ATTR)) {
+            node.setAttribute(CP_MUTED_ATTR, 'true');
+            stateChanged = true;
+        }
+
+        if (!node.classList.contains(CP_MUTED_CLASS)) {
+            node.classList.add(CP_MUTED_CLASS);
+            stateChanged = true;
+        }
+    } else {
+        if (node.hasAttribute(CP_MUTED_ATTR)
+            || node.classList.contains(CP_MUTED_CLASS)
+            || node.classList.contains(CP_MUTED_EXPANDED_CLASS)) {
+            clearCpMutedState(node);
+            stateChanged = true;
+        }
+
+        if (node.hasAttribute(CONDITIONAL_HIDDEN_ATTR)
+            || node.hasAttribute(PAGE_HIDDEN_ATTR)
+            || node.classList.contains(CONDITIONAL_HIDDEN_CLASS)
+            || node.classList.contains(PAGE_HIDDEN_CLASS)) {
+            clearHideState(node);
+            stateChanged = true;
+        }
+    }
+
+    syncAncestorRows(node);
+
+    return stateChanged;
+}

package/src/js/modules/fields/conditions.ts

@@ -72,6 +72,9 @@ export const conditionsModule: FormieModuleDefinition = {
             });
         };
 
+        const cpDisplayMode = ctx.options?.cpDisplayMode === 'muted' ? 'muted' : 'hide';
+        let isApplyingConditions = false;
+
         const runEvaluationPass = (): boolean => {
             let hasStateChanges = false;
 
@@ -80,7 +83,16 @@ export const conditionsModule: FormieModuleDefinition = {
                     return queryConditionInputs(scopeRoot, entry.node, condition);
                 });
 
-                const stateChanged = applyConditionVisibility(entry.node, result.shouldHide, entry.settings.clearOnHide);
+                const displayMode = entry.node.hasAttribute('data-formie-page')
+                    ? 'hide'
+                    : cpDisplayMode;
+
+                const stateChanged = applyConditionVisibility(
+                    entry.node,
+                    result.shouldHide,
+                    entry.settings.clearOnHide,
+                    { displayMode },
+                );
                 hasStateChanges = hasStateChanges || stateChanged;
                 debug.log('Condition evaluated.', {
                     shouldHide: result.shouldHide,
@@ -100,26 +112,45 @@ export const conditionsModule: FormieModuleDefinition = {
         };
 
         const evaluateAll = (): void => {
-            for (let pass = 0; pass < MAX_EVALUATION_PASSES; pass += 1) {
-                if (!runEvaluationPass()) {
-                    break;
-                }
+            if (isApplyingConditions) {
+                return;
+            }
+
+            isApplyingConditions = true;
 
-                if (pass === MAX_EVALUATION_PASSES - 1) {
-                    debug.warn('Reached max evaluation passes.', { maxPasses: MAX_EVALUATION_PASSES });
+            try {
+                for (let pass = 0; pass < MAX_EVALUATION_PASSES; pass += 1) {
+                    if (!runEvaluationPass()) {
+                        break;
+                    }
+
+                    if (pass === MAX_EVALUATION_PASSES - 1) {
+                        debug.warn('Reached max evaluation passes.', { maxPasses: MAX_EVALUATION_PASSES });
+                    }
                 }
+            } finally {
+                isApplyingConditions = false;
             }
         };
 
         const scheduleEvaluateAll = (): void => {
+            if (isApplyingConditions) {
+                return;
+            }
+
             if (evaluationQueued) {
                 return;
             }
 
             evaluationQueued = true;
 
-            queueMicrotask(() => {
+            requestAnimationFrame(() => {
                 evaluationQueued = false;
+
+                if (isApplyingConditions) {
+                    return;
+                }
+
                 evaluateAll();
             });
         };
@@ -168,19 +199,32 @@ export const conditionsModule: FormieModuleDefinition = {
         };
 
         const scheduleRebuild = (): void => {
+            if (isApplyingConditions) {
+                return;
+            }
+
             if (rebuildQueued) {
                 return;
             }
 
             rebuildQueued = true;
 
-            queueMicrotask(() => {
+            requestAnimationFrame(() => {
                 rebuildQueued = false;
+
+                if (isApplyingConditions) {
+                    return;
+                }
+
                 rebuild();
             });
         };
 
         const observer = new MutationObserver((mutations) => {
+            if (isApplyingConditions) {
+                return;
+            }
+
             const shouldRebuild = mutations.some((mutation) => {
                 return mutation.type === 'childList' && (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0);
             });
@@ -200,8 +244,6 @@ export const conditionsModule: FormieModuleDefinition = {
             subtree: true,
             attributes: true,
             attributeFilter: [
-                'class',
-                'style',
                 'hidden',
                 'aria-hidden',
                 'data-formie-conditionally-hidden',

package/src/js/modules/fields/file-upload.ts

@@ -1,9 +1,9 @@
 import fileUploadCss from '#theme-css/fields/_file.css?inline';
 
 import type { FormieModuleDefinition } from '#contracts/modules';
-import { dispatchFieldEvent, getModuleFieldTarget, releaseFormValidators, retainFormValidators } from '#modules/fields/shared';
+import { dispatchFieldEvent, releaseFormValidators, retainFormValidators } from '#modules/fields/shared';
 import { ensureModuleStyles } from '#modules/styles';
-import { getFileUploadEventName, getFormStateEventName } from '#utils/event-names';
+import { getFieldModuleEventName, getFileUploadEventName, getFormStateEventName } from '#utils/event-names';
 import { requestJson } from '#utils/http';
 
 const INPUT_SELECTOR = 'input[type="file"][data-formie-file-input]';
@@ -20,6 +20,8 @@ const FILE_VALIDATORS = [
 ] as const;
 const VALIDATOR_SCOPE = 'file-upload';
 const MODULE_ID = 'file-upload';
+const REPEATER_INIT_ROW_EVENT = getFieldModuleEventName('repeater', 'init-row');
+const FIELD_HANDLE_SELECTOR = '[data-formie-field-handle]';
 
 ensureModuleStyles(MODULE_ID, [fileUploadCss]);
 
@@ -366,6 +368,47 @@ function updateUploadedAssetInputs(field: HTMLElement, input: HTMLInputElement,
     input.value = '';
 }
 
+function getFormHandle(form: HTMLFormElement | null): string {
+    if (!form) {
+        return '';
+    }
+
+    const handleInput = form.querySelector('input[name="handle"]');
+
+    if (handleInput instanceof HTMLInputElement && handleInput.value.trim()) {
+        return handleInput.value.trim();
+    }
+
+    return form.getAttribute('data-formie-handle')?.trim() || '';
+}
+
+function buildHydrateFormData(field: HTMLElement, input: HTMLInputElement, assetIds: number[]): FormData {
+    const form = input.form;
+    const body = new FormData();
+    const handle = getFormHandle(form);
+    const fieldHandle = getFieldHandle(field);
+
+    if (handle) {
+        body.append('handle', handle);
+    }
+
+    if (fieldHandle) {
+        body.append('fieldHandle', fieldHandle);
+    }
+
+    const submissionUidInput = form?.querySelector('input[name="submissionUid"]');
+
+    if (submissionUidInput instanceof HTMLInputElement && submissionUidInput.value.trim()) {
+        body.append('submissionUid', submissionUidInput.value.trim());
+    }
+
+    assetIds.forEach((assetId) => {
+        body.append('assetIds[]', String(assetId));
+    });
+
+    return body;
+}
+
 async function hydrateUploadedAssets(field: HTMLElement, input: HTMLInputElement, uploadedAssets: UploadedAsset[]): Promise<UploadedAsset[]> {
     const assetIds = uploadedAssets.map((asset) => {
         return asset.assetId;
@@ -378,14 +421,9 @@ async function hydrateUploadedAssets(field: HTMLElement, input: HTMLInputElement
     }
 
     const hydrateEndpoint = input.getAttribute(HYDRATE_ENDPOINT_ATTR)?.trim() || '/actions/formie/file-upload/hydrate';
-    const body = new FormData();
-    assetIds.forEach((assetId) => {
-        body.append('assetIds[]', String(assetId));
-    });
-
     const response = await requestJson<FileUploadHydrateResponse>(hydrateEndpoint, {
         method: 'POST',
-        body,
+        body: buildHydrateFormData(field, input, assetIds),
     });
     const hydratedAssets = normalizeUploadedAssets(response.assets);
 
@@ -504,6 +542,118 @@ function getUploadedAssetsFromEvent(event: Event, matcher: FileUploadEventMatche
     return [];
 }
 
+function getFieldContainer(input: HTMLInputElement): HTMLElement | null {
+    const field = input.closest(FIELD_HANDLE_SELECTOR);
+
+    return field instanceof HTMLElement ? field : null;
+}
+
+function collectFileUploadInputs(root: ParentNode): HTMLInputElement[] {
+    return Array.from(root.querySelectorAll(INPUT_SELECTOR)).filter((input): input is HTMLInputElement => {
+        return input instanceof HTMLInputElement;
+    });
+}
+
+function bindFileUploadInput(field: HTMLElement, input: HTMLInputElement, form: HTMLFormElement | null): () => void {
+    const state: FileUploadState = {
+        field,
+        input,
+        summaryRoot: ensureSummaryRoot(field, input),
+        uploadedAssets: mergeUploadedAssets(
+            readUploadedAssetsFromHiddenInputs(field, input),
+            readSummaryItems(field.querySelector('[data-formie-file-summary]') as HTMLElement | null),
+        ),
+        pendingFiles: [],
+        hydrationToken: 0,
+    };
+    const syncPendingFiles = () => {
+        state.pendingFiles = Array.from(input.files || []).map((file) => {
+            return file.name;
+        });
+        renderSummary(state);
+    };
+    const syncUploadedAssets = async(uploadedAssets: UploadedAsset[]) => {
+        state.hydrationToken += 1;
+        const hydrationToken = state.hydrationToken;
+        state.pendingFiles = [];
+        state.uploadedAssets = uploadedAssets;
+        updateUploadedAssetInputs(field, input, uploadedAssets);
+        renderSummary(state);
+
+        try {
+            const hydratedAssets = await hydrateUploadedAssets(field, input, uploadedAssets);
+
+            if (hydrationToken !== state.hydrationToken) {
+                return;
+            }
+
+            state.uploadedAssets = hydratedAssets;
+            renderSummary(state);
+            dispatchFieldEvent(field, MODULE_ID, 'uploaded-assets-sync', {
+                fileUpload: field,
+                assets: hydratedAssets,
+            });
+        } catch (error) {
+            console.error('[formie] Failed to hydrate uploaded file details.', error);
+        }
+    };
+    const resetUploadedAssets = () => {
+        state.hydrationToken += 1;
+        state.pendingFiles = [];
+        state.uploadedAssets = [];
+        updateUploadedAssetInputs(field, input, []);
+        renderSummary(state);
+    };
+    const uploadedAssetHandler = (event: Event) => {
+        const fieldHandle = getFieldHandle(field);
+
+        if (!fieldHandle) {
+            return;
+        }
+
+        const uploadedAssets = getUploadedAssetsFromEvent(event, {
+            fieldHandle,
+            inputKey: getFileUploadKey(input),
+            inputName: input.name,
+            pendingFiles: state.pendingFiles,
+        });
+
+        if (!uploadedAssets.length) {
+            return;
+        }
+
+        void syncUploadedAssets(uploadedAssets);
+    };
+    const resetHandler = () => {
+        resetUploadedAssets();
+    };
+
+    input.addEventListener('change', syncPendingFiles);
+    form?.addEventListener(FILE_UPLOAD_EVENT, uploadedAssetHandler as EventListener);
+    form?.addEventListener(FORM_RESET_EVENT, resetHandler as EventListener);
+
+    const syncInitialState = () => {
+        const assetIdsFromDom = readUploadedAssetsFromHiddenInputs(field, input);
+        const summaryItems = readSummaryItems(state.summaryRoot);
+        state.uploadedAssets = mergeUploadedAssets(assetIdsFromDom, summaryItems);
+
+        if (state.uploadedAssets.some((asset) => asset.assetId && !asset.filename)) {
+            void syncUploadedAssets(state.uploadedAssets);
+            return;
+        }
+
+        renderSummary(state);
+    };
+
+    syncInitialState();
+
+    return () => {
+        input.removeEventListener('change', syncPendingFiles);
+        form?.removeEventListener(FILE_UPLOAD_EVENT, uploadedAssetHandler as EventListener);
+        form?.removeEventListener(FORM_RESET_EVENT, resetHandler as EventListener);
+    };
+}
+
 export const fileUploadModule: FormieModuleDefinition = {
     id: MODULE_ID,
     kind: 'field',
@@ -511,111 +661,53 @@ export const fileUploadModule: FormieModuleDefinition = {
         return !!ctx.target.querySelector(INPUT_SELECTOR);
     },
     setup: async(ctx) => {
-        const field = getModuleFieldTarget(ctx);
-        const scope = field || ctx.target;
-        const inputs = Array.from(scope.querySelectorAll(INPUT_SELECTOR)).filter((input): input is HTMLInputElement => {
-            return input instanceof HTMLInputElement;
-        });
         const form = ctx.form;
+        const boundInputs = new WeakSet<HTMLInputElement>();
+        const unbinds: Array<() => void> = [];
 
-        registerValidators(form);
-
-        const unbinds = inputs.map((input) => {
-            if (!(field instanceof HTMLElement)) {
-                return () => {};
-            }
-
-            const state: FileUploadState = {
-                field,
-                input,
-                summaryRoot: ensureSummaryRoot(field, input),
-                uploadedAssets: mergeUploadedAssets(
-                    readUploadedAssetsFromHiddenInputs(field, input),
-                    readSummaryItems(field.querySelector('[data-formie-file-summary]') as HTMLElement | null)
-                ),
-                pendingFiles: [],
-                hydrationToken: 0,
-            };
-            const syncPendingFiles = () => {
-                state.pendingFiles = Array.from(input.files || []).map((file) => {
-                    return file.name;
-                });
-                renderSummary(state);
-            };
-            const syncUploadedAssets = async(uploadedAssets: UploadedAsset[]) => {
-                state.hydrationToken += 1;
-                const hydrationToken = state.hydrationToken;
-                state.pendingFiles = [];
-                state.uploadedAssets = uploadedAssets;
-                updateUploadedAssetInputs(field, input, uploadedAssets);
-                renderSummary(state);
-
-                try {
-                    const hydratedAssets = await hydrateUploadedAssets(field, input, uploadedAssets);
-
-                    if (hydrationToken !== state.hydrationToken) {
-                        return;
-                    }
-
-                    state.uploadedAssets = hydratedAssets;
-                    renderSummary(state);
-                    dispatchFieldEvent(field, MODULE_ID, 'uploaded-assets-sync', {
-                        fileUpload: field,
-                        assets: hydratedAssets,
-                    });
-                } catch (error) {
-                    console.error('[formie] Failed to hydrate uploaded file details.', error);
-                }
-            };
-            const resetUploadedAssets = () => {
-                state.hydrationToken += 1;
-                state.pendingFiles = [];
-                state.uploadedAssets = [];
-                updateUploadedAssetInputs(field, input, []);
-                renderSummary(state);
-            };
-            const uploadedAssetHandler = (event: Event) => {
-                const fieldHandle = getFieldHandle(field);
-
-                if (!fieldHandle) {
+        const bindInputsInRoot = (root: ParentNode) => {
+            collectFileUploadInputs(root).forEach((input) => {
+                if (boundInputs.has(input)) {
                     return;
                 }
 
-                const uploadedAssets = getUploadedAssetsFromEvent(event, {
-                    fieldHandle,
-                    inputKey: getFileUploadKey(input),
-                    inputName: input.name,
-                    pendingFiles: state.pendingFiles,
-                });
+                const field = getFieldContainer(input);
 
-                if (!uploadedAssets.length) {
+                if (!field) {
                     return;
                 }
 
-                void syncUploadedAssets(uploadedAssets);
-            };
-            const resetHandler = () => {
-                resetUploadedAssets();
-            };
+                boundInputs.add(input);
+                unbinds.push(bindFileUploadInput(field, input, form));
+            });
+        };
+
+        registerValidators(form);
+        bindInputsInRoot(ctx.target);
 
-            input.addEventListener('change', syncPendingFiles);
-            form?.addEventListener(FILE_UPLOAD_EVENT, uploadedAssetHandler as EventListener);
-            form?.addEventListener(FORM_RESET_EVENT, resetHandler as EventListener);
-            renderSummary(state);
+        const repeaterInitRowHandler = (event: Event) => {
+            const detail = (event as CustomEvent<unknown>).detail;
 
-            return () => {
-                input.removeEventListener('change', syncPendingFiles);
-                form?.removeEventListener(FILE_UPLOAD_EVENT, uploadedAssetHandler as EventListener);
-                form?.removeEventListener(FORM_RESET_EVENT, resetHandler as EventListener);
-            };
-        });
+            if (!isRecord(detail)) {
+                return;
+            }
+
+            const row = detail.row;
+
+            if (row instanceof HTMLElement) {
+                bindInputsInRoot(row);
+            }
+        };
+
+        form?.addEventListener(REPEATER_INIT_ROW_EVENT, repeaterInitRowHandler as EventListener);
 
         await ctx.emit('formie:module:file-upload:init', {
-            count: inputs.length,
+            count: unbinds.length,
         });
 
         return {
             destroy: () => {
+                form?.removeEventListener(REPEATER_INIT_ROW_EVENT, repeaterInitRowHandler as EventListener);
                 unbinds.forEach((unbind) => {
                     unbind();
                 });

package/src/js/submit/pipeline.ts

@@ -3,6 +3,7 @@ import type { FormSubmitResult } from '#contracts/schema';
 import { EventBus } from '#events/event-bus';
 import { submitForm } from '#transport/forms-api';
 import { createDebug } from '#utils/debug';
+import { getFormPages, getValidationScope } from '#validation/scope';
 import type { FormieValidator } from '#validation/validator';
 
 export type SubmitPipelineContext = {
@@ -30,32 +31,6 @@ function getAbortedResult(stage: SubmitStage, reason?: string): FormSubmitResult
     };
 }
 
-function getPages(form: HTMLFormElement): HTMLElement[] {
-    return Array.from(form.querySelectorAll('[data-formie-page]')) as HTMLElement[];
-}
-
-function getValidationScope(form: HTMLFormElement): { scope: Element; final: boolean } {
-    const pages = getPages(form);
-
-    if (!pages.length) {
-        return {
-            scope: form,
-            final: true,
-        };
-    }
-
-    // Multi-page submits validate the visible page until the user reaches the
-    // final step, where hidden earlier pages are included again.
-    const currentPage = pages.find((page) => {
-        return !page.hasAttribute('data-formie-page-hidden');
-    }) || pages[pages.length - 1];
-
-    return {
-        scope: currentPage,
-        final: currentPage === pages[pages.length - 1],
-    };
-}
-
 function isSubmittableControl(element: Element): element is HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement {
     return element instanceof HTMLInputElement
         || element instanceof HTMLSelectElement
@@ -172,7 +147,7 @@ function appendMissingFieldClears(formData: FormData, fieldNames: Set<string>):
 }
 
 function buildSubmitFormData(form: HTMLFormElement, action: FormAction): FormData {
-    const pages = getPages(form);
+    const pages = getFormPages(form);
     const currentPage = pages.find((page) => {
         return !page.hasAttribute('data-formie-page-hidden');
     }) || null;
@@ -200,7 +175,7 @@ function isFinalSubmitAttempt(form: HTMLFormElement, action: FormAction): boolea
         return false;
     }
 
-    const pages = getPages(form);
+    const pages = getFormPages(form);
 
     if (!pages.length) {
         return true;