mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
* fix(layers): make Clear All clear the saved and shared layer selection After Clear All every layer control was off, but the share URL could keep listing layers (for example l=e.f) and a reload switched them back on. The URL and local preferences are written from the committed layer state, which only explicit visibility changes update. Clear All issued an explicit OFF only for layers it found on at the start of the batch and whose turn was not superseded. A layer already off for a passive reason (isolated by Contacts or another context mode, or released by Contacts' own teardown while the batch ran) never received one, so it stayed in the committed state. Clear All also discards the context snapshot that would have restored those layers, leaving the screen and the URL out of step. Clear All now publishes the set of layers still on once its batch settles, and the layer-state coordinator commits that selection: every saved layer not in it is dropped and its passive restore is cancelled, while a layer a newer explicit request turned back on is kept. A context restore interrupted by Clear All no longer brings its snapshot back after Contacts settles. * docs: changelog for #1417
184 lines
7.0 KiB
JavaScript
184 lines
7.0 KiB
JavaScript
import {
|
|
contextRestoreLayerIds,
|
|
contextSnapshotLayerIds,
|
|
mergeContextTransitionErrors,
|
|
settleContextIntentReplay,
|
|
} from '../contextModePolicy.js';
|
|
|
|
export function _trackContextLayerReaction(promise) {
|
|
const tracked = Promise.resolve(promise);
|
|
this._contextLayerReactionPromises.add(tracked);
|
|
void tracked.then(
|
|
() => this._contextLayerReactionPromises.delete(tracked),
|
|
() => this._contextLayerReactionPromises.delete(tracked),
|
|
);
|
|
return tracked;
|
|
}
|
|
|
|
export async function _waitForContextLayerSettlement() {
|
|
while (this._contextLayerReactionPromises.size > 0) {
|
|
await Promise.allSettled([...this._contextLayerReactionPromises]);
|
|
}
|
|
}
|
|
|
|
export function _captureContextSessionSnapshot({ excludeLayerIds = [] } = {}) {
|
|
if (!this._dataManager || this._contextSessionSnapshot) return;
|
|
const params = {};
|
|
for (const layerId of ['military-awareness', 'satellites']) {
|
|
const value = this._dataManager.getLayerParams(layerId);
|
|
if (value) params[layerId] = value;
|
|
}
|
|
this._contextSessionSnapshot = {
|
|
enabledLayerIds: contextSnapshotLayerIds(
|
|
this._dataManager.getEnabledLayerIds(),
|
|
this._contextRestoreState?.enabledLayerIds,
|
|
excludeLayerIds,
|
|
),
|
|
userAdded: new Set(),
|
|
userRemoved: new Set(),
|
|
params,
|
|
};
|
|
}
|
|
|
|
export async function _restoreContextSession({
|
|
excludeLayerIds = [],
|
|
notificationToken = null,
|
|
signal = null,
|
|
} = {}) {
|
|
const snapshot = this._contextSessionSnapshot;
|
|
if (!snapshot || !this._dataManager) return;
|
|
// Clear the stored session before emitting restore notifications so none
|
|
// of those transitions can be mistaken for a fresh Context entry.
|
|
this._contextSessionSnapshot = null;
|
|
const restoreState = {
|
|
enabledLayerIds: contextRestoreLayerIds(snapshot),
|
|
explicitLayerStates: new Map(),
|
|
};
|
|
this._contextRestoreState = restoreState;
|
|
for (const [layerId, params] of Object.entries(snapshot.params)) {
|
|
this._dataManager.setLayerParams(layerId, params);
|
|
}
|
|
let restoreError = null;
|
|
const restoreSnapshot = async (restoreSignal = null) => {
|
|
// Contacts owns the dependency intents it starts. Settle that
|
|
// coordinator before restoring the remaining snapshot, otherwise its
|
|
// dependency releases can supersede the restore's same-target requests
|
|
// and make a valid Contacts-to-Missions handoff look like a failure.
|
|
const contactsCoordinatorId = 'military-awareness';
|
|
const settleContactsCoordinator =
|
|
!restoreState.enabledLayerIds.has(contactsCoordinatorId) &&
|
|
this._dataManager.isEffectivelyEnabled(contactsCoordinatorId);
|
|
if (settleContactsCoordinator) {
|
|
const coordinatorSettled = await this._dataManager.setEnabled(
|
|
contactsCoordinatorId,
|
|
false,
|
|
{
|
|
origin: 'context-restore',
|
|
...(notificationToken ? { notificationToken } : {}),
|
|
...(restoreSignal ? { signal: restoreSignal } : {}),
|
|
},
|
|
);
|
|
if (coordinatorSettled === false) {
|
|
const error = new Error(
|
|
'Failed to settle Contacts before restoring Context',
|
|
);
|
|
error.failedLayerIds = [contactsCoordinatorId];
|
|
throw error;
|
|
}
|
|
}
|
|
// Clear All may have run while Contacts settled. It owns the selection
|
|
// now, so the snapshot must not come back behind it.
|
|
if (restoreState.cancelled) return;
|
|
await this._dataManager.restoreEnabledLayerIds(
|
|
restoreState.enabledLayerIds,
|
|
{
|
|
origin: 'context-restore',
|
|
excludeLayerIds: settleContactsCoordinator
|
|
? [...excludeLayerIds, contactsCoordinatorId]
|
|
: excludeLayerIds,
|
|
notificationToken,
|
|
...(restoreSignal ? { signal: restoreSignal } : {}),
|
|
},
|
|
);
|
|
};
|
|
try {
|
|
await restoreSnapshot(signal);
|
|
} catch (error) {
|
|
restoreError = error;
|
|
// A caller abort can arrive after only part of the exact restore has
|
|
// settled. Finish that same target without the stale caller signal while
|
|
// this restoreState still records newer explicit intents; replay below
|
|
// then gives those newer intents final authority.
|
|
if (signal?.aborted && !restoreState.cancelled) {
|
|
try {
|
|
await restoreSnapshot(null);
|
|
restoreError = null;
|
|
} catch (compensationError) {
|
|
restoreError = mergeContextTransitionErrors(
|
|
restoreError,
|
|
compensationError,
|
|
);
|
|
}
|
|
}
|
|
} finally {
|
|
if (this._contextRestoreState === restoreState)
|
|
this._contextRestoreState = null;
|
|
}
|
|
// Clear Selected Layers owns a newer global OFF intent. A restore that was
|
|
// already awaiting lifecycle work must not replay its captured companion
|
|
// intent or recreate the discarded session after Clear invalidates it.
|
|
if (restoreState.cancelled) return;
|
|
// A direct Radio command may finish after restore has already copied its
|
|
// target and queued the opposite state. Replay that newer intent only
|
|
// after the stale queue drains; the replay origin cannot recurse here.
|
|
const replaySignal = signal?.aborted ? null : signal;
|
|
const replayError = await settleContextIntentReplay({
|
|
restoreState,
|
|
setEnabled: (layerId, enabled, options = {}) =>
|
|
this._dataManager.setEnabled(layerId, enabled, {
|
|
...options,
|
|
...(replaySignal ? { signal: replaySignal } : {}),
|
|
}),
|
|
notificationToken,
|
|
});
|
|
restoreError = mergeContextTransitionErrors(restoreError, replayError);
|
|
if (restoreError && !this._contextSessionSnapshot) {
|
|
// Keep the exact still-pending target so a later exit/teardown can retry
|
|
// instead of silently losing the user's pre-Context layer state.
|
|
this._contextSessionSnapshot = {
|
|
enabledLayerIds: new Set(restoreState.enabledLayerIds),
|
|
userAdded: new Set(),
|
|
userRemoved: new Set(),
|
|
params: snapshot.params,
|
|
};
|
|
}
|
|
if (restoreError) throw restoreError;
|
|
}
|
|
|
|
/*
|
|
* Cross-mode cancellation and failure deliberately settle on Context OFF.
|
|
*
|
|
* A reinstatement transaction lived here for three review rounds and was
|
|
* removed on purpose. Restoring the prior mode is genuinely racy: the prior
|
|
* mode has to be read before the teardown, but a second request arriving
|
|
* while the first reinstatement is mid-activation reads `_contextMode` as
|
|
* null and inherits nothing, so two overlapping cancellations still land on
|
|
* OFF — and the only fix is a cross-transaction "logical prior mode" chain,
|
|
* which is new shared mutable state read while an earlier transaction is
|
|
* still awaiting. That trades a rare wrong resting state for a permanent
|
|
* interleaving hazard.
|
|
*
|
|
* The defect that started this was the LIE, not the OFF: the transition
|
|
* claimed to have cancelled cleanly while silently leaving Context off. So
|
|
* the resting state stays OFF and is REPORTED as such, with the failed layer
|
|
* ids preserved. A restore feature can be rebuilt post-launch on the
|
|
* generation discipline the surrounding transaction already follows.
|
|
*/
|
|
export async function _restoreContextSessionAfterLayerSettles(
|
|
layerId,
|
|
{ notificationToken = null } = {},
|
|
) {
|
|
await this._dataManager?.waitForLayerSettled?.(layerId);
|
|
return this._restoreContextSession({ notificationToken });
|
|
}
|