Migration to new Rust-based engine (#401)

* wasm first steps * parsing start * parsing continued * progress * progress * progress * progress * progress * progress * progress * progress * fixes * reorganize * change type * fix * progress * refactoring * progress * progress * progress * keep style info * progress * progress * remove (copy) in name * progress * merge methods into 1 * splice * progress * progress * progress * cleaning * progress * progress * progress * visibility * progress * progress * progress * progress * progress * fixes * progress * fix markers * fix * progress * progress * progress * progress * progress * progress * small fix * use engine info * fix popups * small fix * progress * progress * progress * clean tool * handle self closing elements * reduce data exchanges across boundary * copy on wasm side to avoid any data corruption * speed fix * routing * refactoring * reverse * reverse * crop * split * merge * progress * time tool * fix bounds for waypoints * reduce * fix reactivity * handle corrupt time data * export * progress * remove gpx js package * remove todo * update readme * cleaning * progress * fix link fields * remove unused fields * refactoring and tests * import and export of routes, ref #192 * per-chunk categories storage * cross-tab sync * outdated state * refactoring * reorder methods * refactoring * fix * improve flow * renaming * progress * progress * fix * progress * per file history * keep original flag * use history variant * fix * progress * file explorer * progress * fix * sticky folders * improved sticky folders * fix sortable * fix sortable * fix * fix tab size * no file delete on desktop * fix routing on other file * fix sorting * remember language * open links in browser * commit missing changes * avoid selecting on resize * clarify filename * explorer actions * fix folder styling * drop anywhere in folder * cleaning * fixes * remove focus-ring * full screen * small fix * consistent highlight color * improved preview * performance improvements * sparser data transfers * sparser data transfers * show popup once data is loaded * fix routing control size * fix * sparse desktop build * remove custom ign styles * use new endpoint for openhikingmap * strip native menu * reorder context menu items * route full support * route - track conversion * create route file action * route export, filter out anchors at high zoom level * clarify name handling * move hide & center to view * routes continued * update docs * fix power format, closes #378 * lint fixes * fix display of additional data with gaps, closes #361 * fix linting issues * fix import modules * fix multidrag * change base to resolve * fix type errors * fix layer typings * fix last type error * each keys * improve typings * deploy to cloudflare --------- Co-authored-by: vcoppe <vcoppe@hexaly.com>
2026-11-01 20:19:39 +00:00 · 2026-10-31 18:08:22 +01:00
1 parent 6a0d434371
commit 8fe7d8d64d
@@ -0,0 +1,127 @@
+import { LEGACY_IMPORTED_KEY, readLegacyData } from '$lib/storage/legacy-import';
+import { parseVisibility, VISIBILITY_KEY, type Visibility } from '$lib/engine/file-visibility';
+import type { Outcome, StorageOpened } from 'gpx-wasm';
+import type { Backend } from './backend';
+
+/** Name of the IndexedDB database that keeps the files and the settings. */
+const STORAGE_NAME = 'gpx-studio';
+
+/** Name of the channel that tells the tabs that the files were written. */
+const CHANNEL_NAME = 'gpx-studio-storage';
+
+/** What opening the storage needs of the engine facade. */
+export type StorageHost = {
+    backend: Backend;
+    /** The explicit visibility per file, to fill with the one that was saved. */
+    visibility: Map<string, Visibility>;
+    /** Applies what a call changed to what the facade keeps of the files. */
+    sync(update: Outcome): void;
+    /** Tells that what is stored comes from a newer version of the app: nothing can be saved. */
+    outdated(): void;
+    hasFiles(): boolean;
+    loadFiles(files: { data: Uint8Array; name: string }[]): Promise<boolean>;
+    deselect(): Promise<boolean>;
+};
+
+/**
+ * Keeps the files of the engine as the ones that another tab saved: when a tab writes, the others
+ * are told, and read the storage again if it has changed since they last did, which overwrites
+ * what they hold (see `sync_storage`). The same happens when a write of this tab is refused
+ * because of that, and when the tab is shown again (a hidden tab can miss messages).
+ */
+function followOtherTabs(host: StorageHost): {
+    saved: () => void;
+    behind: () => void;
+    newer: () => void;
+} {
+    const { backend } = host;
+    let reading = Promise.resolve();
+    const refresh = () => {
+        reading = reading
+            .then(async () => host.sync(await backend.sync_storage()))
+            .catch((error) => console.error('The files could not be read again', error));
+    };
+    const channel =
+        typeof BroadcastChannel === 'undefined' ? undefined : new BroadcastChannel(CHANNEL_NAME);
+    if (channel) {
+        channel.onmessage = refresh;
+    }
+    if (typeof document !== 'undefined') {
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                refresh();
+            }
+        });
+    }
+    return {
+        saved: () => channel?.postMessage('saved'),
+        behind: refresh,
+        newer: () => host.outdated(),
+    };
+}
+
+/**
+ * Opens the storage: the files that it holds are put in the engine, and the
+ * changes of the files are kept from then on. Resolves to the settings, as JSON strings by key.
+ *
+ * The first time, what the previous versions of the app kept in the browser is imported.
+ */
+export async function openStoredFiles(host: StorageHost): Promise<Record<string, string>> {
+    const { backend } = host;
+    let opened: StorageOpened;
+    const tabs = followOtherTabs(host);
+    try {
+        opened = await backend.open_storage(STORAGE_NAME, tabs.saved, tabs.behind, tabs.newer);
+    } catch (error) {
+        console.error('The files cannot be kept in this browser', error);
+        return {};
+    }
+    let settings = opened.settings;
+    // what was hidden, which the files that were restored need when they are read
+    parseVisibility(settings[VISIBILITY_KEY]).forEach((visibility, fileId) =>
+        host.visibility.set(fileId, visibility)
+    );
+    host.sync(opened.outcome);
+
+    if (
+        backend.importsLegacyData &&
+        settings[LEGACY_IMPORTED_KEY] === undefined &&
+        !host.hasFiles()
+    ) {
+        settings = { ...settings, ...(await importLegacyData(host)) };
+        await backend.flush_storage();
+    }
+    return settings;
+}
+
+/** Puts the files and the settings of the former database in the engine. */
+async function importLegacyData(host: StorageHost): Promise<Record<string, string>> {
+    const { backend } = host;
+    const imported: Record<string, string> = {};
+    try {
+        const legacy = await readLegacyData();
+        if (legacy) {
+            const encoder = new TextEncoder();
+            if (legacy.files.length > 0) {
+                await host.loadFiles(
+                    legacy.files.map((file) => ({
+                        data: encoder.encode(file.gpx),
+                        name: file.name,
+                    }))
+                );
+                await host.deselect();
+            }
+            for (const [key, value] of Object.entries(legacy.settings)) {
+                await backend.set_setting(key, value);
+                imported[key] = value;
+            }
+        }
+    } catch (error) {
+        // it is tried again next time
+        console.error('The files of the previous version could not be imported', error);
+        return imported;
+    }
+    await backend.set_setting(LEGACY_IMPORTED_KEY, 'true');
+    imported[LEGACY_IMPORTED_KEY] = 'true';
+    return imported;
+}