improve setting load

packages/app/src/settings/index.js

@@ -1,139 +1,74 @@
-async function composeSettingsByGroups() {
+function composeSettingsByGroups() {
-    console.time("load settings")
+	console.time("load settings")
 
-    /* @vite-ignore */
+	const modules = import.meta.glob("/src/settings/*/index.jsx", {
-    let _settings = import.meta.glob("/src/settings/*/index.jsx")
+		eager: true,
+		import: "default",
+	})
 
-    _settings = Object.entries(_settings).map(([route, moduleFile]) => {
+	let settings = Object.entries(modules)
-        const path = route.split("/").slice(-2)
+		.map(([path, module]) => {
-        const name = path[0]
+			const name = path.split("/").slice(-2, -1)[0]
+			return name === "components" || name === "index" ? null : module
+		})
+		.filter(Boolean)
+		.sort((a, b) => (a.group === "bottom") - (b.group === "bottom"))
+		.reduce((acc, curr) => {
+			const group = curr.group
+			;(acc[group] || (acc[group] = [])).push(curr)
+			return acc
+		}, {})
 
-        if (name === "components" || name === "index") {
+	settings = Object.entries(settings).map(([group, groupModules]) => {
-            return null
+		const processedModules = groupModules
-        }
+			.map((module) => {
+				if (!Array.isArray(module.settings)) return module
 
-        return moduleFile
+				return {
-    })
+					...module,
+					settings: module.settings.filter((setting) => {
+						if (!app.isMobile && setting.desktop === false)
+							return false
+						if (app.isMobile && setting.mobile === false)
+							return false
+						return true
+					}),
+				}
+			})
+			.sort((a, b) => (a.order ?? Infinity) - (b.order ?? Infinity))
 
-    _settings = _settings.filter((moduleFile) => moduleFile)
+		return { group, groupModule: processedModules }
+	})
 
-    _settings = await Promise.all(_settings.map((moduleFile) => moduleFile()))
+	console.timeEnd("load settings")
-
+	return settings
-    _settings = _settings.map((moduleFile) => {
-        return moduleFile.default || moduleFile
-    })
-
-    _settings = _settings.sort((a, b) => {
-        if (a.group === "bottom") {
-            return 1
-        }
-
-        if (b.group === "bottom") {
-            return -1
-        }
-
-        return 0
-    })
-
-    _settings = _settings.reduce((acc, settingModule) => {
-        if (typeof acc[settingModule.group] !== "object") {
-            acc[settingModule.group] = []
-        }
-
-        acc[settingModule.group].push(settingModule)
-
-        return acc
-    }, {})
-
-    _settings = Object.entries(_settings).map(([group, groupModule]) => {
-        // filter setting by platform
-        groupModule = groupModule.map((subGroup) => {
-            if (Array.isArray(subGroup.settings)) {
-                subGroup.settings = subGroup.settings.filter((setting) => {
-                    if (!app.isMobile && setting.desktop === false) {
-                        return false
-                    }
-
-                    if (app.isMobile && setting.mobile === false) {
-                        return false
-                    }
-
-                    return true
-                })
-            }
-
-            return subGroup
-        })
-
-        return {
-            group,
-            groupModule: groupModule
-        }
-    })
-
-    // order groups
-    _settings = _settings.map((group) => {
-        group.groupModule = group.groupModule.sort((a, b) => {
-            if (typeof a.order === undefined) {
-                // find index
-                a.order = group.groupModule.indexOf(a)
-            }
-
-            if (typeof b.order === undefined) {
-                // find index
-                b.order = group.groupModule.indexOf(b)
-            }
-
-            return a.order - b.order
-        })
-
-        return group
-    })
-
-    console.timeEnd("load settings")
-
-    return _settings
 }
 
 function composeTabsFromGroups(settingsGroups) {
-    return settingsGroups.reduce((acc, entry) => {
+	return settingsGroups.reduce((acc, entry) => {
-        entry.groupModule.forEach((item) => {
+		entry.groupModule.forEach((item) => {
-            if (item.id) {
+			if (item.id) acc[item.id] = item
-                acc[item.id] = item
+		})
-            }
+		return acc
-        })
+	}, {})
-
-        return acc
-    }, {})
 }
 
 function composeGroupsFromSettingsTab(settings) {
-    if (!Array.isArray(settings)) {
+	return (settings || []).reduce((acc, setting) => {
-        console.error("settings is not an array")
+		if (setting.group) {
-        return []
+			acc[setting.group] = [...(acc[setting.group] || []), setting]
-    }
+		}
-
+		return acc
-    return settings.reduce((acc, setting) => {
+	}, {})
-        if (setting.group) {
-            if (typeof acc[setting.group] === "undefined") {
-                acc[setting.group] = []
-            }
-
-            acc[setting.group].push(setting)
-        }
-
-        return acc
-    }, {})
 }
 
-const composedSettingsByGroups = await composeSettingsByGroups()
+const composedSettingsByGroups = composeSettingsByGroups()
 const composedTabs = composeTabsFromGroups(composedSettingsByGroups)
 
 export {
-    composedSettingsByGroups,
+	composedSettingsByGroups,
-    composedTabs,
+	composedTabs,
-
+	composeSettingsByGroups,
-    composeSettingsByGroups,
+	composeTabsFromGroups,
-    composeTabsFromGroups,
+	composeGroupsFromSettingsTab,
-    composeGroupsFromSettingsTab,
 }