New feature:

- Now we are ready for i18n.
- The setting dialogue has been refined. Very controllable, clearly displayed disabled items, and ready to i18n.
Fixed:
- Many memory leaks have been rescued.
- Chunk caches now work well.
- Many trivial but potential bugs are fixed.
- No longer error messages will be shown on retrieving checkpoint or server information.
- Now we can check and correct tweak mismatch during the setup
Improved:
- Customisation synchronisation has got more smoother.
Tidied
- Practically unused functions have been removed or are being prepared for removal.
- Many of the type-errors and lint errors have been corrected.
- Unused files have been removed.
Note:
- From this version, some test files have been included. However, they are not enabled and released in the release build.

src/tests/TestPane.svelte

@@ -0,0 +1,50 @@
+<script lang="ts">
+    import { onDestroy, onMount } from "svelte";
+    import type ObsidianLiveSyncPlugin from "../main";
+    import { perf_trench } from "./tests";
+    import { MarkdownRenderer } from "../deps";
+    export let plugin: ObsidianLiveSyncPlugin;
+    let performanceTestResult = "";
+    let functionCheckResult = "";
+    let testRunning = false;
+    let prefTestResultEl: HTMLDivElement;
+    let isReady = false;
+    $: {
+        if (performanceTestResult != "" && isReady) {
+            MarkdownRenderer.render(plugin.app, performanceTestResult, prefTestResultEl, "/", plugin);
+        }
+    }
+
+    async function performTest() {
+        try {
+            testRunning = true;
+            performanceTestResult = await perf_trench(plugin);
+        } finally {
+            testRunning = false;
+        }
+    }
+    function clearPerfTestResult() {
+        prefTestResultEl.empty();
+    }
+    onMount(() => {
+        isReady = true;
+        // performTest();
+    });
+</script>
+
+<h2>TESTBENCH: Self-hosted LiveSync</h2>
+
+<h3>Function check</h3>
+<pre>{functionCheckResult}</pre>
+
+<h3>Performance test</h3>
+<button on:click={() => performTest()} disabled={testRunning}>Test!</button>
+<button on:click={() => clearPerfTestResult()}>Clear</button>
+
+<div bind:this={prefTestResultEl}></div>
+
+<style>
+    * {
+        box-sizing: border-box;
+    }
+</style>

src/tests/TestPaneView.ts

@@ -0,0 +1,49 @@
+import {
+    ItemView,
+    WorkspaceLeaf
+} from "obsidian";
+import TestPaneComponent from "./TestPane.svelte"
+import type ObsidianLiveSyncPlugin from "../main"
+export const VIEW_TYPE_TEST = "ols-pane-test";
+//Log view
+export class TestPaneView extends ItemView {
+
+    component?: TestPaneComponent;
+    plugin: ObsidianLiveSyncPlugin;
+    icon = "view-log";
+    title: string = "Self-hosted LiveSync Test and Results"
+    navigation = true;
+
+    getIcon(): string {
+        return "view-log";
+    }
+
+    constructor(leaf: WorkspaceLeaf, plugin: ObsidianLiveSyncPlugin) {
+        super(leaf);
+        this.plugin = plugin;
+    }
+
+
+    getViewType() {
+        return VIEW_TYPE_TEST;
+    }
+
+    getDisplayText() {
+        return "Self-hosted LiveSync Test and Results";
+    }
+
+    // eslint-disable-next-line require-await
+    async onOpen() {
+        this.component = new TestPaneComponent({
+            target: this.contentEl,
+            props: {
+                plugin: this.plugin
+            },
+        });
+    }
+
+    // eslint-disable-next-line require-await
+    async onClose() {
+        this.component?.$destroy();
+    }
+}

src/tests/tests.ts

@@ -0,0 +1,70 @@
+import { Trench } from "../lib/src/memory/memutil.ts";
+import type ObsidianLiveSyncPlugin from "../main.ts";
+type MeasureResult = [times: number, spent: number];
+type NamedMeasureResult = [name: string, result: MeasureResult];
+const measures = new Map<string, MeasureResult>();
+
+function clearResult(name: string) {
+    measures.set(name, [0, 0]);
+}
+async function measureEach(name: string, proc: () => (void | Promise<void>)) {
+    const [times, spent] = measures.get(name) ?? [0, 0];
+
+    const start = performance.now();
+    const result = proc();
+    if (result instanceof Promise) await result;
+    const end = performance.now();
+    measures.set(name, [times + 1, spent + (end - start)]);
+
+}
+function formatNumber(num: number) {
+    return num.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+async function measure(name: string, proc: () => (void | Promise<void>), times: number = 10000, duration: number = 1000): Promise<NamedMeasureResult> {
+    const from = Date.now();
+    let last = times;
+    clearResult(name);
+    do {
+        await measureEach(name, proc);
+    } while (last-- > 0 && (Date.now() - from) < duration)
+    return [name, measures.get(name) as MeasureResult];
+}
+
+// eslint-disable-next-line require-await
+async function formatPerfResults(items: NamedMeasureResult[]) {
+    return `| Name | Runs | Each | Total |\n| --- | --- | --- | --- | \n` + items.map(e => `| ${e[0]} | ${e[1][0]} | ${e[1][0] != 0 ? formatNumber(e[1][1] / e[1][0]) : "-"} | ${formatNumber(e[1][0])} |`).join("\n");
+}
+export async function perf_trench(plugin: ObsidianLiveSyncPlugin) {
+    clearResult("trench");
+    const trench = new Trench(plugin.simpleStore);
+    const result = [] as NamedMeasureResult[];
+    result.push(await measure("trench-short-string", async () => {
+        const p = trench.evacuate("string");
+        await p();
+    }));
+    {
+        const testBinary = await plugin.vaultAccess.adapterReadBinary("testdata/10kb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-10kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.vaultAccess.adapterReadBinary("testdata/100kb.jpeg");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-100kb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    {
+        const testBinary = await plugin.vaultAccess.adapterReadBinary("testdata/1mb.png");
+        const uint8Array = new Uint8Array(testBinary);
+        result.push(await measure("trench-binary-1mb", async () => {
+            const p = trench.evacuate(uint8Array);
+            await p();
+        }));
+    }
+    return formatPerfResults(result);
+}