From 3dce5dc617fbe49a48e38c71b9c7004677f190a3 Mon Sep 17 00:00:00 2001
From: vcoppe <vianney.coppe@gmail.com>
Date: Wed, 1 Apr 2026 09:01:01 +0200
Subject: [PATCH] improve filtering to always show layers in the same order

---
 website/src/lib/logic/settings.ts | 58 ++++++++++++++++++++-----------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/website/src/lib/logic/settings.ts b/website/src/lib/logic/settings.ts
index ab747c59b..28d358e31 100644
--- a/website/src/lib/logic/settings.ts
+++ b/website/src/lib/logic/settings.ts
@@ -10,8 +10,7 @@ import {
     defaultOverpassQueries,
     defaultOverpassTree,
     defaultTerrainSource,
-    overlays,
-    overpassQueryData,
+    overpassTree,
     type CustomLayer,
     type LayerTreeType,
 } from '$lib/assets/layers';
@@ -161,23 +160,42 @@ function getLayerValidator(allowed: Record<string, any>, fallback: string) {
             : fallback;
 }
 
-function filterLayerTree(t: LayerTreeType, allowed: Record<string, any>): LayerTreeType {
+function filterLayerTree(t: LayerTreeType, allowed: LayerTreeType | undefined): LayerTreeType {
     const filtered: LayerTreeType = {};
-    Object.entries(t).forEach(([key, value]) => {
-        if (typeof value === 'object') {
-            filtered[key] = filterLayerTree(value, allowed);
-        } else if (
-            allowed.hasOwnProperty(key) ||
-            key.startsWith('custom-') ||
-            key.startsWith('extension-')
-        ) {
-            filtered[key] = value;
+    const values = Object.values(t);
+    if (values.length == 0) return filtered;
+    if (typeof values[0] === 'boolean') {
+        if (allowed) {
+            Object.keys(allowed).forEach((key) => {
+                if (Object.hasOwn(t, key)) {
+                    filtered[key] = t[key];
+                }
+            });
         }
-    });
+        Object.entries(t).forEach(([key, value]) => {
+            if (
+                !Object.hasOwn(filtered, key) &&
+                (key.startsWith('custom-') || key.startsWith('extension-'))
+            ) {
+                filtered[key] = value;
+            }
+        });
+    } else {
+        Object.entries(t).forEach(([key, value]) => {
+            if (typeof value === 'object') {
+                filtered[key] = filterLayerTree(
+                    value,
+                    typeof allowed === 'object' && typeof allowed[key] === 'object'
+                        ? allowed[key]
+                        : undefined
+                );
+            }
+        });
+    }
     return filtered;
 }
 
-function getLayerTreeValidator(allowed: Record<string, any>) {
+function getLayerTreeValidator(allowed: LayerTreeType) {
     return (value: LayerTreeType) => filterLayerTree(value, allowed);
 }
 
@@ -259,32 +277,32 @@ export const settings = {
     selectedBasemapTree: new Setting(
         'selectedBasemapTree',
         defaultBasemapTree,
-        getLayerTreeValidator(basemaps)
+        getLayerTreeValidator(defaultBasemapTree)
     ),
     currentOverlays: new SettingInitOnFirstRead(
         'currentOverlays',
         defaultOverlays,
-        getLayerTreeValidator(overlays)
+        getLayerTreeValidator(defaultOverlayTree)
     ),
     previousOverlays: new Setting(
         'previousOverlays',
         defaultOverlays,
-        getLayerTreeValidator(overlays)
+        getLayerTreeValidator(defaultOverlayTree)
     ),
     selectedOverlayTree: new Setting(
         'selectedOverlayTree',
         defaultOverlayTree,
-        getLayerTreeValidator(overlays)
+        getLayerTreeValidator(defaultOverlayTree)
     ),
     currentOverpassQueries: new SettingInitOnFirstRead(
         'currentOverpassQueries',
         defaultOverpassQueries,
-        getLayerTreeValidator(overpassQueryData)
+        getLayerTreeValidator(overpassTree)
     ),
     selectedOverpassTree: new Setting(
         'selectedOverpassTree',
         defaultOverpassTree,
-        getLayerTreeValidator(overpassQueryData)
+        getLayerTreeValidator(overpassTree)
     ),
     opacities: new Setting('opacities', defaultOpacities),
     customLayers: new Setting<Record<string, CustomLayer>>('customLayers', {}),