Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

:bug: Initialize maps before all tiles finish loading https://github.com/siyuan-note/siyuan/issues/20129

Danielf65061836efa
diff --git a/app/src/protyle/render/av/map/providers.test.ts b/app/src/protyle/render/av/map/providers.test.ts
index 6a097a7e17..2f68b8db61 100644
--- a/app/src/protyle/render/av/map/providers.test.ts
+++ b/app/src/protyle/render/av/map/providers.test.ts
@@ -59,6 +59,7 @@ const fixture = () => {
const container = {ownerDocument: doc, querySelector: () => attribution,
replaceChildren() { calls.push(["clear"]); }};
return {sdk, calls, instances, container: container as unknown as HTMLElement, attribution, frames, events, documentEvents, doc, scope, rect,
+ ready: () => instances[0].callbacks.get("style.load")(),
load: () => instances[0].callbacks.get("load")(),
advance: (milliseconds: number) => {
now += milliseconds;
@@ -76,6 +77,36 @@ const fixture = () => {
const visibleViewport = {x: 0, y: 0, width: 800, height: 600};
+test("style readiness permits markers before slow tiles finish and preserves full-load attribution timing", () => {
+ const f = fixture();
+ let ready = 0;
+ const adapter = createAVMapAdapter("openfreemap", f.sdk, f.container, {
+ onMarkerClick() {}, onError() { assert.fail("SDK error"); }, onReady() { ready++; },
+ });
+ adapter.setVisible(true, visibleViewport);
+ f.ready();
+ f.ready();
+ assert.equal(ready, 1);
+ adapter.setPoints([{id: "row-1", longitude: 121, latitude: 31}], 1);
+ adapter.fit();
+ assert.deepEqual(f.calls.filter(call => call[0] === "setLngLat"), [["setLngLat", [121, 31]]]);
+ assert.equal(f.calls.filter(call => call[0] === "fitBounds").length, 1);
+ f.advance(30000);
+ assert.equal(f.attribution.open, true, "style readiness does not start the full-map attribution clock");
+ assert.equal(f.calls.some(call => call[0] === "remove"), false);
+ f.load(); f.advance(0); f.advance(4999);
+ assert.equal(f.attribution.open, true);
+ f.advance(1);
+ assert.equal(f.attribution.open, false);
+ const lateReady = f.instances[0].callbacks.get("style.load");
+ const lateLoad = f.instances[0].callbacks.get("load");
+ adapter.destroy();
+ assert.equal(f.instances[0].callbacks.size, 0);
+ lateReady(); lateLoad();
+ assert.equal(ready, 1);
+ assert.equal(f.frames.size, 0);
+});
+
test("OpenFreeMap preserves longitude/latitude, attribution and cleans stale callbacks", () => {
const {sdk, calls, instances, container} = fixture();
const clicked: Array<[string, number]> = [];
@@ -295,8 +326,9 @@ test("only recognized temporary tile HTTP errors after the first load preserve t
onMarkerClick() {}, onError: code => errors.push(code),
});
const error = f.instances[0].callbacks.get("error");
+ f.ready();
error(tileError(status));
- assert.deepEqual(errors, ["mapUnavailable"], "the same failure before load is fatal");
+ assert.deepEqual(errors, ["mapUnavailable"], "style readiness preserves the fatal policy before full load");
f.load();
error(tileError(status));
assert.deepEqual(errors, ["mapUnavailable"]);
diff --git a/app/src/protyle/render/av/map/providers.ts b/app/src/protyle/render/av/map/providers.ts
index 258949acce..cde775240d 100644
--- a/app/src/protyle/render/av/map/providers.ts
+++ b/app/src/protyle/render/av/map/providers.ts
@@ -53,12 +53,18 @@ export const createAVMapAdapter = (provider: AVMapProvider, sdk: any, container:
const map = new sdk.Map({container, style: AV_MAP_OPENFREEMAP_STYLE, center: [0, 0], zoom: 1,
attributionControl: false, trackResize: false});
let attribution: AVMapAttributionController;
- let loaded = false;
+ let ready = false, loaded = false;
const onReady = () => {
+ if (!destroyed && !ready) {
+ ready = true;
+ // 样式初始化后即可接收记录并定位,不等待默认世界视图的全部瓦片。
+ callbacks.onReady?.();
+ }
+ };
+ const onLoad = () => {
if (!destroyed && !loaded) {
loaded = true;
attribution.onReady();
- callbacks.onReady?.();
}
};
const destroy = () => {
@@ -66,7 +72,8 @@ export const createAVMapAdapter = (provider: AVMapProvider, sdk: any, container:
destroyed = true;
try {
attribution?.destroy();
- map.off("load", onReady);
+ map.off("style.load", onReady);
+ map.off("load", onLoad);
map.off("error", error);
cleanMarkers();
points = [];
@@ -81,7 +88,8 @@ export const createAVMapAdapter = (provider: AVMapProvider, sdk: any, container:
try {
attribution = createAVMapAttribution(provider, sdk, map, container, callbacks.onAttributionClick);
map.on("error", error);
- map.on("load", onReady);
+ map.on("style.load", onReady);
+ map.on("load", onLoad);
} catch (error) {
destroy();
throw error;
diff --git a/app/src/protyle/render/av/map/providersLoader.test.ts b/app/src/protyle/render/av/map/providersLoader.test.ts
index e1a853ff96..b31352f777 100644
--- a/app/src/protyle/render/av/map/providersLoader.test.ts
+++ b/app/src/protyle/render/av/map/providersLoader.test.ts
@@ -4,11 +4,13 @@ import {AVMapInit, AVMapLoadError} from "./protocol";
import {loadAVMapAdapter} from "./providersLoader";
import {getAVMapLockedPolicy, prepareAVMapBootstrap} from "./bootstrap";
import {AV_MAP_ASSET_TIMEOUT, AV_MAP_READY_TIMEOUT} from "./loadingBudget";
+import {startAVMapRuntime} from "./hostRuntime";
const fixture = (options: {ready?: boolean; assetFailure?: boolean; scriptFailure?: boolean; missingSDK?: boolean;
mapError?: boolean; controlError?: boolean; manualAssets?: boolean; policyFailure?: boolean} = {}) => {
const requested: any[] = [];
const elements: any[] = [];
+ const mapEvents = new Map<string, () => void>();
let destroyed = 0;
class FakeMap {
constructor() {
@@ -16,15 +18,24 @@ const fixture = (options: {ready?: boolean; assetFailure?: boolean; scriptFailur
if (options.mapError) throw new Error("private error");
}
on(type: string, callback: () => void) {
- if (options.ready !== false && type === "load") queueMicrotask(callback);
+ mapEvents.set(type, callback);
+ if (options.ready !== false && type === "style.load") queueMicrotask(callback);
}
- off() {}
+ off(type: string) { mapEvents.delete(type); }
addControl() { if (options.controlError) throw new Error("private control failure"); }
+ fitBounds(bounds: unknown) { requested.push({bounds}); }
remove() { destroyed++; }
}
const scope: any = {
setTimeout, clearTimeout, cancelAnimationFrame() {},
maplibregl: options.missingSDK ? undefined : {Map: FakeMap, AttributionControl: class {},
+ Marker: class {
+ setLngLat(coordinates: number[]) { requested.push({coordinates}); return this; }
+ addTo() { return this; }
+ getElement() { return {addEventListener() {}, removeEventListener() {}}; }
+ remove() {}
+ },
+ LngLatBounds: class { extend() {} },
setWorkerUrl: (url: string) => requested.push({worker: url})},
fetch: async (url: string, options: unknown) => {
requested.push({url, options});
@@ -49,7 +60,7 @@ const fixture = (options: {ready?: boolean; assetFailure?: boolean; scriptFailur
classList: {toggle() {}}, addEventListener() {}, removeEventListener() {},
querySelector: () => ({}),
})} as unknown as HTMLElement;
- return {scope, requested, elements, container, destroyed: () => destroyed};
+ return {scope, requested, elements, container, mapEvents, destroyed: () => destroyed};
};
const init: AVMapInit = {version: 1, instanceID: "fixture", type: "init", provider: "openfreemap", theme: "light"};
const callbacks = {onMarkerClick() {}, onError() {}};
@@ -138,6 +149,44 @@ const controlledTimers = (scope: any) => {
return pending;
};
+test("style-ready runtime fits records once while slow tiles outlive the old readiness deadline", async () => {
+ const f = fixture({ready: false});
+ const timers = controlledTimers(f.scope);
+ const signal = new AbortController().signal;
+ await prepareAVMapBootstrap(f.scope, "openfreemap", signal);
+ const replies: any[] = [];
+ const port = {onmessage: null as any, postMessage: (value: unknown) => replies.push(value), start() {}, close() {}};
+ const stop = startAVMapRuntime(port as unknown as MessagePort, init.instanceID, init.provider, f.container);
+ const send = (command: object) => port.onmessage({data: {...init, ...command}});
+ try {
+ const pending = send(init);
+ assert.equal(replies.length, 0);
+ const deadline = [...timers.values()].find(timer => timer.delay === AV_MAP_READY_TIMEOUT);
+ assert.ok(deadline);
+ f.mapEvents.get("style.load")();
+ await pending;
+ assert.deepEqual(replies, [{version: 1, instanceID: init.instanceID, type: "ready"}]);
+ assert.equal(timers.size, 0, "slow tiles no longer retain the adapter readiness timer");
+ const point = {id: "row-1", longitude: 121, latitude: 31};
+ await send({type: "setPoints", revision: 1, points: [point]});
+ await send({type: "setPoints", revision: 2, points: [{...point, id: "row-2"}]});
+ assert.deepEqual(f.requested.filter(request => request.coordinates).map(request => request.coordinates), [[121, 31], [121, 31]]);
+ assert.equal(f.requested.filter(request => request.bounds).length, 1, "the first points fit before any full-load event");
+ // 即使过期计时回调已经入队,也不能销毁已能接收记录的地图。
+ deadline.callback();
+ assert.equal(f.destroyed(), 0);
+ f.mapEvents.get("load")();
+ await flush();
+ assert.equal(f.destroyed(), 0);
+ assert.equal(replies.length, 1);
+ assert.equal(f.requested.filter(request => request.bounds).length, 1);
+ } finally {
+ stop();
+ }
+ assert.equal(f.destroyed(), 1);
+ assert.equal(f.mapEvents.size, 0);
+});
+
test("each packaged asset is bounded and CSP cannot lock before the worker body finishes", async () => {
const f = fixture({manualAssets: true});
const timers = controlledTimers(f.scope);
diff --git a/app/tests/mapAttribution.test.js b/app/tests/mapAttribution.test.js
index dcf707125a..e165435954 100644
--- a/app/tests/mapAttribution.test.js
+++ b/app/tests/mapAttribution.test.js
@@ -78,6 +78,8 @@ const verifyTileHTTP = async (win, sources, css, sdk) => {
const png = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAADUlEQVQImWOoWHDiPwAGVALgQhC29AAAAABJRU5ErkJggg==", "base64");
let failNextTile = false;
let failedTiles = 0;
+ let holdTiles = true;
+ const pendingTiles = [];
const server = http.createServer((request, response) => {
if (request.url === "/") {
response.setHeader("Content-Type", "text/html");
@@ -91,8 +93,12 @@ const verifyTileHTTP = async (win, sources, css, sdk) => {
failedTiles++;
response.writeHead(503).end("Temporary fixture failure");
} else {
- response.setHeader("Content-Type", "image/png");
- response.end(png);
+ const sendTile = () => {
+ response.setHeader("Content-Type", "image/png");
+ response.end(png);
+ };
+ if (holdTiles) pendingTiles.push(sendTile);
+ else sendTile();
}
} else {
response.writeHead(404).end();
@@ -122,10 +128,10 @@ const verifyTileHTTP = async (win, sources, css, sdk) => {
}
const sdk = window.maplibregl;
sdk.setWorkerUrl(origin + "/worker.js");
- window.tileHTTP = {errors: [], removed: 0, tileError: null};
+ window.tileHTTP = {errors: [], removed: 0, tileError: null, ready: false, loaded: false};
class FixtureMap extends sdk.Map {
constructor(options) {
- super({...options, style: {version: 8, sources: {fixture: {type: "raster", tileSize: 256,
+ super({...options, preserveDrawingBuffer: true, style: {version: 8, sources: {fixture: {type: "raster", tileSize: 256,
tiles: [origin + "/tile/{z}/{x}/{y}.png"], minzoom: 0, maxzoom: 6, attribution: "Fixture data"}},
layers: [{id: "fixture", type: "raster", source: "fixture"}]}});
window.tileMap = this;
@@ -133,11 +139,16 @@ const verifyTileHTTP = async (win, sources, css, sdk) => {
window.tileHTTP.tileError = {status: event.error?.status, sourceId: event.sourceId,
state: event.tile?.state, canonical: event.tile?.tileID?.canonical};
});
+ this.on("load", () => { window.tileHTTP.loaded = true; });
}
remove() { window.tileHTTP.removed++; super.remove(); }
}
window.tileAdapter = modules.providers.createAVMapAdapter("openfreemap", {...sdk, Map: FixtureMap},
- document.getElementById("map"), {onMarkerClick() {}, onReady() { clearTimeout(timer); resolve(); },
+ document.getElementById("map"), {onMarkerClick() {}, onReady() {
+ window.tileHTTP.ready = true;
+ clearTimeout(timer);
+ resolve();
+ },
onError(code) {
window.tileHTTP.errors.push(code);
window.tileAdapter?.destroy();
@@ -147,6 +158,30 @@ const verifyTileHTTP = async (win, sources, css, sdk) => {
});
await win.webContents.executeJavaScript(`(${installRealMap.toString()})(${JSON.stringify(sources)},
${JSON.stringify(css)}, ${JSON.stringify(origin)})`);
+ assert.equal(await win.webContents.executeJavaScript("tileHTTP.ready"), true);
+ assert.equal(await win.webContents.executeJavaScript("tileHTTP.loaded"), false);
+ await win.webContents.executeJavaScript("tileAdapter.setPoints([{id:'fixture', longitude:121, latitude:31}],1); tileAdapter.fit(); void 0");
+ assert.equal(await win.webContents.executeJavaScript("document.querySelectorAll('.maplibregl-marker').length"), 1);
+ // 真实网络瓦片延迟超过原有 20 秒就绪期限;记录和相机已经可以使用。
+ await new Promise(resolve => setTimeout(resolve, 21000));
+ assert.ok(pendingTiles.length > 0);
+ assert.deepEqual(await win.webContents.executeJavaScript("({ready:tileHTTP.ready,loaded:tileHTTP.loaded,removed:tileHTTP.removed,errors:tileHTTP.errors})"),
+ {ready: true, loaded: false, removed: 0, errors: []});
+ holdTiles = false;
+ pendingTiles.splice(0).forEach(sendTile => sendTile());
+ const loadDeadline = Date.now() + 10000;
+ while (!await win.webContents.executeJavaScript("tileHTTP.loaded") && Date.now() < loadDeadline) {
+ await new Promise(resolve => setTimeout(resolve, 50));
+ }
+ assert.equal(await win.webContents.executeJavaScript("tileHTTP.loaded"), true, "delayed tiles eventually finish rendering");
+ const pixel = await win.webContents.executeJavaScript(`(() => {
+ const canvas = tileMap.getCanvas();
+ const gl = canvas.getContext("webgl2");
+ const pixel = new Uint8Array(4);
+ gl.readPixels(Math.floor(canvas.width / 2), Math.floor(canvas.height / 2), 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+ return Array.from(pixel);
+ })()`);
+ assert.ok(pixel[3] > 0, "the real WebGL canvas paints the delayed raster tile");
failNextTile = true;
await win.webContents.executeJavaScript("tileMap.setZoom(3); void 0");
const deadline = Date.now() + 10000;