core-3nweb-client-lib 0.26.1 → 0.27.3

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

@@ -22,6 +22,13 @@ declare type FileFlags = web3n.files.FileFlags;
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
+declare type WritableFSSyncAPI = web3n.files.WritableFSSyncAPI;
+declare type SyncStatus = web3n.files.SyncStatus;
+declare type WritableFSVersionedAPI = web3n.files.WritableFSVersionedAPI;
+declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
+declare type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
+declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
+declare type FolderDiff = web3n.files.FolderDiff;
 export declare class XspFS implements WritableFS {
     readonly writable: boolean;
     name: string;
@@ -79,7 +86,7 @@ export declare class XspFS implements WritableFS {
     private getCloseEvent$;
     watchFolder(path: string, observer: Observer<FolderEvent>): () => void;
     watchFile(path: string, observer: Observer<FileEvent>): () => void;
-    watchTree(path: string, observer: Observer<FolderEvent | FileEvent>): () => void;
+    watchTree(path: string, depth: number | undefined, observer: Observer<FolderEvent | FileEvent>): () => void;
     readonlyFile(path: string): Promise<ReadonlyFile>;
     writableFile(path: string, flags?: web3n.files.VersionedFileFlags): Promise<WritableFile>;
     copyFile(src: string, dst: string, overwrite?: boolean): Promise<void>;
@@ -94,14 +101,25 @@ export declare class XspFS implements WritableFS {
     writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileFlags): Promise<void>;
     getByteSink(path: string, flags?: web3n.files.VersionedFileFlags): Promise<FileByteSink>;
 }
-declare type WritableFSVersionedAPI = web3n.files.WritableFSVersionedAPI;
-declare class V implements WritableFSVersionedAPI {
+interface N {
+    get(path: string): Promise<NodeInFS<any>>;
+    ensureIsWritable(): void;
+}
+declare class V implements WritableFSVersionedAPI, N {
     private rootNode;
-    constructor(root: FolderNode);
+    private readonly writable;
+    readonly sync: S | undefined;
+    constructor(rootNode: FolderNode | undefined, writable: boolean, isInSyncedStorage: boolean);
+    archiveCurrent(path: string, version?: number): Promise<number>;
+    listVersions(path: string): Promise<{
+        current?: number;
+        archived?: number[];
+    }>;
     close(): void;
     getRootIfNotClosed(excPath: string): FolderNode;
     getOrCreateFile(path: string, flags: FileFlags): Promise<FileNode>;
     get(path: string): Promise<NodeInFS<any>>;
+    ensureIsWritable(): void;
     updateXAttrs(path: string, changes: XAttrsChanges): Promise<number>;
     getXAttr(path: string, xaName: string): Promise<{
         attr: any;
@@ -139,4 +157,17 @@ declare class V implements WritableFSVersionedAPI {
         version: number;
     }>;
 }
+declare class S implements WritableFSSyncAPI {
+    private readonly n;
+    constructor(n: N);
+    upload(path: string, opts?: OptionsToUploadLocal): Promise<void>;
+    status(path: string): Promise<SyncStatus>;
+    updateStatusInfo(path: string): Promise<SyncStatus>;
+    isRemoteVersionOnDisk(path: string, version: number): Promise<'complete' | 'partial' | 'none'>;
+    download(path: string, version: number): Promise<void>;
+    adoptRemote(path: string, opts?: OptionsToAdopteRemote): Promise<void>;
+    private getFolderNode;
+    diffCurrentAndRemoteFolderVersions(path: string, remoteVersion?: number): Promise<FolderDiff | undefined>;
+    adoptRemoteFolderItem(path: string, itemName: string, opts?: OptionsToAdoptRemoteItem): Promise<number>;
+}
 export {};

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");
@@ -62,12 +63,12 @@ class XspFS {
         this.fsObs = new utils_for_observables_1.Broadcast();
         this.store = storage;
         this.type = this.store.type;
-        this.v = new V(rootNode);
+        this.v = new V(rootNode, this.writable, (0, common_1.isSyncedStorage)(this.store));
         Object.seal(this);
     }
     storage() {
         if (!this.store) {
-            throw file_1.makeFileException(file_1.Code.storageClosed, this.name);
+            throw (0, file_1.makeFileException)('storageClosed', this.name);
         }
         return this.store;
     }
@@ -78,7 +79,7 @@ class XspFS {
         const folderName = ((pathParts.length === 0) ?
             this.name : pathParts[pathParts.length - 1]);
         const fs = new XspFS(this.storage(), false, folder, folderName);
-        return files_1.wrapReadonlyFS(fs);
+        return (0, files_1.wrapReadonlyFS)(fs);
     }
     async writableSubRoot(path, flags = WRITE_NONEXCL_FLAGS) {
         const pathParts = splitPathIntoParts(path);
@@ -87,7 +88,7 @@ class XspFS {
         const folderName = ((pathParts.length === 0) ?
             this.name : pathParts[pathParts.length - 1]);
         const fs = new XspFS(this.storage(), true, folder, folderName);
-        return files_1.wrapWritableFS(fs);
+        return (0, files_1.wrapWritableFS)(fs);
     }
     /**
      * This creates in a root object in a given storage, returning fs object
@@ -98,7 +99,7 @@ class XspFS {
     static async makeNewRoot(storage, key) {
         const root = await folder_node_1.FolderNode.newRoot(storage, key);
         const fs = new XspFS(storage, true, root);
-        return files_1.wrapWritableFS(fs);
+        return (0, files_1.wrapWritableFS)(fs);
     }
     /**
      * This creates fs object that represents existing root folder in a given
@@ -107,15 +108,15 @@ class XspFS {
      * @param key is a file key of a root object
      */
     static async fromExistingRoot(storage, key) {
-        const objSrc = await storage.getObj(null);
+        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 files_1.wrapWritableFS(fs);
+        return (0, files_1.wrapWritableFS)(fs);
     }
     static fromASMailMsgRootFromJSON(storage, folderJson, rootName) {
         const root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
         const fs = new XspFS(storage, false, root, rootName);
-        return files_1.wrapIntoVersionlessReadonlyFS(fs);
+        return (0, files_1.wrapIntoVersionlessReadonlyFS)(fs);
     }
     /**
      * Note that this method doesn't close storage.
@@ -128,29 +129,34 @@ class XspFS {
     async makeFolder(path, exclusive = false) {
         const folderPath = splitPathIntoParts(path);
         const root = this.v.getRootIfNotClosed(path);
-        await root.getFolderInThisSubTree(folderPath, true, exclusive).catch(setExcPath(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 root = this.v.getRootIfNotClosed(path);
-        const parentFolder = await root.getFolderInThisSubTree(parentPath).catch(setExcPath(parentPath.join('/')));
+        const parentFolder = await root.getFolderInThisSubTree(parentPath)
+            .catch(setExcPath(parentPath.join('/')));
         if (typeof folderName !== 'string') {
             throw new Error('Cannot remove root folder');
         }
         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)('notEmpty', path);
         }
+        // note that internal folder.delete() removes all children as a matter
+        // of not leaving inaccessible nodes, i.e. content is removed implicitly
         await parentFolder.removeChild(folder);
     }
     async deleteFile(path) {
         const { fileName, folderPath } = split(path);
         const root = this.v.getRootIfNotClosed(path);
-        const parentFolder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
+        const parentFolder = await root.getFolderInThisSubTree(folderPath)
+            .catch(setExcPath(path));
         const file = await parentFolder.getFile(fileName)
             .catch(setExcPath(path));
         await parentFolder.removeChild(file);
@@ -158,8 +164,10 @@ class XspFS {
     async deleteLink(path) {
         const { fileName, folderPath } = split(path);
         const root = this.v.getRootIfNotClosed(path);
-        const parentFolder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
-        const link = await parentFolder.getLink(fileName).catch(setExcPath(path));
+        const parentFolder = await root.getFolderInThisSubTree(folderPath)
+            .catch(setExcPath(path));
+        const link = await parentFolder.getLink(fileName)
+            .catch(setExcPath(path));
         await parentFolder.removeChild(link);
     }
     async move(initPath, newPath) {
@@ -197,13 +205,11 @@ class XspFS {
     }
     async stat(path) {
         const node = await this.v.get(path);
-        const sync = await node.sync();
         const attrs = node.getAttrs();
         const stats = {
             ctime: new Date(attrs.ctime),
             mtime: new Date(attrs.mtime),
             version: node.version,
-            sync,
             writable: this.writable,
         };
         if (node.type === 'file') {
@@ -248,17 +254,11 @@ class XspFS {
             return true;
         }
         else if (throwIfMissing) {
-            let code = '';
-            if (type === 'file') {
-                code = file_1.Code.notFile;
-            }
-            else if (type === 'folder') {
-                code = file_1.Code.notDirectory;
+            switch (type) {
+                case 'file': throw (0, file_1.makeFileException)('notFile', path);
+                case 'folder': throw (0, file_1.makeFileException)('notDirectory', path);
+                case 'link': throw (0, file_1.makeFileException)('notLink', path);
             }
-            else if (type === 'link') {
-                code = file_1.Code.notLink;
-            }
-            throw file_1.makeFileException(code, path);
         }
         else {
             return false;
@@ -306,7 +306,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);
@@ -369,65 +369,58 @@ class XspFS {
         const writable = !params.readonly;
         const root = await folder_node_1.FolderNode.rootFromLinkParams(storage, params.params);
         const fs = new XspFS(storage, writable, root, name);
-        return (fs.writable ? files_1.wrapWritableFS(fs) : files_1.wrapReadonlyFS(fs));
+        return (fs.writable ? (0, files_1.wrapWritableFS)(fs) : (0, files_1.wrapReadonlyFS)(fs));
     }
     getCloseEvent$() {
-        return this.fsObs.event$.pipe(operators_1.filter(ev => (ev === 'close')));
+        return this.fsObs.event$.pipe((0, operators_1.filter)(ev => (ev === 'close')));
     }
     watchFolder(path, observer) {
         const folderPath = splitPathIntoParts(path);
         const root = this.v.getRootIfNotClosed(path);
         const nodeProm = root.getFolderInThisSubTree(folderPath, false);
-        const watchSub = rxjs_1.from(nodeProm)
-            .pipe(operators_1.mergeMap(f => f.event$), operators_1.takeUntil(this.getCloseEvent$()))
-            .subscribe(utils_for_observables_1.toRxObserver(observer));
+        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 root = this.v.getRootIfNotClosed(path);
         const nodeProm = root.getFolderInThisSubTree(folderPath, false);
-        const watchSub = rxjs_1.from(nodeProm)
-            .pipe(operators_1.mergeMap(folder => folder.getFile(fileName)), operators_1.mergeMap(f => f.event$), operators_1.takeUntil(this.getCloseEvent$()))
-            .subscribe(utils_for_observables_1.toRxObserver(observer));
+        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) {
+    watchTree(path, depth, observer) {
         const folderPath = splitPathIntoParts(path);
         const root = this.v.getRootIfNotClosed(path);
-        const idToPath = new ObjIdToPathMap();
+        const idToPath = new ObjIdToPathMap(depth);
         const setupFilterMap = root.getFolderInThisSubTree(folderPath, false)
             .then(rootNode => idToPath.fillFromTree(rootNode));
-        const watchSub = rxjs_1.from(setupFilterMap)
-            .pipe(operators_1.mergeMap(() => this.storage().getNodeEvents()), operators_1.map(nodeEvent => {
-            const path = idToPath.getPathCorrectingTreeMap(nodeEvent);
-            if (path) {
-                const event = nodeEvent.event;
-                event.path = path;
-                return event;
-            }
-        }, 1), operators_1.filter(event => !!event), operators_1.takeUntil(this.getCloseEvent$()))
-            .subscribe(utils_for_observables_1.toRxObserver(observer));
+        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)('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)('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) {
@@ -438,7 +431,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 ?
@@ -449,7 +442,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);
@@ -489,16 +482,33 @@ exports.XspFS = XspFS;
 Object.freeze(XspFS.prototype);
 Object.freeze(XspFS);
 class V {
-    constructor(root) {
-        this.rootNode = root;
+    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 file_1.makeFileException(file_1.Code.storageClosed, excPath);
+            throw (0, file_1.makeFileException)('storageClosed', excPath);
         }
         return this.rootNode;
     }
@@ -511,7 +521,7 @@ class V {
             .catch(setExcPath(path));
         if (file) {
             if (exclusive) {
-                throw file_1.makeFileException(file_1.Code.alreadyExists, path);
+                throw (0, file_1.makeFileException)('alreadyExists', path);
             }
         }
         else {
@@ -530,7 +540,13 @@ class V {
             .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);
     }
@@ -552,6 +568,7 @@ class V {
         return folder.list();
     }
     async writeBytes(path, bytes, flags = WRITE_NONEXCL_FLAGS) {
+        this.ensureIsWritable();
         const f = await this.getOrCreateFile(path, flags);
         return f.save(bytes);
     }
@@ -570,7 +587,7 @@ class V {
             return { txt, version };
         }
         catch (err) {
-            throw file_1.makeFileException(file_1.Code.parsingError, path, err);
+            throw (0, file_1.makeFileException)('parsingError', path, err);
         }
     }
     writeJSONFile(path, json, flags = WRITE_NONEXCL_FLAGS) {
@@ -584,10 +601,11 @@ class V {
             return { json, version };
         }
         catch (err) {
-            throw file_1.makeFileException(file_1.Code.parsingError, path, err);
+            throw (0, file_1.makeFileException)('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);
     }
@@ -599,91 +617,190 @@ class V {
 Object.freeze(V.prototype);
 Object.freeze(V);
 class ObjIdToPathMap {
-    constructor() {
+    constructor(maxDepth) {
+        this.maxDepth = maxDepth;
         this.map = new Map();
-        this.moves = new Map();
         Object.seal(this);
     }
     async fillFromTree(root) {
-        for (const [objId, path] of await recursiveIdAndPathList(root, '.')) {
-            this.map.set(objId, path);
+        const listOfAll = await recursiveIdAndPathList(root, '.', this.maxDepth);
+        for (const [objId, path, depth] of listOfAll) {
+            this.map.set(objId, { path, depth });
         }
     }
-    getPathCorrectingTreeMap({ event, objId, parentObjId }) {
-        let path = this.map.get(objId);
-        if (path) {
-            if (event.type === 'removed') {
-                this.map.delete(objId);
-            }
-            else if (event.type === 'entry-renaming') {
-                const { newName, oldName } = event;
-                const child = this.findObjIdByPath(`${path}/${oldName}`);
-                if (child) {
-                    this.map.set(child, `${path}/${newName}`);
-                }
-            }
-            else if (event.type === 'entry-removal') {
-                const { moveLabel, name } = event;
-                if (moveLabel) {
-                    const child = this.findObjIdByPath(`${path}/${name}`);
-                    if (child) {
-                        const moveInfo = this.moves.get(moveLabel);
-                        if (moveInfo) {
-                            this.map.set(child, moveInfo.newPath);
-                            this.moves.delete(moveLabel);
-                        }
-                        else {
-                            this.moves.set(moveLabel, { objId: child });
-                        }
-                    }
-                }
-            }
-            else if (event.type === 'entry-addition') {
-                const { moveLabel, entry: { name } } = event;
-                const newPath = `${path}/${name}`;
-                if (moveLabel) {
-                    const moveInfo = this.moves.get(moveLabel);
-                    if (moveInfo) {
-                        this.map.set(moveInfo.objId, newPath);
-                        this.moves.delete(moveLabel);
-                    }
-                    else {
-                        this.moves.set(moveLabel, { newPath });
-                    }
-                }
-            }
+    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;
         }
-        const parentPath = this.map.get(parentObjId);
-        if (!parentPath || (event.type === 'removed')) {
+        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;
         }
-        path = `${parentPath}/${event.path}`;
-        this.map.set(objId, path);
+        const path = `${parent.path}/${event.path}`;
+        this.map.set(objId, { path, depth: parent.depth + 1 });
         return path;
     }
-    findObjIdByPath(path) {
-        for (const [objId, p] of this.map.entries()) {
-            if (p === path) {
-                return objId;
+    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) {
+async function recursiveIdAndPathList(folder, path, maxDepth, depth = 0) {
     const { lst } = folder.list();
-    const idAndPaths = [[folder.objId, path]];
+    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, `${path}/${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)('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;