v0.24.2

Rewritten

-   Hidden File Sync is now respects the file changes on the storage. Not simply comparing modified times.
    -   This makes hidden file sync more robust and reliable.

Fixed

-   `Scan hidden files before replication` is now configurable again.
-   Some unexpected errors are now handled more gracefully.
-   Meaningless event passing during boot sequence is now prevented.
-   Error handling for non-existing files has been fixed.
-   Hidden files will not be batched to avoid the potential error.
    -   This behaviour had been causing the error in the previous versions in specific situations.
-   The log which checking automatic conflict resolution is now in verbose level.
-   Replication log (skipping non-targetting files) shows the correct information.
-   The dialogue that asking enabling optional feature during `Rebuild Everything` now prevents to show the `overwrite` option.
    -   The rebuilding device is the first, meaningless.
-   Files with different modified time but identical content are no longer processed repeatedly.
-   Some unexpected errors which caused after terminating plug-in are now avoided.
-

Improved

-   JSON files are now more transferred efficiently.
    -   Now the JSON files are transferred in more fine chunks, which makes the transfer more efficient.

src/modules/coreObsidian/ModuleFileAccessObsidian.ts

@@ -120,12 +120,12 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
         }
     }
     statHidden(path: string): Promise<UXStat | null> {
-        return this.vaultAccess.adapterStat(path);
+        return this.vaultAccess.tryAdapterStat(path);
     }
     async removeHidden(path: string): Promise<boolean> {
         try {
             await this.vaultAccess.adapterRemove(path);
-            if (this.vaultAccess.adapterStat(path) !== null) {
+            if (this.vaultAccess.tryAdapterStat(path) !== null) {
                 return false;
             }
             return true;
@@ -145,7 +145,7 @@ export class ModuleFileAccessObsidian extends AbstractObsidianModule implements
         return await this.vaultAccess.adapterReadBinary(path);
     }
     async isExistsIncludeHidden(path: string): Promise<boolean> {
-        return (await this.vaultAccess.adapterStat(path)) !== null;
+        return (await this.vaultAccess.tryAdapterStat(path)) !== null;
     }
     async ensureDir(path: string): Promise<boolean> {
         try {

src/modules/coreObsidian/storageLib/SerializedFileAccess.ts

@@ -42,6 +42,13 @@ export class SerializedFileAccess {
         this.plugin = plugin;
     }
 
+    async tryAdapterStat(file: TFile | string) {
+        const path = file instanceof TFile ? file.path : file;
+        return await processReadFile(file, async () => {
+            if (!(await this.app.vault.adapter.exists(path))) return null;
+            return this.app.vault.adapter.stat(path);
+        });
+    }
     async adapterStat(file: TFile | string) {
         const path = file instanceof TFile ? file.path : file;
         return await processReadFile(file, () => this.app.vault.adapter.stat(path));

src/modules/coreObsidian/storageLib/StorageEventManager.ts

@@ -171,11 +171,13 @@ export class StorageEventManagerObsidian extends StorageEventManager {
             // Folder
             return;
         }
+
         void this.appendQueue(
             [
                 {
                     type: "INTERNAL",
                     file: InternalFileToUXFileInfoStub(path),
+                    skipBatchWait: true, // Internal files should be processed immediately.
                 },
             ],
             null
@@ -212,11 +214,14 @@ export class StorageEventManagerObsidian extends StorageEventManager {
             // Stop cache using to prevent the corruption;
             // let cache: null | string | ArrayBuffer;
             // new file or something changed, cache the changes.
-            if (file instanceof TFile && (type == "CREATE" || type == "CHANGED")) {
-                // Wait for a bit while to let the writer has marked `touched` at the file.
-                await delay(10);
-                if (this.core.storageAccess.recentlyTouched(file)) {
-                    continue;
+            // if (file instanceof TFile && (type == "CREATE" || type == "CHANGED")) {
+            if (file instanceof TFile || !file.isFolder) {
+                if (type == "CREATE" || type == "CHANGED") {
+                    // Wait for a bit while to let the writer has marked `touched` at the file.
+                    await delay(10);
+                    if (this.core.storageAccess.recentlyTouched(file.path)) {
+                        continue;
+                    }
                 }
             }
 
@@ -380,13 +385,11 @@ export class StorageEventManagerObsidian extends StorageEventManager {
         const file = queue.args.file;
         const lockKey = `handleFile:${file.path}`;
         return await serialized(lockKey, async () => {
-            // TODO CHECK
-            const key = `file-last-proc-${queue.type}-${file.path}`;
-            const last = Number((await this.core.kvDB.get(key)) || 0);
             if (queue.type == "INTERNAL" || file.isInternal) {
                 await this.core.$anyProcessOptionalFileEvent(file.path as unknown as FilePath);
             } else {
-                // let mtime = file.stat.mtime;
+                const key = `file-last-proc-${queue.type}-${file.path}`;
+                const last = Number((await this.core.kvDB.get(key)) || 0);
                 if (queue.type == "DELETE") {
                     await this.core.$anyHandlerProcessesFileEvent(queue);
                 } else {

src/modules/coreObsidian/storageLib/utilObsidian.ts

@@ -55,7 +55,7 @@ export async function InternalFileToUXFileInfo(
     prefix: string = ICHeader
 ): Promise<UXFileInfo> {
     const name = fullPath.split("/").pop() as string;
-    const stat = await vaultAccess.adapterStat(fullPath);
+    const stat = await vaultAccess.tryAdapterStat(fullPath);
     if (stat == null) throw new Error(`File not found: ${fullPath}`);
     if (stat.type == "folder") throw new Error(`File not found: ${fullPath}`);
     const file = await vaultAccess.adapterReadAuto(fullPath);