@countriesdb/widget 0.1.33 → 0.1.35

package/dist/dom-manipulation.js

@@ -132,6 +132,12 @@ export function applyPreselectedValue(select, apiKey) {
     if (select.dataset._widgetTempPreselect !== undefined) {
         delete select.dataset._widgetTempPreselect;
     }
+    // Mark permanent preselect as consumed after first application
+    // This prevents it from being reapplied on user-initiated country changes
+    // But reload: true will clear this flag to allow reapplication
+    if (permanent !== undefined && permanent !== null && String(permanent).trim() !== '') {
+        select.dataset._widgetPreselectedConsumed = '1';
+    }
 }
 /**
  * Handle API error by showing error message in select

package/dist/index.esm.js

@@ -133,6 +133,12 @@ function applyPreselectedValue(select, apiKey) {
     if (select.dataset._widgetTempPreselect !== undefined) {
         delete select.dataset._widgetTempPreselect;
     }
+    // Mark permanent preselect as consumed after first application
+    // This prevents it from being reapplied on user-initiated country changes
+    // But reload: true will clear this flag to allow reapplication
+    if (permanent !== undefined && permanent !== null && String(permanent).trim() !== '') {
+        select.dataset._widgetPreselectedConsumed = '1';
+    }
 }
 /**
  * Handle API error by showing error message in select
@@ -621,7 +627,13 @@ async function updateSubdivisionSelect(select, apiKey, backendUrl, state, config
                 if (!userSelectionRestored) {
                     // Check if preselected value exists (applyPreselectedValue will read it from select element)
                     const hasPreselectedValue = (select.getAttribute('data-preselected') || select.dataset.preselected || select.dataset._widgetTempPreselect) !== undefined;
-                    if (hasPreselectedValue) {
+                    const preselectedConsumed = select.dataset._widgetPreselectedConsumed === '1';
+                    // Only apply preselected if:
+                    // 1. It exists AND
+                    // 2. Either it hasn't been consumed yet, OR this is the initial load (not a reload)
+                    // This prevents reapplying preselected values on user-initiated country changes
+                    // But allows them on initial load and on reload: true (which clears the consumed flag)
+                    if (hasPreselectedValue && (!preselectedConsumed || !isReload)) {
                         applyPreselectedValue(select, apiKey);
                         dispatchUpdateEvent(select, {
                             type: 'subdivision',
@@ -636,16 +648,64 @@ async function updateSubdivisionSelect(select, apiKey, backendUrl, state, config
                             const preselectedSubdivision = subdivisions.find((subdivision) => subdivision.preselected);
                             if (preselectedSubdivision) {
                                 const isMultiple = select.hasAttribute('multiple');
+                                let subdivisionToSelect = preselectedSubdivision;
+                                // Check if the preselected subdivision is disabled (parent with children when allowParentSelection is false)
+                                if (!config.allowParentSelection && !isMultiple) {
+                                    const option = Array.from(select.options).find((opt) => opt.value === preselectedSubdivision.code);
+                                    // If option is disabled, find the first child subdivision
+                                    if (option && option.disabled) {
+                                        const tree = buildSubdivisionTree(subdivisions);
+                                        // Find the node in the tree
+                                        function findNodeInTree(nodes, code) {
+                                            for (const node of nodes) {
+                                                if (node.code === code) {
+                                                    return node;
+                                                }
+                                                if (node.children && node.children.length > 0) {
+                                                    const found = findNodeInTree(node.children, code);
+                                                    if (found)
+                                                        return found;
+                                                }
+                                            }
+                                            return null;
+                                        }
+                                        const preselectedNode = findNodeInTree(tree, preselectedSubdivision.code);
+                                        // Get the first child (recursively if needed)
+                                        function getFirstChild(node) {
+                                            if (!node || !node.children || node.children.length === 0) {
+                                                return null;
+                                            }
+                                            // Sort children to get consistent first child
+                                            const sortedChildren = [...node.children].sort((a, b) => {
+                                                const nameA = a.name || '';
+                                                const nameB = b.name || '';
+                                                return nameA.localeCompare(nameB);
+                                            });
+                                            const firstChild = sortedChildren[0];
+                                            // If first child also has children and would be disabled, recurse
+                                            if (firstChild.children && firstChild.children.length > 0) {
+                                                const deeperChild = getFirstChild(firstChild);
+                                                return deeperChild || firstChild;
+                                            }
+                                            return firstChild;
+                                        }
+                                        const firstChild = preselectedNode ? getFirstChild(preselectedNode) : null;
+                                        if (firstChild) {
+                                            // Find the subdivision object by code
+                                            subdivisionToSelect = subdivisions.find((sub) => sub.code === firstChild.code) || preselectedSubdivision;
+                                        }
+                                    }
+                                }
                                 if (isMultiple) {
                                     // For multi-select, find and select the option
-                                    const option = Array.from(select.options).find((opt) => opt.value === preselectedSubdivision.code);
+                                    const option = Array.from(select.options).find((opt) => opt.value === subdivisionToSelect.code);
                                     if (option) {
                                         option.selected = true;
                                     }
                                 }
                                 else {
                                     // Single select: set value directly
-                                    select.value = preselectedSubdivision.code;
+                                    select.value = subdivisionToSelect.code;
                                 }
                                 dispatchUpdateEvent(select, {
                                     type: 'subdivision',
@@ -935,6 +995,16 @@ async function CountriesWidgetLoad(options = {}) {
     if (shouldReload) {
         NS.initialized = false;
         NS.initPromise = null;
+        // Clear consumed preselected flags to allow preselected values to be reapplied on reload: true
+        // This ensures full reload behavior where preselected values are reapplied
+        if (typeof document !== 'undefined') {
+            const subdivisionSelects = document.querySelectorAll('.subdivision-selection');
+            subdivisionSelects.forEach((select) => {
+                if (select.dataset._widgetPreselectedConsumed) {
+                    delete select.dataset._widgetPreselectedConsumed;
+                }
+            });
+        }
     }
     // Share the same promise across concurrent calls
     NS.initPromise = (async () => {