Files
gods-eye-view/src/ui/radioPresentation.js
T
German Khokhlov a2be947aba Merge origin/main into fix/hal-722-radio-next-no-autoplay
main moved the Radio markup into Vue views and rebuilt the UI tests on
stores. Resolved:
- src/ui/templates/context.html: deleted in main; the new privacy note now
  lives in src/ui/views/panels/RadioPanel.vue.
- src/ui/radioControls.test.mjs: main's store fixture; the Next/Previous
  autoplay test drives store.act('cycleRadio').
- src/voice/gevRealtime.test.mjs: main's createTestVoiceUi; the stop and
  select handoff cases stay one table-driven test.
- src/data/radioNextState.test.mjs reads the published gev-radio view.
- src/i18n/locales/ar.json: the new note translated for the Arabic locale.
2026-11-02 12:36:31 +04:00

338 lines
11 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* Present Radio state without making playback or Context decisions: the
* panel view renders the directory row, station card, transport, volume and
* playback line, the Cockpit's compact radio controls and the directory
* tuner from what this publishes (`gev-radio` store).
*/
import { t } from '../i18n/index.js';
export function renderRadioState(state) {
if (this.destroyed || !state || !this._radioPanel) return;
const lifecycle = this.actions.getLifecycle() || null;
const lifecycleState =
lifecycle?.lifecycleState || (state.enabled ? 'enabled' : 'disabled');
state = {
...state,
enabled: lifecycle ? lifecycle.enabled : state.enabled,
lifecycleState,
lifecycleUncertain: lifecycle?.uncertain || false,
};
this._radioState = state;
const enabled = Boolean(state.enabled);
const transitioning =
lifecycleState === 'enabling' || lifecycleState === 'disabling';
const uncertain = Boolean(state.lifecycleUncertain);
const interactive = enabled && !transitioning && !uncertain;
const selected = state.selected || null;
const hasStations = state.filteredCount > 0;
const activePlayback = ['loading', 'buffering', 'playing'].includes(
state.audioState,
);
document
.getElementById('title-bar')
?.classList.toggle('radio-broadcasting', state.audioState === 'playing');
const lifecycleLabel =
lifecycleState === 'enabling' ? t('ENABLING') : t('DISABLING');
const layerStateText = transitioning
? lifecycleLabel
: uncertain
? t('UNCERTAIN')
: state.loading
? t('SYNC')
: enabled
? `${state.filteredCount}/${state.stationCount}`
: t('OFF');
const enableLabel = uncertain
? t('RECONCILE')
: enabled
? t('DISABLE')
: t('ENABLE');
const enableAria = uncertain
? t('Reconcile Radio — lifecycle uncertain')
: enabled
? t('Disable Radio')
: t('Enable Radio');
const filter = state.filter || 'all';
const categories = state.categories || [];
// The options change only with the categories; until they first do, the
// markup's own option stands.
const categorySignature = categories
.map(
(category) =>
`${category.id}:${category.label}:${category.count}:${category.color}`,
)
.join('|');
if (categorySignature !== (this._radioCategorySignature ?? '')) {
this._radioCategorySignature = categorySignature;
this._radioFilterOptions = categories.map((category) => ({
id: category.id,
color: category.color,
label: t('{category} ({count})', {
category: category.label,
count: category.count,
}),
}));
}
const filterColor =
categories.find((category) => category.id === filter)?.color || '';
const tunerAvailable = interactive && state.filteredCount > 0;
const activeCategory = categories.find(
(category) => category.id === state.filter,
);
showRadioTuner.call(this, {
available: tunerAvailable,
band:
state.filter === 'all'
? t('DIRECTORY BAND')
: t('{category} BAND', {
category: String(
activeCategory?.label || state.filter,
).toUpperCase(),
}),
static: Boolean(state.tuningStatic),
});
if (tunerAvailable) this._refreshRadioTunerBand?.();
if (!tunerAvailable && this._radioTunerDragging) {
this._radioTunerDragging = false;
this._radioTunerDragSnapshot = null;
this._radioTunerStations = [];
showRadioTuner.call(this, { static: false, dragging: false });
}
if (!tunerAvailable) {
this._radioTunerStations = [];
this._radioTunerPool = [];
this._radioTunerBandSignature = '';
this._radioTunerSelectedId = null;
}
const place = selected
? [selected.state, selected.countryCode].filter(Boolean).join(' · ')
: '';
const signal = selected
? [selected.codec, selected.bitrate ? `${selected.bitrate} kbps` : '']
.filter(Boolean)
.join(' · ')
: '';
const stationMeta = selected
? [place, signal].filter(Boolean).join(' / ') ||
t('Directory metadata only')
: state.loading
? t('Loading station directory…')
: t('Choose a globe marker or use next.');
const tags = Array.isArray(selected?.tags) ? selected.tags.slice(0, 8) : [];
const playbackAction = activePlayback
? t('Pause')
: state.audioState === 'paused'
? t('Resume')
: t('Play');
// The transport button is narrow: it gets its own short uppercase labels.
const playbackButtonLabel = activePlayback
? t('PAUSE')
: state.audioState === 'paused'
? t('RESUME')
: t('PLAY');
const playTargetWord = selected ? t('selected') : t('nearest');
const playAria = t('{action} {target} radio station', {
action: playbackAction,
target: playTargetWord,
});
// A slider the person is dragging keeps the value they are setting.
this._radioVolumeShown =
this._radioVolume && document.activeElement === this._radioVolume
? Number(this._radioVolume.value)
: Math.round(state.volume * 100);
let playbackText = '';
let playbackError = false;
{
const stationName = selected?.name || t('station');
const catalogSuffix = state.degraded
? state.stale
? t(' · stale/degraded directory')
: t(' · degraded directory')
: state.stale
? t(' · stale directory')
: '';
const outsideFilter =
selected && state.selectedIndex < 0 ? t(' · outside current filter') : '';
const messages = {
stopped: enabled
? t('Ready — playback starts only from your action')
: t('Radio off'),
loading: t('Connecting directly to broadcaster…'),
buffering: t('Buffering broadcaster stream…'),
playing: t('Playing {station}', { station: stationName }),
paused: t('Paused {station}', { station: stationName }),
// Playback keeps its messages in English (msg()); shown in the UI language.
error: state.audioError
? t(state.audioError)
: t('Broadcaster stream unavailable'),
};
const voiceSuffix = state.voiceDucked
? t(' · muted during voice interaction')
: state.voiceRestoring
? t(' · restoring volume after voice')
: '';
const tuningSuffix = state.tuningAwaitingStationId
? state.audioState === 'error'
? t(' · static indicates no broadcaster audio')
: t(' · tuning static until broadcaster starts')
: '';
const unavailable = state.tuningUnavailableStationId
? t(
'Station unavailable after directory refresh — choose another channel',
)
: null;
const lifecycleMessage = transitioning
? lifecycleState === 'enabling'
? t('Radio is enabling…')
: t('Radio is disabling…')
: null;
const uncertainMessage = uncertain
? t('Radio lifecycle is uncertain — use Enable or Disable to reconcile')
: null;
// Directory errors are msg() literals from the radio layer's ingestion.
const directoryError = state.error ? t(state.error) : null;
playbackText = `${uncertainMessage || unavailable || lifecycleMessage || directoryError || messages[state.audioState] || t('Ready')}${tuningSuffix}${voiceSuffix}${catalogSuffix}${outsideFilter}`;
playbackError = Boolean(
uncertainMessage ||
unavailable ||
state.error ||
state.audioState === 'error',
);
}
const enable = {
active: enabled,
text: transitioning ? lifecycleLabel : enableLabel,
label: enableAria,
busy: transitioning,
};
this._radioView = {
enabled,
uncertain,
layerState: { active: enabled, text: layerStateText },
enable,
filter: {
options: this._radioFilterOptions ?? null,
value: filter,
color: filterColor,
disabled: !interactive || !state.stationCount,
},
station: {
name: selected?.name || t('NO STATION SELECTED'),
meta: stationMeta,
tags: tags.length ? t('TAGS · {tags}', { tags: tags.join(' · ') }) : '',
homepage: selected?.homepage || '',
},
transport: {
stepDisabled: !interactive || !hasStations,
play: {
disabled: !interactive || !hasStations,
active: activePlayback,
text: playbackButtonLabel,
label: playAria,
},
stopDisabled: !interactive || state.audioState === 'stopped',
},
volume: { disabled: !interactive, value: this._radioVolumeShown },
playback: { text: playbackText, error: playbackError },
// The Cockpit's compact controls: a glyph transport and the layer's own
// volume, which only a focused slider holds back.
cockpit: {
station: uncertain
? t('UNCERTAIN')
: selected?.name || (state.loading ? t('SYNCING') : t('READY')),
enable: { ...enable },
// The rest of the transport is the panel's; the glyphs are the Cockpit's.
play: { glyph: activePlayback ? 'Ⅱ' : '▶', title: playbackAction },
volume: {
disabled: !interactive,
value: Math.round(state.volume * 100),
},
},
};
this.store?.publish(this._radioView);
if (
!enabled &&
!transitioning &&
!this.actions.preservePanelStateDuringClear() &&
!this._radioPanel.classList.contains('collapsed')
) {
this.actions.setPanelCollapsed('radio-panel', true);
}
this.actions.scheduleLayout();
}
/**
* Show the volume the person is setting, on either slider, before the layer
* reports it.
* @param {number} value Percent, as the slider holds it.
*/
export function showRadioVolume(value) {
this._radioVolumeShown = value;
if (!this._radioView) return;
const { volume, cockpit } = this._radioView;
this._radioView = {
...this._radioView,
volume: { ...volume, value },
cockpit: { ...cockpit, volume: { ...cockpit.volume, value } },
};
this.store?.publish(this._radioView);
}
/** The tuner before RadioControls presents it; null texts keep the markup's. */
export function createRadioTunerState() {
return {
available: false,
band: null,
value: null,
station: null,
valuetext: null,
// The slider's range and value.
max: 0,
slot: 0,
// The needle's place across the dial, 0–1; null before the first preview.
ratio: null,
// The tick tape: the fractional station under the needle, and how many.
coordinate: 0,
count: 0,
static: false,
dragging: false,
};
}
/**
* Change what the tuner shows and publish it.
* @param {Partial<ReturnType<typeof createRadioTunerState>>} changes
*/
export function showRadioTuner(changes) {
this._radioTunerView = { ...this._radioTunerView, ...changes };
this.store?.publishTuner({ ...this._radioTunerView });
}
/**
* Mark an Enable button busy while its own toggle runs, as a render would
* until the next one reports the lifecycle.
* @param {boolean} busy
* @param {'panel'|'cockpit'} [where] The panel's button or the Cockpit's.
* @returns {boolean} False before the first render, when nothing is shown yet.
*/
export function showRadioEnableBusy(busy, where = 'panel') {
if (!this._radioView) return false;
const view = this._radioView;
this._radioView =
where === 'cockpit'
? {
...view,
cockpit: {
...view.cockpit,
enable: { ...view.cockpit.enable, busy },
},
}
: { ...view, enable: { ...view.enable, busy } };
this.store?.publish(this._radioView);
return true;
}