core-3nweb-client-lib 0.53.5 → 0.53.6

package/build/core/storage/synced/obj-files.js

@@ -352,9 +352,9 @@ class SyncedObj {
         this.scheduleSelfGC();
     }
     dropCachedLocalObjVersionsLessOrEqual(version) {
-        for (const version of this.localVers.keys()) {
-            if (version <= version) {
-                this.localVers.delete(version);
+        for (const localVersion of this.localVers.keys()) {
+            if (localVersion <= version) {
+                this.localVers.delete(localVersion);
             }
         }
     }

package/build/lib-client/xsp-fs/folder-node.js

@@ -323,41 +323,40 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         const deferred = (0, deferred_1.defer)();
         const nodeSet = this.storage.nodes.setPromise(info.objId, deferred.promise);
-        try {
-            let node;
+        (async () => {
             if (info.isFile) {
-                node = await file_node_1.FileNode.makeForExisting(this.storage, this.objId, info.name, info.objId, info.key);
+                return await file_node_1.FileNode.makeForExisting(this.storage, this.objId, info.name, info.objId, info.key);
             }
             else if (info.isFolder) {
                 const src = await this.storage.getObjSrc(info.objId);
-                node = await FolderNode.readNodeFromObjBytes(this.storage, info.name, info.objId, src, info.key);
+                return await FolderNode.readNodeFromObjBytes(this.storage, info.name, info.objId, src, info.key);
             }
             else if (info.isLink) {
-                node = await link_node_1.LinkNode.makeForExisting(this.storage, this.objId, info.name, info.objId, info.key);
+                return await link_node_1.LinkNode.makeForExisting(this.storage, this.objId, info.name, info.objId, info.key);
             }
             else {
                 throw new Error(`Unknown type of fs node`);
             }
-            deferred.resolve(node);
-            return nodeSet;
-        }
-        catch (exc) {
+        })().then((node) => deferred.resolve(node), async (exc) => {
             if (exc.failedCipherVerification) {
                 exc = (0, file_1.makeFileException)('ioError', `${this.name}/${info.name}`, exc);
             }
             else if (exc.objNotFound) {
                 if (fromCurrentNodes) {
-                    await this.fixMissingChildAndThrow(exc, info);
+                    try {
+                        await this.fixMissingChildAndThrow(exc, info);
+                    }
+                    catch (exc) {
+                        deferred.reject(exc);
+                        return;
+                    }
                 }
                 else {
                     try {
                         const node = await this.getNonLocal(info);
                         if (node) {
                             deferred.resolve(node);
-                            return nodeSet;
-                        }
-                        else {
-                            throw exc;
+                            return;
                         }
                     }
                     catch (exc2) {
@@ -366,8 +365,8 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 }
             }
             deferred.reject((0, error_1.errWithCause)(exc, `Failed to instantiate fs node '${this.name}/${info.name}'`));
-            return nodeSet;
-        }
+        });
+        return nodeSet;
     }
     async getNonLocal(info) {
         var _a;

package/build/lib-client/xsp-fs/fs.js

@@ -644,17 +644,15 @@ class ObjIdToPathMap {
         Object.seal(this);
     }
     async fillFromTree(root) {
-        const listOfAll = await recursiveIdAndPathList(root, '.', this.maxDepth);
-        for (const [objId, path, depth] of listOfAll) {
-            this.map.set(objId, { path, depth });
-        }
+        const rootItem = { depth: 0, nameInParent: '.' };
+        this.map.set(root.objId, rootItem);
+        await recursivelyAddIntoMap(this.map, root, rootItem, this.maxDepth, 1);
     }
-    getPathCorrectingTreeMap({ event, objId, parentObjId, childObjId }) {
-        let pathAndDepth = this.map.get(objId);
-        if (pathAndDepth) {
-            const { path, depth } = pathAndDepth;
-            this.updateFoundObjMapOnEvent(objId, path, depth, childObjId, event);
-            return path;
+    getPathAndIfNeededCorrectTreeMap({ event, objId, parentObjId, childObjId }) {
+        let pathMapItem = this.map.get(objId);
+        if (pathMapItem) {
+            this.updateFoundObjMapOnEvent(objId, pathMapItem, childObjId, event);
+            return pathOfMapItem(pathMapItem);
         }
         if (event.type === 'removed') {
             return;
@@ -666,66 +664,88 @@ class ObjIdToPathMap {
         if (!parent) {
             return;
         }
-        if ((this.maxDepth !== undefined)
-            && (this.maxDepth <= parent.depth)) {
+        if ((this.maxDepth !== undefined) && (this.maxDepth <= parent.depth)) {
             return;
         }
-        const path = `${parent.path}/${event.path}`;
-        this.map.set(objId, { path, depth: parent.depth + 1 });
-        return path;
+        const item = { nameInParent: event.path, parent, depth: parent.depth + 1 };
+        this.map.set(objId, item);
+        return pathOfMapItem(item);
     }
-    updateFoundObjMapOnEvent(objId, path, depth, childObjId, event) {
+    updateFoundObjMapOnEvent(objId, objPathItem, childObjId, event) {
         if (event.type === 'removed') {
-            this.map.delete(objId);
+            recursivelyRemoveFromMap(this.map, objId, objPathItem);
             return;
         }
-        if ((this.maxDepth !== undefined) && (this.maxDepth <= depth)) {
+        if ((this.maxDepth !== undefined) && (this.maxDepth <= objPathItem.depth)) {
             return;
         }
         if (event.type === 'entry-renaming') {
             const childEntry = this.map.get(childObjId);
             if (childEntry) {
-                childEntry.path === `${path}/${event.newName}`;
+                childEntry.nameInParent === event.newName;
             }
         }
         else if (event.type === 'entry-removal') {
             const childEntry = this.map.get(childObjId);
-            if (childEntry && (childEntry.path === `${path}/${event.name}`)) {
+            if (childEntry && (childEntry.nameInParent === event.name)) {
                 this.map.delete(childObjId);
             }
         }
         else if (event.type === 'entry-addition') {
-            this.map.set(childObjId, { path: `${path}/${event.entry.name}`, depth: depth + 1 });
+            const childEntry = {
+                parent: objPathItem, nameInParent: event.entry.name, depth: objPathItem.depth + 1
+            };
+            this.map.set(objId, childEntry);
+            // XXX if childEntry is a folder with its own children, subtree should be added
+            // if (event.entry.isFolder && (!this.maxDepth || (childEntry.depth < this.maxDepth))) {
+            // 	await recursivelyAddIntoMap(this.map, childNode, childEntry, this.maxDepth, childEntry.depth+1);
+            // }
         }
     }
     copyWithLongPath(nodeEvent) {
-        const path = this.getPathCorrectingTreeMap(nodeEvent);
+        const path = this.getPathAndIfNeededCorrectTreeMap(nodeEvent);
         return (path ? shallowCopyWithPath(nodeEvent.event, path) : undefined);
     }
 }
 Object.freeze(ObjIdToPathMap.prototype);
 Object.freeze(ObjIdToPathMap);
-async function recursiveIdAndPathList(folder, path, maxDepth, depth = 0) {
-    const { lst } = folder.list();
-    const idAndPaths = [
-        [folder.objId, path, depth]
-    ];
-    if ((maxDepth !== undefined) && (depth === maxDepth)) {
-        return idAndPaths;
-    }
+async function recursivelyAddIntoMap(map, parentNode, parent, maxDepth, depth) {
+    const { lst } = parentNode.list();
     for (const item of lst) {
-        const childPath = `${path}/${item.name}`;
+        const childItem = { depth, parent, nameInParent: item.name };
         if (item.isFile || item.isLink) {
-            const { objId } = folder.getCurrentNodeInfo(item.name);
-            idAndPaths.push([objId, childPath, depth + 1]);
+            const { objId } = parentNode.getCurrentNodeInfo(item.name);
+            map.set(objId, childItem);
         }
         else if (item.isFolder) {
-            const child = await folder.getFolder(item.name);
-            const childLst = await recursiveIdAndPathList(child, childPath, maxDepth, depth + 1);
-            idAndPaths.push(...childLst);
+            const child = await parentNode.getFolder(item.name);
+            map.set(child.objId, childItem);
+            if ((maxDepth === undefined) || (depth < maxDepth)) {
+                await recursivelyAddIntoMap(map, child, childItem, maxDepth, depth + 1);
+            }
+        }
+    }
+}
+function recursivelyRemoveFromMap(map, objId, objItem) {
+    map.delete(objId);
+    const childrenToRm = [];
+    for (const [childId, childItem] of map.entries()) {
+        if (childItem.parent === objItem) {
+            childrenToRm.push([childId, childItem]);
         }
     }
-    return idAndPaths;
+    for (const [childId, childItem] of childrenToRm) {
+        recursivelyRemoveFromMap(map, childId, childItem);
+    }
+}
+function pathOfMapItem(item) {
+    if (item.parent) {
+        const prefix = pathOfMapItem(item.parent);
+        return `${prefix}/${item.nameInParent}`;
+    }
+    else {
+        return item.nameInParent;
+    }
 }
 function shallowCopyWithPath(event, path) {
     const shallowCopy = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-3nweb-client-lib",
-  "version": "0.53.5",
+  "version": "0.53.6",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",