From b07b38b5b74d0c6eb5c339f61bd81059ec5f4af2 Mon Sep 17 00:00:00 2001 From: Maurice Date: Fri, 6 Nov 2026 12:25:29 +0100 Subject: [PATCH] feat(map): never leave an offline map grey, whatever the basemap Offline, a Mapbox map, another OpenFreeMap style or a raster template the device cannot serve now switches to the stored OpenFreeMap basemap, light or dark with the colour scheme, keeping every marker, route and track, with a small Offline map pill. It switches back once the connection returns. "Prepare for offline" stores that basemap's region for every trip, whatever the provider, and both styles' sprites and glyphs, including the scripts a trip in East or South Asia labels its places in. The vector prefetch keeps to OpenFreeMap's download rules (four requests at a time, 50 MB per run), raster tiles are no longer prefetched from OpenStreetMap's own servers, which their policy forbids, nor inside the iOS app, which has no service worker to serve them. --- .../Map/MapViewAuto.offline.test.tsx | 123 ++++++++++++++++++ client/src/components/Map/MapViewAuto.tsx | 61 +++++++-- client/src/components/Map/MapViewGL.tsx | 5 +- .../src/components/Map/offlineBasemap.test.ts | 33 +++++ client/src/components/Map/offlineBasemap.ts | 54 ++++++++ client/src/sync/glPrefetcher.ts | 114 ++++++++++++---- client/src/sync/tilePrefetcher.ts | 38 +++++- client/tests/unit/sync/tilePrefetcher.test.ts | 57 ++++++++ shared/src/i18n/ar/map.ts | 1 + shared/src/i18n/az/map.ts | 1 + shared/src/i18n/br/map.ts | 1 + shared/src/i18n/ca/map.ts | 1 + shared/src/i18n/cs/map.ts | 1 + shared/src/i18n/de/map.ts | 1 + shared/src/i18n/en/map.ts | 1 + shared/src/i18n/es/map.ts | 1 + shared/src/i18n/et/map.ts | 1 + shared/src/i18n/fr/map.ts | 1 + shared/src/i18n/gr/map.ts | 1 + shared/src/i18n/he/map.ts | 1 + shared/src/i18n/hu/map.ts | 1 + shared/src/i18n/id/map.ts | 1 + shared/src/i18n/it/map.ts | 1 + shared/src/i18n/ja/map.ts | 1 + shared/src/i18n/ko/map.ts | 1 + shared/src/i18n/nl/map.ts | 1 + shared/src/i18n/pl/map.ts | 1 + shared/src/i18n/ru/map.ts | 1 + shared/src/i18n/sk/map.ts | 1 + shared/src/i18n/sv/map.ts | 1 + shared/src/i18n/th/map.ts | 1 + shared/src/i18n/tr/map.ts | 1 + shared/src/i18n/uk/map.ts | 1 + shared/src/i18n/vi/map.ts | 1 + shared/src/i18n/zh-TW/map.ts | 1 + shared/src/i18n/zh/map.ts | 1 + 36 files changed, 473 insertions(+), 40 deletions(-) create mode 100644 client/src/components/Map/MapViewAuto.offline.test.tsx create mode 100644 client/src/components/Map/offlineBasemap.test.ts create mode 100644 client/src/components/Map/offlineBasemap.ts diff --git a/client/src/components/Map/MapViewAuto.offline.test.tsx b/client/src/components/Map/MapViewAuto.offline.test.tsx new file mode 100644 index 000000000..885aef6d1 --- /dev/null +++ b/client/src/components/Map/MapViewAuto.offline.test.tsx @@ -0,0 +1,123 @@ +/** + * The trip map offline (FE-COMP-MAPAUTO-OFFLINE-*). + * + * Whatever basemap the user picked, offline the map never goes grey: a basemap + * with nothing stored switches to the stored OpenFreeMap one, with the same + * markers and routes, and says so. + */ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { render, screen } from '../../../tests/helpers/render'; +import { resetAllStores, seedStore } from '../../../tests/helpers/store'; +import { OFM_DARK, OFM_POSITRON } from '../../constants/mapDefaults'; +import { useSettingsStore } from '../../store/settingsStore'; +import { resetWebGLProbe } from '../../utils/webgl'; +import { MapViewAuto } from './MapViewAuto'; + +const env = vi.hoisted(() => ({ offline: false, dark: false })); +const seen = vi.hoisted(() => ({ + leaflet: null as null | { tileUrl?: string }, + gl: null as null | { engine: string; glProvider?: string; styleOverride?: string }, +})); + +vi.mock('./MapView', () => ({ + MapView: (props: { tileUrl?: string }) => { + seen.leaflet = props; + return
; + }, +})); +vi.mock('./glLazy', () => ({ + MapViewGLMaplibre: (props: { glProvider?: string; styleOverride?: string }) => { + seen.gl = { engine: 'maplibre', ...props }; + return
; + }, + MapViewGLMapbox: (props: { glProvider?: string; styleOverride?: string }) => { + seen.gl = { engine: 'mapbox', ...props }; + return
; + }, +})); +vi.mock('./useRoadtripHazards', () => ({ useRoadtripHazards: () => ({ feed: null }) })); +vi.mock('../../hooks/useNetworkMode', () => ({ + useNetworkMode: () => ({ offline: env.offline, forced: false, setForced: () => {} }), +})); +vi.mock('../../hooks/useIsDark', () => ({ useIsDark: () => env.dark })); +vi.mock('../../native/platform', async (importOriginal) => ({ + ...(await importOriginal()), + isNativeIos: () => false, +})); + +const realGetContext = HTMLCanvasElement.prototype.getContext; + +beforeEach(() => { + resetAllStores(); + resetWebGLProbe(); + env.offline = false; + env.dark = false; + seen.leaflet = null; + seen.gl = null; + const ctx = { getExtension: () => ({ loseContext: () => {} }) }; + HTMLCanvasElement.prototype.getContext = vi.fn((type: string) => + type === 'webgl2' ? ctx : null + ) as unknown as typeof realGetContext; +}); + +afterEach(() => { + HTMLCanvasElement.prototype.getContext = realGetContext; + resetWebGLProbe(); +}); + +const pill = () => screen.queryByRole('status'); + +describe('MapViewAuto offline', () => { + it('FE-COMP-MAPAUTO-OFFLINE-001: a Mapbox map online stays Mapbox, with no pill', async () => { + seedStore(useSettingsStore, { settings: { map_provider: 'mapbox-gl', mapbox_access_token: 'pk.test' } }); + + render(); + + await screen.findByTestId('gl-map'); + expect(seen.gl).toMatchObject({ engine: 'mapbox', glProvider: 'mapbox-gl', styleOverride: undefined }); + expect(pill()).not.toBeInTheDocument(); + }); + + it('FE-COMP-MAPAUTO-OFFLINE-002: offline, a Mapbox map draws the stored basemap with MapLibre and says so', async () => { + seedStore(useSettingsStore, { settings: { map_provider: 'mapbox-gl', mapbox_access_token: 'pk.test' } }); + env.offline = true; + env.dark = true; + + render(); + + await screen.findByTestId('gl-map'); + expect(seen.gl).toMatchObject({ engine: 'maplibre', glProvider: 'maplibre-gl', styleOverride: OFM_DARK }); + expect(pill()).toBeInTheDocument(); + }); + + it('FE-COMP-MAPAUTO-OFFLINE-003: a MapLibre map already on a stored style stays as it is', async () => { + seedStore(useSettingsStore, { settings: { map_provider: 'maplibre-gl', maplibre_style: OFM_POSITRON } }); + env.offline = true; + + render(); + + await screen.findByTestId('gl-map'); + expect(seen.gl?.styleOverride).toBeUndefined(); + expect(pill()).not.toBeInTheDocument(); + }); + + it('FE-COMP-MAPAUTO-OFFLINE-004: offline, Leaflet on OpenStreetMap tiles switches to the stored basemap', () => { + seedStore(useSettingsStore, { settings: { map_provider: 'leaflet' } }); + env.offline = true; + + render(); + + expect(seen.leaflet?.tileUrl).toBe(OFM_POSITRON); + expect(pill()).toBeInTheDocument(); + }); + + it('FE-COMP-MAPAUTO-OFFLINE-005: offline, a raster template the service worker stored stays', () => { + seedStore(useSettingsStore, { settings: { map_provider: 'leaflet' } }); + env.offline = true; + + render(); + + expect(seen.leaflet?.tileUrl).toBe('https://tiles.example.com/{z}/{x}/{y}.png'); + expect(pill()).not.toBeInTheDocument(); + }); +}); diff --git a/client/src/components/Map/MapViewAuto.tsx b/client/src/components/Map/MapViewAuto.tsx index 28d670417..878334835 100644 --- a/client/src/components/Map/MapViewAuto.tsx +++ b/client/src/components/Map/MapViewAuto.tsx @@ -1,5 +1,5 @@ import { Suspense } from 'react' -import { AlertTriangle, Clock, Info } from 'lucide-react' +import { AlertTriangle, Clock, CloudOff, Info } from 'lucide-react' import { Tooltip } from '../shared/Tooltip' import { useSettingsStore } from '../../store/settingsStore' import { MapView } from './MapView' @@ -9,15 +9,21 @@ import { useGlRenderer } from './glSupport' import { useRoadtripHazards } from './useRoadtripHazards' import { useTranslation } from '../../i18n/TranslationContext' import type { MapViewAutoProps, MapViewProps } from './mapViewContract' +import { useNetworkMode } from '../../hooks/useNetworkMode' +import { useIsDark } from '../../hooks/useIsDark' +import { OFM_POSITRON } from '../../constants/mapDefaults' +import { glWorksOffline, leafletWorksOffline, offlineStyleFor } from './offlineBasemap' // Auto-selects the map renderer based on user settings. Keeps the existing // Leaflet MapView untouched so the Mapbox GL variant can mature iteratively // behind a toggle. Atlas is not affected — it imports Leaflet directly. // -// Offline maps: only the Leaflet renderer supports full pre-download (raster -// tiles via sync/tilePrefetcher.ts). GL maps are best-effort offline — their -// vector tiles are cached opportunistically by the Service Worker as you view -// them online (see the GL tile rules in vite.config.js), not prefetched. +// Offline maps: "prepare for offline" stores the OpenFreeMap basemap for every +// trip, whatever the provider (sync/tilePrefetcher.ts). Offline, a map whose own +// basemap cannot be drawn from storage (Mapbox, another OpenFreeMap style, a +// raster template the device cannot serve) switches to that stored basemap, +// with the same markers, routes and tracks, and says so with a small pill. It +// switches back once the connection returns. See offlineBasemap.ts. export function MapViewAuto(props: MapViewAutoProps) { const { t } = useTranslation() const hazards = useRoadtripHazards(props.tripId, !!props.clusterLoosely) @@ -32,7 +38,17 @@ export function MapViewAuto(props: MapViewAutoProps) { // Fall back to Leaflet when Mapbox is selected but no token is set, or when the // browser has no WebGL2 (both GL engines need it), so the trip planner never // shows an empty map or one that fails to start. - const glProvider = useGlRenderer(provider, token) + const configuredGl = useGlRenderer(provider, token) + const maplibreStyle = useSettingsStore(s => s.settings.maplibre_style) + const { offline } = useNetworkMode() + const dark = useIsDark() + const offlineStyle = offlineStyleFor(dark) + // Offline on a basemap that has nothing stored: draw the stored one with MapLibre. + const glFallback = !!configuredGl && offline && !glWorksOffline(configuredGl, maplibreStyle) + const glProvider = glFallback ? 'maplibre-gl' : configuredGl + const leafletFallback = !configuredGl && offline && !leafletWorksOffline(mapProps.tileUrl ?? OFM_POSITRON) + if (leafletFallback) mapProps.tileUrl = offlineStyle + const pill = (glFallback || leafletFallback) && // One chunk per engine: picking the binding here is what keeps mapbox-gl and // maplibre-gl out of each other's downloads. const MapViewGL = glProvider === 'maplibre-gl' ? MapViewGLMaplibre : MapViewGLMapbox @@ -45,12 +61,33 @@ export function MapViewAuto(props: MapViewAutoProps) { // to Leaflet keeps a usable map instead of an error card. // resetKeys: with two engine chunks, a failure under one provider must not // keep showing Leaflet after the user switches to the other. - }> - }> - - - + <> + }> + }> + + + + {pill} + ) } - return + return ( + <> + + {pill} + + ) +} + +/** Says the map on screen is the stored offline basemap, not the user's own. */ +function OfflineBasemapPill({ label }: { label: string }) { + return ( +
+
+ ) } diff --git a/client/src/components/Map/MapViewGL.tsx b/client/src/components/Map/MapViewGL.tsx index 9ccae95f7..95402c9ed 100644 --- a/client/src/components/Map/MapViewGL.tsx +++ b/client/src/components/Map/MapViewGL.tsx @@ -100,6 +100,8 @@ const NO_DAYS: Day[] = [] /** The GL renderer: the shared map contract plus the engine it is bound to. */ interface Props extends MapViewProps { glProvider?: GlMapProvider + /** Draws this style instead of the user's: the offline basemap (offlineBasemap.ts). */ + styleOverride?: string /** * The GL engine, injected instead of imported. Both SDKs used to be pulled in * statically here, so a single 2.8 MB chunk carried mapbox-gl and maplibre-gl @@ -482,6 +484,7 @@ export function MapViewGL({ onRemoveVia, onViewportChange, glProvider = 'mapbox-gl', + styleOverride, gl, onMapReady, ...assistant @@ -506,7 +509,7 @@ export function MapViewGL({ const showEndpointLabels = useSettingsStore(s => s.settings.map_booking_labels) === true const mapLang = useSettingsStore(s => s.settings.language) const isMapLibre = glProvider === 'maplibre-gl' - const glStyle = styleForActiveProvider(glProvider, rawMapboxStyle, rawMaplibreStyle) + const glStyle = styleOverride ?? styleForActiveProvider(glProvider, rawMapboxStyle, rawMaplibreStyle) const enableMapbox3d = !isMapLibre && mapbox3d const [mapReady, setMapReady] = useState(false) const [readyMap, setReadyMap] = useState(null) // the ready map, read without touching mapRef diff --git a/client/src/components/Map/offlineBasemap.test.ts b/client/src/components/Map/offlineBasemap.test.ts new file mode 100644 index 000000000..3901fe722 --- /dev/null +++ b/client/src/components/Map/offlineBasemap.test.ts @@ -0,0 +1,33 @@ +import { describe, expect, it } from 'vitest'; +import { OFM_DARK, OFM_POSITRON } from '../../constants/mapDefaults'; +import { glWorksOffline, isOfflineForbiddenTemplate, leafletWorksOffline, offlineStyleFor } from './offlineBasemap'; + +describe('offlineBasemap', () => { + it('picks the stored style for the colour scheme', () => { + expect(offlineStyleFor(false)).toBe(OFM_POSITRON); + expect(offlineStyleFor(true)).toBe(OFM_DARK); + }); + + it('knows OpenStreetMap standard tiles may not be stored, sharded or not', () => { + expect(isOfflineForbiddenTemplate('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png')).toBe(true); + expect(isOfflineForbiddenTemplate('https://tile.openstreetmap.org/{z}/{x}/{y}.png')).toBe(true); + expect(isOfflineForbiddenTemplate('https://tile.openstreetmap.de/{z}/{x}/{y}.png')).toBe(false); + expect(isOfflineForbiddenTemplate('not a url')).toBe(false); + }); + + it('lets only MapLibre on a stored style draw offline as configured', () => { + expect(glWorksOffline('maplibre-gl', OFM_POSITRON)).toBe(true); + expect(glWorksOffline('maplibre-gl', OFM_DARK)).toBe(true); + // The default MapLibre style is Liberty, whose sprite and glyphs are not stored. + expect(glWorksOffline('maplibre-gl', '')).toBe(false); + expect(glWorksOffline('mapbox-gl', OFM_POSITRON)).toBe(false); + }); + + it('keeps a stored raster template on the web, never in the iOS app or for OSM', () => { + expect(leafletWorksOffline(OFM_POSITRON, true)).toBe(true); + expect(leafletWorksOffline('https://tiles.openfreemap.org/styles/liberty', false)).toBe(false); + expect(leafletWorksOffline('https://tiles.example.com/{z}/{x}/{y}.png', false)).toBe(true); + expect(leafletWorksOffline('https://tiles.example.com/{z}/{x}/{y}.png', true)).toBe(false); + expect(leafletWorksOffline('https://tile.openstreetmap.org/{z}/{x}/{y}.png', false)).toBe(false); + }); +}); diff --git a/client/src/components/Map/offlineBasemap.ts b/client/src/components/Map/offlineBasemap.ts new file mode 100644 index 000000000..a89b59099 --- /dev/null +++ b/client/src/components/Map/offlineBasemap.ts @@ -0,0 +1,54 @@ +import { OFM_DARK, OFM_POSITRON } from '../../constants/mapDefaults'; +import { isNativeIos } from '../../native/platform'; +import { isVectorStyle } from '../../utils/tileUrl'; +import { normalizeStyleForProvider, type GlMapProvider } from './glProviders'; + +/** + * The basemap a map falls back to offline, so that whatever the user picked + * online (Mapbox, a raster template, another OpenFreeMap style) they never + * face a grey map once the connection goes. + * + * The two OpenFreeMap styles below are the ones "prepare for offline" stores + * for every trip, whatever the configured provider (sync/tilePrefetcher.ts): + * both share one planet tile set, so the dark one only adds its style, sprite + * and glyphs. A fallback has to be exactly a style that was stored, or its + * sprite and labels are missing offline. + */ +export const OFFLINE_STYLES: readonly string[] = [OFM_POSITRON, OFM_DARK]; + +/** The stored style that matches the colour scheme. */ +export function offlineStyleFor(dark: boolean): string { + return dark ? OFM_DARK : OFM_POSITRON; +} + +/** Hosts whose tiles may not be stored for offline use at all (OSM tile usage policy). */ +const NO_OFFLINE_HOSTS = ['tile.openstreetmap.org']; + +export function isOfflineForbiddenTemplate(template: string): boolean { + try { + const host = new URL(template.replace(/\{s\}/g, 'a')).hostname; + return NO_OFFLINE_HOSTS.some((h) => host === h || host.endsWith(`.${h}`)); + } catch { + return false; + } +} + +/** + * Whether a GL map can be drawn offline as configured. Only MapLibre on one of + * the stored styles can: Mapbox has nothing stored to draw from, and another + * OpenFreeMap style lacks its sprite and glyphs offline. + */ +export function glWorksOffline(provider: GlMapProvider, maplibreStyle: string | null | undefined): boolean { + return provider === 'maplibre-gl' && OFFLINE_STYLES.includes(normalizeStyleForProvider('maplibre-gl', maplibreStyle)); +} + +/** + * Whether the Leaflet map's basemap can be drawn offline as configured. A + * stored vector style can. A raster template can where the service worker + * serves the prefetched tiles, which the iOS app's WebView does not run for a + * self-hosted server, and never for a host whose tiles may not be stored. + */ +export function leafletWorksOffline(tileUrl: string, nativeIos: boolean = isNativeIos()): boolean { + if (isVectorStyle(tileUrl)) return OFFLINE_STYLES.includes(tileUrl); + return !nativeIos && !isOfflineForbiddenTemplate(tileUrl); +} diff --git a/client/src/sync/glPrefetcher.ts b/client/src/sync/glPrefetcher.ts index be9e0090b..5ce99624e 100644 --- a/client/src/sync/glPrefetcher.ts +++ b/client/src/sync/glPrefetcher.ts @@ -25,8 +25,15 @@ const VECTOR_MAX_ZOOM = 14 // The low zooms cost a few dozen tiles at most. const VECTOR_MIN_ZOOM = 0 -/** Requests in flight, kept low for the same reason the raster side keeps it low. */ -const CONCURRENCY = 6 +/** + * Requests in flight. OpenFreeMap allows offline downloads with at most four + * parallel requests, at most 3000 tiles and at most 50 MB each + * (openfreemap.org/tos), so the run keeps under all three. + */ +const CONCURRENCY = 4 + +/** Byte budget per run, the 50 MB OpenFreeMap allows for one download. */ +const MAX_RUN_BYTES = 50 * 1024 * 1024 /** * Hard cap on vector tiles per run. Each is far larger than a raster tile but @@ -38,12 +45,52 @@ const MAX_VECTOR_TILES = 2000 export const VECTOR_CACHE = 'gl-map-offline' /** - * Latin glyph ranges. A label needs the range its codepoints fall in, and Latin - * text lives in the first few; asking for all 256 ranges would download megabytes - * of CJK nobody on this map is going to render. + * Glyph ranges every map needs: Latin, Greek, Cyrillic, Hebrew, Arabic and the + * punctuation blocks. A label needs the range its codepoints fall in; asking for + * all 256 ranges would download megabytes of scripts nobody on this map renders. */ const GLYPH_RANGES = ['0-255', '256-511', '512-767', '768-1023', '1024-1279', '1280-1535', '1536-1791', '8192-8447', '8448-8703'] +/** One range string per 256 codepoints from `from` up to `to`. */ +function rangesBetween(from: number, to: number): string[] { + const out: string[] = [] + for (let start = from - (from % 256); start <= to; start += 256) out.push(`${start}-${start + 255}`) + return out +} + +/** + * Scripts whose labels a trip in that part of the world shows in the local + * name, so a trip there gets their ranges too, or its labels render blank + * offline. Boxes are generous [minLng, minLat, maxLng, maxLat]. + */ +const REGIONAL_GLYPHS: { box: [number, number, number, number]; ranges: string[] }[] = [ + // China, Japan, Korea, Taiwan: kana and CJK punctuation, unified ideographs, Hangul, full-width forms. + { + box: [73, 18, 146, 54], + ranges: [...rangesBetween(0x3000, 0x30ff), ...rangesBetween(0x4e00, 0x9fff), ...rangesBetween(0xac00, 0xd7af), ...rangesBetween(0xff00, 0xffef)], + }, + // Thailand, Laos, Cambodia, Myanmar. + { box: [92, 5, 110, 28], ranges: rangesBetween(0x0e00, 0x0eff).concat(rangesBetween(0x1000, 0x109f), rangesBetween(0x1780, 0x17ff)) }, + // India, Nepal, Bangladesh, Sri Lanka: Devanagari through Malayalam, Sinhala. + { box: [60, 5, 98, 36], ranges: rangesBetween(0x0900, 0x0dff) }, + // Georgia and Armenia. + { box: [39, 38, 47, 44], ranges: rangesBetween(0x0530, 0x058f).concat(rangesBetween(0x10a0, 0x10ff)) }, + // Ethiopia and Eritrea. + { box: [33, 3, 48, 18], ranges: rangesBetween(0x1200, 0x139f) }, +] + +/** The glyph ranges a map of `bbox` needs: the common ones plus its region's scripts. */ +export function glyphRangesFor(bbox: TileBbox | null): string[] { + const out = new Set(GLYPH_RANGES) + if (bbox) { + for (const { box, ranges } of REGIONAL_GLYPHS) { + const overlaps = bbox.minLng <= box[2] && bbox.maxLng >= box[0] && bbox.minLat <= box[3] && bbox.maxLat >= box[1] + if (overlaps) for (const r of ranges) out.add(r) + } + } + return [...out] +} + interface StyleSource { type?: string url?: string @@ -96,15 +143,18 @@ function fontStacks(style: StyleDoc): string[] { * the Service Worker's handler, so a repeated or resumed run over a warm cache * costs almost nothing. Same reasoning as the raster side. */ -async function warm(cache: Cache | null, url: string): Promise { +async function warm(cache: Cache | null, url: string): Promise { try { - if (cache && (await cache.match(url))) return false + if (cache && (await cache.match(url))) return 0 const res = await fetch(url, { mode: 'cors' }) - if (!res.ok) return false - await cache?.put(url, res.clone()) - return true + if (!res.ok) return 0 + // The length header when the server sends one; otherwise the body itself. + const header = Number(res.headers.get('content-length')) + const size = header > 0 ? header : (await res.clone().blob()).size || 1 + await cache?.put(url, res) + return size } catch { - return false + return 0 } } @@ -178,11 +228,11 @@ async function readTileSources(style: StyleDoc, cache: Cache | null): Promise { - return (await prefetchStyle(styleUrl))?.[0]?.template ?? null +export async function prefetchStyleAssets(styleUrl: string, bbox: TileBbox | null = null): Promise { + return (await prefetchStyle(styleUrl, bbox))?.[0]?.template ?? null } -async function prefetchStyle(styleUrl: string): Promise { +async function prefetchStyle(styleUrl: string, bbox: TileBbox | null = null): Promise { const cache = await openVectorCache() const style = await fetchJson(styleUrl) if (!style) return null @@ -199,14 +249,14 @@ async function prefetchStyle(styleUrl: string): Promise { } if (style.glyphs) { - const stacks = fontStacks(style) - await Promise.all( - stacks.flatMap(stack => - GLYPH_RANGES.map(range => - warm(cache, style.glyphs!.replace('{fontstack}', encodeURIComponent(stack)).replace('{range}', range)), - ), + // Through the same pool as the tiles: a trip in East Asia asks for a few + // hundred glyph ranges, and OpenFreeMap allows four requests at a time. + const urls = fontStacks(style).flatMap(stack => + glyphRangesFor(bbox).map(range => + style.glyphs!.replace('{fontstack}', encodeURIComponent(stack)).replace('{range}', range), ), ) + await inPool(urls, url => warm(cache, url)) } return readTileSources(style, cache) @@ -233,7 +283,7 @@ export async function prefetchVectorForPlaces( const bbox = computeBbox(places) if (!bbox) return { tiles: 0, template: null } - const sources = await prefetchStyle(styleUrl) + const sources = await prefetchStyle(styleUrl, bbox) const template = sources?.[0]?.template ?? null if (!sources?.length || isCancelled()) return { tiles: 0, template } @@ -242,13 +292,18 @@ export async function prefetchVectorForPlaces( let cursor = 0 let fetched = 0 + let bytes = 0 async function worker(): Promise { while (cursor < urls.length) { - if (isCancelled() || !navigator.onLine) return + if (isCancelled() || !navigator.onLine || bytes >= MAX_RUN_BYTES) return const url = urls[cursor++] if (!url) return - if (await warm(cache, url)) fetched++ + const size = await warm(cache, url) + if (size > 0) { + fetched++ + bytes += size + } } } @@ -256,6 +311,19 @@ export async function prefetchVectorForPlaces( return { tiles: fetched, template } } +/** Runs `task` over `items`, CONCURRENCY at a time. */ +async function inPool(items: T[], task: (item: T) => Promise): Promise { + let cursor = 0 + async function worker(): Promise { + while (cursor < items.length) { + const item = items[cursor++] + if (item === undefined) return + await task(item) + } + } + await Promise.all(Array.from({ length: CONCURRENCY }, () => worker())) +} + /** Drop the offline vector basemap, alongside the raster cache. */ export async function clearVectorCache(): Promise { try { diff --git a/client/src/sync/tilePrefetcher.ts b/client/src/sync/tilePrefetcher.ts index 120c054cb..4a1416bd6 100644 --- a/client/src/sync/tilePrefetcher.ts +++ b/client/src/sync/tilePrefetcher.ts @@ -28,8 +28,10 @@ import { offlineDb, upsertSyncMeta } from '../db/offlineDb' import { isAuthed } from './authGate' import { isStoragePersisted } from './persistentStorage' import { isVectorStyle, normalizeTileUrl, resolveTileUrl, withTileApiKey } from '../utils/tileUrl' -import { OFM_POSITRON } from '../constants/mapDefaults' -import { clearVectorCache, prefetchVectorForPlaces } from './glPrefetcher' +import { OFM_DARK, OFM_POSITRON } from '../constants/mapDefaults' +import { clearVectorCache, prefetchStyleAssets, prefetchVectorForPlaces } from './glPrefetcher' +import { isOfflineForbiddenTemplate } from '../components/Map/offlineBasemap' +import { isNativeIos } from '../native/platform' // ── Constants ───────────────────────────────────────────────────────────────── @@ -385,6 +387,21 @@ function sameBbox(a: [number, number, number, number], b: TileBbox): boolean { ) } +/** The OpenFreeMap styles the offline fallback draws; they share one tile set. */ +const OFFLINE_BASEMAPS: readonly string[] = [OFM_POSITRON, OFM_DARK] + +/** + * The trip's region of the offline basemap: the light style's tiles, style, + * sprite and glyphs, and the dark style's own style, sprite and glyphs on top, + * whose tiles are the same ones. + */ +async function prefetchOfflineBasemap(places: Place[], template: string, cancelled: () => boolean): Promise { + const light = template === OFM_DARK ? OFM_DARK : OFM_POSITRON + const other = light === OFM_DARK ? OFM_POSITRON : OFM_DARK + await prefetchVectorForPlaces(places, light, cancelled).catch(console.error) + if (!cancelled()) await prefetchStyleAssets(other, computeBbox(places)).catch(console.error) +} + /** * Full pipeline: compute bbox → guard → prefetch → update syncMeta. * Designed to be called fire-and-forget from tripSyncManager. @@ -415,8 +432,16 @@ export async function prefetchTilesForTrip( // The default basemap is a vector style, and walking a {z}/{x}/{y} template // over one would fetch nothing the map ever asks for. A user who configured // their own raster template keeps the path below unchanged. + const cancelled = () => !navigator.onLine || !isAuthed() + // Whatever the map is set to, the trip's region of the offline basemap goes + // along: offline, a Mapbox map or one the device cannot serve switches to it + // (components/Map/offlineBasemap.ts). + await prefetchOfflineBasemap(places, template, cancelled) + if (isVectorStyle(template)) { - const { tiles } = await prefetchVectorForPlaces(places, template, () => !navigator.onLine || !isAuthed()) + const { tiles } = OFFLINE_BASEMAPS.includes(template) + ? { tiles: 0 } + : await prefetchVectorForPlaces(places, template, cancelled) const meta = await offlineDb.syncMeta.get(tripId) if (meta) { await upsertSyncMeta({ @@ -447,7 +472,12 @@ export async function prefetchTilesForTrip( // dozen tiles (#2180); the deep ones are the volume, and they are what the // user loses rather than the ability to start the app at all (#2228). const maxZoom = isStoragePersisted() ? 16 : UNPERSISTED_MAX_ZOOM - const fetched = await prefetchTiles(bbox, template, 0, maxZoom, cartoKey) + // Not for a host whose tiles may not be stored (OSM's tile usage policy), and + // not inside the iOS app, whose WebView runs no service worker to serve them: + // the offline basemap above stands in there. + const fetched = isOfflineForbiddenTemplate(template) || isNativeIos() + ? 0 + : await prefetchTiles(bbox, template, 0, maxZoom, cartoKey) // Update syncMeta with bbox and tile count const meta = await offlineDb.syncMeta.get(tripId) diff --git a/client/tests/unit/sync/tilePrefetcher.test.ts b/client/tests/unit/sync/tilePrefetcher.test.ts index f3fb5a059..96b3f3e8b 100644 --- a/client/tests/unit/sync/tilePrefetcher.test.ts +++ b/client/tests/unit/sync/tilePrefetcher.test.ts @@ -26,6 +26,21 @@ import { offlineDb, clearAll, upsertSyncMeta } from '../../../src/db/offlineDb'; import { requestPersistentStorage, _resetPersistentStorage } from '../../../src/sync/persistentStorage'; import { setAuthed } from '../../../src/sync/authGate'; import { buildPlace } from '../../helpers/factories'; +import { prefetchStyleAssets, prefetchVectorForPlaces } from '../../../src/sync/glPrefetcher'; +import { isNativeIos } from '../../../src/native/platform'; +import { OFM_DARK, OFM_POSITRON } from '../../../src/constants/mapDefaults'; + +// The vector basemap has its own tests (glPrefetcher.test.ts). Here it is a seam, +// so the raster runs below count only their own tile requests. +vi.mock('../../../src/sync/glPrefetcher', async importOriginal => ({ + ...(await importOriginal()), + prefetchVectorForPlaces: vi.fn(async () => ({ tiles: 0, template: null })), + prefetchStyleAssets: vi.fn(async () => null), +})); +vi.mock('../../../src/native/platform', async importOriginal => ({ + ...(await importOriginal()), + isNativeIos: vi.fn(() => false), +})); beforeEach(async () => { await clearAll(); @@ -406,6 +421,48 @@ describe('prefetchTilesForTrip', () => { }); }); +// ── the offline basemap ─────────────────────────────────────────────────────── + +describe('prefetchTilesForTrip — the offline basemap', () => { + const places = [buildPlace({ trip_id: 1, lat: 35.68, lng: 139.76 })]; + + beforeEach(async () => { + await upsertSyncMeta({ tripId: 1, lastSyncedAt: Date.now(), status: 'idle', tilesBbox: null, filesCachedCount: 0 }); + vi.mocked(prefetchVectorForPlaces).mockClear(); + vi.mocked(prefetchStyleAssets).mockClear(); + vi.mocked(isNativeIos).mockReturnValue(false); + }); + + it('stores the light and dark OpenFreeMap styles for a trip on any provider', async () => { + await prefetchTilesForTrip(1, places, 'https://{s}.example.com/{z}/{x}/{y}.png'); + + expect(vi.mocked(prefetchVectorForPlaces).mock.calls.map(c => c[1])).toEqual([OFM_POSITRON]); + expect(vi.mocked(prefetchStyleAssets).mock.calls.map(c => c[0])).toEqual([OFM_DARK]); + }); + + it('does not walk the stored style twice when it is the configured one', async () => { + await prefetchTilesForTrip(1, places, OFM_POSITRON); + + expect(vi.mocked(prefetchVectorForPlaces)).toHaveBeenCalledTimes(1); + }); + + it('never prefetches OpenStreetMap standard tiles, which their policy forbids', async () => { + await prefetchTilesForTrip(1, places, 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'); + + expect(vi.mocked(fetch).mock.calls.some(c => String(c[0]).includes('tile.openstreetmap.org'))).toBe(false); + expect(vi.mocked(prefetchVectorForPlaces)).toHaveBeenCalled(); + }); + + it('skips raster tiles inside the iOS app, which has no service worker to serve them', async () => { + vi.mocked(isNativeIos).mockReturnValue(true); + + await prefetchTilesForTrip(1, places, 'https://{s}.example.com/{z}/{x}/{y}.png'); + + expect(vi.mocked(fetch)).not.toHaveBeenCalled(); + expect(vi.mocked(prefetchVectorForPlaces)).toHaveBeenCalled(); + }); +}); + // ── repeat runs ─────────────────────────────────────────────────────────────── describe('prefetchTilesForTrip — repeat runs', () => { diff --git a/shared/src/i18n/ar/map.ts b/shared/src/i18n/ar/map.ts index 4595bf8c2..572c62cf9 100644 --- a/shared/src/i18n/ar/map.ts +++ b/shared/src/i18n/ar/map.ts @@ -52,5 +52,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'لا يوفّر هذا المتصفح WebGL2 الذي تحتاجه خرائط GL، لذا تُعرض الخرائط باستخدام Leaflet بدلًا منها.', 'map.webgl2.terrain': 'يحتاج العرض ثلاثي الأبعاد إلى WebGL2، وهذا المتصفح لا يوفّره. تبقى الخريطة ثنائية الأبعاد.', + 'map.offlineBasemap': 'خريطة دون اتصال', }; export default map; diff --git a/shared/src/i18n/az/map.ts b/shared/src/i18n/az/map.ts index b8e228698..6f00aa0ca 100644 --- a/shared/src/i18n/az/map.ts +++ b/shared/src/i18n/az/map.ts @@ -50,6 +50,7 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Bu brauzer GL xəritələrinin ehtiyac duyduğu WebGL2-ni təqdim etmir, ona görə xəritələr Leaflet ilə göstərilir.', 'map.webgl2.terrain': '3D üçün WebGL2 lazımdır, bu brauzer isə onu təqdim etmir. Xəritə 2D olaraq qalır.', + 'map.offlineBasemap': 'Oflayn xəritə', }; export default map; diff --git a/shared/src/i18n/br/map.ts b/shared/src/i18n/br/map.ts index 96b01ba14..bf433284d 100644 --- a/shared/src/i18n/br/map.ts +++ b/shared/src/i18n/br/map.ts @@ -47,5 +47,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Este navegador não oferece WebGL2, necessário para os mapas GL, por isso os mapas são exibidos com o Leaflet.', 'map.webgl2.terrain': 'O 3D precisa de WebGL2, que este navegador não oferece. O mapa continua em 2D.', + 'map.offlineBasemap': 'Mapa offline', }; export default map; diff --git a/shared/src/i18n/ca/map.ts b/shared/src/i18n/ca/map.ts index 15f66e8a3..502acda19 100644 --- a/shared/src/i18n/ca/map.ts +++ b/shared/src/i18n/ca/map.ts @@ -45,5 +45,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Aquest navegador no ofereix WebGL2, que necessiten els mapes GL, així que els mapes es mostren amb Leaflet.', 'map.webgl2.terrain': 'El 3D necessita WebGL2, que aquest navegador no ofereix. El mapa es queda en 2D.', + 'map.offlineBasemap': 'Mapa fora de línia', }; export default map; diff --git a/shared/src/i18n/cs/map.ts b/shared/src/i18n/cs/map.ts index 0139c1030..407292af7 100644 --- a/shared/src/i18n/cs/map.ts +++ b/shared/src/i18n/cs/map.ts @@ -46,5 +46,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Tento prohlížeč nenabízí WebGL2, které mapy GL potřebují, proto se mapy zobrazují pomocí Leafletu.', 'map.webgl2.terrain': '3D potřebuje WebGL2, které tento prohlížeč nenabízí. Mapa zůstává ve 2D.', + 'map.offlineBasemap': 'Offline mapa', }; export default map; diff --git a/shared/src/i18n/de/map.ts b/shared/src/i18n/de/map.ts index c8df7a83b..951536543 100644 --- a/shared/src/i18n/de/map.ts +++ b/shared/src/i18n/de/map.ts @@ -47,5 +47,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Dieser Browser bietet kein WebGL2, das GL-Karten brauchen. Karten werden deshalb mit Leaflet angezeigt.', 'map.webgl2.terrain': '3D braucht WebGL2, das dieser Browser nicht bietet. Die Karte bleibt in 2D.', + 'map.offlineBasemap': 'Offline-Karte', }; export default map; diff --git a/shared/src/i18n/en/map.ts b/shared/src/i18n/en/map.ts index 03a8767e9..531d0252b 100644 --- a/shared/src/i18n/en/map.ts +++ b/shared/src/i18n/en/map.ts @@ -45,5 +45,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'This browser does not offer WebGL2, which GL maps need, so maps are shown with Leaflet instead.', 'map.webgl2.terrain': '3D needs WebGL2, which this browser does not offer. The map stays in 2D.', + 'map.offlineBasemap': 'Offline map', }; export default map; diff --git a/shared/src/i18n/es/map.ts b/shared/src/i18n/es/map.ts index 5eca743c0..974495e1c 100644 --- a/shared/src/i18n/es/map.ts +++ b/shared/src/i18n/es/map.ts @@ -44,5 +44,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Este navegador no ofrece WebGL2, que necesitan los mapas GL, así que los mapas se muestran con Leaflet.', 'map.webgl2.terrain': 'El 3D necesita WebGL2, que este navegador no ofrece. El mapa se queda en 2D.', + 'map.offlineBasemap': 'Mapa sin conexión', }; export default map; diff --git a/shared/src/i18n/et/map.ts b/shared/src/i18n/et/map.ts index 552dc0cec..8871e8086 100644 --- a/shared/src/i18n/et/map.ts +++ b/shared/src/i18n/et/map.ts @@ -43,5 +43,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': 'Topograafiline', 'map.webgl2.fallback': 'See brauser ei paku WebGL2-te, mida GL-kaardid vajavad, seega kuvatakse kaardid Leafletiga.', 'map.webgl2.terrain': '3D vajab WebGL2-te, mida see brauser ei paku. Kaart jääb 2D-vaatesse.', + 'map.offlineBasemap': 'Võrguühenduseta kaart', }; export default map; diff --git a/shared/src/i18n/fr/map.ts b/shared/src/i18n/fr/map.ts index af8170e26..316f4adbf 100644 --- a/shared/src/i18n/fr/map.ts +++ b/shared/src/i18n/fr/map.ts @@ -46,5 +46,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Ce navigateur ne propose pas WebGL2, nécessaire aux cartes GL : les cartes s’affichent donc avec Leaflet.', 'map.webgl2.terrain': 'La 3D nécessite WebGL2, que ce navigateur ne propose pas. La carte reste en 2D.', + 'map.offlineBasemap': 'Carte hors ligne', }; export default map; diff --git a/shared/src/i18n/gr/map.ts b/shared/src/i18n/gr/map.ts index 4bc53c6e6..22b24e22b 100644 --- a/shared/src/i18n/gr/map.ts +++ b/shared/src/i18n/gr/map.ts @@ -46,5 +46,6 @@ const map: TranslationStrings = { 'Αυτό το πρόγραμμα περιήγησης δεν προσφέρει WebGL2, που χρειάζονται οι χάρτες GL, οπότε οι χάρτες εμφανίζονται με το Leaflet.', 'map.webgl2.terrain': 'Το 3D χρειάζεται WebGL2, που αυτό το πρόγραμμα περιήγησης δεν προσφέρει. Ο χάρτης μένει σε 2D.', + 'map.offlineBasemap': 'Χάρτης εκτός σύνδεσης', }; export default map; diff --git a/shared/src/i18n/he/map.ts b/shared/src/i18n/he/map.ts index 94f674e24..ec7c202a4 100644 --- a/shared/src/i18n/he/map.ts +++ b/shared/src/i18n/he/map.ts @@ -45,6 +45,7 @@ const map: TranslationStrings = { 'map.baseLayer.topo': 'טופוגרפית', 'map.webgl2.fallback': 'הדפדפן הזה לא תומך ב-WebGL2, שמפות GL צריכות, ולכן המפות מוצגות עם Leaflet.', 'map.webgl2.terrain': 'תלת-ממד דורש WebGL2, והדפדפן הזה לא תומך בו. המפה נשארת בדו-ממד.', + 'map.offlineBasemap': 'מפה לא מקוונת', }; export default map; diff --git a/shared/src/i18n/hu/map.ts b/shared/src/i18n/hu/map.ts index f526a44fa..bfd29efff 100644 --- a/shared/src/i18n/hu/map.ts +++ b/shared/src/i18n/hu/map.ts @@ -44,5 +44,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Ez a böngésző nem kínál WebGL2-t, amelyre a GL-térképeknek szükségük van, ezért a térképek Leaflettel jelennek meg.', 'map.webgl2.terrain': 'A 3D-hez WebGL2 kell, amelyet ez a böngésző nem kínál. A térkép 2D-ben marad.', + 'map.offlineBasemap': 'Offline térkép', }; export default map; diff --git a/shared/src/i18n/id/map.ts b/shared/src/i18n/id/map.ts index 3feb67b3b..46a4dd820 100644 --- a/shared/src/i18n/id/map.ts +++ b/shared/src/i18n/id/map.ts @@ -43,5 +43,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Browser ini tidak menyediakan WebGL2 yang dibutuhkan peta GL, jadi peta ditampilkan dengan Leaflet.', 'map.webgl2.terrain': '3D membutuhkan WebGL2, yang tidak disediakan browser ini. Peta tetap dalam 2D.', + 'map.offlineBasemap': 'Peta offline', }; export default map; diff --git a/shared/src/i18n/it/map.ts b/shared/src/i18n/it/map.ts index 89687a927..91a345d17 100644 --- a/shared/src/i18n/it/map.ts +++ b/shared/src/i18n/it/map.ts @@ -47,5 +47,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Questo browser non offre WebGL2, necessario alle mappe GL, quindi le mappe vengono mostrate con Leaflet.', 'map.webgl2.terrain': 'Il 3D richiede WebGL2, che questo browser non offre. La mappa resta in 2D.', + 'map.offlineBasemap': 'Mappa offline', }; export default map; diff --git a/shared/src/i18n/ja/map.ts b/shared/src/i18n/ja/map.ts index 6c778b8bc..af4a2b1cb 100644 --- a/shared/src/i18n/ja/map.ts +++ b/shared/src/i18n/ja/map.ts @@ -43,5 +43,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'このブラウザーは GL マップに必要な WebGL2 に対応していないため、地図は Leaflet で表示されます。', 'map.webgl2.terrain': '3D には WebGL2 が必要ですが、このブラウザーは対応していません。地図は 2D のままです。', + 'map.offlineBasemap': 'オフライン地図', }; export default map; diff --git a/shared/src/i18n/ko/map.ts b/shared/src/i18n/ko/map.ts index b4a5c2f26..544b39650 100644 --- a/shared/src/i18n/ko/map.ts +++ b/shared/src/i18n/ko/map.ts @@ -42,5 +42,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': '지형도', 'map.webgl2.fallback': '이 브라우저는 GL 지도에 필요한 WebGL2를 지원하지 않아 지도를 Leaflet으로 표시합니다.', 'map.webgl2.terrain': '3D에는 WebGL2가 필요하지만 이 브라우저는 지원하지 않습니다. 지도는 2D로 유지됩니다.', + 'map.offlineBasemap': '오프라인 지도', }; export default map; diff --git a/shared/src/i18n/nl/map.ts b/shared/src/i18n/nl/map.ts index 486bbdd2e..bca23f52b 100644 --- a/shared/src/i18n/nl/map.ts +++ b/shared/src/i18n/nl/map.ts @@ -46,5 +46,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Deze browser biedt geen WebGL2, dat GL-kaarten nodig hebben, dus kaarten worden met Leaflet getoond.', 'map.webgl2.terrain': '3D heeft WebGL2 nodig, dat deze browser niet biedt. De kaart blijft in 2D.', + 'map.offlineBasemap': 'Offline kaart', }; export default map; diff --git a/shared/src/i18n/pl/map.ts b/shared/src/i18n/pl/map.ts index 74c943dde..126d4d7c8 100644 --- a/shared/src/i18n/pl/map.ts +++ b/shared/src/i18n/pl/map.ts @@ -49,5 +49,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Ta przeglądarka nie obsługuje WebGL2, którego potrzebują mapy GL, więc mapy są wyświetlane za pomocą Leaflet.', 'map.webgl2.terrain': 'Tryb 3D wymaga WebGL2, którego ta przeglądarka nie obsługuje. Mapa pozostaje w 2D.', + 'map.offlineBasemap': 'Mapa offline', }; export default map; diff --git a/shared/src/i18n/ru/map.ts b/shared/src/i18n/ru/map.ts index e054bb65a..6114a6b49 100644 --- a/shared/src/i18n/ru/map.ts +++ b/shared/src/i18n/ru/map.ts @@ -50,5 +50,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Этот браузер не поддерживает WebGL2, нужный картам GL, поэтому карты показываются через Leaflet.', 'map.webgl2.terrain': 'Для 3D нужен WebGL2, а этот браузер его не поддерживает. Карта остаётся в 2D.', + 'map.offlineBasemap': 'Офлайн-карта', }; export default map; diff --git a/shared/src/i18n/sk/map.ts b/shared/src/i18n/sk/map.ts index 565b82971..231d5d0dc 100644 --- a/shared/src/i18n/sk/map.ts +++ b/shared/src/i18n/sk/map.ts @@ -46,5 +46,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Tento prehliadač neponúka WebGL2, ktoré mapy GL potrebujú, preto sa mapy zobrazujú pomocou Leafletu.', 'map.webgl2.terrain': '3D potrebuje WebGL2, ktoré tento prehliadač neponúka. Mapa zostáva v 2D.', + 'map.offlineBasemap': 'Offline mapa', }; export default map; diff --git a/shared/src/i18n/sv/map.ts b/shared/src/i18n/sv/map.ts index 9386ee555..7cde3cfb1 100644 --- a/shared/src/i18n/sv/map.ts +++ b/shared/src/i18n/sv/map.ts @@ -44,5 +44,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': 'Den här webbläsaren erbjuder inte WebGL2, som GL-kartor behöver, så kartorna visas med Leaflet i stället.', 'map.webgl2.terrain': '3D kräver WebGL2, som den här webbläsaren inte erbjuder. Kartan stannar i 2D.', + 'map.offlineBasemap': 'Offlinekarta', }; export default map; diff --git a/shared/src/i18n/th/map.ts b/shared/src/i18n/th/map.ts index c4e3f027f..288de9af7 100644 --- a/shared/src/i18n/th/map.ts +++ b/shared/src/i18n/th/map.ts @@ -41,5 +41,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': 'ภูมิประเทศ', 'map.webgl2.fallback': 'เบราว์เซอร์นี้ไม่รองรับ WebGL2 ที่แผนที่ GL ต้องใช้ จึงแสดงแผนที่ด้วย Leaflet แทน', 'map.webgl2.terrain': 'โหมด 3D ต้องใช้ WebGL2 ซึ่งเบราว์เซอร์นี้ไม่รองรับ แผนที่จึงยังคงเป็น 2D', + 'map.offlineBasemap': 'แผนที่ออฟไลน์', }; export default map; diff --git a/shared/src/i18n/tr/map.ts b/shared/src/i18n/tr/map.ts index 62374c2c8..70b1df378 100644 --- a/shared/src/i18n/tr/map.ts +++ b/shared/src/i18n/tr/map.ts @@ -44,5 +44,6 @@ const map: TranslationStrings = { 'map.webgl2.fallback': "Bu tarayıcı GL haritalarının ihtiyaç duyduğu WebGL2'yi sunmuyor, bu yüzden haritalar Leaflet ile gösteriliyor.", 'map.webgl2.terrain': '3D için WebGL2 gerekir, bu tarayıcı ise onu sunmuyor. Harita 2D olarak kalır.', + 'map.offlineBasemap': 'Çevrimdışı harita', }; export default map; diff --git a/shared/src/i18n/uk/map.ts b/shared/src/i18n/uk/map.ts index c6566c57d..4db23d21f 100644 --- a/shared/src/i18n/uk/map.ts +++ b/shared/src/i18n/uk/map.ts @@ -48,5 +48,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': 'Топо', 'map.webgl2.fallback': 'Цей браузер не підтримує WebGL2, потрібний картам GL, тому карти показуються через Leaflet.', 'map.webgl2.terrain': 'Для 3D потрібен WebGL2, а цей браузер його не підтримує. Карта залишається у 2D.', + 'map.offlineBasemap': 'Офлайн-карта', }; export default map; diff --git a/shared/src/i18n/vi/map.ts b/shared/src/i18n/vi/map.ts index 7124d6d27..34ce24447 100644 --- a/shared/src/i18n/vi/map.ts +++ b/shared/src/i18n/vi/map.ts @@ -44,5 +44,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': 'Địa hình', 'map.webgl2.fallback': 'Trình duyệt này không hỗ trợ WebGL2 mà bản đồ GL cần, nên bản đồ được hiển thị bằng Leaflet.', 'map.webgl2.terrain': 'Chế độ 3D cần WebGL2, nhưng trình duyệt này không hỗ trợ. Bản đồ vẫn ở dạng 2D.', + 'map.offlineBasemap': 'Bản đồ ngoại tuyến', }; export default map; diff --git a/shared/src/i18n/zh-TW/map.ts b/shared/src/i18n/zh-TW/map.ts index 9868dce15..9c00df569 100644 --- a/shared/src/i18n/zh-TW/map.ts +++ b/shared/src/i18n/zh-TW/map.ts @@ -40,5 +40,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': '地形圖', 'map.webgl2.fallback': '此瀏覽器不支援 GL 地圖所需的 WebGL2,因此地圖改用 Leaflet 顯示。', 'map.webgl2.terrain': '3D 需要 WebGL2,而此瀏覽器不支援。地圖維持 2D。', + 'map.offlineBasemap': '離線地圖', }; export default map; diff --git a/shared/src/i18n/zh/map.ts b/shared/src/i18n/zh/map.ts index 5605cb727..bef81a9de 100644 --- a/shared/src/i18n/zh/map.ts +++ b/shared/src/i18n/zh/map.ts @@ -40,5 +40,6 @@ const map: TranslationStrings = { 'map.baseLayer.topo': '地形图', 'map.webgl2.fallback': '此浏览器不支持 GL 地图所需的 WebGL2,因此地图改用 Leaflet 显示。', 'map.webgl2.terrain': '3D 需要 WebGL2,而此浏览器不支持。地图保持 2D。', + 'map.offlineBasemap': '离线地图', }; export default map;