Files
gods-eye-view/src/ui/omnibarIntent.js
T
Manjunath PaparajuandSameh Khamis a3f4af91f8 Add the Omnibar: one field above the footer for places, layers and commands
On desktop the dock becomes one search bar (Omnibar.vue) that shows the
rows the line-reading pipeline makes: places with nearby suggestions,
coordinates, map items, layers, commands, plans such as "go to Austin and
show flights", guided walks through the real controls, and Ask GEV for
questions. Enter runs only what the line asks for outright. The map
credits move below the bar onto the Power Up row, the voice waveform
shows in the bar while voice is on, and the dock's Location and Visual
trays are hidden in this layout. The phone layout is unchanged. Long
place names are kept out of automatic Ask GEV.

Co-authored-by: Sameh Khamis <[email protected]>
2026-11-18 15:00:06 -08:00

877 lines
36 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.
// What a line typed into the omnibar asks for. A line is split into clauses
// ("noir and cctv near austin, north up"); each clause can name a place,
// layers to show or hide, a visual style, the HUD, a map stack, a camera move,
// radio, the cockpit, the nearest aircraft or something to follow. What is
// left of a clause after those are read is taken as a place.
//
// The result is a plan of steps in the order they should run: the camera
// travels first, so layers and radio load for the new view, and following an
// entity comes last.
import { msg } from '../i18n/index.js';
/** Visual styles, by the words people use for them. */
const STYLES = [
[/\bblack[- ]and[- ]white\b|\bnoir\b/, 'noir'],
[/\b(thermal|flir|heat ?map|infra-?red)\b/, 'thermal'],
[/\b(night ?vision|nvg|surveillance)\b/, 'surveillance'],
[/\b(retro|crt)\b/, 'retro'],
[/\banime\b/, 'anime'],
[/\b(normal|default|plain) (style|view|look|colou?rs?)\b/, 'normal'],
];
/** Map stacks. */
const STACKS = [
[/\b(osm|openstreetmap|street map)\b/, 'osm'],
[/\bbing( aerial)?\b/, 'bing-aerial'],
[/\b(photo ?real(istic)?|3d tiles)\b/, 'photoreal'],
[/\b(esri|satellite imagery)\b/, 'esri-imagery'],
];
/**
* Whole-map clears: "turn off all layers", "hide everything", "remove
* everything" all clear the layers.
*/
const CLEAR_ALL =
/^(?:(?:(?:turn|switch) off|hide|clear|remove|disable|kill) (?:everything|(?:all|every)(?: the)?(?: data)?(?: layers?)?)|clear (?:the )?(?:layers|map)|no layers)$/;
/** Camera moves, as globe actions or runner actions. */
const CAMERA = [
// Whole-map commands come first, so "turn off all layers" is never a place.
[CLEAR_ALL, { act: 'clear' }],
[
/\b(share|copy)( this| the)? (view|link|map|url)\b|^share$/,
{ act: 'share' },
],
[/\breset( the)? (view|camera)\b|\bstart over\b|^home$/, { act: 'reset' }],
[/\bnorth[- ]?up\b|\bface north\b/, { act: 'northUp' }],
[/\b(tilt|3d view|perspective)\b/, { act: 'tilt' }],
[
/\b(globe view|whole (globe|earth|world)|reset (the )?globe)\b/,
{ name: 'zoom_to_globe', args: {} },
],
[/\bzoom in\b/, { name: 'adjust_camera_zoom', args: { direction: 'in' } }],
[/\bzoom out\b/, { name: 'adjust_camera_zoom', args: { direction: 'out' } }],
[
/\bstop (the )?(camera|orbit|moving|rotating)\b/,
{ name: 'move_camera', args: { motion: 'stop' } },
],
[
/\borbit\b/,
{
name: 'move_camera',
args: { motion: 'orbit', mode: 'continuous' },
},
],
];
/** Side panels by name, with the rail and rail item that open them. */
const PANEL_NAMES = [
[
/data ?layers?( panel)?|layers panel/,
'left',
'data-panel',
msg('Data layers'),
],
[
/utilities( panel)?|tools panel/,
'left',
'utilities-panel',
msg('Utilities'),
],
[/authoring( panel)?|scenes? panel/, 'left', 'scene-panel', msg('Authoring')],
[/display( panel)?|visual( panel)?/, 'left', 'pp-toggles', msg('Visual')],
[/cctv panel|cameras? panel/, 'right', 'cctv-panel', msg('CCTV')],
[/street ?level panel/, 'right', 'street-level-panel', msg('Street Level')],
[/context( panel)?/, 'right', 'global-context-panel', msg('Context')],
];
const CLOSE = /\b(collapse|close|hide|minimi[sz]e|dismiss|shut|fold)\b/;
const OPEN = /\b(open|expand|show|reveal)\b/;
/** Words that may sit around a panel's name without naming anything else. */
const PANEL_FILLER =
/\b(open|expand|show|reveal|collapse|close|hide|minimi[sz]e|dismiss|shut|fold|please|the|me|my|a|panel|sidebar|tab)\b/g;
/** Whether the clause names this panel and nothing besides it. */
const onlyNames = (clause, pattern) =>
!tidy(clause.replace(pattern, ' ').replace(PANEL_FILLER, ' '));
/** A clause about side panels, or null. */
function panelStep(clause) {
// "hide everything" clears the layers, as "remove everything" does.
if (CLEAR_ALL.test(clause)) return null;
if (CLOSE.test(clause)) {
if (
/\b(all|every|both)\b.*\b(panels?|sidebars?)\b|\b(panels|sidebars)\b/.test(
clause,
) ||
// "close everything" alone; "hide everything near tokyo" clears.
(/\beverything\b/.test(clause) && onlyNames(clause, /\beverything\b/))
)
return { kind: 'panel', action: 'close', side: 'all' };
// "hide the left panel", never "hide flights near Left Bank".
if (/\bleft\b/.test(clause) && onlyNames(clause, /\b(left|side)\b/g))
return { kind: 'panel', action: 'close', side: 'left' };
if (/\bright\b/.test(clause) && onlyNames(clause, /\b(right|side)\b/g))
return { kind: 'panel', action: 'close', side: 'right' };
for (const [pattern, side, item, name] of PANEL_NAMES)
if (pattern.test(clause) && /panel/.test(clause))
return { kind: 'panel', action: 'close', side, item, name };
}
// "open data layers" opens the panel; "show earthquake data layer" names
// a layer, so a name with anything else beside it is not the panel.
if (OPEN.test(clause))
for (const [pattern, side, item, name] of PANEL_NAMES)
if (pattern.test(clause) && onlyNames(clause, pattern))
return { kind: 'panel', action: 'open', side, item, name };
return null;
}
/**
* Whether a line clears the whole map ("hide everything", "clear the map",
* "hide everything near tokyo"), so layer switches leave it to the plan.
*/
export function isWholeMapClear(text) {
const line = tidy(String(text || '').toLowerCase());
const near = line.match(NEAR);
return (
CLEAR_ALL.test(line) ||
Boolean(near && CLEAR_ALL.test(tidy(line.slice(0, near.index))))
);
}
/** Whether a line is about side panels, so layer switches leave it alone. */
export const isPanelText = (text) =>
Boolean(
panelStep(
String(text || '')
.toLowerCase()
.trim(),
),
);
const LAYER_OFF = /^(hide|turn off|switch off|disable|remove|no)\s+/;
const LAYER_ON = /^(show|turn on|switch on|enable|add|display)\s+(me\s+)?/;
// "go to" with the place after it, or alone at the end of the line.
// "goto" counts only with a place after it: "Goto" is a town in Japan.
const GO =
/^(?:(?:go to|fly to|take me to|zoom to|jump to|head to)(?:\s+|$)|goto\s+)/i;
const FOLLOW = /^(follow|track)\s+(.+)$/;
/**
* Something that can be followed: a callsign or ICAO address (a word or two
* with letters and a digit: "ual123", "a12b2e", "UAL 123"), a nine-digit
* MMSI, or the name of something loaded on the map. "Follow Me Bar", "Track
* Hill" and "Track 29" are places.
*/
const FOLLOWABLE = /^(?:the\s+)?(?:(?=.*\d)(?=.*\p{L})\S+(?:\s+\S+)?|\d{9})$/u;
/** "nearest plane to heathrow" as well as "near", "in" and the rest. */
const NEAR_TO = /\s*\b(?:near|in|at|around|over|across|above|of|to)\s+(.+)$/;
const NEAR = /\s*\b(?:near|in|at|around|over|across|above|of)\s+(.+)$/;
/** The words of NEAR that place a request somewhere (not "of" or "at"). */
const AROUND = /^\s*(?:near|in|around|over|across|above)\b/;
const FILLER =
/\b(please|the|a|an|me|on|mode|style|view|look|layer|layers|map|data|live)\b/g;
/**
* A question's form: a question word followed by an auxiliary or another
* question word ("what is", "how far", "where's"), or an auxiliary followed
* by a pronoun or determiner ("is it raining", "can you show"): "Can Tho
* City" and "Is Kinabalu Park" are places.
*/
const WH_FORM =
/^(?:what|where|when|who|why|how|which)(?:'s\b|\s+(?:is|are|was|were|do|does|did|can|could|should|would|will|many|much|far|long|to)\b)/i;
const AUX_FORM =
/^(?:is|are|was|were|do|does|did|can|could|should|would|will)\s+(?:it|there|you|i|we|they|he|she|the|a|an|this|that|my|your|our|any)\b/i;
/**
* Whether a line is a real question, which Ask GEV may answer on Enter (a
* billed call):
* - one ending with "?" that has a question form or two non-Latin words
* with a word of two letters or more, or five Han, Kana or Hangul characters;
* - without "?", only a question word's form ("what is here", "how far is
* paris") with a word about something after it, and not written as a
* name ("Where Is My Mind").
* An auxiliary's form without "?" is never one: "Can You Imagine", "Do it
* Best Hardware" and "Is This It" are names. A line with a comma and no "?"
* is a place ("Why, Arizona"). Read the line after normalizeLine, in its own
* letter case.
* @param {string} text
*/
/** Greetings shaped like questions ("what's up", "how's it going"). */
const SMALL_TALK =
/^(?:what'?s\s+(?:up|new|good|happening|going on|cooking)|how'?s\s+(?:it going|everything|life|things|your day)|how are (?:you|things)|what are you (?:up to|doing))\b/i;
export function isRealQuestion(text) {
// Full-width and Arabic question marks read as "?".
const line = String(text || '')
.trim()
.replace(/[?؟]/g, '?');
if (SMALL_TALK.test(line)) return false;
const words = line.replace(/\?+$/, '').split(/\s+/).filter(Boolean);
if (line.endsWith('?'))
// A name with "?" ("New York?", "Truth or Consequences?", "東京都?") is
// offered to GEV, not sent: a question's form, or five Han, Kana or
// Hangul characters written without spaces, or two words in other
// non-Latin scripts.
return (
((WH_FORM.test(line) ||
AUX_FORM.test(line) ||
// Question words in other scripts are not read: two words do.
(words.length >= 2 && !/\p{Script=Latin}/u.test(line))) &&
words.some((word) => (word.match(/\p{L}/gu) || []).length >= 2)) ||
(
line.match(
/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/gu,
) || []
).length >= 5
);
if (line.includes(',')) return false;
// The form alone is too little ("how to", "who is it"): a word about
// something must follow ("what is here").
return (
WH_FORM.test(line) &&
words.some(
(word) => !FORM_WORDS.has(word.toLowerCase().replace(/'s$/, '')),
) &&
!writtenAsName(words)
);
}
/** Three words or more, each with a capital first letter: a title or a name. */
export const writtenAsName = (words) =>
words.length >= 3 &&
words.every((word) => !/\p{L}/u.test(word) || /^\p{Lu}/u.test(word));
/**
* An auxiliary's question without "?" ("can you show me", "is it raining
* in tokyo"): Ask GEV is offered first but never runs on Enter. Written with
* a capital after its first two words it is a name ("Can You Imagine", "Do
* it Best Hardware"), and the form alone ("Is there", "Can I") says nothing.
*/
function isUnmarkedQuestion(text) {
const line = String(text || '').trim();
const words = line.split(/\s+/).filter(Boolean);
return (
AUX_FORM.test(line) &&
!line.includes(',') &&
words.some((word) => !FORM_WORDS.has(word.toLowerCase())) &&
!words.slice(2).some((word) => /^\p{Lu}/u.test(word))
);
}
/** The words a question's form is made of, which say nothing on their own. */
const FORM_WORDS = new Set(
'what where when who why how which is are was were do does did can could should would will many much far long to it there you i we they he she the a an this that my your our any'.split(
' ',
),
);
/**
* A typed line as the Omnibar reads it, the one normalisation every reader
* shares: compatibility forms folded (full-width letters and "?"), curly
* apostrophes and quotes made straight, spaces collapsed, a "please" before
* or after the request dropped, and a closing full stop or "!" dropped (not
* an initial's: "Washington D.C."). Letter case is kept.
* @param {string} text
*/
export function normalizeLine(text, { isRequest = isPlainRequest } = {}) {
let line = String(text ?? '')
.normalize('NFKC')
.replace(/[\u2018\u2019\u201A\u201B\u2032\u02BC]/g, "'")
.replace(/[\u201C\u201D\u201E\u201F\u2033]/g, '"')
.replace(/؟/g, '?')
.replace(/\s+/g, ' ')
.trim();
const end = /(?<!(?:^|[\s.])\p{L})[.!。]+$/u;
line = line.replace(end, '');
// "please" is dropped only around a request: "Please Touch Museum",
// "Kindly Lane" and "Pretty Please" are names.
const polite = line
.replace(/^(?:please|pls|plz|kindly)\b[,!]?\s+(?=\S)/i, '')
.replace(/(?:\s*,\s*|\s+)(?:please|pls|plz)$/i, '')
.replace(end, '')
.trim();
return polite !== line && polite && isRequest(polite) ? polite : line;
}
/** A request by its own words: a verb starting it, or a real question. */
const isPlainRequest = (text) => hasActionVerb(text) || isRealQuestion(text);
/**
* Whether a clause starts with an action verb, in any letter case: the one
* test the parser and the Enter rule share.
*/
export function hasActionVerb(text) {
return ACTION_VERB.test(tidy(String(text || '').toLowerCase()));
}
/**
* The verbs that make a clause a request, the one list for the parser and
* for what Enter may run (src/ui/omnibarEnter.js). A verb counts where the
* clause starts ("show flights", "turn radio on"; "radio off" ends one), so
* a place named after it never does ("radio near Clear Lake", "radio in
* Show Low"). Words that also start names count only alone or before what
* they act on: "clear the map", "zoom in", "tilt", "orbit", "stop the
* radio", not "Clear Lake", "Zoom Hill", "Tilt Cove" or "Stop, Arkansas".
* A keyword in a clause without a verb may be part of a name, and a verb
* ends at a space or the line's end ("Hide-A-Way Lake" names a lake).
*/
export const ACTION_VERB =
/^(?:please\s+|now\s+|also\s+)?(?:show|hide|turn|switch|toggle|enable|disable|add|remove|display(?=\s+\S)|play|start|close|open|enter|listen|tune|mute|unmute|follow|track|draw|measure|share|copy|reset|kill(?=\s+(?:the\s+)?(?:radio|music|sound)\b)|silence|pause|face(?=\s+(?:north|south|east|west)\b)|go to|fly to|take me to|head to|jump to|goto|(?:find |select )?nearest|zoom(?=$|\s+(?:in|out|to)\b)|tilt(?=$|\s+(?:the\s+)?(?:camera|view|map|up|down)\b)|orbit(?=$|\s+(?:the\s+)?(?:camera|view|map|it|here|around)\b)|stop(?=$|\s+(?:the\s+)?(?:radio|camera|orbit|orbiting|moving|rotating|music|following)\b)|clear(?=$|\s+(?:the\s+)?(?:map|layers?|everything|all|it)\b))(?=\s|$)|^\S+\s+(?:on|off)$/;
/**
* The cockpit only with a verb, and only as the end of its clause ("enter
* the cockpit", "open cockpit view"): "Cockpit Country" is a place.
*/
const COCKPIT =
/\b(?:enter|open|go into|get in(?:to)?|switch to|show)\s+(?:the\s+)?cockpit(?:\s+(?:view|mode))?$/;
/**
* The radio only with a verb that applies to it: "play radio in Kill Devil
* Hills" turns it on, "Radio City Music Hall" is a place.
*/
const RADIO_ON =
/\b(?:(?:turn|switch) on|play|listen to|tune in(?: to)?|open|start|put on|enable|unmute)\s+(?:the\s+)?radio(?:\s+stations?)?\b|\b(?:turn|switch)\s+(?:the\s+)?radio\s+on\b|\bradio\s+on\b/;
const RADIO_OFF =
/\b(?:(?:turn|switch) off|stop|mute|disable|silence|pause|kill)\s+(?:the\s+)?radio\b|\b(?:turn|switch)\s+(?:the\s+)?radio\s+off\b|\bradio\s+off\b/;
/** Lines this long are not split into a layer and a place word by word. */
const MAX_PAIR_WORDS = 6;
/**
* A place's name has six words at most; an address with a number in it
* ("1600 Pennsylvania Ave NW Washington DC 20500") ten.
*/
export const placeWordLimit = (text) => (/\d/.test(text) ? 10 : 6);
/** Lines longer than this that ask for nothing outright are sentences. */
const MAX_SENTENCE_WORDS = 8;
/** A clause that is only a switch verb, once what it switched is read. */
const SWITCH_ONLY =
/^(?:(?:turn|switch) (?:on|off)|show|hide|enable|disable|remove|add|display|no)?$/;
/** Words beside a layer that say more about it, never a place. */
const NOT_A_PLACE =
/^(?:stations?|feeds?|data|layers?|live|now|here|map|overlay|tracker|tracking|updates?|info|status|positions?|activity|today|tonight)$/;
/** A camera move turned off: orbiting stops; clearing stays a clear. */
const cameraOff = (move) =>
move.act === 'clear'
? move
: move.name === 'move_camera' && move.args.motion === 'orbit'
? { name: 'move_camera', args: { motion: 'stop' } }
: null;
/**
* The end of a "go to" clause that is a request, not part of the name: "in
* noir", "with flights", "at night vision", "show flights".
*/
const GO_TAIL =
/^(.+?)\s+(?:(?:in|with|at)\s+|(show|hide|turn on|turn off|switch on|switch off|enable|disable)\s+)(.+)$/;
/** Clause separators; "black and white" is joined first so it survives. */
const SEPARATORS =
/(\s*(?:,|;(?!\s*[-+]?\d)|\+(?!\d)|&|\band then\b|\bthen\b|\band\b|\balso\b)\s*)/;
function tidy(text) {
return text.replace(/\s+/g, ' ').trim();
}
/** A place without the joining words a removed phrase left at its edges. */
const placeName = (text) => {
const name = tidy(text)
.replace(/^((in|at|near|over|on|of|to|with|and|the)\s+)+/, '')
.replace(/(\s+(in|at|near|over|on|of|to|with|and|the))+$/, '')
.trim();
// A joining word left on its own ("flights in") names no place.
return JOINING.test(name) ? '' : name;
};
const JOINING = /^(in|at|near|over|on|of|to|with|and|the)$/;
/**
* Take the first pattern that matches out of the clause.
* @returns {{value: *, rest: string}|null}
*/
function takeFirst(clause, table) {
for (const [pattern, value] of table) {
const match = clause.match(pattern);
// A whole word only, in any script: "bing" is no part of "Bingöl".
const before = match && clause[match.index - 1];
const after = match && clause[match.index + match[0].length];
if (match && (/\p{L}/u.test(before || '') || /\p{L}/u.test(after || '')))
continue;
if (match)
return {
value,
rest: tidy(clause.replace(match[0], ' ')),
text: match[0],
};
}
return null;
}
/**
* Read one line into a plan.
* @param {string} text What was typed.
* @param {(term: string) => Array<{id: string, shown: string, enabled: boolean, score: number}>} matchLayers
* @returns {{steps: Array<object>, question: boolean}}
*/
export function parseOmnibar(
text,
matchLayers,
{ isEntity = () => false } = {},
) {
const raw = String(text || '').trim();
const line = tidy(raw.toLowerCase()).replace(
/\b(black[- ]and[- ]white|b ?& ?w)\b/g,
'noir',
);
// `asks`: a real question, which Ask GEV may answer by default. Small talk
// ("hi", "help") also goes to GEV, but only when picked.
// A comma line without "?" is a place ("Why, Arizona"), not a question.
// Only a real question is read as one; any other line ("why", "help",
// "what cheer", "List") may still be a place, with Ask GEV offered after.
const asks = isRealQuestion(raw);
// A line ending in "?" is for GEV even when too short to ask by default.
const question = asks || /[??؟]$/.test(line) || isUnmarkedQuestion(raw);
if (!line || question) return { steps: [], question, asks, asked: new Set() };
const steps = [];
// The steps whose own clause asked for them with a verb, and the clause
// each step came from.
const asked = new Set();
const clauseOf = new Map();
// The clauses with a name left beside their keywords.
const placeClauses = new Set();
let place = null;
const clauses = line.split(SEPARATORS);
// Keyword steps read from a clause without a verb, and whether the place
// is what was left beside them: together they make the line ambiguous.
const bareSteps = new Set();
let placeBare = false;
// Further places joined with "and" ("near New York and Paris"): the plan
// goes to the first, and the rest are offered on their own.
const extraPlaces = [];
let previousHadPlace = false;
let previousBarePlace = false;
let previousGo = false;
// Whether a request was peeled off a "go to" clause, and how the place
// was named: after "go to", after "near"/"in", or bare.
let goPeeled = false;
let placeFrom = null;
/** A whole clause that is one style, map, camera move or layer, or null. */
const requestIn = (text) => {
const words = tidy(text.replace(/\b(mode|style|view|look)\b/g, ' '));
for (const table of [STYLES, STACKS, CAMERA]) {
const found = takeFirst(words, table);
if (found && !found.rest) {
if (table === STYLES) return { kind: 'style', style: found.value };
if (table === STACKS) return { kind: 'stack', stack: found.value };
return { kind: 'camera', ...found.value };
}
}
return layerRequest(words);
};
/** A layer named in full, switched on unless the verb says off. */
const layerRequest = (text, verb = '') => {
const [layer] = matchLayers(tidy(text.replace(FILLER, ' ')));
if (!named(layer)) return null;
return {
kind: 'layer',
layer,
enabled: !/^(hide|turn off|switch off|disable)$/.test(verb),
};
};
let previousLayerEnabled = null;
// Whether a clause was read whole as a switch that has no step ("osm
// off"): the line is then no place either.
let consumed = false;
for (let i = 0; i < clauses.length; i += 2) {
let clause = tidy(clauses[i]);
const separator = clauses[i - 1]?.trim();
const afterPlaceComma = previousHadPlace && separator === ',';
// "trinidad and tobago": a bare place joined to a bare place by "and".
const afterBarePlaceAnd = previousBarePlace && separator === 'and';
const continuedLayer = previousLayerEnabled;
const afterGo = previousGo;
previousGo = false;
previousHadPlace = false;
previousBarePlace = false;
previousLayerEnabled = null;
if (!clause) continue;
// "noir off", "flights on", "orbit off": a switch after what it switches
// reads as one before it ("turn off noir"), so "off" is never a place.
const switchAfter = clause.match(/^(.+?)\s+(on|off)$/);
if (
switchAfter &&
!/\b(?:radio|hud)\b/.test(switchAfter[1]) &&
requestIn(switchAfter[1])
)
clause = `turn ${switchAfter[2]} ${switchAfter[1]}`;
// Steps of a clause that has a verb are asked for; so are those joined
// to a "go to" clause by "and" or "then" ("go to Paris and noir").
const clauseVerb =
ACTION_VERB.test(clause) ||
(afterGo && /^(and|then|and then)$/.test(separator || ''));
// `wanted`: whether this step's own clause asked for it; a layer is
// asked for only by a switch right before its word (see below).
const add = (step, wanted = clauseVerb) => {
const key = JSON.stringify(step);
let kept = steps.find((existing) => JSON.stringify(existing) === key);
if (!kept) steps.push((kept = step));
if (!clauseOf.has(kept)) clauseOf.set(kept, i);
if (wanted && step.kind !== 'place') asked.add(kept);
return kept;
};
const addBare = (step, wanted = clauseVerb) => {
const kept = add(step, wanted);
if (!wanted) bareSteps.add(kept);
};
// `leftover`: a name left beside the clause's keywords ("Show Low
// noir"), not one named after near or in ("turn on radio in tokyo").
const addPlace = (value, { bare = false, leftover = false } = {}) => {
if (!value) return;
if (leftover) placeClauses.add(i);
if (place && bare && afterBarePlaceAnd) place += ` and ${value}`;
else if (place && !afterPlaceComma) {
if (separator === 'and') extraPlaces.push(value);
return;
} else if (!place) {
place = value;
placeBare = bare;
} else place += `, ${value}`;
previousHadPlace = true;
previousBarePlace = bare;
};
// "go to Thermal, California", "fly to Tilt Cove": the rest of a "go to"
// clause is the place, read before any keyword in it, and so is a part
// after a comma that has no verb of its own.
// A request that ends the clause is peeled off it ("go to tokyo in
// noir", "go to London with flights", "go to tokyo show flights", "go
// to tokyo, north up"); the line is then ambiguous, so the place row
// still comes first. Names that merely hold a keyword stay whole.
const go = clause.match(GO);
const tailStep =
afterGo && separator === ',' && !clauseVerb ? requestIn(clause) : null;
if (tailStep) {
add(tailStep);
goPeeled = true;
previousGo = true;
continue;
}
if (go || (afterGo && separator === ',' && !clauseVerb)) {
let value = go ? clause.slice(go[0].length) : clause;
const peel = go && value.match(GO_TAIL);
const peeled =
peel && (peel[2] ? layerRequest(peel[3], peel[2]) : requestIn(peel[3]));
if (peeled) {
value = peel[1];
add(peeled);
goPeeled = true;
}
value = placeName(value);
if (go) addPlace(value, { bare: true });
else if (value) place += `, ${value}`;
if (go && value) placeFrom = 'go';
previousHadPlace = true;
previousBarePlace = true;
previousGo = true;
continue;
}
// "hide everything near tokyo": a whole-map clear with a place after it.
const clearNear = clause.match(NEAR);
if (clearNear && CLEAR_ALL.test(tidy(clause.slice(0, clearNear.index)))) {
add({ kind: 'camera', act: 'clear' });
addPlace(placeName(clearNear[1]));
placeFrom ??= 'near';
continue;
}
const panel = panelStep(clause);
if (panel) {
add(panel);
continue;
}
const follow = clause.match(FOLLOW);
if (follow) {
// "track flights near austin" shows a layer there; "follow AAL123"
// follows a craft, and "track it over texas" still goes to Texas.
const where = follow[2].match(NEAR);
const target = where ? tidy(follow[2].slice(0, where.index)) : follow[2];
const [layer] = matchLayers(target.replace(FILLER, ' ').trim());
if (named(layer)) {
add({ kind: 'layer', layer, enabled: true });
previousLayerEnabled = true;
if (where) addPlace(placeName(where[1]));
continue;
}
if (FOLLOWABLE.test(target) || isEntity(target.replace(/^the\s+/, ''))) {
if (where) addPlace(placeName(where[1]));
add({ kind: 'follow', query: target.replace(/^the\s+/, '') });
continue;
}
// Not something to follow: read on, as a place.
}
// "nearest plane", alone or with a place: "Nearest Plane Crash Site" is
// a name.
if (
/\b(nearest|closest) (plane|aircraft|flight|jet)s?(?:$|\s+(?:to|near|in|at|around|over)\b)/.test(
clause,
)
) {
const where = clause.match(NEAR_TO);
if (where) addPlace(placeName(where[1]));
add({ kind: 'nearest' });
continue;
}
// "turn off noir" goes back to the normal style, "turn off orbit"
// stops the camera; a map or a camera move has nothing to turn off.
const switchOff = LAYER_OFF.test(clause);
let took = false;
const style = takeFirst(clause, STYLES);
if (style) {
addBare({ kind: 'style', style: switchOff ? 'normal' : style.value });
clause = style.rest;
took = true;
}
const stack = takeFirst(clause, STACKS);
if (stack) {
if (!switchOff) addBare({ kind: 'stack', stack: stack.value });
clause = stack.rest;
took = true;
}
const camera = takeFirst(clause, CAMERA);
if (camera) {
const move = switchOff ? cameraOff(camera.value) : camera.value;
if (move) addBare({ kind: 'camera', ...move });
clause = camera.rest;
took = true;
}
const hud = clause.match(
/\b(hide|show|turn off|turn on)?\s*hud\s*(on|off)?\b/,
);
if (hud) {
const off = /hide|off/.test(hud[0]) || switchOff;
addBare({ kind: 'hud', visible: off ? 'off' : 'on' });
clause = tidy(clause.replace(hud[0], ' '));
took = true;
}
// The switch verb is all that is left beside what it switched.
if (took && SWITCH_ONLY.test(clause)) {
consumed = true;
continue;
}
const cockpit = clause.match(COCKPIT);
if (cockpit) {
add({ kind: 'cockpit' });
clause = tidy(clause.replace(cockpit[0], ' '));
}
const radioOff = clause.match(RADIO_OFF);
const radio = radioOff || clause.match(RADIO_ON);
if (radio) {
// "turn off the radio", "stop the radio", "mute radio": radio off. The
// verbs are never a place.
const disable = Boolean(radioOff);
const rest = tidy(clause.replace(radio[0], ' '));
const where = rest.match(NEAR);
// "play radio in tokyo", or the place left beside it: "play radio tokyo".
const beside = tidy(rest.replace(FILLER, ' '));
if (where) addPlace(placeName(where[1]));
else if (beside && !disable) addPlace(placeName(beside));
add({ kind: 'radio', action: disable ? 'disable' : 'enable' });
continue;
}
// Layers: "hide flights", "cctv near austin", "earthquakes".
const off = clause.match(LAYER_OFF);
const on = LAYER_ON.test(clause);
let body = clause.replace(LAYER_OFF, '').replace(LAYER_ON, '');
body = tidy(body.replace(GO, ''));
const where = body.match(NEAR);
const what = (where ? tidy(body.slice(0, where.index)) : body).replace(
/(\s+(in|at|on|with|of|near|to))+$/,
'',
);
const subject = tidy(
what.replace(/^(?:all|every)\s+/, '').replace(FILLER, ' '),
);
const layers = subject ? matchLayers(subject) : [];
const enabled = off ? false : on ? true : (continuedLayer ?? true);
// A whole layer name: "rock" begins "rockets" but names no layer.
if (named(layers[0])) {
// Without a switch right before it a layer word may be a place's name
// ("Hurricane, Utah", "Kill Devil Hills" is no "kill").
addBare({ kind: 'layer', layer: layers[0], enabled }, Boolean(off || on));
previousLayerEnabled = enabled;
if (where) {
addPlace(placeName(where[1]));
// "of" and "at" may join the words of a name ("Planes of Fame Air
// Museum", "Boats at Sea"); near, in, around, over, across and above
// place a request ("flights near Tokyo", "flights over Texas").
placeFrom ??= AROUND.test(where[0]) ? 'near' : 'of';
}
continue;
}
// A layer and a place side by side, without "in": "tokyo traffic",
// "earthquakes japan". The place is whichever side is not the layer.
if (
!where &&
subject.includes(' ') &&
subject.split(' ').length <= MAX_PAIR_WORDS
) {
const words = subject.split(' ');
let pair = null;
// Only a whole layer name or synonym counts here.
for (let cut = 1; cut < words.length && !pair; cut++) {
const head = words.slice(0, cut).join(' ');
const tail = words.slice(cut).join(' ');
const [tailLayer] = matchLayers(tail);
const [headLayer] = matchLayers(head);
if (named(tailLayer))
pair = { layer: tailLayer, place: head, layerFirst: false };
else if (named(headLayer))
pair = { layer: headLayer, place: tail, layerFirst: true };
}
// "show radio stations", "flights here": a word about the layer, not
// a place.
if (pair && (off || on) && NOT_A_PLACE.test(pair.place)) {
addBare(
{ kind: 'layer', layer: pair.layer, enabled },
Boolean(off || on) && pair.layerFirst,
);
previousLayerEnabled = enabled;
continue;
}
if (pair) {
// Asked for only when the switch comes right before the layer word
// ("show traffic tokyo"); "show low radio" names Show Low.
addBare(
{ kind: 'layer', layer: pair.layer, enabled },
Boolean(off || on) && pair.layerFirst,
);
previousLayerEnabled = enabled;
addPlace(placeName(pair.place), { bare: true, leftover: true });
continue;
}
}
if (where && subject === '') addPlace(placeName(where[1]));
else if (tidy(body.replace(FILLER, ' '))) {
const before = place;
addPlace(placeName(body), { bare: !off && !on, leftover: true });
// Left over after a switch that switched nothing ("Show Low noir").
if (!before && place && (off || on)) placeFrom ??= 'verb';
}
}
// A verb with a name left beside its keywords asks for nothing but a layer
// switched right after it: "Show Low noir", "Start Point noir" and "Track
// Hill noir" name places, they do not ask for noir.
for (const [step, index] of clauseOf) {
if (step.kind === 'layer' || !asked.has(step)) continue;
if (!ACTION_VERB.test(tidy(clauses[index] || ''))) continue;
// "show noir" alone asks for noir; only a name left beside the switch
// ("Show Low noir") makes it a place.
if (!placeClauses.has(index)) continue;
const layerAsked = [...clauseOf].some(
([other, at]) =>
at === index && other.kind === 'layer' && asked.has(other),
);
if (!layerAsked) {
asked.delete(step);
bareSteps.add(step);
}
}
// A standalone place retains the user's spelling and punctuation. A comma
// before a real command still separates actions in a combined plan.
if (!steps.length && !consumed) place = raw.replace(GO, '');
// A place is a name of six words at most: anything longer is a sentence
// (pasted text, a remark), which names no place. With nothing asked for
// beside it, the line is for GEV only and Enter runs nothing.
// A long name dropped beside keywords nobody asked for ("San Jose, Santa
// Clara County, California, USA flights") makes the line a sentence too.
let droppedPlace = false;
if (place && place.split(/\s+/).length > placeWordLimit(place)) {
place = null;
droppedPlace = true;
}
const sentence =
(!place && !steps.length) ||
(droppedPlace && steps.every((step) => !asked.has(step))) ||
(line.split(' ').length > MAX_SENTENCE_WORDS &&
!(place && /\d/.test(place) && !steps.length) &&
placeFrom !== 'go' &&
steps.every((step) => !asked.has(step)));
if (sentence)
return {
steps: [],
question: false,
asks: false,
sentence: true,
asked: new Set(),
clauseOf: new Map(),
extraPlaces: [],
};
// One keyword without a verb beside what is left of the line ("Thermal,
// California", "Tilt Cove", "tokyo traffic") may be a place's own name:
// the whole line is offered as a place ahead of the plan.
const joined = /\b(and|then|also)\b|[;+&]/.test(line);
const ambiguous =
(Boolean(place) && goPeeled) ||
(Boolean(place) &&
placeBare &&
steps.length === 1 &&
bareSteps.has(steps[0]) &&
!joined) ||
// A switch that switched nothing and a keyword nobody asked for, beside
// what is left: "Show Low noir", "Show Low radio" name Show Low.
(Boolean(place) &&
placeFrom === 'verb' &&
steps.length > 0 &&
steps.every((step) => !asked.has(step)) &&
!joined) ||
// Keywords nobody asked for beside the rest of a name, joined or not:
// "Storm Lake and Spencer", "Thermal and Indio" may be one place, so the
// whole line is offered first.
(Boolean(place) &&
placeFrom !== 'near' &&
steps.length > 0 &&
steps.every((step) => !asked.has(step)));
// Several keywords and nothing asked for ("Fire and Rain", "Noir and
// Thermal"): no plan runs on Enter; the line may still be a name.
const unasked = steps.length > 0 && steps.every((step) => !asked.has(step));
if (place && !placeFrom) placeFrom = placeBare ? 'bare' : 'near';
if (place) steps.unshift({ kind: 'place', place });
steps.verb = LAYER_OFF.test(line) || LAYER_ON.test(line) || GO.test(line);
// Following happens once the camera has settled on the new view.
steps.sort((a, b) => (a.kind === 'follow') - (b.kind === 'follow'));
return {
steps,
question,
asks,
ambiguous,
unasked,
extraPlaces,
placeFrom,
peeled: goPeeled,
asked,
clauseOf,
};
}
/** A layer match that names the whole layer, not the start of its name. */
function named(layer) {
return layer?.score >= 2 && layer.exact !== false;
}
/** "above M5", "m4.5+", "magnitude 6": a magnitude floor in a line. */
const MAGNITUDE =
/\b(?:above|over|at least|greater than|>=?)?\s*m(?:ag(?:nitude)?)?\s*(\d+(?:\.\d+)?)\s*\+?(?=\s|$)/i;
/** Layers whose items have a magnitude. */
const MAGNITUDE_LAYERS = /^(earthquakes?|quakes?)$|earthquake/;
/**
* A count request's text without its magnitude floor, and the floor. Only an
* earthquake layer reads one: "flights over m25" keeps its words.
* @returns {{text: string, minMagnitude: ?number}}
*/
export function magnitudeFloor(text, matchLayers) {
const raw = String(text || '').trim();
const match = raw.match(MAGNITUDE);
if (!match) return { text: raw, minMagnitude: null };
const plain = tidy(raw.replace(match[0], ' '));
const layer = parseOmnibar(plain, matchLayers).steps.find(
(step) => step.kind === 'layer',
)?.layer;
return layer && MAGNITUDE_LAYERS.test(String(layer.id))
? { text: plain, minMagnitude: Number(match[1]) }
: { text: raw, minMagnitude: null };
}