mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 01:32:19 +00:00
"hide everything except flights" (or "all but", "other than") switches off
every layer that is on but the ones named, or says no other layers are on.
"remove flights from the map" is "remove flights", "hide hide everything"
reads the verb once, and "flights near 14R PU 2090 4906" flies to the grid
reference. A keyword that begins a name ("Fire Island", "Radio City Music
Hall") no longer offers a plan to the rest of the name. The arrow keys drop
a check for a list that opens upward, which it never does.
Co-authored-by: Manjunath Paparaju <[email protected]>
1646 lines
54 KiB
JavaScript
1646 lines
54 KiB
JavaScript
// What the Omnibar offers for a typed line, and which row Enter runs. The
|
|
// one pipeline from text to rows: the line is normalised once
|
|
// (normalizeLine), read once (parseOmnibar), turned into rows here, and the
|
|
// Enter rule (src/ui/omnibarEnter.js) orders them and picks the default.
|
|
// Omnibar.vue only supplies what the app knows (layers, place suggestions,
|
|
// things on the map, the selection) and runs the row that is chosen.
|
|
//
|
|
// Pure: no DOM, no stores. Tested by an input-to-outcome table in
|
|
// src/ui/omnibarRows.test.mjs.
|
|
|
|
import { msg, t, tn } from '../i18n/index.js';
|
|
import { parseCoordinateQuery } from '../search/coordinateParser.js';
|
|
import {
|
|
mayBePrivate,
|
|
minPlaceChars,
|
|
onlyNumbersLookPrivate,
|
|
} from '../search/placeSuggestions.js';
|
|
import { shownLayerName } from './layerNames.js';
|
|
import { featureGuideFor } from './omnibarGuide.js';
|
|
import { enterDefault, isPlaceWord, orderForEnter } from './omnibarEnter.js';
|
|
import {
|
|
hasActionVerb,
|
|
isPanelText,
|
|
isRealQuestion,
|
|
asTypedIn,
|
|
isWholeMapClear,
|
|
magnitudeFloor,
|
|
normalizeLine,
|
|
parseOmnibar,
|
|
placeWordLimit,
|
|
writtenAsName,
|
|
} from './omnibarIntent.js';
|
|
|
|
export const GUIDE_LABELS = {
|
|
styles: msg('Visual styles'),
|
|
hud: msg('HUD'),
|
|
north: msg('North up'),
|
|
tilt: msg('Tilt / 3D view'),
|
|
globe: msg('Globe view'),
|
|
share: msg('Sharing this view'),
|
|
clear: msg('Clearing all layers'),
|
|
'map-source': msg('Changing the map'),
|
|
scope: msg('The scope'),
|
|
clean: msg('Clean UI'),
|
|
'find-layer': msg('Searching layers'),
|
|
'filter-layers': msg('Filtering layers'),
|
|
'section-index': msg('Jumping between layer groups'),
|
|
preferences: msg('Keys and language'),
|
|
edge: msg('Panels at the screen edge'),
|
|
context: msg('The Context panel'),
|
|
properties: msg('Layer properties'),
|
|
draw: msg('Drawing and measuring'),
|
|
};
|
|
|
|
// Guides for parts of the interface that are not commands: matched on the
|
|
// words after "show me how", "how do I", etc.
|
|
const GUIDE_TOPICS = [
|
|
{
|
|
id: 'find-layer',
|
|
words:
|
|
/^layers?$|\b(search|find|look ?up)\b.*\blayers?\b|\blayers?\b.*\bsearch\b|^(search|find)( a)? layer/,
|
|
},
|
|
{
|
|
id: 'filter-layers',
|
|
words: /\bfilter|\bcategor|\bonly (the )?(on|off|active)\b/,
|
|
},
|
|
{
|
|
id: 'section-index',
|
|
words:
|
|
/\b(jump|skip|go) to (a )?(group|section|category)|\bsection index|\blayer groups?\b/,
|
|
},
|
|
{
|
|
id: 'preferences',
|
|
words:
|
|
/\b(preferences?|prefs|settings|language|translat|api keys?|keys?|power ?up)\b/,
|
|
},
|
|
{
|
|
id: 'edge',
|
|
words:
|
|
/\b(edge|dock|align|move|slide)\b.*\bpanels?\b|\bpanels?\b.*\b(edge|align|over the rail)\b/,
|
|
},
|
|
{
|
|
id: 'properties',
|
|
words: /\bproperties\b|\blabels?\b|\b3d (models?|aircraft)\b|\bdensity\b/,
|
|
},
|
|
{
|
|
id: 'context',
|
|
words: /\bcontext\b|\binspector\b|\bwhat'?s (in view|here)\b/,
|
|
},
|
|
{ id: 'scope', words: /\bscope\b|\bkeyhole\b|\bfeather\b/ },
|
|
{
|
|
id: 'clean',
|
|
words: /\bclean (ui|view|screen)|\bhide (the )?(ui|panels|interface)/,
|
|
},
|
|
{
|
|
id: 'map-source',
|
|
words:
|
|
/\bmap (source|imagery|layer)|\b(base ?map|imagery)\b|\b(google 3d|bing|esri|osm|openstreetmap)\b/,
|
|
},
|
|
];
|
|
// The words people use for the features that have their own walk
|
|
// (src/ui/omnibarGuide.js FEATURE_GUIDES), read after GUIDE_TOPICS and
|
|
// before any layer: "how do I change the map style", "how do I tilt the
|
|
// map", "how do I get back to the globe", "how to measure distance".
|
|
const FEATURE_TOPICS = [
|
|
{
|
|
id: 'styles',
|
|
words:
|
|
/\b(?:visual |map |view )?styles?\b|\blooks?\b|\bfilters?\b|\b(?:noir|thermal|night vision|nvg|flir|retro|crt|anime|black and white)\b/,
|
|
},
|
|
{
|
|
id: 'map-source',
|
|
words:
|
|
/^(?:base ?)?maps?$|\b(?:base ?map|map (?:type|view|provider)|satellite (?:view|imagery)|google 3d|bing|esri|osm|openstreetmap|photoreal)\b/,
|
|
},
|
|
{ id: 'hud', words: /\bhud\b|\bheads?[- ]up\b/ },
|
|
{ id: 'north', words: /\bnorth\b|\bcompass\b|\bheading\b/ },
|
|
{
|
|
id: 'tilt',
|
|
words: /\btilt|\b3d (?:view|mode)\b|\bperspective\b|\bpitch\b/,
|
|
},
|
|
{
|
|
id: 'globe',
|
|
words:
|
|
/\bglobe\b|\bwhole (?:earth|world|planet)\b|\breset\b|\bzoom (?:all the way )?out\b|\bstart over\b|\bhome view\b/,
|
|
},
|
|
{ id: 'share', words: /\bshare|\blink\b|\burl\b/ },
|
|
{
|
|
id: 'clear',
|
|
words: /\bclear\b|\b(?:all|every) (?:the )?(?:data )?layers?\b/,
|
|
},
|
|
{
|
|
id: 'draw',
|
|
words:
|
|
/\bdraw|\bsketch|\bannotat|\bmeasur|\bdistance\b|\bruler\b|\bmarkup\b|\bpolygon\b/,
|
|
},
|
|
];
|
|
const guideTopic = (subject) =>
|
|
GUIDE_TOPICS.find((topic) => topic.words.test(subject))?.id ||
|
|
FEATURE_TOPICS.find((topic) => topic.words.test(subject))?.id ||
|
|
null;
|
|
|
|
// "how do I see …", "show me how to turn on …", "guide me to …". The first
|
|
// group is a verb that turns something off ("how do I turn off flights"),
|
|
// the second what it is about.
|
|
const HOW_TO =
|
|
/^(?:can you |could you )?(?:(?:show|tell|teach) me how|how (?:do|can|would|should) i|how to|guide me|walk me through)(?: to)?\s+(?:(turn off|switch off|disable|hide|remove)\s+|(?:see|view|turn on|switch on|enable|show|find|use|get|watch|open|change|switch|set|pick|add)\s+)?(?:the\s+)?(.+)$/;
|
|
// "satellite settings", "options for flights": straight to the settings walk.
|
|
const SETTINGS_FOR =
|
|
/^(?:(?:open|show|change)\s+)?(.+?)\s+(?:settings|options|preferences|prefs)$|^(?:settings|options|preferences)\s+(?:for|of)\s+(.+)$/;
|
|
|
|
// "turn on …" / "hide …" / "toggle …": a switch, not a place.
|
|
const SWITCH =
|
|
/^(turn on|switch on|enable|show|display|add|turn off|switch off|disable|hide|remove|toggle)(?:\s+(.*))?$/;
|
|
const SWITCH_OFF = /^(turn off|switch off|disable|hide|remove)\b/;
|
|
/** "hide everything except …", "turn off all layers but …". */
|
|
const EXCEPT =
|
|
/^(?:turn off|switch off|disable|hide|remove|clear)\s+(?:everything|all(?: the)?(?: other)?(?: layers?)?|every layer)\s+(?:except(?: for)?|but(?: for)?|other than|apart from|besides|save for)\s+(.+)$/;
|
|
// Layers people reach for first, so "turn on" offers these before the rest.
|
|
export const POPULAR_LAYERS = [
|
|
'flights',
|
|
'ais-live-vessels',
|
|
'satellites',
|
|
'cctv',
|
|
'earthquakes',
|
|
'weather-radar',
|
|
'local-firms',
|
|
'traffic',
|
|
'military',
|
|
'rocket-launches',
|
|
];
|
|
|
|
// Everyday words for layers whose names do not contain them.
|
|
export const ALIASES = Object.freeze({
|
|
plane: ['flights'],
|
|
planes: ['flights'],
|
|
aircraft: ['flights'],
|
|
ship: ['ais-live-vessels'],
|
|
ships: ['ais-live-vessels'],
|
|
boats: ['ais-live-vessels'],
|
|
vessels: ['ais-live-vessels'],
|
|
camera: ['cctv'],
|
|
cameras: ['cctv'],
|
|
webcams: ['cctv'],
|
|
quakes: ['earthquakes'],
|
|
fires: ['local-firms', 'fire-perimeters'],
|
|
wildfires: ['local-firms', 'fire-perimeters'],
|
|
rain: ['weather-radar'],
|
|
weather: ['weather-radar', 'weather-satellite'],
|
|
clouds: ['weather-satellite'],
|
|
lightning: ['weather-lightning'],
|
|
storms: ['weather-cyclones'],
|
|
hurricanes: ['weather-cyclones'],
|
|
cables: ['telegeography-submarine-cables'],
|
|
launches: ['rocket-launches'],
|
|
rockets: ['rocket-launches'],
|
|
bikes: ['bikeshare'],
|
|
trains: ['transit'],
|
|
buses: ['transit'],
|
|
'radio stations': ['radio'],
|
|
'radio station': ['radio'],
|
|
});
|
|
|
|
export const escapeRegExp = (text) =>
|
|
text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
/** A match that starts a word: "air" finds "Air quality", "hi" not "Prohibited". */
|
|
const wordStart = (needle) =>
|
|
new RegExp(`(^|[^a-z0-9])${escapeRegExp(needle)}`);
|
|
|
|
// Words in layer names that say what kind, not which: alone they name no
|
|
// layer ("Local" is not Local ADS-B, "Global" no global layer).
|
|
const GENERIC_LAYER_WORDS = new Set([
|
|
'local',
|
|
'global',
|
|
'live',
|
|
'world',
|
|
'real',
|
|
'time',
|
|
'new',
|
|
'open',
|
|
'all',
|
|
'data',
|
|
'map',
|
|
'maps',
|
|
'view',
|
|
'level',
|
|
'area',
|
|
'areas',
|
|
'zone',
|
|
'zones',
|
|
'of',
|
|
'and',
|
|
'the',
|
|
]);
|
|
|
|
/** Edit distance, for typos like "satelite". */
|
|
function editDistance(a, b) {
|
|
const row = Array.from({ length: b.length + 1 }, (_, i) => i);
|
|
for (let i = 1; i <= a.length; i++) {
|
|
let previous = row[0];
|
|
row[0] = i;
|
|
for (let j = 1; j <= b.length; j++) {
|
|
const kept = row[j];
|
|
row[j] = Math.min(
|
|
row[j] + 1,
|
|
row[j - 1] + 1,
|
|
previous + (a[i - 1] === b[j - 1] ? 0 : 1),
|
|
);
|
|
previous = kept;
|
|
}
|
|
}
|
|
return row[b.length];
|
|
}
|
|
|
|
/**
|
|
* The layers' names, read once, and the matchers over them. A match carries
|
|
* the live layer's fields (its `enabled` as the app reports it), its shown
|
|
* name, a score and whether it names the whole layer (`exact`).
|
|
* @param {Array<{id: string, name: string, enabled?: boolean, showInTogglePanel?: boolean}>} layers
|
|
*/
|
|
export function createLayerIndex(layers = []) {
|
|
const index = layers
|
|
.filter((layer) => layer.showInTogglePanel !== false)
|
|
.map((layer) => {
|
|
const shown = shownLayerName(layer.name, layer.id);
|
|
const names = [shown, String(layer.name), String(layer.id)].map((n) =>
|
|
n.toLowerCase(),
|
|
);
|
|
// Whole words come from the names people see, never from ids ("local",
|
|
// "global" name no layer).
|
|
const titles = names.slice(0, 2);
|
|
const words = titles
|
|
.flatMap((n) => n.split(/[^\p{L}\p{N}]+/u))
|
|
.filter((word) => word && !GENERIC_LAYER_WORDS.has(word));
|
|
return { layer, shown, names, titles, words: new Set(words) };
|
|
});
|
|
|
|
/** Data layers matching a word or phrase, best first. */
|
|
function matchLayers(term) {
|
|
const needle = String(term || '')
|
|
.trim()
|
|
.toLowerCase();
|
|
if (!needle) return [];
|
|
// Synonyms match as they are typed: "cam" already means cameras.
|
|
const aliased = [
|
|
...new Set(
|
|
Object.entries(ALIASES)
|
|
.filter(
|
|
([word]) =>
|
|
word === needle ||
|
|
(needle.length >= 3 && word.startsWith(needle)),
|
|
)
|
|
.flatMap(([, ids]) => ids),
|
|
),
|
|
];
|
|
const startsWord = wordStart(needle);
|
|
return index
|
|
.map(({ layer, shown, names, titles, words }) => {
|
|
// Synonyms rank in the order they are listed.
|
|
const score = aliased.includes(layer.id)
|
|
? 4 - aliased.indexOf(layer.id) / 10
|
|
: names.some((n) => n.startsWith(needle))
|
|
? 2
|
|
: names.some((n) => startsWord.test(n))
|
|
? 1
|
|
: 0;
|
|
// A whole name, a whole word of one or a whole synonym (a plural "s"
|
|
// from four letters: "fire" names fires, "new" does not name News),
|
|
// not the start of one: "rock" begins "rockets" but names no layer.
|
|
const exact =
|
|
Boolean(
|
|
ALIASES[needle]?.includes(layer.id) ||
|
|
(needle.length >= 4 && ALIASES[`${needle}s`]?.includes(layer.id)),
|
|
) ||
|
|
titles.includes(needle) ||
|
|
words.has(needle) ||
|
|
(needle.length >= 4 && words.has(`${needle}s`));
|
|
return { ...layer, shown, score, exact };
|
|
})
|
|
.filter((layer) => layer.score > 0)
|
|
.sort((a, b) => b.score - a.score || b.exact - a.exact);
|
|
}
|
|
|
|
/** Layers for a phrase, forgiving a typo or two when nothing matches exactly. */
|
|
function matchLayersLoosely(term) {
|
|
const exact = matchLayers(term);
|
|
if (exact.length) return exact;
|
|
const words = String(term || '')
|
|
.toLowerCase()
|
|
.split(/\s+/)
|
|
.filter((word) => word.length >= 4);
|
|
if (!words.length) return [];
|
|
const near = (word, candidate) =>
|
|
editDistance(word, candidate) <= (word.length >= 7 ? 2 : 1);
|
|
return index
|
|
.filter(({ layer, words: names }) => {
|
|
const candidates = [
|
|
...names,
|
|
...Object.entries(ALIASES)
|
|
.filter(([, ids]) => ids.includes(layer.id))
|
|
.map(([word]) => word),
|
|
].filter((candidate) => candidate.length >= 3);
|
|
return words.some((word) =>
|
|
candidates.some((candidate) => near(word, candidate)),
|
|
);
|
|
})
|
|
.map(({ layer, shown }) => ({ ...layer, shown, score: 2 }));
|
|
}
|
|
|
|
/** Every listed layer, with its shown name. */
|
|
const all = () => index.map(({ layer, shown }) => ({ ...layer, shown }));
|
|
|
|
return { matchLayers, matchLayersLoosely, all };
|
|
}
|
|
|
|
/** Words in "how do I …" that name no feature on their own. */
|
|
const GUIDE_STOP_WORDS = new Set([
|
|
'this',
|
|
'that',
|
|
'it',
|
|
'these',
|
|
'those',
|
|
'here',
|
|
'app',
|
|
'the',
|
|
'a',
|
|
'an',
|
|
'my',
|
|
'thing',
|
|
'things',
|
|
'one',
|
|
'stuff',
|
|
'feature',
|
|
'features',
|
|
'tool',
|
|
'button',
|
|
]);
|
|
|
|
/** A layer match that names the whole layer, not the start of its name. */
|
|
const named = (layer) => layer?.score >= 2 && layer.exact !== false;
|
|
|
|
/**
|
|
* "new york" → "New York", "trinidad and tobago" → "Trinidad and Tobago", for
|
|
* labels only; the search gets the text as typed.
|
|
*/
|
|
const SMALL_WORDS = new Set([
|
|
'and',
|
|
'of',
|
|
'the',
|
|
'on',
|
|
'upon',
|
|
'de',
|
|
'del',
|
|
'la',
|
|
'le',
|
|
'du',
|
|
'da',
|
|
'des',
|
|
]);
|
|
/**
|
|
* A place's name for a row: as typed when it has a capital ("iPhone store",
|
|
* "McAllen", "İstanbul"), else each word capitalised but the small joining
|
|
* ones ("santa fe de bogotá" reads "Santa Fe de Bogotá").
|
|
*/
|
|
export const titleCase = (text) =>
|
|
/\p{Lu}/u.test(text)
|
|
? text
|
|
: text.replace(/\S+/g, (word, at) =>
|
|
at > 0 && SMALL_WORDS.has(word)
|
|
? word
|
|
: word[0].toUpperCase() + word.slice(1),
|
|
);
|
|
|
|
const STYLE_LABELS = {
|
|
noir: msg('Style: Noir'),
|
|
thermal: msg('Style: Thermal'),
|
|
surveillance: msg('Style: Night vision'),
|
|
retro: msg('Style: Retro'),
|
|
anime: msg('Style: Anime'),
|
|
normal: msg('Style: Normal'),
|
|
};
|
|
const STACK_LABELS = {
|
|
osm: msg('Map: OpenStreetMap'),
|
|
'bing-aerial': msg('Map: Bing aerial'),
|
|
photoreal: msg('Map: Photoreal 3D'),
|
|
'esri-imagery': msg('Map: Esri imagery'),
|
|
};
|
|
const CAMERA_LABELS = {
|
|
clear: msg('Clear all layers'),
|
|
share: msg('Share this view'),
|
|
reset: msg('Reset view'),
|
|
northUp: msg('North up'),
|
|
tilt: msg('Tilt / 3D view'),
|
|
zoom_to_globe: msg('Globe view'),
|
|
move_camera: msg('Orbit'),
|
|
};
|
|
|
|
// Every command the omnibar can run directly. Type ">" to list them all, or
|
|
// type a command's name or one of its words to find it among the results.
|
|
const cmd = (id, label, words, icon, step) =>
|
|
Object.freeze({ id, label, words, icon, step });
|
|
export const COMMANDS = Object.freeze([
|
|
cmd(
|
|
'clear',
|
|
msg('Clear all layers'),
|
|
'turn off hide remove every everything layers',
|
|
'layers_clear',
|
|
{ kind: 'camera', act: 'clear' },
|
|
),
|
|
cmd(
|
|
'layers',
|
|
msg('Open data layers'),
|
|
'layers panel menu list show',
|
|
'layers',
|
|
{ kind: 'camera', name: 'show_data_layers_menu', args: {} },
|
|
),
|
|
cmd(
|
|
'close-panels',
|
|
msg('Close all panels'),
|
|
'collapse close hide minimise minimize fold all panels sidebars',
|
|
'close_fullscreen',
|
|
{ kind: 'panel', action: 'close', side: 'all' },
|
|
),
|
|
cmd(
|
|
'close-left',
|
|
msg('Close left panel'),
|
|
'collapse close hide left panel sidebar',
|
|
'chevron_left',
|
|
{ kind: 'panel', action: 'close', side: 'left' },
|
|
),
|
|
cmd(
|
|
'close-right',
|
|
msg('Close right panel'),
|
|
'collapse close hide right panel sidebar',
|
|
'chevron_right',
|
|
{ kind: 'panel', action: 'close', side: 'right' },
|
|
),
|
|
cmd(
|
|
'open-utilities',
|
|
msg('Open Utilities'),
|
|
'utilities tools panel open',
|
|
'handyman',
|
|
{
|
|
kind: 'panel',
|
|
action: 'open',
|
|
side: 'left',
|
|
item: 'utilities-panel',
|
|
name: 'Utilities',
|
|
},
|
|
),
|
|
cmd(
|
|
'open-authoring',
|
|
msg('Open Authoring'),
|
|
'authoring scenes panel open',
|
|
'movie',
|
|
{
|
|
kind: 'panel',
|
|
action: 'open',
|
|
side: 'left',
|
|
item: 'scene-panel',
|
|
name: 'Authoring',
|
|
},
|
|
),
|
|
cmd(
|
|
'open-display',
|
|
msg('Open Visual'),
|
|
'visual display settings presets looks styles panel open',
|
|
'palette',
|
|
{
|
|
kind: 'panel',
|
|
action: 'open',
|
|
side: 'left',
|
|
item: 'pp-toggles',
|
|
name: 'Visual',
|
|
},
|
|
),
|
|
cmd('open-context', msg('Open Context'), 'context panel open', 'radar', {
|
|
kind: 'panel',
|
|
action: 'open',
|
|
side: 'right',
|
|
item: 'global-context-panel',
|
|
name: 'Context',
|
|
}),
|
|
cmd('reset', msg('Reset view'), 'home start over reset camera', 'public', {
|
|
kind: 'camera',
|
|
act: 'reset',
|
|
}),
|
|
cmd(
|
|
'globe',
|
|
msg('Globe view'),
|
|
'whole earth world zoom out globe',
|
|
'public',
|
|
{ kind: 'camera', name: 'zoom_to_globe', args: {} },
|
|
),
|
|
cmd('north', msg('North up'), 'face north compass heading', 'navigation', {
|
|
kind: 'camera',
|
|
act: 'northUp',
|
|
}),
|
|
cmd('tilt', msg('Tilt / 3D view'), 'perspective 3d tilt', 'view_in_ar', {
|
|
kind: 'camera',
|
|
act: 'tilt',
|
|
}),
|
|
cmd('zoom-in', msg('Zoom in'), 'closer zoom in', 'open_in_full', {
|
|
kind: 'camera',
|
|
name: 'adjust_camera_zoom',
|
|
args: { direction: 'in' },
|
|
}),
|
|
cmd('zoom-out', msg('Zoom out'), 'further zoom out', 'close_fullscreen', {
|
|
kind: 'camera',
|
|
name: 'adjust_camera_zoom',
|
|
args: { direction: 'out' },
|
|
}),
|
|
cmd('orbit', msg('Orbit'), 'rotate spin orbit circle', 'adjust', {
|
|
kind: 'camera',
|
|
name: 'move_camera',
|
|
args: { motion: 'orbit', mode: 'continuous' },
|
|
}),
|
|
cmd('stop', msg('Stop camera'), 'stop orbit halt still', 'close', {
|
|
kind: 'camera',
|
|
name: 'move_camera',
|
|
args: { motion: 'stop' },
|
|
}),
|
|
cmd('share', msg('Share this view'), 'share copy link url', 'east', {
|
|
kind: 'camera',
|
|
act: 'share',
|
|
}),
|
|
cmd('hud-on', msg('HUD on'), 'show hud overlay', 'visibility', {
|
|
kind: 'hud',
|
|
visible: 'on',
|
|
}),
|
|
cmd('hud-off', msg('HUD off'), 'hide hud overlay clean', 'visibility_off', {
|
|
kind: 'hud',
|
|
visible: 'off',
|
|
}),
|
|
cmd(
|
|
'style-normal',
|
|
msg('Style: Normal'),
|
|
'normal default plain style',
|
|
'tune',
|
|
{ kind: 'style', style: 'normal' },
|
|
),
|
|
cmd('style-noir', msg('Style: Noir'), 'noir black white style', 'dark_mode', {
|
|
kind: 'style',
|
|
style: 'noir',
|
|
}),
|
|
cmd(
|
|
'style-thermal',
|
|
msg('Style: Thermal'),
|
|
'thermal flir heat infrared style',
|
|
'flare',
|
|
{ kind: 'style', style: 'thermal' },
|
|
),
|
|
cmd(
|
|
'style-nvg',
|
|
msg('Style: Night vision'),
|
|
'night vision nvg surveillance green style',
|
|
'light_mode',
|
|
{ kind: 'style', style: 'surveillance' },
|
|
),
|
|
cmd('style-retro', msg('Style: Retro'), 'retro crt style', 'tune', {
|
|
kind: 'style',
|
|
style: 'retro',
|
|
}),
|
|
cmd('style-anime', msg('Style: Anime'), 'anime cartoon style', 'draw', {
|
|
kind: 'style',
|
|
style: 'anime',
|
|
}),
|
|
cmd(
|
|
'map-photoreal',
|
|
msg('Map: Photoreal 3D'),
|
|
'photoreal 3d tiles google map',
|
|
'view_in_ar',
|
|
{ kind: 'stack', stack: 'photoreal' },
|
|
),
|
|
cmd(
|
|
'map-esri',
|
|
msg('Map: Esri imagery'),
|
|
'esri satellite imagery map',
|
|
'satellite_alt',
|
|
{ kind: 'stack', stack: 'esri-imagery' },
|
|
),
|
|
cmd('map-bing', msg('Map: Bing aerial'), 'bing aerial map', 'satellite_alt', {
|
|
kind: 'stack',
|
|
stack: 'bing-aerial',
|
|
}),
|
|
cmd(
|
|
'map-osm',
|
|
msg('Map: OpenStreetMap'),
|
|
'osm openstreetmap street map',
|
|
'location_on',
|
|
{ kind: 'stack', stack: 'osm' },
|
|
),
|
|
cmd('cockpit', msg('Enter cockpit'), 'cockpit pilot fly plane', 'flight', {
|
|
kind: 'cockpit',
|
|
}),
|
|
cmd(
|
|
'nearest',
|
|
msg('Nearest aircraft'),
|
|
'nearest closest plane aircraft flight',
|
|
'flight',
|
|
{ kind: 'nearest' },
|
|
),
|
|
cmd('radio', msg('Enable Radio'), 'radio music news listen', 'radio', {
|
|
kind: 'radio',
|
|
}),
|
|
cmd('voice', msg('Talk to GEV'), 'voice mic microphone talk speak', 'radar', {
|
|
kind: 'mic',
|
|
}),
|
|
]);
|
|
|
|
const withoutPrefix = (label) => label.replace(/^[^:]+:\s*/, '');
|
|
|
|
/**
|
|
* The command the text names exactly, by its label ("North up", "Style:
|
|
* Noir" or "Noir"), after the line's normalisation ("North up.", "please
|
|
* north up"). One of its search words alone ("music", "link", "heat") only
|
|
* finds it.
|
|
*/
|
|
export function exactCommand(text) {
|
|
return labelledCommand(readLine(text));
|
|
}
|
|
|
|
/** The command whose label is exactly this text, as typed, or null. */
|
|
function labelledCommand(text) {
|
|
const needle = String(text || '')
|
|
.replace(/^>\s*/, '')
|
|
.replace(/\s+/g, ' ')
|
|
.trim()
|
|
.toLowerCase();
|
|
if (!needle) return null;
|
|
return (
|
|
COMMANDS.find((command) => {
|
|
const labels = [command.label, t(command.label)].map((label) =>
|
|
label.toLowerCase(),
|
|
);
|
|
return (
|
|
labels.includes(needle) || labels.map(withoutPrefix).includes(needle)
|
|
);
|
|
}) || null
|
|
);
|
|
}
|
|
|
|
/**
|
|
* The line as the Omnibar reads it: normalizeLine, with "please" dropped
|
|
* only around a request (a verb, a real question or a command's label).
|
|
* Place rows and the place service get the text as typed.
|
|
*/
|
|
export function readLine(text) {
|
|
return normalizeLine(text, {
|
|
isRequest: (rest) =>
|
|
hasActionVerb(rest) ||
|
|
isRealQuestion(rest) ||
|
|
Boolean(labelledCommand(rest)),
|
|
});
|
|
}
|
|
|
|
/** Commands matching words typed in order from their starts, best first. */
|
|
export function matchCommands(text) {
|
|
const words = String(text || '')
|
|
.toLowerCase()
|
|
.split(/\s+/)
|
|
.filter(Boolean);
|
|
if (!words.length) return [...COMMANDS];
|
|
return COMMANDS.map((command) => {
|
|
const hay = `${command.label} ${command.words}`.toLowerCase();
|
|
const hits = words.filter((word) => wordStart(word).test(hay)).length;
|
|
const label = command.label.toLowerCase();
|
|
const score =
|
|
hits === words.length ? (label.startsWith(words.join(' ')) ? 3 : 2) : 0;
|
|
return { command, score };
|
|
})
|
|
.filter(({ score }) => score > 0)
|
|
.sort((a, b) => b.score - a.score)
|
|
.map(({ command }) => command);
|
|
}
|
|
|
|
/** One step of a plan, in a few words. */
|
|
export function stepLabel(step) {
|
|
switch (step.kind) {
|
|
case 'place':
|
|
return titleCase(step.shown ?? step.place);
|
|
case 'layer':
|
|
return step.enabled
|
|
? t('{layer} on', { layer: step.layer.shown })
|
|
: t('{layer} off', { layer: step.layer.shown });
|
|
case 'style':
|
|
return t(STYLE_LABELS[step.style]);
|
|
case 'stack':
|
|
return t(STACK_LABELS[step.stack]);
|
|
case 'camera':
|
|
if (step.name === 'adjust_camera_zoom')
|
|
return step.args.direction === 'in' ? t('Zoom in') : t('Zoom out');
|
|
if (step.name === 'move_camera' && step.args.motion === 'stop')
|
|
return t('Stop camera');
|
|
return t(CAMERA_LABELS[step.act || step.name]);
|
|
case 'hud':
|
|
return step.visible === 'off' ? t('HUD off') : t('HUD on');
|
|
case 'panel':
|
|
if (step.action === 'open')
|
|
return t('Open {panel}', { panel: t(step.name) });
|
|
if (step.side === 'all') return t('Close all panels');
|
|
if (step.item) return t('Close {panel}', { panel: t(step.name) });
|
|
return step.side === 'left'
|
|
? t('Close left panel')
|
|
: t('Close right panel');
|
|
case 'radio':
|
|
return step.action === 'disable' ? t('Radio off') : t('Radio');
|
|
case 'cockpit':
|
|
return t('Cockpit');
|
|
case 'nearest':
|
|
return t('Nearest aircraft');
|
|
case 'follow':
|
|
return t('Follow {target}', { target: step.query.toUpperCase() });
|
|
default:
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/** A callsign (UAL2110, BAW15K, N123AB) or a hex transponder code (a12b2e). */
|
|
export const CALLSIGN =
|
|
/^(?:[a-z]{2,3}\d{1,4}[a-z]{0,2}|n\d{1,5}[a-z]{0,2}|[0-9a-f]{6})$/i;
|
|
|
|
// "villages near Manor", "towns around here": answered from the bundled packs.
|
|
export const VILLAGES =
|
|
/^(?:(?:show|list|find)\s+)?(?:me\s+)?(?:the\s+)?(?:villages?|towns?|small towns|hamlets?|settlements?|places)\s+(?:near|around|close to|in|by)\s+(.+)$/i;
|
|
|
|
// "draw" (or the start of it) offers Draw's shapes and options, and so does
|
|
// a draw verb with something to draw ("draw a line"); "Draw Bridge" and
|
|
// "draw well" are names.
|
|
const DRAW_WORDS = ['draw', 'sketch', 'annotate', 'drawing', 'markup'];
|
|
const DRAW_SOMETHING =
|
|
/^(?:draw|sketch|annotate|markup)\s+(?:a|an|the|some|on|here|it|shapes?|lines?|areas?|pins?|polygons?|circles?|routes?|paths?|boxes?|zones?)(?:\s|$)/;
|
|
export function drawAsked(text) {
|
|
const low = readLine(text).toLowerCase();
|
|
if (low.length < 3) return false;
|
|
return (
|
|
DRAW_WORDS.some((word) => word.startsWith(low) || low === word) ||
|
|
DRAW_SOMETHING.test(low)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Decimal degrees ("30.27, -97.74"), degrees-minutes-seconds ("30°16'N
|
|
* 97°44'W") or an MGRS grid ("14R PU 2090 4906"), or null.
|
|
*/
|
|
export function coordinateTarget(text) {
|
|
const point = parseCoordinateQuery(text);
|
|
if (!point) return null;
|
|
const grid = /^\d{1,2}[C-HJ-NP-X][A-HJ-NP-Z]{2}(\d{2}){1,5}$/i.test(
|
|
text.replace(/\s+/g, ''),
|
|
);
|
|
return { ...point, kind: grid ? 'MGRS' : t('Coordinates') };
|
|
}
|
|
|
|
/**
|
|
* The coordinates a line names as its place ("go to 30.27, -97.74", "flights
|
|
* near 48.85 2.35"), as typed, or null.
|
|
*/
|
|
function placeCoordinates(text, parsed) {
|
|
const place = parsed.steps.find((step) => step.kind === 'place')?.place;
|
|
if (!place || !coordinateTarget(place)) return null;
|
|
const at = text.toLowerCase().indexOf(place.toLowerCase());
|
|
return at < 0 ? null : text.slice(at, at + place.length);
|
|
}
|
|
|
|
/** The line without the coordinates it names, for the privacy rules. */
|
|
function withoutCoordinates(text, parsed) {
|
|
const coordinates = placeCoordinates(text, parsed);
|
|
return coordinates ? text.replace(coordinates, ' ').trim() : text;
|
|
}
|
|
|
|
function coordinateRow(target, text) {
|
|
const where = `${Math.abs(target.lat).toFixed(4)}°${target.lat >= 0 ? 'N' : 'S'} ${Math.abs(target.lon).toFixed(4)}°${target.lon >= 0 ? 'E' : 'W'}`;
|
|
return {
|
|
key: `coords:${where}`,
|
|
kind: 'place',
|
|
icon: 'my_location',
|
|
place: text,
|
|
coords: { latitude: target.lat, longitude: target.lon },
|
|
label: t('Go to {where}', { where }),
|
|
hint: target.kind,
|
|
};
|
|
}
|
|
|
|
const askRow = (text) => ({
|
|
key: 'ask',
|
|
kind: 'ask',
|
|
icon: null,
|
|
query: text,
|
|
label: t('Ask GEV: “{query}”', { query: text }),
|
|
hint: t('Opens chat'),
|
|
});
|
|
/** `shown`: the place as typed, for the label ("İstanbul", "iPhone store"). */
|
|
const placeRow = (place, shown = place) => ({
|
|
key: `place:${place}`,
|
|
kind: 'place',
|
|
icon: 'location_on',
|
|
place,
|
|
label: t('Go to {place}', { place: titleCase(shown) }),
|
|
hint: t('Place or coordinates'),
|
|
});
|
|
/**
|
|
* The line searched as a place only when picked: offered for a long name
|
|
* read as a sentence, and for text that may be private ("Tverskaya 13
|
|
* 125009 Moscow" looks like a number to keep). Never the Enter default, and
|
|
* nothing is looked up while typing.
|
|
*/
|
|
const explicitPlaceRow = (text, { private: secret = false } = {}) => ({
|
|
...placeRow(text),
|
|
key: `place-explicit:${text}`,
|
|
explicit: true,
|
|
...(secret && {
|
|
label: t('Search “{query}” as a place anyway', { query: text }),
|
|
}),
|
|
});
|
|
/**
|
|
* A layer's switch. `best`: the line names this layer before any other, so
|
|
* Enter may run it (see mayRunOnEnter).
|
|
*/
|
|
const layerRow = (layer, enabled = !layer.enabled, { best = false } = {}) => ({
|
|
key: `layer:${layer.id}:${enabled}`,
|
|
kind: 'layer',
|
|
id: layer.id,
|
|
enabled,
|
|
best,
|
|
icon: 'layers',
|
|
label: layer.shown,
|
|
hint:
|
|
Boolean(layer.enabled) === enabled
|
|
? t('Layer')
|
|
: enabled
|
|
? t('Turn on')
|
|
: t('Turn off'),
|
|
});
|
|
const commandRow = (command, line = '') => ({
|
|
key: `cmd:${command.id}`,
|
|
command: command.id,
|
|
// The line named this command exactly (see mayRunOnEnter).
|
|
named: exactCommand(line) === command,
|
|
kind: command.step.kind === 'mic' ? 'mic' : 'plan',
|
|
icon: command.icon,
|
|
steps: [command.step],
|
|
label: t(command.label),
|
|
hint: t('Command'),
|
|
});
|
|
/**
|
|
* A guided walk. `loose`: found by forgiving a typo; `titled`: the line is
|
|
* written as a title. Either way it is offered, never run on Enter.
|
|
*/
|
|
const guideRow = (key, guide, label, icon = 'east', flags = {}) => ({
|
|
key: `guide:${key}`,
|
|
kind: 'guide',
|
|
icon,
|
|
guide,
|
|
label,
|
|
hint: t('Guide'),
|
|
...flags,
|
|
});
|
|
|
|
/**
|
|
* The Omnibar's reader for one set of layers: what a line asks for, the rows
|
|
* it offers, and what may go to the place service.
|
|
* @param {{layers?: Array<object>, isEntity?: (text: string) => boolean}} options
|
|
*/
|
|
export function createOmnibar({ layers = [], isEntity = () => false } = {}) {
|
|
const { matchLayers, matchLayersLoosely, all } = createLayerIndex(layers);
|
|
const cache = new Map();
|
|
|
|
/**
|
|
* A line, normalised once and read once: `line` is what the user meant
|
|
* ("Show flights." → "Show flights"), `plain` the line without a
|
|
* magnitude floor, `parsed` how parseOmnibar read it.
|
|
*/
|
|
function read(text) {
|
|
const line = readLine(text);
|
|
if (!cache.has(line)) {
|
|
if (cache.size >= 16) cache.delete(cache.keys().next().value);
|
|
const { text: plain, minMagnitude } = magnitudeFloor(line, matchLayers);
|
|
cache.set(line, {
|
|
line,
|
|
plain,
|
|
minMagnitude,
|
|
parsed: parseOmnibar(plain, matchLayers, { isEntity }),
|
|
});
|
|
}
|
|
return cache.get(line);
|
|
}
|
|
|
|
/**
|
|
* "turn on …", "hide …", "toggle …", alone or with a few letters: the
|
|
* layers and features that switch that way, never places. Null when the
|
|
* line is not such a switch, or names nothing to switch and may be a place
|
|
* ("Show Low, AZ").
|
|
*/
|
|
/**
|
|
* "hide everything except flights", "turn off all but ships": a plan that
|
|
* switches off every layer that is on but the ones named. Null when the
|
|
* line is not that, or names no layer to keep.
|
|
*/
|
|
function exceptRows(line, ask) {
|
|
const match = EXCEPT.exec(line.toLowerCase());
|
|
if (!match) return null;
|
|
const kept = match[1]
|
|
.split(/\s*(?:,|\band\b|&)\s*/)
|
|
.map((term) => matchLayers(term)[0])
|
|
.filter(named);
|
|
if (!kept.length) return null;
|
|
const keptIds = new Set(kept.map((layer) => layer.id));
|
|
const steps = all()
|
|
.filter((layer) => layer.enabled && !keptIds.has(layer.id))
|
|
.map((layer) => ({ kind: 'layer', layer, enabled: false }));
|
|
if (!steps.length)
|
|
return [
|
|
{
|
|
key: 'none',
|
|
kind: 'none',
|
|
icon: 'layers',
|
|
label: t('No other layers are on'),
|
|
hint: '',
|
|
},
|
|
ask,
|
|
];
|
|
return [
|
|
{
|
|
key: `plan:${JSON.stringify(steps)}`,
|
|
kind: 'plan',
|
|
icon: 'bolt',
|
|
steps,
|
|
label: steps.map(stepLabel).join(' · '),
|
|
hint: t('Do all'),
|
|
},
|
|
ask,
|
|
];
|
|
}
|
|
|
|
function switchRows(line, ask) {
|
|
const excepted = exceptRows(line, ask);
|
|
if (excepted) return excepted;
|
|
// "remove flights from the map": the map is where every layer is.
|
|
line = line.replace(
|
|
/\s+(?:from|off) (?:the )?(?:map|globe|screen|view)$/i,
|
|
'',
|
|
);
|
|
const switching = line.toLowerCase().match(SWITCH);
|
|
if (
|
|
!switching ||
|
|
isPanelText(line) ||
|
|
isWholeMapClear(line) ||
|
|
// More than one request ("hide flights, show ships") is the parser's.
|
|
/\b(near|in|at|over|around|and|then)\b|[,;+&]/.test(switching[2] || '')
|
|
)
|
|
return null;
|
|
const verb = switching[1];
|
|
const rest = (switching[2] || '')
|
|
.replace(/^((me|the|all|my)\s+)+/, '')
|
|
.trim();
|
|
// "turn off noir", "show osm", "turn on orbit": a style, map or camera
|
|
// move is read by the parser, not listed as a layer switch.
|
|
if (
|
|
rest &&
|
|
read(line).parsed.steps.some((step) =>
|
|
['style', 'stack', 'camera'].includes(step.kind),
|
|
)
|
|
)
|
|
return null;
|
|
const wantOff = SWITCH_OFF.test(verb);
|
|
const toggle = verb === 'toggle';
|
|
const want = (layer) => (toggle ? !layer.enabled : !wantOff);
|
|
const pool = rest
|
|
? matchLayers(rest)
|
|
: all().sort((a, b) => {
|
|
const rank = (id) => {
|
|
const at = POPULAR_LAYERS.indexOf(id);
|
|
return at === -1 ? POPULAR_LAYERS.length : at;
|
|
};
|
|
return rank(a.id) - rank(b.id);
|
|
});
|
|
// The layer the words name leads, whatever its state: "show flights"
|
|
// with Flights already on offers Flights (nothing to do), never the next
|
|
// layer that has the word in its name.
|
|
const [first] = pool;
|
|
const best = rest && named(first) ? first : null;
|
|
const layerRows = [
|
|
...(best ? [layerRow(best, want(best), { best: true })] : []),
|
|
...pool
|
|
.filter((layer) => layer !== best)
|
|
.filter((layer) => toggle || (wantOff ? layer.enabled : !layer.enabled))
|
|
.map((layer) => layerRow(layer, want(layer))),
|
|
].slice(0, rest ? 5 : 6);
|
|
const featureIds = wantOff
|
|
? ['clear', 'hud-off', 'stop']
|
|
: toggle
|
|
? ['hud-on', 'hud-off', 'radio']
|
|
: ['hud-on', 'radio', 'orbit'];
|
|
const features = COMMANDS.filter((command) =>
|
|
featureIds.includes(command.id),
|
|
)
|
|
.filter((command) => !rest || matchCommands(rest).includes(command))
|
|
.map((command) => commandRow(command, line));
|
|
const found = [...layerRows, ...features];
|
|
if (found.length) return [...found, ask];
|
|
// "Show Low, AZ" names no layer or feature: it may be a place, and so
|
|
// may "Remove Island" or "Toggle Inn", written as names.
|
|
if (rest && !wantOff && !toggle) return null;
|
|
if (rest && /\p{Lu}/u.test(line.slice(verb.length))) return null;
|
|
return [
|
|
{
|
|
key: 'none',
|
|
kind: 'none',
|
|
icon: 'layers',
|
|
label: wantOff ? t('No layers are on') : t('No matching layers'),
|
|
hint: '',
|
|
},
|
|
ask,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Things loaded on the map whose name or id matches, added to a list. A
|
|
* callsign, tail number or transponder code leads it; otherwise a place
|
|
* row keeps the top ("Hamburg" goes to Hamburg, not to the ship HAMBURG),
|
|
* with exact names right after it, and they lead only when there is no
|
|
* place row.
|
|
*/
|
|
function withEntities(list, line, entities) {
|
|
if (!entities || line.length < 2 || line.startsWith('>')) return list;
|
|
const callsign = CALLSIGN.test(line.replace(/\s+/g, ''));
|
|
const rows = entities(line.replace(/\s+/g, callsign ? '' : ' '), {
|
|
limit: callsign ? 5 : 3,
|
|
}).map((found) => ({
|
|
key: `entity:${found.key}`,
|
|
kind: 'entity',
|
|
icon: found.icon,
|
|
identity: found.identity,
|
|
exact: found.title.toLowerCase() === line.toLowerCase(),
|
|
label: found.title,
|
|
hint: found.layerName,
|
|
}));
|
|
if (!rows.length) return list;
|
|
const place = list.findIndex((item) => item.kind === 'place');
|
|
const exact = rows.filter((row) => row.exact);
|
|
const leads = callsign ? rows : place === -1 ? exact : [];
|
|
const rest = [
|
|
...(callsign || place === -1 ? [] : exact),
|
|
...rows.filter((row) => !leads.includes(row) && !exact.includes(row)),
|
|
];
|
|
const ask = list.findIndex((item) => item.kind === 'ask');
|
|
const at = place !== -1 ? place + 1 : ask !== -1 ? ask : list.length;
|
|
return [...leads, ...list.slice(0, at), ...rest, ...list.slice(at)];
|
|
}
|
|
|
|
/** The rows for a line that is neither private, coordinates nor a count. */
|
|
function lineRows(text, line, { places = [], entities } = {}) {
|
|
const ask = askRow(text);
|
|
const low = line.toLowerCase();
|
|
// Real places for this text once the suggester answers; the line itself
|
|
// only stands in while it has nothing.
|
|
const realPlaces = places.map((found) => ({
|
|
key: `place:${found.name}|${found.detail}`,
|
|
kind: 'place',
|
|
icon: 'location_on',
|
|
place: found.name,
|
|
coords: { latitude: found.latitude, longitude: found.longitude },
|
|
source: 'photon',
|
|
label: t('Go to {place}', { place: found.name }),
|
|
hint: found.detail || t('Place'),
|
|
}));
|
|
const placeRows = (place) =>
|
|
realPlaces.length
|
|
? realPlaces
|
|
: place.trim().length >= minPlaceChars(place)
|
|
? [placeRow(place, asTypedIn(text, place))]
|
|
: [];
|
|
|
|
const titled = writtenAsName(text.split(/\s+/));
|
|
const settingsFor = low.match(SETTINGS_FOR);
|
|
if (settingsFor) {
|
|
const term = (settingsFor[1] || settingsFor[2]).trim();
|
|
const [layer] = matchLayersLoosely(term);
|
|
if (layer)
|
|
return [
|
|
guideRow(
|
|
`settings:${layer.id}`,
|
|
{ settings: layer },
|
|
t('Show me {thing} settings', { thing: layer.shown }),
|
|
'tune',
|
|
{ loose: !matchLayers(term).length, titled },
|
|
),
|
|
ask,
|
|
];
|
|
}
|
|
|
|
// "show me how to see satellites": a guided walk through the real
|
|
// controls, doing it directly, and asking GEV.
|
|
const howTo = low.match(HOW_TO);
|
|
if (howTo) {
|
|
const wantOff = Boolean(howTo[1]);
|
|
const subject = howTo[2].replace(/^((the|a|an|my|some)\s+)+/, '').trim();
|
|
const [layer] = matchLayersLoosely(subject);
|
|
// Words that say what the walk is about: "how do I use this" names
|
|
// nothing ("this" is no part of "Share this view").
|
|
const content = subject
|
|
.split(/\s+/)
|
|
.filter((word) => word && !GUIDE_STOP_WORDS.has(word));
|
|
const [command] = content.length
|
|
? matchCommands(content.join(' ')).filter((found) =>
|
|
featureGuideFor(found.id),
|
|
)
|
|
: [];
|
|
// A walk is run on Enter only when every word is a whole word of the
|
|
// command ("how do I share"); a word it merely begins is offered.
|
|
const commandWords = command
|
|
? new Set(
|
|
`${command.label} ${command.words}`.toLowerCase().split(/\W+/),
|
|
)
|
|
: new Set();
|
|
const commandLoose = !content.every((word) => commandWords.has(word));
|
|
const guides = [];
|
|
const topic = guideTopic(subject);
|
|
if (topic)
|
|
guides.push(
|
|
guideRow(
|
|
`feature:${topic}`,
|
|
{ feature: topic },
|
|
t('Show me how: {thing}', { thing: t(GUIDE_LABELS[topic]) }),
|
|
'east',
|
|
{ titled },
|
|
),
|
|
// Doing it directly, when the line names the walk's own command
|
|
// ("how do I turn on the HUD": HUD on).
|
|
...(command && featureGuideFor(command.id) === topic
|
|
? [commandRow(command, line)]
|
|
: []),
|
|
);
|
|
// A feature's own walk wins over a layer the words only resemble
|
|
// ("tilt the camera" is no CCTV walk, "change the map" no layer's).
|
|
const layerNamed = named(matchLayers(subject)[0]);
|
|
if (layer && !(topic && (/layers?$/.test(subject) || !layerNamed))) {
|
|
const layerGuides = [
|
|
guideRow(
|
|
`layer:${layer.id}`,
|
|
{ layer },
|
|
t('Show me how: {thing}', { thing: layer.shown }),
|
|
'east',
|
|
{ loose: !matchLayers(subject).length, titled },
|
|
),
|
|
layerRow(layer, !wantOff),
|
|
];
|
|
// A layer named in full leads a topic its words also hold: "how do
|
|
// I see recent imagery" is the Recent Imagery walk, not the map's.
|
|
// The Context panel's own walk stays first for "open global context".
|
|
if (
|
|
layerNamed &&
|
|
matchLayers(subject)[0].id === layer.id &&
|
|
topic !== 'context'
|
|
)
|
|
guides.unshift(...layerGuides);
|
|
else guides.push(...layerGuides);
|
|
} else if (command && !topic)
|
|
guides.push(
|
|
guideRow(
|
|
`feature:${command.id}`,
|
|
{ feature: featureGuideFor(command.id) },
|
|
t('Show me how: {thing}', {
|
|
thing: t(
|
|
GUIDE_LABELS[featureGuideFor(command.id)] || command.label,
|
|
),
|
|
}),
|
|
'east',
|
|
{ titled, loose: commandLoose },
|
|
),
|
|
commandRow(command, line),
|
|
);
|
|
return [...guides, ask];
|
|
}
|
|
|
|
const switched = switchRows(line, ask);
|
|
if (switched) return switched;
|
|
|
|
// ">" lists commands, filtered by whatever follows it.
|
|
if (line.startsWith('>')) {
|
|
const term = line.slice(1).trim();
|
|
const verb = /^(show|hide|enable|disable)\s+(.+)$/i.exec(term);
|
|
if (verb) {
|
|
const needle = verb[2].toLowerCase();
|
|
const exact = matchLayers(needle).find((layer) =>
|
|
[layer.id, layer.name, layer.shown].some(
|
|
(name) => String(name).toLowerCase() === needle,
|
|
),
|
|
);
|
|
if (exact)
|
|
return [
|
|
layerRow(exact, /^(show|enable)$/i.test(verb[1]), { best: true }),
|
|
];
|
|
}
|
|
// A bare ">" lists them all with none picked.
|
|
return matchCommands(term)
|
|
.slice(0, 8)
|
|
.map((command) => commandRow(command, line));
|
|
}
|
|
|
|
// A command leads only when the line is its exact label; one the line
|
|
// merely begins or holds a word of ("voi", "globe") follows the first
|
|
// row, so Enter never starts voice or a cockpit by accident.
|
|
const found = line.length >= 3 ? matchCommands(line).slice(0, 2) : [];
|
|
const exact = exactCommand(line);
|
|
const leading = exact ? [exact] : [];
|
|
const trailing = found.filter((command) => command !== exact).slice(0, 2);
|
|
const withCommands = (rows) => [
|
|
...leading.map((command) => commandRow(command, line)),
|
|
...rows.slice(0, 1),
|
|
...trailing.map((command) => commandRow(command, line)),
|
|
...rows.slice(1),
|
|
];
|
|
const { parsed } = read(line);
|
|
const { steps, question, ambiguous, peeled, sentence, unasked } = parsed;
|
|
const extraPlaces = parsed.extraPlaces || [];
|
|
// The whole line as a place is searched as typed ("Paris, Texas.",
|
|
// "Yahoo!"); only commands read the normalised line.
|
|
const asTyped = (place) => (place === line ? text : place);
|
|
if (question)
|
|
return [
|
|
ask,
|
|
...found.map((command) => commandRow(command, line)),
|
|
...matchLayers(line)
|
|
.slice(0, 3)
|
|
.map((layer) => layerRow(layer)),
|
|
];
|
|
// A pasted sentence is no place and asks for nothing: only GEV is
|
|
// offered, and Enter runs nothing.
|
|
if (sentence)
|
|
return [
|
|
ask,
|
|
...(text.length >= minPlaceChars(text) ? [explicitPlaceRow(text)] : []),
|
|
];
|
|
if (!steps.length)
|
|
return withEntities(
|
|
withCommands([...placeRows(text), ask]),
|
|
line,
|
|
entities,
|
|
);
|
|
const [first] = steps;
|
|
const placeStep = steps.find((step) => step.kind === 'place');
|
|
if (steps.length === 1 && first.kind === 'place') {
|
|
if (leading.length || trailing.length)
|
|
return withEntities(
|
|
withCommands([...placeRows(asTyped(first.place)).slice(0, 2), ask]),
|
|
line,
|
|
entities,
|
|
);
|
|
return withEntities(
|
|
[
|
|
...placeRows(asTyped(first.place)),
|
|
...matchLayers(line)
|
|
.slice(0, 2)
|
|
.map((layer) => layerRow(layer)),
|
|
ask,
|
|
],
|
|
line,
|
|
entities,
|
|
);
|
|
}
|
|
if (steps.length === 1 && first.kind === 'layer')
|
|
return [
|
|
layerRow(first.layer, first.enabled, { best: true }),
|
|
// "earth" might be a place; "hide flights" is not.
|
|
...(steps.verb ? [] : placeRows(text).slice(0, 2)),
|
|
ask,
|
|
];
|
|
|
|
const plan = {
|
|
key: `plan:${JSON.stringify(steps)}`,
|
|
kind: 'plan',
|
|
icon: 'bolt',
|
|
steps,
|
|
label: steps.map(stepLabel).filter(Boolean).join(' · '),
|
|
hint: steps.length > 1 ? t('Do all') : t('Do it'),
|
|
};
|
|
const alternatives = [
|
|
...(placeStep ? placeRows(placeStep.place).slice(0, 2) : []),
|
|
// "near New York and Paris": the plan goes to the first; the others
|
|
// are offered rather than dropped.
|
|
...extraPlaces.map((extra) => placeRow(extra, asTypedIn(text, extra))),
|
|
...steps
|
|
.filter((step) => step.kind === 'layer')
|
|
.map((step) => layerRow(step.layer, step.enabled)),
|
|
];
|
|
// "Thermal, California", "Tilt Cove", "tokyo traffic": one keyword
|
|
// without a verb may be part of the place's name, so the whole line as a
|
|
// place comes first and the plan second. After "go to …" with a request
|
|
// peeled off, the place is the one read ("go to London with flights").
|
|
// A keyword ahead of the rest of a name ("Fire Island", "Ship Bottom",
|
|
// "Radio City Music Hall") begins that name: the leftover is a fragment,
|
|
// not a place, so no plan goes there. "tokyo traffic" and "Thermal,
|
|
// California" (a comma parts them) keep their plans.
|
|
const lower = text.toLowerCase();
|
|
const fragment =
|
|
ambiguous &&
|
|
!peeled &&
|
|
placeStep &&
|
|
!/[,;]/.test(text) &&
|
|
lower.endsWith(placeStep.place.toLowerCase()) &&
|
|
!lower.startsWith(placeStep.place.toLowerCase());
|
|
if (ambiguous)
|
|
return withEntities(
|
|
[
|
|
peeled ? placeRow(placeStep.place, placeStep.shown) : placeRow(text),
|
|
...(fragment ? [] : [plan]),
|
|
...alternatives.filter((row) => row.kind !== 'place'),
|
|
ask,
|
|
],
|
|
line,
|
|
entities,
|
|
);
|
|
// Keywords alone and nothing asked for ("Fire and Rain", "Noir and
|
|
// Thermal"): the plan is offered, never run; the line may be a name.
|
|
if (unasked && !placeStep && steps.length >= 2 && !exact)
|
|
return withEntities(
|
|
[placeRow(text), plan, ...alternatives, ask],
|
|
line,
|
|
entities,
|
|
);
|
|
return [plan, ...alternatives, ask];
|
|
}
|
|
|
|
/**
|
|
* A bundled place's name that is also a command or layer word ("Thermal",
|
|
* "Normal", "Hurricane"): the place comes first, the switch after it.
|
|
*/
|
|
function withPlaceWord(list, line) {
|
|
if (!isPlaceWord(line) || list[0]?.kind === 'place') return list;
|
|
const place = placeRow(line);
|
|
return [place, ...list.filter((item) => item.key !== place.key)];
|
|
}
|
|
|
|
/** Rows for the selected item, offered when the field is empty. */
|
|
function selectionRows(selection) {
|
|
const name = selection.title;
|
|
return [
|
|
{
|
|
key: 'sel:fly',
|
|
kind: 'sel-fly',
|
|
icon: 'my_location',
|
|
label: t('Fly to {name}', { name }),
|
|
hint: selection.layerName,
|
|
},
|
|
...(selection.canFollow
|
|
? [
|
|
{
|
|
key: 'sel:follow',
|
|
kind: 'sel-follow',
|
|
icon: 'navigation',
|
|
label: t('Follow {name}', { name }),
|
|
hint: t('Camera'),
|
|
},
|
|
]
|
|
: []),
|
|
...(selection.canCockpit
|
|
? [
|
|
{
|
|
key: 'sel:cockpit',
|
|
kind: 'sel-cockpit',
|
|
icon: 'airline_seat_recline_normal',
|
|
label: t('Cockpit behind {name}', { name }),
|
|
hint: t('Cockpit'),
|
|
},
|
|
]
|
|
: []),
|
|
{
|
|
key: 'sel:ask',
|
|
kind: 'sel-ask',
|
|
icon: null,
|
|
label: t('Ask GEV about {name}', { name }),
|
|
hint: t('Opens chat'),
|
|
},
|
|
{
|
|
key: 'sel:close',
|
|
kind: 'sel-close',
|
|
icon: 'close',
|
|
label: t('Close {name}', { name }),
|
|
hint: t('Context'),
|
|
},
|
|
];
|
|
}
|
|
|
|
/**
|
|
* With nothing typed or selected: "What's here?" and the most used layers
|
|
* that are off.
|
|
*/
|
|
function viewRows(viewPlace) {
|
|
const off = all()
|
|
.filter((layer) => !layer.enabled && POPULAR_LAYERS.includes(layer.id))
|
|
.sort(
|
|
(a, b) => POPULAR_LAYERS.indexOf(a.id) - POPULAR_LAYERS.indexOf(b.id),
|
|
)
|
|
.slice(0, 2)
|
|
.map((layer) => ({
|
|
key: `view-on:${layer.id}`,
|
|
kind: 'layer',
|
|
id: layer.id,
|
|
enabled: true,
|
|
icon: 'layers',
|
|
label: t('Turn on {layer} here', { layer: layer.shown }),
|
|
hint: t('Layer'),
|
|
}));
|
|
const where = viewPlace
|
|
? [viewPlace.name, viewPlace.state || viewPlace.country]
|
|
.filter(Boolean)
|
|
.join(', ')
|
|
: t('this view');
|
|
return [
|
|
{
|
|
key: 'view-ask',
|
|
kind: 'view-ask',
|
|
icon: null,
|
|
label: t("What's here?"),
|
|
hint: where,
|
|
},
|
|
...off,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* The rows for what is typed, in the order shown, and the one Enter runs
|
|
* before any is chosen (-1 for none).
|
|
* @param {string} typed
|
|
* @param {{
|
|
* places?: Array<object>,
|
|
* entities?: (text: string, options: {limit: number}) => Array<object>,
|
|
* selection?: ?{title: string, layerName: string, canFollow: boolean, canCockpit: boolean},
|
|
* viewPlace?: ?{name: string, state?: string, country?: string},
|
|
* counted?: ?{count: number, what: string, placeName: string, place: object, layer: object},
|
|
* }} context
|
|
* @returns {{rows: Array<object>, defaultIndex: number}}
|
|
*/
|
|
function rows(typed, context = {}) {
|
|
const text = String(typed || '').trim();
|
|
if (!text) {
|
|
const list = context.selection
|
|
? selectionRows(context.selection)
|
|
: viewRows(context.viewPlace);
|
|
return { rows: list, defaultIndex: -1 };
|
|
}
|
|
const line = readLine(text);
|
|
const { parsed } = read(line);
|
|
const enterContext = { named: Boolean(exactCommand(line)) };
|
|
const finish = (list) => {
|
|
const ordered = orderForEnter(
|
|
withPlaceWord(list, line),
|
|
line,
|
|
parsed,
|
|
enterContext,
|
|
);
|
|
return {
|
|
rows: ordered,
|
|
defaultIndex: enterDefault(ordered, line, parsed, enterContext),
|
|
};
|
|
};
|
|
const coordinates = placeCoordinates(text, parsed);
|
|
const onlyPlace = parsed.steps.length === 1 && coordinates;
|
|
const target =
|
|
coordinateTarget(line) ??
|
|
(onlyPlace ? coordinateTarget(coordinates) : null);
|
|
// Coordinates are a spot, not a secret; nothing about them leaves the
|
|
// app unless GEV is asked.
|
|
if (target)
|
|
return finish([
|
|
coordinateRow(target, onlyPlace ? coordinates : line),
|
|
...(mayBePrivate(text) ? [] : [askRow(text)]),
|
|
]);
|
|
// Coordinates named as a line's place ("flights near 30.27, -97.74") are
|
|
// no secret either: the rest of the line is what the rules read.
|
|
const privateText = withoutCoordinates(text, parsed);
|
|
// Text that may be private (an email address, a card, phone, SSN or
|
|
// account number, a password or key) is never offered to the place
|
|
// service, the place search or GEV: only things already loaded on the
|
|
// map may match it.
|
|
if (mayBePrivate(privateText))
|
|
return finish([
|
|
...withEntities([], line, context.entities),
|
|
// An address may look like a number to keep; a bare number never
|
|
// names a place, and an email, password, key or code is never
|
|
// offered as one.
|
|
...(onlyNumbersLookPrivate(text)
|
|
? [explicitPlaceRow(text, { private: true })]
|
|
: []),
|
|
]);
|
|
const counted = context.counted;
|
|
if (counted) {
|
|
const show = {
|
|
key: 'count-show',
|
|
kind: 'count-show',
|
|
icon:
|
|
counted.layer.icon && /^[a-z_]+$/.test(counted.layer.icon)
|
|
? counted.layer.icon
|
|
: 'travel_explore',
|
|
label: tn(
|
|
counted.count,
|
|
'Show {what} in {place} ({count} item)',
|
|
'Show {what} in {place} ({count} items)',
|
|
{ what: counted.what, place: counted.placeName },
|
|
),
|
|
hint: t('Go there'),
|
|
coords: {
|
|
latitude: counted.place.latitude,
|
|
longitude: counted.place.longitude,
|
|
},
|
|
place: counted.placeName,
|
|
source: counted.place.source,
|
|
};
|
|
return finish([
|
|
show,
|
|
...lineRows(text, line, context).filter((item) => item.kind !== 'plan'),
|
|
]);
|
|
}
|
|
const list = lineRows(text, line, context);
|
|
if (!drawAsked(line)) return finish(list);
|
|
return finish(
|
|
[
|
|
{
|
|
key: 'tool:draw',
|
|
kind: 'open-draw',
|
|
icon: 'draw',
|
|
label: t('Open draw options'),
|
|
hint: t('Utilities'),
|
|
},
|
|
...list.filter((item) => item.kind !== 'place').slice(0, 3),
|
|
...list.filter((item) => item.kind === 'place').slice(0, 1),
|
|
].sort((a, b) => (a.kind === 'ask') - (b.kind === 'ask')),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* What may go to the place service (Photon) for a line, or null: the part
|
|
* that names a place, or the whole line when it may be one name
|
|
* ("Satellite Beach", "Home, Washington"). Never private text, a question,
|
|
* a pasted sentence, a command, coordinates, a callsign, a switch or
|
|
* "villages near …".
|
|
*/
|
|
function placeQuery(typed) {
|
|
const text = String(typed || '').trim();
|
|
if (!text || mayBePrivate(text)) return null;
|
|
const line = readLine(text);
|
|
if (line.length < minPlaceChars(line) || line.startsWith('>')) return null;
|
|
if (/^[0-9a-f]{6}$/i.test(line) || CALLSIGN.test(line.replace(/\s+/g, '')))
|
|
return null;
|
|
if (line.includes('?')) return null;
|
|
if (VILLAGES.test(line) || exactCommand(line) || coordinateTarget(line))
|
|
return null;
|
|
if (switchRows(line, askRow(text))) return null;
|
|
const { parsed } = read(line);
|
|
if (parsed.question || parsed.sentence) return null;
|
|
// Coordinates are flown to as they are, never looked up as a name.
|
|
if (placeCoordinates(text, parsed)) return null;
|
|
const place = parsed.steps.find((step) => step.kind === 'place');
|
|
// "go to ,": punctuation names no place.
|
|
if (place && !/[\p{L}\p{N}]/u.test(place.place)) return null;
|
|
// A line of commands with no place in it ("night vision", "zoom in").
|
|
if (parsed.steps.length && !place) return null;
|
|
const words = (value) => value.split(/\s+/).length;
|
|
// The words the place has, not the command around it ("take me to New
|
|
// York City NY"); a line that may be one name counts all of its words.
|
|
const named = place && !parsed.ambiguous ? place.place : line;
|
|
if (words(named) > placeWordLimit(named)) return null;
|
|
// "flights near Trinidad and Tobago": the whole name is looked up; the
|
|
// rows still offer each part ("Tokyo and Osaka").
|
|
const joined = (value) =>
|
|
[value, ...(parsed.extraPlaces || [])].join(' and ');
|
|
// After "go to … , noir" the place read is the one to look up.
|
|
if (parsed.peeled && place) return joined(place.place);
|
|
return parsed.ambiguous || !place
|
|
? text
|
|
: place.place === line
|
|
? text
|
|
: joined(place.place);
|
|
}
|
|
|
|
/**
|
|
* A count request ("flights over Texas", "quakes above M5 in Japan"): the
|
|
* layer to count and its magnitude floor, or null.
|
|
*/
|
|
function countRequest(typed) {
|
|
const text = String(typed || '').trim();
|
|
if (text.length < 5 || text.startsWith('>') || mayBePrivate(text))
|
|
return null;
|
|
const { parsed, minMagnitude } = read(text);
|
|
const layer = parsed.steps.find((step) => step.kind === 'layer');
|
|
const place = parsed.steps.find((step) => step.kind === 'place');
|
|
if (!layer || !place || layer.enabled === false) return null;
|
|
// Only a layer counted in or near a place ("flights over Texas"): a
|
|
// line that may be one name ("Ship Bottom", "Satellite Beach") or asks
|
|
// for something else ("radio settings") is no count.
|
|
if (parsed.ambiguous || parsed.placeFrom !== 'near') return null;
|
|
return { layer: layer.layer, minMagnitude };
|
|
}
|
|
|
|
return {
|
|
rows,
|
|
placeQuery,
|
|
countRequest,
|
|
matchLayers,
|
|
/** The line as read: for tests and diagnostics. */
|
|
read,
|
|
};
|
|
}
|