cap the comment

spaces around +

This system is driving on the fact there is exactly one such panel. It would be better to make a g_OtherPanels = ["charts"] in layout.js and concat that one with the object.keys array. from that we can then work our way to get the wanted behaviour (going to the next, except when last tab the first)

make jsDoc and period

that is looping twice over the same thing, first in the map then the for. Move the map into the for scope so:

for (let button of g_PanelsButton)
{
   tab = Engine.GetGUIObjectByName(button); // (or find a better name for tabObject)
   blabla()
}

let => var

With the exception of typed arrays, there is only one JS number type I'm aware of and that's called number. The comment implies the type, so the type definition could be avoided too.

\0/ that has annoyed me a lot

Notice this check is correct, but not required, however its good for optimization I guess, so meh => just keep the check

let i = 0; i < panels.length; ++i ?

(That way the +i below can become just i)

maybe is correct, maybe not: why do we need to have g_DefaultPanel? and can't we just set here g_ViewPanel = "scorePanelButton" and then just let the init overwrite that when it wants to (like it already does).

= undefined; should be removed (we got a linter rule)

not sure +i+1 and +i-1 must be with spaces +i + 1 and +i - 1

maybe rename to j or so, to avoid confusion

Show next/previous panel.?

seems to be no need for this => inline

nuke [] around direction

even when we declare let j = 0; instead of let panel = panels[0]; on line 134, this line can be inlined in line 145

nuke the optionality in the argument, just make it a required one and put the 1 in the call

It is a js disgrace to take the remainder as negative for negative values imo, (index + direction + panels.length) % panels.length

see previous comment

Correct since if g_ViewPanel == "" then slicing just remains "" and that is not an element of panels. (Noting for self, no change needed)

Aww well (index + direction) % panels.length means (index + direction) modulo panels.length So that returns the remainder of dividing (index + direction) by panels.length, in the range [0, panels.length - 1]. So -1 % panels.length returns panels.length - 1 thus so we can remove the second ternary.

Also nextIndex is used only once so inline.

what about index = panels.indexOf(g_ViewPanel.slice(0, -"PanelButton".length));

rethinking this: using some modulo calculation and ternary would make the code cleaner so we get i = (g_ViewPanel == "" || index == -1) ? 0 : (index + direction) % panels.length;

And with all that i can and inlined

making the function a nice short two liner

newline before

{ "bbLint": "on", "needsFix": true, "errorType": "objectSpaces" }

nope

"scorePanelButton" looks like a magical value to me => put it in a global g_DefaultPanel

would be better to swap negate the statement and swap the cases
g_ViewPanel == "" ? g_DefaultPanel : g_ViewPanel

with removing g_DefaultPanel this would simplify to selectPanel(Engine.GetGUIObjectByName(g_ViewPanel));

some more juice here.
go next/prev panel on mouse scroll wheel up/down over the tab buttons.

As we use this thing twice now Object.keys(g_ScorePanelsData).concat(["charts"]) make it a global, also do Object.keys(g_ScorePanelsData).push("charts")
And just add the "PanelButton" to each element in that global that can be nuked in both usages

When being in the little space between the buttons, the scrolling doesn't work, probably just meh, since it would run in some inconsistencies when we allow it.

Nice, didn't notice so far. Would also be useful in the other GUI pages with tabs and consistent.