34 KiB
Vue migration
The application UI moves from static templates plus imperative DOM wiring to Vue 3 components with Pinia stores. The migration keeps the experience the same: element ids, classes, the global stylesheet, translations, keyboard shortcuts, voice actions, share links and the phone layout all behave as before. The one intended change is the panel rail described below.
Goals
- Views are Vue single-file components; state that several views read lives in Pinia stores rather than in DOM classes.
- The owners listed in UI-OWNERSHIP.md keep their responsibilities. A component replaces DOM construction; it does not add a second owner of the same state.
- Public methods used by layers, scene playback, voice and host applications
(
setPanelCollapsed,setContextMode,setStyle, share and location subscriptions) keep their signatures. - Ids and classes used by browser QA and host applications stay stable until a host can use an explicit extension point instead.
The panel rail
Each desktop sidebar gets a floating icon rail that lists every panel available on that side. Selecting an icon opens that panel; selecting it again closes it. One panel is open per side at a time, so the rail replaces the accordion stacking. Panels that are not available in the current mode (for example Weather before a weather layer is active) are shown disabled or omitted as the panel's own availability rule dictates. The rail hides with the rest of the chrome in Cockpit, scene playback, recording and the clean view.
Phones keep the existing bottom tab bar and sheets; the rail is desktop only.
Voice and keyboard openings go through the same panel store, so they follow the one-panel rule too. Share links continue to record which panels are open.
Component kit
src/ui/kit/ holds the generic components: UiRail, UiTooltip, UiIcon,
UiButton, UiCloseButton, UiPanel, UiSegmented, UiSlider, UiChip,
UiSelect, UiSearchField, UiCheckbox, UiDialog, UiBadge and UiEmpty so far, with more
joining as the controls they serve are converted. One component
serves every use of a control, with props for the differences (UiPanel's
sideways, glow, scroll), rather than a copy per panel. The components
are styled by the existing stylesheet and custom properties, and they contain
no application state. The kit's own classes wear Core's standard looks, each
sharing one selector list with the Core skin it comes from, so the rules are
never copied:
| Kit class | Look | Rules |
|---|---|---|
UiButton variant="ghost" (default) |
none: the caller's classes style it | — |
UiButton variant="action" |
the action surface (gev-action-button); tone="danger" hovers red, size="compact" is the shot-row footprint (on this variant only) |
src/ui/styles/action-button.css |
UiButton variant="primary" |
the action surface with a group's main-action accent | src/ui/styles/action-button.css |
UiButton variant="icon" |
the 22px square glyph button of a panel's collapse toggle | src/ui/styles/controls.css |
UiCloseButton |
a close, dismiss or clear button: a bare glyph (× with glyph="times", the Material close symbol with glyph="icon") with no padding, border or background of its own and a pointer; the site's feature class sets size, colour, hover and any surface, and bare leaves the look off for a skin that sets its own padding and border |
src/ui/styles/close-button.css |
UiSearchField |
a search field: the Material search glyph and a search input in a flex row, the input bare (no border or background, free to shrink); the site's feature classes set the frame's size, surface and focus ring and the input's type and outline, and the browser's own cancel button is left to each skin |
src/ui/styles/search-field.css |
UiCheckbox |
a checkbox: a label wrapping a native box and its words in a centred flex row; the box keeps each site's size, margin and accent colour, and the site's feature class sets the row's gap, direction and colour | src/ui/styles/checkbox.css |
UiDialog |
none: a native modal <dialog>; the site's feature class or inline style draws it |
— |
UiChip |
the read-only chip (a pill of uppercase mono text); selected takes the accent |
src/ui/styles/chip.css |
UiEmpty |
the one-line empty state (dim mono text), its hint on a line below | src/ui/styles/empty-state.css |
UiBadge |
the read-only badge (gev-status-badge) |
src/ui/styles/status-badge.css |
UiSegmented |
the segmented control (gev-segmented, gev-segment) |
src/ui/styles/segmented-control.css |
A pressed action, primary or icon button looks as a hovered regular one does
(a compact action's quieter hover is for an unpressed button), and a disabled
one dims and ignores hover and press. tone is accent or danger, and
size styles the action variant only. Each look's resting rule selects one
kit class; the button, chip and empty-state skins load before the feature
stylesheets that restyle them, so a feature class still wins. The badge and
segmented skins are the stylesheets their Core classes always used. A
converted control keeps its own classes beside the kit's.
src/ui/kit/kitStyles.test.mjs pins these rules.
UiPanel takes a title, slots and v-model:collapsed, but its
collapsed drives only the button and ui-panel--collapsed: the root's
collapsed class, which hides the body, is drawn at once by v-panel-state
from the panel chrome store, and there is no closable, since Core's panels collapse rather than close.
UiSegmented adds keyboard (none, arrows, or radio with
Home and End), since each of Core's groups keeps its own keyboard policy, and
itemClass/activeClass for Core's segment classes. A key moves focus at
once and asks for a change only when it lands on another option. Every
segmented group in Core is a UiSegmented; the old segmentedControl.js
adapter is gone.
UiButton adds pressedClass, Core's class on a pressed toggle (most use
active); its pressed classes toggle through classList, so a class other
code adds (a voice highlight) survives a press. Not every pressed toggle in
the views is one yet: the context view, the Layer Finder,
the Stories screens and a few panel buttons still hand-write theirs, and
Bhote Koshi's cinematic button and the tilt-map button have owners that
write their state into the DOM. Core's
pressable chips and pills (rail card chips, map sources, cities and places)
are UiButtons too; UiChip is a non-interactive label chip, used by
the voice card.
The welcome card's buttons (SKIP, the three start tiles, BROWSE STORIES,
BACK and the main NEXT / ENTER GOD MODE action) are ghost UiButtons:
the start tiles are pressed toggles, and all but SKIP keep aria-disabled
rather than disabled, so they stay focusable while the card is busy. Its
tile, tip, Stories and arrow glyphs are UiIcons with :size="null", so
first-run.css still sizes them (src/ui/kit/welcomeControls.test.mjs pins
it). God mode's preview globe and callouts stay inline SVG drawings, and
its outbound links stay links.
The Omnibar's mic (a pressed toggle with active) and its suggestion
strip's chips (options, so aria-current rather than pressed) are
ghost UiButtons, and its search, row and chip glyphs are UiIcons with
:size="null", so its own rules still size them
(src/ui/kit/omnibarControls.test.mjs pins it). The mic's and the chat
row's glyphs stay inline SVG, since no Material symbol the page loads
draws them, and its field is its own combobox rather than a
UiSearchField.
The Visual panel's buttons (its presets and map sources, HUD, Sonar,
Detection, 3D, Clean UI, Celestial, Bloom, Sharpen and Reset to default) are
ghost UiButtons. HUD, Sonar, 3D, Celestial, Bloom and Sharpen are
pressed toggles with active as their pressed class; Detection sets its own
active and panoptic classes, and Clean UI is not a pressed toggle (its
owner marks it active). The panel's Scope, Celestial,
sky, application-row and Reset glyphs are UiIcons with :size="null", so
the panel's rules still size them (src/ui/kit/visualControls.test.mjs pins
it). The toggles' other glyphs (◎ ▣ ✈ □ ✨ 🔍) and the presets' style glyphs
are text characters, not Material symbols, and stay plain spans.
The entity card's buttons are ghost UiButtons: its four preview buttons
(Photos, Route, 3D, Cockpit view) are pressed toggles with active, Follow
is one with entity-card__action--on, and the cockpit entry, Fly to and
Ask GEV are plain buttons; so are the camera preview's bigger-view and More
info buttons and the nearby lists' rows (SpotConditions, which the
context view shows too). Their glyphs are UiIcons with :size="null",
so entity-card.css and spot-conditions.css still size them
(src/ui/kit/entityCardControls.test.mjs pins it). Ask GEV's chat bubble
stays inline SVG, since no Material symbol the page loads draws it.
UiSelect renders the bare native select (Core's labels sit outside it or
come as an aria-label) with v-model, options and disabled;
options that carry their own attributes come through the slot, a caller's
@change still reaches the select, and hold works as in UiSlider.
Without hold, a select takes its model back after its own change renders,
so a pick its owner refuses goes back; an owner that answers later (the SDR
gain) takes hold. Every select in the views is a UiSelect.
UiBadge takes a tone and carries Core's gev-status-badge; its
density variants and colours stay caller classes, and it renders the CCTV
source and calibration badges and the rail card badges. UiEmpty takes
a title and hint, but Core's empty states are one line, so the title
is the text itself rather than a bold heading; the News feed, Scene shot
list, mission roster and imagery strip use it. The locale picker's and the mission tables'
empty rows stay a paragraph and table cells.
UiCloseButton is a UiButton with a fixed glyph, a required label and
no tip unless the site passes a title; attributes and classes pass through,
so each site keeps its id, feature class and look. Every close, dismiss and
clear button in the views is one (src/ui/kit/closeButtons.test.mjs pins
it); Street Level's and the space mission's keep bare, since their skins
set their own padding and border, and so does the credits list's. The
Quebec CCTV overlay's close is one too, and so is the Omnibar guide's,
which keeps its feature class and tip.
UiSearchField takes v-model, a required label (the input's
accessible name), placeholder and tag (div, given role="search" by
the site, or label); attributes and classes go to the frame, and
inputId, inputClass, autocomplete and spellcheck to the input. With
clearLabel it shows a UiCloseButton (clearClass, its label as its tip)
while text is typed, which empties the field and focuses the input again.
Escape stops at the input and is emitted with its event, so a site that also
keeps the browser from clearing the field prevents it there; focus()
focuses the input. The Context search and the Layer Finder's are
UiSearchFields; the locale picker's combobox, the Omnibar's location
field and the Data Library's labelled search are other controls. Its kit rules hold the declarations both search
skins had in common, moved rather than copied, and load before them.
UiCheckbox is a <label> wrapping a native <input type="checkbox"> and
its default slot; trailing puts the box after the words, as the Visual
panel's rows have it. It takes v-model (the change emits the checked state)
and emits change with its event; without a modelValue the box is the
browser's own, as the welcome card's "Don't show this again" is, whose
owner puts a refused save back itself. restore puts the box back to
modelValue once a change has rendered without the owner taking it, so the
voice panel's quick commands and Voice Preview show the applied value after
a refused change. Attributes and classes go to the label; inputId and
inputAttrs (such as aria-describedby or a data hook) to the box. The
Visual panel's Scope, sky and application toggles, the voice and chat
preferences, the Data Library's filter and the welcome card's box are
UiCheckboxes (src/ui/kit/checkboxes.test.mjs pins it); Story Explore's
filters are not converted yet. Its kit rule holds the centred row the
checkbox-only labels drew, moved rather than copied.
UiDialog is a native <dialog> its owner opens and closes with open:
true opens it with showModal() (on mount, for one mounted open), false
closes it, and unmounting closes it. Each change is applied once the content
has rendered and then emitted as opened or closed, so the Data Library
focuses its search field on open and returns focus to Browse on close.
Escape's cancel is prevented and emitted as dismiss, so the owner
decides; backdropDismiss makes a click on the dialog itself, outside its
content, a dismiss too. When the browser closes the dialog on its own
while open is still true (an Escape the page may not cancel),
browserClose tells the owner; closing on unmount reports nothing. A DOM
without showModal() leaves it closed rather than failing. Attributes,
classes, styles and listeners go to the dialog, and element is exposed.
The Data Library and the scene sharing dialogs are UiDialogs
(src/ui/kit/dialogs.test.mjs pins it); the panels drawn as
role="dialog" (key setup, the welcome launcher, the CCTV popup, Story
Explore's filter, the credits) and the render failure's alertdialog are
other controls. The two dialogs share no declarations, so it has no kit
rules.
UiSlider keeps the native range input rather than drawing a
role="slider" track, so Core's keyboard, form behaviour and styling stay;
it takes v-model, min, max, step and disabled, emits a
number, and adds hold (never rewrite a focused handle, and take the model
back on blur) and unstyled (the browser's own range, as Bhote Koshi's
are, without Core's slider surface). A caller's own input, change and blur
handlers still reach the input, and a null model leaves it as it is. It is
a functional render-function component, so the portable ./ui/input rows
use it without a component compiler. Every range in the views is a
UiSlider except the radio tuner's: its owner moves the handle back to the
selected station on a drag's first input without changing the slot, which
a functional component would not render again.
Controls share one skin, so every panel reads the same. Every scrolling
surface carries the kit's .ui-scroll, which draws the thin
themed scrollbar from --scroll-thumb and --scroll-track, and Cockpit's HUD windows keep their accent tint. A
surface without it would draw the platform's light scrollbar, because the
page declares no dark color-scheme. Selects and number fields are
.gev-field, which draws its own chevron in place of the platform's arrow
and keeps native spinners dark; ranges are .gev-quantitative-slider, with
a feature supplying only its accent.
t() is not reactive. Words a view passes to a kit component as a prop
(UiCloseButton's label) follow a locale change on the view's next
render, but words in a kit component's slot do not: the compiled slot does
not render the child again. A view whose words must follow the locale at
once passes the locale itself as a prop or key, as the credits line does.
Phases
-
Foundation. Vue, Pinia and the Vite Vue plugin join the browser build (
build/vite.js, so host applications receive them too). One Vue runtime is created by the shell (src/ui/vueRuntime.js) with one Pinia instance that every view shares; disposing the shell unmounts them. Stores are added when a view needs one, mirroring state an owner already publishes, so there is never a second owner of the same state. -
Rail.
PanelChromeenforces one panel per side; the panel store mirrors each side's panels and the rail renders from it. The rail panels areRailPanels: the kit'sUiPaneldrawing Core's panel markup, bound to thegev-panel-chromestore, with their titles rendered byt()rather thandata-i18n. Each panel's collapse button, the dock tray toggles and the dock pins render the open and pinned state PanelChrome presents to thegev-panel-chromestore, and their clicks call it there. Each panel's root draws its own state from there too (v-panel-state:collapsed,dock-pinned,dock-pinned-top,layout-auto-collapsed,accordion-collapsed): PanelChrome, the rails and the accordion present it rather than writing classes. The directive applies it in a synchronous watcher, not on Vue's next render, because the rails measure a panel in the same task that opens or closes it. PanelChrome and its preference restore, and the phone shell, read a panel's state back from the store (_shownPanel; the markup's classes before its first presentation), so once a panel is presented a class written outside the store no longer counts. The rails, the accordion and the hover disclosure (panelDisclosure.js), which act within the same task as a layout, read the classes the directive has just drawn. Done. -
Panels. Each template and its wiring become a component, keeping ids, classes and CSS; text a template renders with
t()drops itsdata-i18nmarker. The page places each view with a.gev-viewhost (display: contents), andmountApplicationViews()(src/ui/views/index.js) renders the view into it before the page is translated and wired.createApplication()calls it too, removing the hosts of any views itsomitViewsnames. Views belong to the page and are unmounted only when a later call omits them. The loading screen is static markup in the page so it paints before any script runs. Markup tests readrenderApplicationHtml()fromsrc/testSupport, which renders the views on the server. Templates compile with Vue'spreservewhitespace, which keeps the whitespace between elements as a single space, so a view renders as its template did; no view markup sits under awhite-space: prerule. Application views (src/ui/views/*View.vue) are kept out of Prettier; other components are formatted with strict whitespace sensitivity, so their source spacing is what renders. The markup has moved, unchanged: every template except the loading screen is a view.Next each view takes over its wiring: markup an owner builds with
createElementbecomes component markup that renders from a Pinia store the owner publishes to, and user actions come back to the owner through the store, so the owner keeps every decision. Component text usest(), which follows the locale as the view renders; the views carry nodata-i18n*markers, whichnpm run i18nrejects in a template. Shared builders become components first and keep their imperative entry points until their owners are components: the rail cards and card blocks (src/ui/rail/) render through Vue's synchronousrender()behindcreateRailCards()andcreateRailCardBlocks(). Order: Scenes (done:SceneOptionsandSceneShotListover thegev-scenesstore; the panel's buttons, status line, progress bar and the runtime chip render the panel SceneControls presents there, and the buttons and file chooser call its actions), Weather (done: the owner rendersWeatherReadoutfrom the view it computes), Recent imagery (done:RecentImageryReadoutand its day cards, the same way), Street level (done:StreetLevelPanelrenders thegev-street-levelstore thatStreetLevelControlspublishes to; the controls keep their listeners, EXPAND, focus and resizing), CCTV (done:CctvPanelrenders the whole panel from thegev-cctvstore, including the camera picker, the inline pose editor, the frame preview, source badge and typed summary;CctvControlskeeps its listeners, the frame requests and the live video surface;QuebecCctvOverlayteleports the Québec 511 player and its map preview to the end of the body, rendered synchronously bycreateQuebecCctvOverlay()from the view it computes, as the rail cards are; the owner keeps every decision and the parts the template never binds: each video's source, playback and refresh timer, the window's drag and the marker's per-frame visibility and place), Layers (done:LayerPanelpresents each row and rendersLayerRowssynchronously; keyed chips and list items keep focus through the refresh their own click triggers, and clicks re-read the live descriptor before acting), Display (in progress:DisplayPanelrenders the HUD, Sonar, Scope, Celestial, detection, bloom, sharpen and the active style's parameter sliders from thegev-displaystore, which VisualSettings publishes to and answers the sliders through, and the 3D aircraft group, the Draw controls and the imported file list, which AircraftDisplay, the draw tool and the file import publish beside it; the controls call DisplayBindings, the draw tool and the file import through the store'sconnect/act, the newest owner of an action answering it;GeoImporthands keyboard focus on before a focused row goes, withv-focus-safe-children; the style parameter rows render through Vue behindcreateStyleParameters(), as a render function so the portable./ui/inputentry needs no component compiler; the other groups follow one owner at a time), Context and Radio (in progress:RadioPanelrenders the directory row, station card, transport, volume and playback line from thegev-radiostore that RadioControls publishes to and whose controls it answers through the store'sconnect/act(the sharedcreateOwners(); a refused station tag gets the kept tag back fromact), andSdrCardthe local RTL-SDR card that LocalSdrControls publishes beside it and answers the same way; fields a person edits take their value throughv-field-value, which never writes a focused field;RadioTunerrenders the directory tuner, where RadioControls keeps the drag and its slot, takes the slider's pointer, key and value events through the store and publishes the band, readouts, slider and needle, and the component lays out the tick tape against the dial's measured width and lays out the snapped needle before it drops the drag class;ContextViewrenders the mode switch and the nearby sites search from thegev-contextstore, which ContextControls reaches only through itspublishoption, so./ui/contextneeds no Vue;AwarenessPanelrenders the Contacts panel that the awareness layer publishes throughsubscribePanel(), the first layer to hand its rail content to a view, andMissionRosterandMissionDetailthe Space Missions roster and selected mission that the launches layer publishes the same way), the command dock (in progress: the style buttons, the dock's style mini status and the ACTIVE STYLE corner render the style VisualSettings publishes to thegev-displaystore; the buttons keep their owner's listeners; the map source chips and status badge render whatcreateMapSourceControls()publishes beside it, so./ui/mapsneeds no Vue; the location tray's city and landmark pills, mini status and search error render whatLocationControlspublishes to thegev-locationstore, and the search field keeps its listeners; beside the voice control, the dock teleports each voice pointer reticle to the body where itsPointerReticlepresents it in thegev-pointer-reticlestore;startGuide()renders the Omnibar's guided walk,OmnibarGuide, synchronously from the view it computes for each step, teleported to the end of the body, and keeps every decision and word, focus and its return, Escape, the entrance replay, and the callout's and spotlight rings' place each frame), the phone shell (PhoneTabBarrenders the tabs and open sheet the shell publishes to thegev-displaystore, teleporting the tab bar and sheet backdrop to the end of the page from the first publish until the shell is destroyed; the shell takes their clicks from the document), the imagery dividers (ImagerySplitView, in the scene chrome, teleports each before/after divider thatcreateImagerySplitpublishes to thegev-imagery-splitstore to the body; the split keeps the drag, keyboard, CSS position and scene split), the status chips (the top-center loading status and the road network and camera grid chips render what ShellFeedback and CctvControls publish to thegev-statusstore;SplitFlapTextplays the departure-board flip thatsplitFlap.jsplans, writing only the label's one text node; the toast renders what each owner'screateToast()publishes there, on that owner's own timer, and the title bar's FPS readout whatcreateFrameRateMonitor()publishes), the globe actions (GlobeActionsrenders the top-center bar; its clear, share, tilt, north-up and reset buttons, and the cockpit's reset, call the shell through thegev-globe-actionsstore, which also carries a clear or a reset under way and the camera's tilt and heading thatbindCameraOrientationControlspublishes each drawn frame it changes, which onlyGlobeCompassrenders; an owner publishes only while it answers the button, so a shell replaced by a newer one leaves its state alone), the recording safe frame (the scene chrome renders the frameRecordingControlspublishes to thegev-recordingstore), the Scene actions panel (SceneInteractionsteleports what the scene interactions owner publishes to thegev-scene-interactionsstore into the viewer's container; the owner keeps the pick handler and focuses the picked action), the data-pack attribution cards (DataPacksteleports what the data-pack presentations publish to thegev-data-packsstore into the viewer's container and stops a removed card's player), the wind inspection marker (WindInspectionMarkerteleports the marker into the wind layer's container wherecreateWindInspectionMarker(), now insrc/layers/wind/inspectionMarker.jsso the portable./toolsentry needs no Vue, places it after each rendered frame; an unchanged frame publishes nothing), the Space Missions replay vehicle (MissionReplayOverlayteleports into the globe container what the launches layer presents throughsubscribeReplayOverlay(), which the application shell publishes to thegev-mission-replaystore, so the portable./layers/launchesentry needs no Vue), the Bhote Koshi reconstruction panel (BhoteKoshiPanel, last in the context rail, renders what the event layer publishes to thegev-bhote-koshi-panelstore: each control's text, hidden, disabled, value and attributes as the layer writes them, unchanged frames sending nothing; the rail takesbhote-event-activewhile it shows), the full-globe celestial ring (CelestialRingteleports into the globe container whatCelestialRinginsrc/celestialRing.jspublishes to thegev-celestial-ringstore and hands its two canvases back for the owner to paint; the application shell passes the store in, so the keyhole helpers other packages import need no Vue), the screen-space map annotations (ScreenAnnotationsteleports to the body the board the screen annotation renderer publishes to thegev-screen-annotationsstore after each rendered frame: each mark's SVG parts as attribute records, the fading marks until they leave; the view hands back the callout text and mark groups the renderer measures, and the tracked-entity fade is measured once the frame is in the document; the styles it injected now live insrc/ui/styles/annotations.css), the visible map target list (the scene chrome renders the buttons and status the world overlay presents throughsubscribeWorldOverlayActions(), which the application shell publishes to thegev-world-overlay-actionsstore and answers withactivateWorldOverlayAction(); the module needs no Vue for the portable transit entry, and its card and detection canvases stay painting surfaces it draws on, like the Cesium canvas), the Global Context compass and contact bearings (AwarenessDirectionteleports into the globe container what the awareness layer presents throughsubscribeDirectionOverlay(), which the application shell publishes to thegev-awareness-directionstore, so the portable./layers/awarenessentry needs no Vue), the Intel HUD (theintel-hudview renders#intel-hud, its corners, edges and bottom bar from thegev-hudstore, which IntelHUD publishes to through itspublishoption: the readouts, the typing summary, the REC blink, visibility, layout variant and style colors; the vessel layer presents the selected vessel's readout throughsrc/hudReadouts.jsinstead of writing into the HUD), the first-run mission launcher (the welcome view renders the card's visibility, busy state, status line, copy and scroll fade from thegev-first-runstore thatinitFirstRunExperiencepublishes to, and its choices, DISMISS and "Don't show this again" call the launcher's controls; a refused save hands the tick back to the view to revert. The launcher still reads the rendered card for its hit test, keyboard trap, focus and overflow measurement), the attribution line (for a renderer without its own credit display,mountCreditsView()rendersCreditsViewsynchronously, as the weather readout is, and the view teleports the line and its "Data attribution" list to the end of the body, where the page's rules select them; the owner keeps the credits shown, the list's open state and its focus, and words the view again when the locale changes; the list's close button is a bareUiCloseButton), then Cockpit (in progress:CockpitBriefingrenders the briefing card's pages, cycle toggle, regional news and local conditions, andCockpitContextthe Contact card's scope, navigation, counts, nearest contact and weather toggle,CockpitViewthe instruments, destination arrow and vision selector, andCockpitRoutethe flight plan card, from thegev-cockpitstore that the Cockpit controller publishes to, starting fromcockpitBriefPages.js,cockpitContextState.jsandcockpitInstrumentState.js, which both read; the odometer readouts (CockpitRollingValue) keep their throttle and roll incockpitRollingValue.js.CockpitSignalListrenders the live signal rows;v-focus-safe-childrenturns Vue's move of the focused row into moves of the rows around it, and hands focus to the shown briefing tab before the focused row is removed, so a keyed list reorders several times a second without dropping keyboard focus. The instruments publish on every HUD update (about 10 Hz); in a dev build their Vue patch costs about 0.5 ms, close to the DOM writes it replaced. The controller also publishes which surfaces are shown: the entry button and TR-3B chip in the Context panel, the HUD with its exit and reset buttons and briefing card, and the Contact card. Focus moves to the exit button, and back to the entry, only after Vue renders them. The cards' collapse is part of that presence too: each card'sdata-collapsedand its toggle's words and icon render from it. The controls keep the controller's listeners, and the cards' layout stays with the controller, which reads their visibility when it lays them out. Its layout pass publishes the utility strip's measured fit (the HUD's anchor and height limits, whether only the expanded control fits and which control is hidden from assistive technology), whichCockpitViewandCockpitUtilityControlsrender; the briefing and Contact cards' positions stay imperative, because the same pass measures them straight after writing them.CockpitUtilityControlsrenders the Display and Radio launchers, which popover is open and the compact Radio controls from thegev-radiostore that RadioControls publishes to and answers through. The Cockpit display portal publishes the Display popover's slots to thegev-displaystore while Cockpit is on, andDisplayPanelteleports its HUD, Detection, Parameters and 3D groups into them and back; the portal keeps each surface's scroll position and puts back focus the move dropped). Layers that write into the right rail directly gain a slot instead. -
Cleanup. The build-time template expansion is retired:
index.htmllists the view hosts and the loading screen itself. Every owner that showed UI state through hand-written DOM writes now publishes to a store that a view renders, apart from the imperative parts this document records surface by surface; Building UI now requires the pattern for new UI. The page-level markup tests readrenderApplicationHtml(), the real views rendered on the server, and new tests mount components; two tests still read a.vuefile's source (panelStorageDocs,geoFileImport). The views translate witht()while rendering, and vue-i18n holds the locale they read; the attribute translation pass is left for static page markup (the loading screen and a host's own markup). An explicit API for hosts to register panels and rail items is deferred until a host adds one: no host does today (the hosted application's account interface is its own markup), and the first such panel, the hosted timeline, will shape it.
Verification
- Unit tests: stores and components run under
npm test. Single-file components are compiled by a test loader; component tests render with@vue/test-utilsandhappy-dom.npm testregisters the loader; to run one file that reaches a component (including anything importing the shell), usenode --import=./build/registerVue.js --test <file>. - Never pass happy-dom nodes to
assert.equalordeepEqual: a failure prints both operands, and a node reaches the whole page and window, which runs the process out of memory. Compare nodes withassertSameNode()(src/testSupport/domAssert.mjs). - Panels lifted out of a view keep its verbatim markup in
src/ui/views/panels/, which Prettier leaves alone like the views. - Visual parity: before/after screenshots of every panel at desktop and phone widths, in the default theme, with the rail as the only expected difference.
- Browser QA: the selector-based
scripts/qa-*.mjssuites keep passing. npm run format:check,npm run check:boundaries,npm run i18nandnpm run build.