@countriesdb/widget 0.1.35 → 0.1.36

package/dist/index.esm.js

@@ -649,50 +649,36 @@ async function updateSubdivisionSelect(select, apiKey, backendUrl, state, config
                             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 preselected is disabled and allowParentSelection is false, find first enabled child
                                 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;
+                                    const preselectedOption = Array.from(select.options).find((opt) => opt.value === preselectedSubdivision.code);
+                                    if (preselectedOption?.disabled) {
+                                        // Find direct children by parent_id
+                                        const directChildren = subdivisions.filter((sub) => sub.parent_id === preselectedSubdivision.id);
+                                        if (directChildren.length > 0) {
+                                            // Sort by name and get first child
+                                            const sorted = directChildren.sort((a, b) => {
+                                                return (a.name || '').localeCompare(b.name || '', subdivisionsLanguage, { sensitivity: 'accent' });
+                                            });
+                                            const firstChild = sorted[0];
+                                            // Check if first child is also disabled (has its own children)
+                                            const firstChildOption = Array.from(select.options).find((opt) => opt.value === firstChild.code);
+                                            if (firstChildOption?.disabled) {
+                                                // First child is disabled, find its first child (grandchild)
+                                                const grandChildren = subdivisions.filter((sub) => sub.parent_id === firstChild.id);
+                                                if (grandChildren.length > 0) {
+                                                    const sortedGrandChildren = grandChildren.sort((a, b) => {
+                                                        return (a.name || '').localeCompare(b.name || '', subdivisionsLanguage, { sensitivity: 'accent' });
+                                                    });
+                                                    subdivisionToSelect = sortedGrandChildren[0];
                                                 }
-                                                if (node.children && node.children.length > 0) {
-                                                    const found = findNodeInTree(node.children, code);
-                                                    if (found)
-                                                        return found;
+                                                else {
+                                                    subdivisionToSelect = firstChild;
                                                 }
                                             }
-                                            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;
+                                            else {
+                                                subdivisionToSelect = firstChild;
                                             }
-                                            // 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;
                                         }
                                     }
                                 }