feat: fs.watch apis for filer and fs access paths

Author: abose

dist/virtualfs.js

@@ -33,7 +33,14 @@ const Constants = {
     MOUNT_POINT_ROOT: '/mnt',
     TAURI_ROOT: "/tauri",
     BINARY_ENCODING: "binary",
-    BYTE_ARRAY_ENCODING: "byte_array"
+    BYTE_ARRAY_ENCODING: "byte_array",
+    WATCH_EVENTS: {
+        ADD_FILE: "add",
+        ADD_DIR: "addDir",
+        CHANGE: "change",
+        UNLINK_FILE: "unlink",
+        UNLINK_DIR: "unlinkDir"
+    }
 };
 
 module.exports ={

dist/virtualfs.js.map

@@ -140,10 +140,15 @@ const fileSystemLib = {
     },
     writeFile: function (...args) { // (path, data, options, callback)
         let path = args[0];
+        let newFileCreated = false;
         function callbackInterceptor(...interceptedArgs) {
             let err = interceptedArgs.length >= 1 ? interceptedArgs[0] : null;
             if(!err){
-                FsWatch.reportChangeEvent(path);
+                if(newFileCreated){
+                    FsWatch.reportCreateEvent(path, false);
+                } else {
+                    FsWatch.reportChangeEvent(path);
+                }
             }
             if(args.originalCallback){
                 args.originalCallback(...interceptedArgs);
@@ -157,17 +162,23 @@ const fileSystemLib = {
 
         if(TauriFS.isTauriSubPath(path)) {
             return TauriFS.writeFile(...args);
-        } else if(Mounts.isMountSubPath(path)) {
-            return NativeFS.writeFile(...args);
         }
-        return FilerFSModified.writeFile(...args);
+        fileSystemLib.stat(path, (err)=>{
+            if(err && err.code === ERR_CODES.ERROR_CODES.ENOENT){
+                newFileCreated = true;
+            }
+            if(Mounts.isMountSubPath(path)) {
+                return NativeFS.writeFile(...args);
+            }
+            return FilerFSModified.writeFile(...args);
+        });
     },
     mkdir: function (...args) { // (path, mode, callback)
         let path = args[0];
         function callbackInterceptor(...interceptedArgs) {
             let err = interceptedArgs.length >= 1 ? interceptedArgs[0] : null;
             if(!err){
-                FsWatch.reportCreateEvent(path);
+                FsWatch.reportCreateEvent(path, true);
             }
             if(args.originalCallback){
                 args.originalCallback(...interceptedArgs);
@@ -191,8 +202,18 @@ const fileSystemLib = {
         function callbackInterceptor(...args) {
             let err = args.length >= 1 ? args[0] : null;
             if(!err){
-                FsWatch.reportUnlinkEvent(oldPath);
-                FsWatch.reportCreateEvent(newPath);
+                if(!TauriFS.isTauriSubPath(oldPath) || !TauriFS.isTauriSubPath(newPath)) {
+                    // we only need to manually handle watch events for non tauri paths as tauri watch is done at node
+                    fileSystemLib.stat(newPath, (err, stat)=>{
+                        const isDir = !err && stat.isDirectory();
+                        if(!TauriFS.isTauriSubPath(oldPath)) {
+                            FsWatch.reportUnlinkEvent(oldPath, isDir);
+                        }
+                        if(!TauriFS.isTauriSubPath(newPath)) {
+                            FsWatch.reportCreateEvent(newPath, isDir);
+                        }
+                    });
+                }
             }
             if(cb){
                 cb(...args);
@@ -224,10 +245,11 @@ const fileSystemLib = {
         });
     },
     unlink: function (path, cb) {
+        let isDir;
         function callbackInterceptor(...args) {
             let err = args.length >= 1 ? args[0] : null;
             if(!err){
-                FsWatch.reportUnlinkEvent(path);
+                FsWatch.reportUnlinkEvent(path, isDir);
             }
             if(cb){
                 cb(...args);
@@ -239,20 +261,30 @@ const fileSystemLib = {
             return ;
         } else if(TauriFS.isTauriSubPath(path)) {
             return TauriFS.unlink(path, callbackInterceptor);
-        } else if(Mounts.isMountSubPath(path)) {
-            return NativeFS.unlink(path, callbackInterceptor);
-        }
-        if (typeof path !== 'string') {
-            callbackInterceptor(new Errors.EINVAL('Invalid arguments.'));
-            return;
         }
-        return filerShell.rm(path, { recursive: true }, callbackInterceptor);
+
+        fileSystemLib.stat(path, (err, stat)=>{
+            isDir = !err && stat.isDirectory();
+            // we do this to emit fs watch events for non-tauri path unlinks.
+            // We only need to manually handle watch events for non tauri paths as tauri watch is done at node
+            if(Mounts.isMountSubPath(path)) {
+                return NativeFS.unlink(path, callbackInterceptor);
+            }
+            if (typeof path !== 'string') {
+                callbackInterceptor(new Errors.EINVAL('Invalid arguments.'));
+                return;
+            }
+            return filerShell.rm(path, { recursive: true }, callbackInterceptor);
+        });
     },
     copy: function (src, dst, cb) {
         function callbackInterceptor(...args) {
             let err = args.length >= 1 ? args[0] : null;
             if(!err){
-                FsWatch.reportCreateEvent(dst);
+                fileSystemLib.stat(dst, (err, stat)=>{
+                    const isDir = !err && stat.isDirectory();
+                    FsWatch.reportCreateEvent(dst, isDir);
+                });
             }
             if(cb){
                 cb(...args);
@@ -293,15 +325,6 @@ const fileSystemLib = {
         }
         return FsWatch.unwatchAsync(eventEmitter);
     },
-    watch: function (...args) {
-        return FsWatch.watch(...args);
-    },
-    unwatch: function (...args) {
-        return FsWatch.unwatch(...args);
-    },
-    unwatchAll: function (...args) {
-        return FsWatch.unwatchAll(...args);
-    },
     moveToTrash: function () {
         throw new Errors.ENOSYS('Phoenix fs moveToTrash function not yet supported.');
     },
@@ -356,13 +379,7 @@ const fileSystemLib = {
     MOUNT_POINT_ROOT: Constants.MOUNT_POINT_ROOT,
     TAURI_ROOT: Constants.TAURI_ROOT,
     ERR_CODES: {},
-    WATCH_EVENTS: {
-        ADD_FILE: "add",
-        ADD_DIR: "addDir",
-        CHANGE: "change",
-        UNLINK_FILE: "unlink",
-        UNLINK_DIR: "unlinkDir"
-    },
+    WATCH_EVENTS: Constants.WATCH_EVENTS,
     isEncodingSupported: function (encoding) {
         if(encoding.toLowerCase() === Constants.BYTE_ARRAY_ENCODING){
             return true;

src/constants.js

@@ -74,7 +74,8 @@ async function _mkdir(parentDirHandle, dirName, callback) {
         return childDirHandle;
     } catch (e) {
         if(callback){
-            callback(new Errors.EIO('Filer native fs function not yet supported.', e));
+            callback(new Errors.EIO('Filer native fs.mkdir failed.', e));
+            return ;
         }
         throw new Errors.EIO('Filer native fs function not yet supported.', e);
     }

src/fslib.js

@@ -493,7 +493,7 @@ function unlink(path, callback) {
 /**
  *
  * @param {string} path
- * @param {string} gitIgnorePaths The contents of the gitIgnore file as text. The watcher will ignore all files matching git ignore.
+ * @param {string|Array<string>} gitIgnorePaths The contents of the gitIgnore file as text. The watcher will ignore all files matching git ignore.
  * @returns {Promise<EventEmitter>} That will be resolved with a watcher once the watcher is ready.
  */
 async function watchAsync(path, gitIgnorePaths="") {

src/fslib_native.js

@@ -26,46 +26,10 @@ const {Errors, ERR_CODES} = require("./errno");
 const {Utils} = require("./utils");
 const {NodeTauriFS} = require("./fslib_node_ws");
 
-const TAURI_PATH_PREFIX = Constants.TAURI_ROOT+ '/';
 const IS_WINDOWS = navigator.userAgent.includes('Windows');
 let preferNodeWs = false,
     forceNodeWs = false;
 
-/**
- * Check if the given path is a subpath of the '/tauri' folder.
- * @param path
- */
-function isTauriSubPath(path) {
-    if (typeof path !== 'string') {
-        return false;
-    }
-    if (path) {
-        path = globalObject.path.normalize(path);
-        if (path.startsWith(TAURI_PATH_PREFIX) && path.length > TAURI_PATH_PREFIX.length) {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * Check if the given path is '/tauri' folder.
- * @param path
- */
-function isTauriPath(path) {
-    if (typeof path !== 'string') {
-        return false;
-    }
-    if (path) {
-        path = globalObject.path.normalize(path);
-        if (path === Constants.TAURI_ROOT) {
-            return true;
-        }
-    }
-    return false;
-}
-
-
 /**
  * Opens the Tauri file picker asynchronously with given options. If options aren't provided, defaults to picking a single file.
  * If the `defaultPath` option isn't provided, it will default to the user's document directory.
@@ -637,8 +601,8 @@ function preferNodeWSEndpoint(use) {
 }
 
 const TauriFS = {
-    isTauriPath,
-    isTauriSubPath,
+    isTauriPath: Utils.isTauriPath,
+    isTauriSubPath: Utils.isTauriSubPath,
     getTauriPlatformPath: Utils.getTauriPlatformPath,
     getTauriVirtualPath: Utils.getTauriVirtualPath,
     openTauriFilePickerAsync,