339 lines
25 KiB
JavaScript
339 lines
25 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* check-experimental-shelf — "all experimental plugins working", as a measurement.
|
|
*
|
|
* THE SHELF is derived, never listed: every bundle in the built manifest that the Research Gallery
|
|
* would discover into its Experimental folder, i.e. not a curated tab and not in NOT_EXPERIMENTAL.
|
|
* Both sets are read from plugin-designs/doxa-maps-spa/doxa-maps-spa.vue, so a bundle that joins or
|
|
* leaves the shelf changes what this gate measures without an edit here.
|
|
*
|
|
* PER BUNDLE, PER ENGINE (mapbox, maplibre), on FOUR surfaces:
|
|
* A its own leaf page
|
|
* B a host page on a DIFFERENT ORIGIN that iframes the leaf, built from the manifest's own
|
|
* embed.iframe snippet; the host's title, URL and scroll must not change
|
|
* C a host page on a different origin that pastes the manifest's own embed.script snippet with
|
|
* the HOST's token and provider filled in. Under maplibre it must make 0 api.mapbox.com
|
|
* requests; under mapbox, where the plugin draws a Mapbox map, a second run with a fake host
|
|
* token must show that token in its tile requests and no other (the host's token is used,
|
|
* not one baked into the bundle). A MapLibre-only plugin takes no token: reported n/a
|
|
* D its tab inside the Research Gallery
|
|
* B and C test exactly what a partner pastes, so a broken snippet fails here too.
|
|
* Every surface with a map also gets the PAINT arm (after gospel's check-gospel-map-paints):
|
|
* distinct colours read off the map's own canvas (floor 40) and the map's height over the plugin
|
|
* element's (floor 70%). Feature counts cannot see a white rectangle; these two can. Each has its
|
|
* own self-test poison and must be the arm that catches it: 'blank' (every layer's opacity 0,
|
|
* every feature still "drawn") and 'collapse' (the container squeezed to 300px).
|
|
* Drawn counts are read SETTLED: equal on two consecutive polls, never the first non-zero read.
|
|
* A surface passes when:
|
|
* - the element mounted with content (its shadow tree has real nodes),
|
|
* - 0 page errors and 0 failed requests (4xx/5xx; Mapbox telemetry and favicons excluded),
|
|
* - no loading text is left on screen (Loading / Adding / Computing),
|
|
* - and, for every MAP on the page: its 'load' fired, and it DRAWS its own data, meaning at
|
|
* least one rendered feature on a layer fed by a GeoJSON source. That is the lesson from the
|
|
* PPLR check: 'load' alone is not loaded, and an empty GeoJSON source still counts as a
|
|
* source.
|
|
* Maps are found without touching any bundle: an init script wraps the engine's Map class as the
|
|
* engine script defines it, so every map the page constructs is recorded.
|
|
*
|
|
* IDENTITY: the gate serves THIS checkout's public/ itself, on a port the OS hands out, so it
|
|
* cannot grade another worktree's tree (the fixed-port trap internal/_serves-this-tree.mjs names).
|
|
*
|
|
* SELF-TEST (--self-test, and always first unless --no-self-test): the first shelf bundle's script
|
|
* is replaced in flight by one that throws. That bundle MUST fail on both surfaces; if it does not,
|
|
* the gate is blind and exits 3 before grading anything.
|
|
*
|
|
* Usage: node internal/check-experimental-shelf.mjs [--engines mapbox,maplibre] [--only a,b]
|
|
* [--no-self-test] [--self-test]
|
|
* Exit: 0 all pass · 1 a bundle failed · 3 self-test could not see a broken bundle · 2 setup.
|
|
* Run browser gates through internal/browser-slot.sh.
|
|
*/
|
|
import { readFileSync, existsSync } from 'node:fs'
|
|
import { resolve, dirname } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { spawn } from 'node:child_process'
|
|
import { createServer } from 'node:net'
|
|
import { createServer as createHttpServer } from 'node:http'
|
|
import { TREE_NAME } from './_tree-name.mjs'
|
|
|
|
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
|
|
const argv = process.argv.slice(2)
|
|
const arg = (n, d) => { const i = argv.indexOf(n); return i >= 0 && argv[i + 1] ? argv[i + 1] : d }
|
|
const ENGINES = arg('--engines', 'mapbox,maplibre').split(',')
|
|
const ONLY = arg('--only', '') ? arg('--only', '').split(',') : null
|
|
// --surfaces A,B,C,D (default all). The full shelf is ~60 page loads, ~20 min under SwiftShader:
|
|
// run it with BROWSER_MAX_HOLD raised, or split it by --only / --surfaces.
|
|
const SURFACES = arg('--surfaces', 'A,B,C,D').split(',')
|
|
const SELF_TEST = !argv.includes('--no-self-test')
|
|
const WAIT_MS = Number(process.env.SHELF_WAIT_MS || 75000)
|
|
// the PAINT arm (after gospel's check-gospel-map-paints, 0574fe7f): every assertion above counts
|
|
// FEATURES, and queryRenderedFeatures answers happily over a white rectangle. These two look.
|
|
const MIN_COLOURS = Number(process.env.MIN_MAP_COLOURS || 40)
|
|
const MIN_FILL = Number(process.env.MIN_MAP_FILL || 0.7)
|
|
|
|
// Through the slot guard like every repo browser gate (it imported node_modules/playwright by path and so
|
|
// launched outside the slot; upg100 measured it).
|
|
const { chromium } = await import('./lib/playwright-guarded.mjs')
|
|
const manifest = JSON.parse(readFileSync(resolve(ROOT, `public/${TREE_NAME}/manifest.json`), 'utf8'))
|
|
const spa = readFileSync(resolve(ROOT, 'plugin-designs/doxa-maps-spa/doxa-maps-spa.vue'), 'utf8')
|
|
const cfg = JSON.parse(readFileSync(resolve(ROOT, 'vite.doxa-maps-build-config.json'), 'utf8'))
|
|
const TK = process.env.MAPBOX_TOKEN || cfg.token || ''
|
|
|
|
// ── the shelf, derived from the Gallery's own rules ───────────────────────────
|
|
const notExp = new Set((spa.match(/const NOT_EXPERIMENTAL = new Set\(\[([\s\S]*?)\]\)/) || [, ''])[1].match(/'([a-z0-9-]+)'/g)?.map(s => s.slice(1, -1)) || [])
|
|
const curated = new Set([...spa.matchAll(/bundle:\s*'([a-z0-9-]+)'/g)].map(m => m[1]))
|
|
if (!notExp.size || !curated.size) { console.error('check-experimental-shelf: could not read NOT_EXPERIMENTAL / curated tabs from doxa-maps-spa.vue'); process.exit(2) }
|
|
const shelf = manifest.bundles
|
|
.filter(b => !notExp.has(b.bundle) && !curated.has(b.bundle) && (b.profiles || []).length)
|
|
.filter(b => !ONLY || ONLY.includes(b.bundle))
|
|
.map(b => {
|
|
// the entry profile the Gallery opens: a map profile, else the one named like the bundle, else the first
|
|
const p = b.profiles.find(x => x.isMap) || b.profiles.find(x => x.profile === b.bundle) || b.profiles[0]
|
|
return { bundle: b.bundle, profile: p.profile, isMap: !!p.isMap, tag: p.element || (b.elements || [])[0] || b.bundle }
|
|
})
|
|
if (!shelf.length) { console.error('check-experimental-shelf: the shelf is empty'); process.exit(2) }
|
|
|
|
// ── SEEDS: bundles whose data is the USER'S, so a fresh browser correctly shows none ─────────
|
|
// Seeded before load, then required to be DRAWN, which is stronger than exempting them. Printed on
|
|
// every run with the reason, so a seed can never quietly hide a regression.
|
|
const SEED = {
|
|
'prayer-walk-planner': {
|
|
why: 'walk zones are user-drawn and kept in localStorage; a fresh browser has none, so one known zone is seeded and must be drawn',
|
|
keyPrefix: 'prayer-walk-planner:v1:',
|
|
value: JSON.stringify([{ id: 'shelf-seed', title: 'Shelf check zone', coords: [[0, 10], [20, 10], [20, 25], [0, 25]] }]),
|
|
},
|
|
}
|
|
|
|
// ── our own server, on a port nobody else can be holding ──────────────────────
|
|
const port = await new Promise(ok => { const s = createServer().listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => ok(p)) }) })
|
|
const srv = spawn(process.execPath, [resolve(ROOT, 'internal/serve-strict.mjs'), '--port', String(port), '--directory', 'public'], { cwd: ROOT, stdio: 'ignore' })
|
|
const reap = () => { try { srv.kill() } catch (_) {} }
|
|
process.on('exit', reap); for (const s of ['SIGINT', 'SIGTERM']) process.on(s, () => { reap(); process.exit(130) })
|
|
const BASE = `http://127.0.0.1:${port}/${TREE_NAME}`
|
|
for (let i = 0; i < 40; i++) { try { if ((await fetch(BASE + '/manifest.json')).ok) break } catch (_) {} await new Promise(r => setTimeout(r, 250)) }
|
|
|
|
// ── the PARTNER: a host site on a different origin (localhost vs 127.0.0.1) ────────────────
|
|
// Its pages are built from the manifest's own embed snippets, placeholders filled the way the
|
|
// snippet's comments tell a partner to.
|
|
const byBundle = Object.fromEntries(manifest.bundles.map(x => [x.bundle, x]))
|
|
const snippet = (bundle, profile, kind) => ((byBundle[bundle].profiles.find(x => x.profile === profile) || {}).embed || {})[kind] || ''
|
|
function hostPage(kind, s, eng, token) {
|
|
let body
|
|
if (kind === 'B') {
|
|
const leafUrl = `${BASE}/${s.bundle}/${s.profile}/index.html?provider=${eng}` + (eng === 'mapbox' ? `&tk=${token}` : '')
|
|
body = snippet(s.bundle, s.profile, 'iframe').replace(/src="[^"]*"/, `src="${leafUrl}&utm_source=shelf"`).replace(/height="\d+"/, 'height="720"')
|
|
} else {
|
|
body = snippet(s.bundle, s.profile, 'script')
|
|
.replaceAll('src="./', `src="${BASE}/`).replaceAll('href="./', `href="${BASE}/`)
|
|
.replaceAll('YOUR_MAPBOX_TOKEN', token).replaceAll('YOUR_SOURCE', 'shelf').replaceAll('YOUR_TREE_URL', BASE)
|
|
if (eng === 'maplibre') body = body.replace(/<!--[^>]*(?:remove this line|this line must go)[^>]*-->\s*<link[^>]*>\s*/i, '')
|
|
.replace(/profile-config='\{/, `profile-config='{"provider":"maplibre",`)
|
|
}
|
|
return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>PARTNER ${kind}</title>
|
|
<style>body{margin:0;font:14px sans-serif}header{height:64px;background:#eee;padding:8px}main>*{display:block;width:100%;height:720px;position:relative}</style></head>
|
|
<body><header>A partner's own site</header><main>${body}</main></body></html>`
|
|
}
|
|
const FAKE_TK = 'pk.SHELFHOSTTOKEN' + 'x'.repeat(20)
|
|
const hostSrv = createHttpServer((req, res) => {
|
|
const m = req.url.match(/^\/(B|C)\/([a-z0-9-]+)\/(mapbox|maplibre)(\/fake)?/)
|
|
const s = m && shelf.find(x => x.bundle === m[2])
|
|
if (!s) { res.writeHead(404); return res.end('no') }
|
|
res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
|
|
res.end(hostPage(m[1], s, m[3], m[4] ? FAKE_TK : TK))
|
|
})
|
|
const hostPort = await new Promise(ok => hostSrv.listen(0, '127.0.0.1', () => ok(hostSrv.address().port)))
|
|
const HOST = `http://localhost:${hostPort}`
|
|
process.on('exit', () => { try { hostSrv.close() } catch (_) {} })
|
|
|
|
// ── every Map the page builds, recorded without touching the bundle ───────────
|
|
const RECORD_MAPS = () => {
|
|
window.__shelfMaps = []
|
|
for (const name of ['mapboxgl', 'maplibregl']) {
|
|
let v
|
|
Object.defineProperty(window, name, {
|
|
configurable: true,
|
|
get() { return v },
|
|
set(val) {
|
|
if (val && val.Map && !val.Map.__shelfWrapped) {
|
|
const Orig = val.Map
|
|
class Recorded extends Orig { constructor(...a) { super(...a); window.__shelfMaps.push(this); this.once('load', () => { this.__shelfLoaded = true }) } }
|
|
Recorded.__shelfWrapped = true
|
|
try { val.Map = Recorded } catch (_) { try { Object.defineProperty(val, 'Map', { value: Recorded }) } catch (_) {} }
|
|
}
|
|
v = val
|
|
},
|
|
})
|
|
}
|
|
}
|
|
const PROBE = (tag) => `(() => {
|
|
const acc = []; const w = (r) => { for (const el of r.querySelectorAll('*')) { acc.push(el); if (el.shadowRoot) w(el.shadowRoot) } }; w(document)
|
|
// CONTENT is the plugin's own subtree, not the page: a small card on a bare leaf and a card inside the
|
|
// Gallery's chrome must be judged the same way.
|
|
const host = acc.find(e => e.tagName === ${JSON.stringify('__TAG__')}.toUpperCase())
|
|
let own = 0, sized = false
|
|
if (host) { const inner = []; const w2 = (r) => { for (const el of r.querySelectorAll('*')) { inner.push(el); if (el.shadowRoot) w2(el.shadowRoot) } }; w2(host.shadowRoot || host); own = inner.length
|
|
const hr = host.getBoundingClientRect(); sized = hr.width > 100 && hr.height > 100 }
|
|
const busy = acc.filter(e => e.children.length === 0 && /Loading|Adding|Computing/i.test(e.textContent || '') && e.getBoundingClientRect().height > 0).length
|
|
const maps = (window.__shelfMaps || []).filter(m => { try { return m.getContainer() && m.getContainer().isConnected } catch (_) { return false } }).map(m => {
|
|
let drawn = 0, geo = 0
|
|
try {
|
|
const st = m.getStyle(); const srcs = st.sources || {}
|
|
const geoIds = Object.keys(srcs).filter(k => srcs[k].type === 'geojson'); geo = geoIds.length
|
|
const layers = (st.layers || []).filter(l => geoIds.includes(l.source)).map(l => l.id)
|
|
if (layers.length) drawn = m.queryRenderedFeatures({ layers }).length
|
|
} catch (_) {}
|
|
return { loaded: !!(m.__shelfLoaded || (m.isStyleLoaded && m.isStyleLoaded())), geo, drawn, mapbox: !!(window.mapboxgl && m instanceof window.mapboxgl.Map) }
|
|
})
|
|
return { own, sized, host: !!host, busy, maps }
|
|
})()`.replace('__TAG__', tag)
|
|
|
|
// ── PAINT: does each map put pixels on the screen, and does it fill its plugin? ───────────────
|
|
// COLOURS are read off the map's OWN WebGL canvas inside its 'render' event (the drawing buffer is
|
|
// still intact there), so a legend or panel floating over the map cannot inflate the count, and
|
|
// no per-plugin clip rectangle is needed. A basemap with land, water, borders and data has hundreds
|
|
// of colours; a blank map has one. FILL is the map's height over the PLUGIN ELEMENT's height, not
|
|
// canvas over container: in gospel's incident a stylesheet collapsed the container and the canvas
|
|
// followed it, so canvas/container stayed 1.0 over a 300px strip in a 900px box.
|
|
// POISON (self-test only): 'blank' zeroes every layer's opacity (the map is white and every
|
|
// feature still counts as drawn); 'collapse' squeezes the container to 300px (the real incident).
|
|
const PAINT = (tag, poison) => `(async () => {
|
|
const acc = []; const w = (r) => { for (const el of r.querySelectorAll('*')) { acc.push(el); if (el.shadowRoot) w(el.shadowRoot) } }; w(document)
|
|
const host = acc.find(e => e.tagName === ${JSON.stringify('__TAG__')}.toUpperCase())
|
|
const hb = host ? host.getBoundingClientRect() : null
|
|
const maps = (window.__shelfMaps || []).filter(m => { try { return m.getContainer() && m.getContainer().isConnected } catch (_) { return false } })
|
|
const poison = ${JSON.stringify('__POISON__')}
|
|
const OPACITY = { background: ['background-opacity'], fill: ['fill-opacity'], line: ['line-opacity'], circle: ['circle-opacity', 'circle-stroke-opacity'], symbol: ['text-opacity', 'icon-opacity'], raster: ['raster-opacity'], 'fill-extrusion': ['fill-extrusion-opacity'], heatmap: ['heatmap-opacity'] }
|
|
for (const m of maps) {
|
|
if (poison === 'blank') for (const l of (m.getStyle().layers || [])) for (const k of (OPACITY[l.type] || [])) { try { m.setPaintProperty(l.id, k, 0) } catch (_) {} }
|
|
if (poison === 'collapse') { const c = m.getContainer(); c.style.position = 'relative'; c.style.inset = 'auto'; c.style.height = '300px'; c.style.flex = 'none'; m.resize() }
|
|
}
|
|
if (poison) await new Promise(r => setTimeout(r, 1200))
|
|
const out = []
|
|
for (const m of maps) {
|
|
const cb = m.getContainer().getBoundingClientRect()
|
|
const colours = await new Promise(res => {
|
|
const t = setTimeout(() => res(-1), 8000)
|
|
m.once('render', () => { clearTimeout(t); try {
|
|
const cv = m.getCanvas(), W = Math.min(480, cv.width), H = Math.max(1, Math.round(cv.height * W / cv.width))
|
|
const c = document.createElement('canvas'); c.width = W; c.height = H; const x = c.getContext('2d'); x.drawImage(cv, 0, 0, W, H)
|
|
const d = x.getImageData(0, 0, W, H).data, seen = new Set()
|
|
for (let i = 0; i < d.length; i += 4) seen.add(((d[i] >> 3) << 11) | ((d[i + 1] >> 3) << 6) | ((d[i + 2] >> 3) << 1) | (d[i + 3] > 127 ? 1 : 0))
|
|
res(seen.size)
|
|
} catch (_) { res(-2) } })
|
|
m.triggerRepaint()
|
|
})
|
|
let drawn = 0
|
|
try { const st = m.getStyle(), srcs = st.sources || {}, geo = Object.keys(srcs).filter(k => srcs[k].type === 'geojson'); const layers = (st.layers || []).filter(l => geo.includes(l.source)).map(l => l.id); if (layers.length) drawn = m.queryRenderedFeatures({ layers }).length } catch (_) {}
|
|
out.push({ colours, fill: hb && hb.height ? cb.height / hb.height : 0, drawn })
|
|
}
|
|
return out
|
|
})()`.replace('__TAG__', tag).replace('__POISON__', poison || '')
|
|
|
|
const b = await chromium.launch({ headless: true, args: ['--use-gl=swiftshader', '--enable-unsafe-swiftshader', '--ignore-gpu-blocklist', '--enable-webgl', '--no-sandbox'] })
|
|
|
|
async function measure(url, s, poisonBundle, opts = {}) {
|
|
const p = await b.newPage({ viewport: { width: 1280, height: 800 } })
|
|
await p.addInitScript(RECORD_MAPS)
|
|
const seed = SEED[s.bundle]
|
|
if (seed) await p.addInitScript(({ keyPrefix, value }) => {
|
|
const get = Storage.prototype.getItem
|
|
Storage.prototype.getItem = function (k) { const v = get.call(this, k); return (v == null && String(k).startsWith(keyPrefix)) ? value : v }
|
|
}, seed)
|
|
if (poisonBundle) await p.route(new RegExp(`/${poisonBundle}/${poisonBundle}\\.js(\\?|$)`), r => r.fulfill({ status: 200, contentType: 'text/javascript', body: 'throw new Error("shelf self-test: deliberately broken bundle")' }))
|
|
const errs = [], fails = [], mapboxReqs = [], tokens = new Set()
|
|
p.on('request', r => { const u = r.url(); if (/api\.mapbox\.com/.test(u)) mapboxReqs.push(u.replace(/\?.*/, '').slice(-60)); const t = u.match(/access_token=([^&]+)/); if (t) tokens.add(t[1]) })
|
|
p.on('pageerror', e => errs.push(e.message.slice(0, 140)))
|
|
p.on('response', r => { if (r.status() >= 400 && !/events\.mapbox\.com|favicon/.test(r.url())) fails.push(r.status() + ' ' + r.url().replace(/\?.*/, '').slice(-80)) })
|
|
await p.goto(url)
|
|
const host0 = opts.frame ? await p.evaluate(() => ({ title: document.title, href: location.href, y: scrollY })) : null
|
|
// B: the plugin lives in the iframe whose document comes from the tree
|
|
const ctx = () => (opts.frame ? p.frames().find(f => f.url().startsWith(BASE)) : p.mainFrame()) || p.mainFrame()
|
|
let st = null, prevDrawn = ''
|
|
const t0 = Date.now()
|
|
// provenance needs one tile request, not a drawn map: a fake token cannot draw anything
|
|
while (Date.now() - t0 < (opts.provenanceOnly ? Math.min(WAIT_MS, 25000) : WAIT_MS)) {
|
|
await p.waitForTimeout(2500)
|
|
try { st = await ctx().evaluate(PROBE(s.tag)) } catch (_) { st = null; continue }
|
|
// SETTLED, not first-non-zero: the drawn counts must hold across two polls, or a count read
|
|
// mid-fit (1752 of 2107 while tiles were still arriving) passes as the answer
|
|
const drawnNow = st.maps.map(m => m.drawn).join(','), steady = drawnNow === prevDrawn; prevDrawn = drawnNow
|
|
const mapsReady = st.maps.every(m => m.loaded && m.drawn > 0) && steady
|
|
if (opts.provenanceOnly ? tokens.has(FAKE_TK) : (st.own > 8 && st.sized && st.busy === 0 && mapsReady && Date.now() - t0 > 6000)) break
|
|
}
|
|
const host1 = opts.frame ? await p.evaluate(() => ({ title: document.title, href: location.href, y: scrollY })) : null
|
|
let paint = []
|
|
if (!opts.provenanceOnly && st && st.maps.length) { try { paint = await ctx().evaluate(PAINT(s.tag, opts.poisonPaint)) } catch (e) { paint = [{ colours: -3, fill: 0, drawn: 0 }] } }
|
|
await p.close()
|
|
if (opts.provenanceOnly) {
|
|
// C provenance: with a FAKE host token the tiles cannot load, so only one thing is asserted:
|
|
// the requests carry the HOST's token, not a token baked into the bundle.
|
|
const used = tokens.has(FAKE_TK), baked = [...tokens].filter(t => t !== FAKE_TK)
|
|
return { pass: used && !baked.length, why: used ? (baked.length ? [`a token other than the host's was also used (${baked[0].slice(0, 14)}…)`] : []) : ['the host token never reached a tile request'], maps: 0 }
|
|
}
|
|
const why = []
|
|
if (!st || !st.host) why.push(`<${s.tag}> never appeared`)
|
|
else if (st.own <= 8 || !st.sized) why.push(`<${s.tag}> mounted empty (${st.own} node(s)${st.sized ? '' : ', not sized'})`)
|
|
if (st && st.busy) why.push(`${st.busy} loading label(s) left`)
|
|
if (st) st.maps.forEach((m, i) => { if (!m.loaded) why.push(`map ${i + 1}: 'load' never fired`); else if (!m.drawn) why.push(`map ${i + 1}: no own data drawn (${m.geo} geojson source(s))`) })
|
|
paint.forEach((q, i) => {
|
|
if (q.colours < 0) why.push(`map ${i + 1}: could not read its pixels (${q.colours})`)
|
|
else if (q.colours < MIN_COLOURS) why.push(`map ${i + 1}: only ${q.colours} colour(s) on its canvas, a blank map (floor ${MIN_COLOURS})${q.drawn ? `, while ${q.drawn} features still count as drawn` : ''}`)
|
|
if (q.fill < MIN_FILL) why.push(`map ${i + 1}: fills ${Math.round(q.fill * 100)}% of <${s.tag}>'s height, collapsed (floor ${Math.round(MIN_FILL * 100)}%)`)
|
|
})
|
|
if (host0 && host1 && (host0.title !== host1.title || host0.href !== host1.href || host0.y !== host1.y)) why.push(`the host page changed (title/URL/scroll): ${JSON.stringify(host0)} -> ${JSON.stringify(host1)}`)
|
|
if (opts.noMapbox && mapboxReqs.length) why.push(`${mapboxReqs.length} api.mapbox.com request(s) under maplibre, e.g. ${mapboxReqs[0]}`)
|
|
if (errs.length) why.push(`page error: ${errs[0]}`)
|
|
if (fails.length) why.push(`failed request: ${fails[0]}`)
|
|
return { pass: !why.length, why, maps: st ? st.maps.length : 0, paint, drawn: st ? st.maps.map(m => m.drawn) : [], mapboxMaps: st ? st.maps.filter(m => m.mapbox).length : 0 }
|
|
}
|
|
|
|
const leaf = (s, eng) => `${BASE}/${s.bundle}/${s.profile}/index.html?provider=${eng}` + (eng === 'mapbox' ? `&tk=${TK}` : '')
|
|
const gallery = (s, eng) => `${BASE}/doxa-maps-spa/doxa-maps-spa/index.html?tab=${s.bundle}&provider=${eng}` + (eng === 'mapbox' ? `&tk=${TK}` : '')
|
|
|
|
let exit = 0
|
|
try {
|
|
if (SELF_TEST) {
|
|
const s = shelf[0]
|
|
const a = await measure(leaf(s, 'maplibre'), s, s.bundle), d = await measure(gallery(s, 'maplibre'), s, s.bundle)
|
|
const c = await measure(`${HOST}/C/${s.bundle}/maplibre`, s, s.bundle, { noMapbox: true })
|
|
if (a.pass || d.pass || c.pass) { console.error(`SELF-TEST FAILED: a deliberately broken ${s.bundle} still passed (${a.pass ? 'leaf ' : ''}${d.pass ? 'gallery ' : ''}${c.pass ? 'script-embed' : ''}). This gate cannot see a broken bundle.`); exit = 3 }
|
|
else console.log(`self-test: a deliberately broken ${s.bundle} fails as it must (leaf: ${a.why[0]}; script-embed: ${c.why[0]}; gallery: ${d.why[0]})`)
|
|
// each PAINT arm gets its own poison and must be the arm that catches it: a collapse caught
|
|
// only by the colour floor (or a blank map caught only by fill) proves nothing about the other
|
|
const sm = shelf.find(x => x.isMap)
|
|
if (sm) for (const [poison, arm] of [['blank', /colour\(s\) on its canvas/], ['collapse', /of <.*>'s height, collapsed/]]) {
|
|
const r = await measure(leaf(sm, 'maplibre'), sm, null, { poisonPaint: poison })
|
|
if (!r.why.some(w => arm.test(w))) { console.error(`SELF-TEST FAILED: a ${poison} ${sm.bundle} map was not caught by its own arm (${r.pass ? 'it passed' : r.why.join('; ')}). This gate cannot see a ${poison} map.`); exit = 3 }
|
|
else console.log(`self-test: a ${poison} ${sm.bundle} map fails as it must (${r.why.find(w => arm.test(w))})`)
|
|
}
|
|
}
|
|
if (exit !== 3) {
|
|
for (const [k, v] of Object.entries(SEED)) if (shelf.some(s => s.bundle === k)) console.log(`SEEDED ${k}: ${v.why}`)
|
|
console.log(`EXPERIMENTAL SHELF — ${shelf.length} bundle(s): ${shelf.map(s => s.bundle).join(', ')} · engines: ${ENGINES.join(', ')}`)
|
|
// B does NOT assert 0 api.mapbox.com: the iframe loads the LEAF page, and every generated leaf
|
|
// <head> links Mapbox's JS/CSS statically whatever the provider (generate-tree's template).
|
|
// That is a fleet-wide leaf property, reported separately; C is where a partner chooses.
|
|
const row = (r, s, eng, surf, t0) => {
|
|
if (!r.pass) exit = 1
|
|
console.log(`${r.pass ? 'PASS' : 'FAIL'} ${s.bundle.padEnd(24)} ${eng.padEnd(9)} ${surf.padEnd(10)} ${(r.maps ? r.maps + ' map(s)' : 'no map').padEnd(9)} ${(r.paint && r.paint.length ? r.paint.map(q => `${q.colours}c ${Math.round(q.fill * 100)}%`).join(' ') : '').padEnd(12)} ${String(Math.round((Date.now() - t0) / 1000)).padStart(3)}s${r.pass ? '' : ' — ' + r.why.join('; ')}`)
|
|
}
|
|
for (const s of shelf) for (const eng of ENGINES) for (const [surf, url, opts] of [
|
|
['A leaf', leaf(s, eng), {}],
|
|
['B iframe', `${HOST}/B/${s.bundle}/${eng}`, { frame: true }],
|
|
['C script', `${HOST}/C/${s.bundle}/${eng}`, { noMapbox: eng === 'maplibre' }],
|
|
['D gallery', gallery(s, eng), {}],
|
|
].filter(x => SURFACES.includes(x[0][0]))) {
|
|
let t0 = Date.now()
|
|
const r = await measure(url, s, null, opts)
|
|
row(r, s, eng, surf, t0)
|
|
// C host-tk: only where the script embed really made a MAPBOX map. A MapLibre-only plugin
|
|
// (prayer-walk-planner) takes no token at all, so there is nothing to prove.
|
|
if (surf === 'C script' && eng === 'mapbox' && r.pass) {
|
|
if (!r.mapboxMaps) { console.log(`n/a ${s.bundle.padEnd(24)} ${eng.padEnd(9)} C host-tk — no Mapbox map on this plugin, it takes no token`); continue }
|
|
t0 = Date.now()
|
|
row(await measure(`${HOST}/C/${s.bundle}/mapbox/fake`, s, null, { provenanceOnly: true }), s, eng, 'C host-tk', t0)
|
|
}
|
|
}
|
|
console.log(exit ? 'EXPERIMENTAL-SHELF: FAIL' : `EXPERIMENTAL-SHELF: PASS — every experimental plugin works ${SURFACES.map(x => ({ A: 'on its own page', B: 'iframed on another site', C: 'script-embedded on another site', D: 'in the Gallery' })[x]).filter(Boolean).join(', ')}, and every map paints, under ${ENGINES.join(' and ')}`)
|
|
}
|
|
} finally { await b.close(); reap() }
|
|
process.exit(exit)
|