core-3nweb-client-lib 0.25.6 → 0.27.0

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

@@ -24,6 +24,7 @@ exports.XspFS = void 0;
 const file_1 = require("../../../lib-common/exceptions/file");
 const folder_node_1 = require("./folder-node");
 const file_2 = require("./file");
+const common_1 = require("./common");
 const files_1 = require("../../files");
 const files_select_1 = require("../../files-select");
 const path_1 = require("path");
@@ -31,6 +32,7 @@ const pipe_1 = require("../../../lib-common/byte-streaming/pipe");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
+const utils_for_observables_1 = require("../../../lib-common/utils-for-observables");
 function splitPathIntoParts(path) {
     return path_1.posix.resolve('/', path).split('/').filter(part => !!part);
 }
@@ -55,33 +57,38 @@ const WRITE_NONEXCL_FLAGS = {
     truncate: true
 };
 class XspFS {
-    constructor(storage, writable, name = '') {
-        this.storage = storage;
+    constructor(storage, writable, rootNode, name = '') {
         this.writable = writable;
         this.name = name;
-        this.v = new V();
-        this.type = this.storage.type;
+        this.fsObs = new utils_for_observables_1.Broadcast();
+        this.store = storage;
+        this.type = this.store.type;
+        this.v = new V(rootNode, this.writable, (0, common_1.isSyncedStorage)(this.store));
         Object.seal(this);
     }
+    storage() {
+        if (!this.store) {
+            throw (0, file_1.makeFileException)(file_1.Code.storageClosed, this.name);
+        }
+        return this.store;
+    }
     async readonlySubRoot(path) {
         const pathParts = splitPathIntoParts(path);
-        const folder = await this.v.root.getFolderInThisSubTree(pathParts, false)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(pathParts, false).catch(setExcPath(path));
         const folderName = ((pathParts.length === 0) ?
             this.name : pathParts[pathParts.length - 1]);
-        const fs = new XspFS(this.storage, false, folderName);
-        fs.v.root = folder;
-        return files_1.wrapReadonlyFS(fs);
+        const fs = new XspFS(this.storage(), false, folder, folderName);
+        return (0, files_1.wrapReadonlyFS)(fs);
     }
     async writableSubRoot(path, flags = WRITE_NONEXCL_FLAGS) {
         const pathParts = splitPathIntoParts(path);
-        const folder = await this.v.root.getFolderInThisSubTree(pathParts, flags.create, flags.exclusive)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(pathParts, flags.create, flags.exclusive).catch(setExcPath(path));
         const folderName = ((pathParts.length === 0) ?
             this.name : pathParts[pathParts.length - 1]);
-        const fs = new XspFS(this.storage, true, folderName);
-        fs.v.root = folder;
-        return files_1.wrapWritableFS(fs);
+        const fs = new XspFS(this.storage(), true, folder, folderName);
+        return (0, files_1.wrapWritableFS)(fs);
     }
     /**
      * This creates in a root object in a given storage, returning fs object
@@ -90,9 +97,9 @@ class XspFS {
      * @param key is a file key of a root object
      */
     static async makeNewRoot(storage, key) {
-        const fs = new XspFS(storage, true);
-        fs.v.root = await folder_node_1.FolderNode.newRoot(fs.storage, key);
-        return files_1.wrapWritableFS(fs);
+        const root = await folder_node_1.FolderNode.newRoot(storage, key);
+        const fs = new XspFS(storage, true, root);
+        return (0, files_1.wrapWritableFS)(fs);
     }
     /**
      * This creates fs object that represents existing root folder in a given
@@ -101,34 +108,37 @@ class XspFS {
      * @param key is a file key of a root object
      */
     static async fromExistingRoot(storage, key) {
-        const fs = new XspFS(storage, true);
-        const objSrc = await storage.getObj(null);
-        fs.v.root = await folder_node_1.FolderNode.rootFromObjBytes(fs.storage, undefined, null, objSrc, key);
-        return files_1.wrapWritableFS(fs);
+        const objSrc = await storage.getObjSrc(null);
+        const root = await folder_node_1.FolderNode.rootFromObjBytes(storage, undefined, null, objSrc, key);
+        const fs = new XspFS(storage, true, root);
+        return (0, files_1.wrapWritableFS)(fs);
     }
     static fromASMailMsgRootFromJSON(storage, folderJson, rootName) {
-        const fs = new XspFS(storage, false, rootName);
-        fs.v.root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
-        return files_1.wrapIntoVersionlessReadonlyFS(fs);
+        const root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
+        const fs = new XspFS(storage, false, root, rootName);
+        return (0, files_1.wrapIntoVersionlessReadonlyFS)(fs);
     }
     /**
      * Note that this method doesn't close storage.
      */
     async close() {
-        this.v.root = undefined;
-        this.storage = undefined;
+        this.v.close();
+        this.store = undefined;
+        this.fsObs.done();
     }
     async makeFolder(path, exclusive = false) {
         const folderPath = splitPathIntoParts(path);
-        await this.v.root.getFolderInThisSubTree(folderPath, true, exclusive)
+        const root = this.v.getRootIfNotClosed(path);
+        await root.getFolderInThisSubTree(folderPath, true, exclusive)
             .catch(setExcPath(path));
     }
     select(path, criteria) {
-        return files_select_1.selectInFS(this, path, criteria);
+        return (0, files_select_1.selectInFS)(this, path, criteria);
     }
     async deleteFolder(path, removeContent = false) {
         const { fileName: folderName, folderPath: parentPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(parentPath)
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(parentPath)
             .catch(setExcPath(parentPath.join('/')));
         if (typeof folderName !== 'string') {
             throw new Error('Cannot remove root folder');
@@ -136,13 +146,14 @@ class XspFS {
         const folder = (await parentFolder.getFolder(folderName)
             .catch(setExcPath(path)));
         if (!removeContent && !folder.isEmpty()) {
-            throw file_1.makeFileException(file_1.Code.notEmpty, path);
+            throw (0, file_1.makeFileException)(file_1.Code.notEmpty, path);
         }
         await parentFolder.removeChild(folder);
     }
     async deleteFile(path) {
         const { fileName, folderPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(folderPath)
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(folderPath)
             .catch(setExcPath(path));
         const file = await parentFolder.getFile(fileName)
             .catch(setExcPath(path));
@@ -150,7 +161,8 @@ class XspFS {
     }
     async deleteLink(path) {
         const { fileName, folderPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(folderPath)
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(folderPath)
             .catch(setExcPath(path));
         const link = await parentFolder.getLink(fileName)
             .catch(setExcPath(path));
@@ -169,10 +181,11 @@ class XspFS {
         }
         const dstFName = dstFolderPath[dstFolderPath.length - 1];
         dstFolderPath.splice(dstFolderPath.length - 1, 1);
+        const root = this.v.getRootIfNotClosed(initPath);
         try {
-            const srcFolder = await this.v.root.getFolderInThisSubTree(srcFolderPath);
+            const srcFolder = await root.getFolderInThisSubTree(srcFolderPath);
             srcFolder.hasChild(initFName, true);
-            const dstFolder = await this.v.root.getFolderInThisSubTree(dstFolderPath, true);
+            const dstFolder = await root.getFolderInThisSubTree(dstFolderPath, true);
             await srcFolder.moveChildTo(initFName, dstFolder, dstFName);
         }
         catch (exc) {
@@ -249,7 +262,7 @@ class XspFS {
             else if (type === 'link') {
                 code = file_1.Code.notLink;
             }
-            throw file_1.makeFileException(code, path);
+            throw (0, file_1.makeFileException)(code, path);
         }
         else {
             return false;
@@ -297,7 +310,7 @@ class XspFS {
                     truncate: true
                 };
                 const sink = await this.getByteSink(dst, flags);
-                await pipe_1.pipe(src, sink);
+                await (0, pipe_1.pipe)(src, sink);
             }
             else if (f.isFolder) {
                 const subFolder = await folder.readonlySubRoot(f.name);
@@ -311,21 +324,22 @@ class XspFS {
         }
     }
     ensureLinkingAllowedTo(params) {
-        if (this.storage.type === 'local') {
+        const storage = this.storage();
+        if (storage.type === 'local') {
             return;
         }
-        else if (this.storage.type === 'synced') {
+        else if (storage.type === 'synced') {
             if ((params.storageType === 'share') ||
                 (params.storageType === 'synced')) {
                 return;
             }
         }
-        else if (this.storage.type === 'share') {
+        else if (storage.type === 'share') {
             if (params.storageType === 'share') {
                 return;
             }
         }
-        throw new Error(`Cannot create link to ${params.storageType} from ${this.storage.type} storage.`);
+        throw new Error(`Cannot create link to ${params.storageType} from ${storage.type} storage.`);
     }
     async link(path, target) {
         if (!target ||
@@ -335,20 +349,21 @@ class XspFS {
         const params = await target.getLinkParams();
         this.ensureLinkingAllowedTo(params);
         const { fileName, folderPath } = split(path);
-        const folder = await this.v.root.getFolderInThisSubTree(folderPath, true)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(folderPath, true).catch(setExcPath(path));
         await folder.createLink(fileName, params);
     }
     async readLink(path) {
         const { fileName, folderPath } = split(path);
-        const folder = await this.v.root.getFolderInThisSubTree(folderPath)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
         const link = await folder.getLink(fileName)
             .catch(setExcPath(path));
         return await link.read();
     }
     async getLinkParams() {
-        const linkParams = this.v.root.getParamsForLink();
+        const root = this.v.getRootIfNotClosed(this.name);
+        const linkParams = root.getParamsForLink();
         linkParams.params.folderName = this.name;
         linkParams.readonly = !this.writable;
         return linkParams;
@@ -356,44 +371,60 @@ class XspFS {
     static async makeFolderFromLinkParams(storage, params) {
         const name = params.params.folderName;
         const writable = !params.readonly;
-        const fs = new XspFS(storage, writable, name);
-        fs.v.root = await folder_node_1.FolderNode.rootFromLinkParams(storage, params.params);
-        return (fs.writable ? files_1.wrapWritableFS(fs) : files_1.wrapReadonlyFS(fs));
+        const root = await folder_node_1.FolderNode.rootFromLinkParams(storage, params.params);
+        const fs = new XspFS(storage, writable, root, name);
+        return (fs.writable ? (0, files_1.wrapWritableFS)(fs) : (0, files_1.wrapReadonlyFS)(fs));
+    }
+    getCloseEvent$() {
+        return this.fsObs.event$.pipe((0, operators_1.filter)(ev => (ev === 'close')));
     }
     watchFolder(path, observer) {
-        const watchSub = rxjs_1.from(this.v.root.getFolderInThisSubTree(splitPathIntoParts(path), false))
-            .pipe(operators_1.mergeMap(f => f.event$))
-            .subscribe(observer);
+        const folderPath = splitPathIntoParts(path);
+        const root = this.v.getRootIfNotClosed(path);
+        const nodeProm = root.getFolderInThisSubTree(folderPath, false);
+        const watchSub = (0, rxjs_1.from)(nodeProm)
+            .pipe((0, operators_1.mergeMap)(f => f.event$), (0, operators_1.map)(event => shallowCopyWithPath(event, path)), (0, operators_1.takeUntil)(this.getCloseEvent$()))
+            .subscribe((0, utils_for_observables_1.toRxObserver)(observer));
         return () => watchSub.unsubscribe();
     }
     watchFile(path, observer) {
         const { fileName, folderPath } = split(path);
-        const watchSub = rxjs_1.from(this.v.root.getFolderInThisSubTree(folderPath, false))
-            .pipe(operators_1.mergeMap(folder => folder.getFile(fileName)), operators_1.mergeMap(f => f.event$))
-            .subscribe(observer);
+        const root = this.v.getRootIfNotClosed(path);
+        const nodeProm = root.getFolderInThisSubTree(folderPath, false);
+        const watchSub = (0, rxjs_1.from)(nodeProm)
+            .pipe((0, operators_1.mergeMap)(folder => folder.getFile(fileName)), (0, operators_1.mergeMap)(f => f.event$), (0, operators_1.map)(event => shallowCopyWithPath(event, path)), (0, operators_1.takeUntil)(this.getCloseEvent$()))
+            .subscribe((0, utils_for_observables_1.toRxObserver)(observer));
         return () => watchSub.unsubscribe();
     }
-    watchTree(path, observer) {
-        throw new Error('Not implemented, yet');
+    watchTree(path, depth, observer) {
+        const folderPath = splitPathIntoParts(path);
+        const root = this.v.getRootIfNotClosed(path);
+        const idToPath = new ObjIdToPathMap(depth);
+        const setupFilterMap = root.getFolderInThisSubTree(folderPath, false)
+            .then(rootNode => idToPath.fillFromTree(rootNode));
+        const watchSub = (0, rxjs_1.from)(setupFilterMap)
+            .pipe((0, operators_1.mergeMap)(() => this.storage().getNodeEvents()), (0, operators_1.map)(nodeEvent => idToPath.copyWithLongPath(nodeEvent)), (0, operators_1.filter)(event => !!event), (0, operators_1.takeUntil)(this.getCloseEvent$()))
+            .subscribe((0, utils_for_observables_1.toRxObserver)(observer));
+        return () => watchSub.unsubscribe();
     }
     async readonlyFile(path) {
         const fNode = await this.v.getOrCreateFile(path, {});
-        return files_1.wrapReadonlyFile(file_2.FileObject.makeExisting(fNode, false));
+        return (0, files_1.wrapReadonlyFile)(file_2.FileObject.makeExisting(fNode, false));
     }
     async writableFile(path, flags = WRITE_NONEXCL_FLAGS) {
         const exists = await this.checkFilePresence(path);
         if (exists) {
             if (flags.create && flags.exclusive) {
-                throw file_1.makeFileException(file_1.Code.alreadyExists, path);
+                throw (0, file_1.makeFileException)(file_1.Code.alreadyExists, path);
             }
             const fNode = await this.v.getOrCreateFile(path, flags);
-            return files_1.wrapWritableFile(file_2.FileObject.makeExisting(fNode, true));
+            return (0, files_1.wrapWritableFile)(file_2.FileObject.makeExisting(fNode, true));
         }
         else {
             if (!flags.create) {
-                throw file_1.makeFileException(file_1.Code.notFound, path);
+                throw (0, file_1.makeFileException)(file_1.Code.notFound, path);
             }
-            return files_1.wrapWritableFile(file_2.FileObject.makeForNotExisiting(path_1.posix.basename(path), () => this.v.getOrCreateFile(path, flags)));
+            return (0, files_1.wrapWritableFile)(file_2.FileObject.makeForNotExisiting(path_1.posix.basename(path), () => this.v.getOrCreateFile(path, flags), !!this.v.sync));
         }
     }
     async copyFile(src, dst, overwrite = false) {
@@ -404,7 +435,7 @@ class XspFS {
             truncate: true
         };
         const sink = await this.getByteSink(dst, flags);
-        await pipe_1.pipe(srcBytes, sink);
+        await (0, pipe_1.pipe)(srcBytes, sink);
     }
     async saveFile(file, dst, overwrite = false) {
         const src = (file.v ?
@@ -415,7 +446,7 @@ class XspFS {
             truncate: true
         };
         const sink = await this.getByteSink(dst, flags);
-        await pipe_1.pipe(src, sink);
+        await (0, pipe_1.pipe)(src, sink);
     }
     async listFolder(folder) {
         const { lst } = await this.v.listFolder(folder);
@@ -455,21 +486,46 @@ exports.XspFS = XspFS;
 Object.freeze(XspFS.prototype);
 Object.freeze(XspFS);
 class V {
-    constructor() {
-        this.root = undefined;
+    constructor(rootNode, writable, isInSyncedStorage) {
+        this.rootNode = rootNode;
+        this.writable = writable;
+        this.sync = (isInSyncedStorage ? new S(this) : undefined);
         Object.seal(this);
     }
+    async archiveCurrent(path, version) {
+        this.ensureIsWritable();
+        const node = await this.get(path);
+        try {
+            const archivedVer = await node.archiveCurrent(version);
+            return archivedVer;
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+    async listVersions(path) {
+        const node = await this.get(path);
+        return node.listVersions();
+    }
+    close() {
+        this.rootNode = undefined;
+    }
+    getRootIfNotClosed(excPath) {
+        if (!this.rootNode) {
+            throw (0, file_1.makeFileException)(file_1.Code.storageClosed, excPath);
+        }
+        return this.rootNode;
+    }
     async getOrCreateFile(path, flags) {
         const { fileName, folderPath } = split(path);
         const { create, exclusive } = flags;
-        const folder = await this.root.getFolderInThisSubTree(folderPath, create)
-            .catch(setExcPath(path));
+        const folder = await this.getRootIfNotClosed(path).getFolderInThisSubTree(folderPath, create).catch(setExcPath(path));
         const nullOnMissing = create;
         let file = await folder.getFile(fileName, nullOnMissing)
             .catch(setExcPath(path));
         if (file) {
             if (exclusive) {
-                throw file_1.makeFileException(file_1.Code.alreadyExists, path);
+                throw (0, file_1.makeFileException)(file_1.Code.alreadyExists, path);
             }
         }
         else {
@@ -479,16 +535,22 @@ class V {
     }
     async get(path) {
         const { fileName, folderPath } = split(path);
-        const folder = await this.root.getFolderInThisSubTree(folderPath, false)
-            .catch(setExcPath(path));
+        const root = this.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(folderPath, false).catch(setExcPath(path));
         if (fileName === undefined) {
-            return this.root;
+            return root;
         }
         const node = await folder.getNode(undefined, fileName)
             .catch(setExcPath(path));
         return node;
     }
+    ensureIsWritable() {
+        if (!this.writable) {
+            throw new Error(`FS is not writable`);
+        }
+    }
     async updateXAttrs(path, changes) {
+        this.ensureIsWritable();
         const node = await this.get(path);
         return node.updateXAttrs(changes);
     }
@@ -505,10 +567,12 @@ class V {
         };
     }
     async listFolder(path) {
-        const folder = await this.root.getFolderInThisSubTree(splitPathIntoParts(path), false).catch(setExcPath(path));
+        const root = this.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(splitPathIntoParts(path), false).catch(setExcPath(path));
         return folder.list();
     }
     async writeBytes(path, bytes, flags = WRITE_NONEXCL_FLAGS) {
+        this.ensureIsWritable();
         const f = await this.getOrCreateFile(path, flags);
         return f.save(bytes);
     }
@@ -527,7 +591,7 @@ class V {
             return { txt, version };
         }
         catch (err) {
-            throw file_1.makeFileException(file_1.Code.parsingError, path, err);
+            throw (0, file_1.makeFileException)(file_1.Code.parsingError, path, err);
         }
     }
     writeJSONFile(path, json, flags = WRITE_NONEXCL_FLAGS) {
@@ -541,10 +605,11 @@ class V {
             return { json, version };
         }
         catch (err) {
-            throw file_1.makeFileException(file_1.Code.parsingError, path, err);
+            throw (0, file_1.makeFileException)(file_1.Code.parsingError, path, err);
         }
     }
     async getByteSink(path, flags = WRITE_NONEXCL_FLAGS) {
+        this.ensureIsWritable();
         const f = await this.getOrCreateFile(path, flags);
         return f.writeSink(flags.truncate, flags.currentVersion);
     }
@@ -555,4 +620,191 @@ class V {
 }
 Object.freeze(V.prototype);
 Object.freeze(V);
+class ObjIdToPathMap {
+    constructor(maxDepth) {
+        this.maxDepth = maxDepth;
+        this.map = new Map();
+        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 });
+        }
+    }
+    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;
+        }
+        if (event.type === 'removed') {
+            return;
+        }
+        if (parentObjId === undefined) {
+            return;
+        }
+        const parent = this.map.get(parentObjId);
+        if (!parent) {
+            return;
+        }
+        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;
+    }
+    updateFoundObjMapOnEvent(objId, path, depth, childObjId, event) {
+        if (event.type === 'removed') {
+            this.map.delete(objId);
+            return;
+        }
+        if ((this.maxDepth !== undefined) && (this.maxDepth <= depth)) {
+            return;
+        }
+        if (event.type === 'entry-renaming') {
+            const childEntry = this.map.get(childObjId);
+            if (childEntry) {
+                childEntry.path === `${path}/${event.newName}`;
+            }
+        }
+        else if (event.type === 'entry-removal') {
+            const childEntry = this.map.get(childObjId);
+            if (childEntry && (childEntry.path === `${path}/${event.name}`)) {
+                this.map.delete(childObjId);
+            }
+        }
+        else if (event.type === 'entry-addition') {
+            this.map.set(childObjId, { path: `${path}/${event.entry.name}`, depth: depth + 1 });
+        }
+    }
+    copyWithLongPath(nodeEvent) {
+        const path = this.getPathCorrectingTreeMap(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;
+    }
+    for (const item of lst) {
+        const childPath = `${path}/${item.name}`;
+        if (item.isFile || item.isLink) {
+            const { objId } = folder.getNodeInfo(item.name);
+            idAndPaths.push([objId, childPath, depth + 1]);
+        }
+        else if (item.isFolder) {
+            const child = await folder.getFolder(item.name);
+            const childLst = await recursiveIdAndPathList(child, childPath, maxDepth, depth + 1);
+            idAndPaths.push(...childLst);
+        }
+    }
+    return idAndPaths;
+}
+function shallowCopyWithPath(event, path) {
+    const shallowCopy = {};
+    for (const [field, value] of Object.entries(event)) {
+        shallowCopy[field] = value;
+    }
+    shallowCopy.path = path;
+    return shallowCopy;
+}
+class S {
+    constructor(n) {
+        this.n = n;
+        Object.freeze(this);
+    }
+    async upload(path, opts) {
+        this.n.ensureIsWritable();
+        const node = await this.n.get(path);
+        try {
+            await node.upload(opts);
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+        ;
+    }
+    async status(path) {
+        const node = await this.n.get(path);
+        try {
+            const status = await node.syncStatus();
+            return status;
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+    async updateStatusInfo(path) {
+        const node = await this.n.get(path);
+        const status = await node.updateStatusInfo();
+        return status;
+    }
+    async isRemoteVersionOnDisk(path, version) {
+        const node = await this.n.get(path);
+        try {
+            const isOnDisk = await node.isSyncedVersionOnDisk(version);
+            return isOnDisk;
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+    async download(path, version) {
+        const node = await this.n.get(path);
+        try {
+            await node.download(version);
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+    async adoptRemote(path, opts) {
+        const node = await this.n.get(path);
+        try {
+            await node.adoptRemote(opts);
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+    async getFolderNode(path) {
+        const node = await this.n.get(path);
+        if (node.type !== 'folder') {
+            throw (0, file_1.makeFileException)(file_1.Code.notDirectory, path);
+        }
+        return node;
+    }
+    async diffCurrentAndRemoteFolderVersions(path, remoteVersion) {
+        const node = await this.getFolderNode(path);
+        try {
+            const diff = await node.diffCurrentAndRemote(remoteVersion);
+            return diff;
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+    async adoptRemoteFolderItem(path, itemName, opts) {
+        const node = await this.getFolderNode(path);
+        try {
+            const newVersion = await node.adoptRemoteFolderItem(itemName, opts);
+            return newVersion;
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
+}
+Object.freeze(S.prototype);
+Object.freeze(S);
 Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/link-node.d.ts

@@ -24,6 +24,7 @@ export declare class LinkNode extends NodeInFS<LinkPersistance> {
     constructor(storage: Storage, name: string, objId: string, version: number, parentId: string | undefined, key: Uint8Array);
     static makeForNew(storage: Storage, parentId: string, name: string, key: Uint8Array): Promise<LinkNode>;
     static makeForExisting(storage: Storage, parentId: string, name: string, objId: string, key: Uint8Array): Promise<LinkNode>;
+    protected setCurrentStateFrom(src: ObjSource): Promise<void>;
     private setUpdatedState;
     save(params: LinkParameters<any>, changes?: XAttrsChanges): Promise<void>;
     private getLinkParams;

package/build/lib-client/3nstorage/xsp-fs/link-node.js

@@ -82,7 +82,7 @@ class LinkNode extends node_in_fs_1.NodeInFS {
         if (!name || !objId || !parentId) {
             throw new Error("Bad link parameter(s) given");
         }
-        this.crypto = new LinkPersistance(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
+        this.crypto = new LinkPersistance((0, xsp_files_1.idToHeaderNonce)(this.objId), key, this.storage.cryptor);
         Object.seal(this);
     }
     static async makeForNew(storage, parentId, name, key) {
@@ -92,12 +92,17 @@ class LinkNode extends node_in_fs_1.NodeInFS {
         return link;
     }
     static async makeForExisting(storage, parentId, name, objId, key) {
-        const src = await storage.getObj(objId);
+        const src = await storage.getObjSrc(objId);
         const link = new LinkNode(storage, name, objId, src.version, parentId, key);
         const { params, attrs, xattrs } = await link.crypto.read(src);
         link.setUpdatedState(params, src.version, attrs, xattrs);
+        link.setCurrentStateFrom(src);
         return link;
     }
+    async setCurrentStateFrom(src) {
+        const { params, attrs, xattrs } = await this.crypto.read(src);
+        this.setUpdatedState(params, src.version, attrs, xattrs);
+    }
     setUpdatedState(params, version, attrs, xattrs) {
         this.linkParams = params;
         super.setUpdatedParams(version, attrs, xattrs);