core-3nweb-client-lib 0.27.3 → 0.27.4

package/build/ipc-via-protobuf/fs.js

@@ -261,10 +261,10 @@ var stat;
 Object.freeze(stat);
 var getXAttr;
 (function (getXAttr) {
-    getXAttr.requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.GetXAttrRequestBody);
+    const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.GetXAttrRequestBody);
     function wrapService(fn) {
         return buf => {
-            const { path, xaName } = getXAttr.requestType.unpack(buf);
+            const { path, xaName } = requestType.unpack(buf);
             const promise = fn(path, xaName)
                 .then(file_1.packXAttrValue);
             return { promise };
@@ -274,7 +274,7 @@ var getXAttr;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('getXAttr');
         return (path, xaName) => caller
-            .startPromiseCall(ipcPath, getXAttr.requestType.pack({ path, xaName }))
+            .startPromiseCall(ipcPath, requestType.pack({ path, xaName }))
             .then(file_1.unpackXAttrValue);
     }
     getXAttr.makeCaller = makeCaller;
@@ -695,10 +695,10 @@ var readTxtFile;
 Object.freeze(readTxtFile);
 var readBytes;
 (function (readBytes) {
-    readBytes.requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.ReadBytesRequestBody);
+    const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.ReadBytesRequestBody);
     function wrapService(fn) {
         return buf => {
-            const { path, start, end } = readBytes.requestType.unpack(buf);
+            const { path, start, end } = requestType.unpack(buf);
             const promise = fn(path, (0, protobuf_msg_1.valOfOptInt)(start), (0, protobuf_msg_1.valOfOptInt)(end))
                 .then(file.readBytes.packReply);
             return { promise };
@@ -708,7 +708,7 @@ var readBytes;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('readBytes');
         return (path, start, end) => caller
-            .startPromiseCall(ipcPath, readBytes.requestType.pack({
+            .startPromiseCall(ipcPath, requestType.pack({
             path, start: (0, protobuf_msg_1.toOptVal)(start), end: (0, protobuf_msg_1.toOptVal)(end)
         }))
             .then(file.readBytes.unpackReply);
@@ -1169,12 +1169,27 @@ var fsItem;
     fsItem.fsItemFromMsg = fsItemFromMsg;
 })(fsItem = exports.fsItem || (exports.fsItem = {}));
 Object.freeze(fsItem);
+const reqWithPathAndFlagsType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.PathAndFlagsRequestBody);
+function packRequestWithPathAndFlags(path, flags) {
+    return reqWithPathAndFlagsType.pack({
+        path,
+        flags: file.versionedReadFlagsToMsg(flags)
+    });
+}
+function unpackRequestWithPathAndFlags(buf) {
+    const { path, flags } = reqWithPathAndFlagsType.unpack(buf);
+    return {
+        path,
+        flags: file.versionedReadFlagsFromMsg(flags)
+    };
+}
 var vGetXAttr;
 (function (vGetXAttr) {
+    const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.VersionedGetXAttrRequestBody);
     function wrapService(fn) {
         return buf => {
-            const { path, xaName } = getXAttr.requestType.unpack(buf);
-            const promise = fn(path, xaName)
+            const { path, xaName, flags } = requestType.unpack(buf);
+            const promise = fn(path, xaName, file.versionedReadFlagsFromMsg(flags))
                 .then(attrAndVer => file.vGetXAttr.replyType.pack(attrAndVer));
             return { promise };
         };
@@ -1182,8 +1197,10 @@ var vGetXAttr;
     vGetXAttr.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('getXAttr');
-        return (path, xaName) => caller
-            .startPromiseCall(ipcPath, getXAttr.requestType.pack({ path, xaName }))
+        return (path, xaName, flags) => caller
+            .startPromiseCall(ipcPath, requestType.pack({
+            path, xaName, flags: file.versionedReadFlagsToMsg(flags)
+        }))
             .then(file.vGetXAttr.unpackReply);
     }
     vGetXAttr.makeCaller = makeCaller;
@@ -1193,8 +1210,8 @@ var vListXAttrs;
 (function (vListXAttrs) {
     function wrapService(fn) {
         return buf => {
-            const { path } = reqWithPathType.unpack(buf);
-            const promise = fn(path)
+            const { path, flags } = unpackRequestWithPathAndFlags(buf);
+            const promise = fn(path, flags)
                 .then(({ version, lst }) => file.vListXAttrs.replyType.pack({ version, xaNames: lst }));
             return { promise };
         };
@@ -1202,8 +1219,8 @@ var vListXAttrs;
     vListXAttrs.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('listXAttrs');
-        return path => caller
-            .startPromiseCall(ipcPath, reqWithPathType.pack({ path }))
+        return (path, flags) => caller
+            .startPromiseCall(ipcPath, packRequestWithPathAndFlags(path, flags))
             .then(buf => {
             const { version: v, xaNames } = file.vListXAttrs.replyType.unpack(buf);
             return { version: (0, protobuf_msg_1.fixInt)(v), lst: (xaNames ? xaNames : []) };
@@ -1217,8 +1234,8 @@ var vListFolder;
     const replyType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.VersionedListFolderReplyBody);
     function wrapService(fn) {
         return buf => {
-            const { path } = reqWithPathType.unpack(buf);
-            const promise = fn(path)
+            const { path, flags } = unpackRequestWithPathAndFlags(buf);
+            const promise = fn(path, flags)
                 .then(({ version, lst }) => replyType.pack({
                 version, entries: lst.map(lsEntryToMsg)
             }));
@@ -1228,8 +1245,8 @@ var vListFolder;
     vListFolder.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('listFolder');
-        return path => caller
-            .startPromiseCall(ipcPath, reqWithPathType.pack({ path }))
+        return (path, flags) => caller
+            .startPromiseCall(ipcPath, packRequestWithPathAndFlags(path, flags))
             .then(buf => {
             const { version: v, entries } = replyType.unpack(buf);
             return {
@@ -1244,8 +1261,8 @@ var vReadJSONFile;
 (function (vReadJSONFile) {
     function wrapService(fn) {
         return buf => {
-            const { path } = reqWithPathType.unpack(buf);
-            const promise = fn(path)
+            const { path, flags } = unpackRequestWithPathAndFlags(buf);
+            const promise = fn(path, flags)
                 .then(({ version, json }) => {
                 return file.vReadJSON.replyType.pack({ version, json: JSON.stringify(json) });
             });
@@ -1255,8 +1272,8 @@ var vReadJSONFile;
     vReadJSONFile.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('readJSONFile');
-        return path => caller
-            .startPromiseCall(ipcPath, reqWithPathType.pack({ path }))
+        return (path, flags) => caller
+            .startPromiseCall(ipcPath, packRequestWithPathAndFlags(path, flags))
             .then(buf => {
             const { version: v, json } = file.vReadJSON.replyType.unpack(buf);
             return { version: (0, protobuf_msg_1.fixInt)(v), json: JSON.parse(json) };
@@ -1269,8 +1286,8 @@ var vReadTxtFile;
 (function (vReadTxtFile) {
     function wrapService(fn) {
         return buf => {
-            const { path } = reqWithPathType.unpack(buf);
-            const promise = fn(path)
+            const { path, flags } = unpackRequestWithPathAndFlags(buf);
+            const promise = fn(path, flags)
                 .then(verAndTxt => file.vReadTxt.replyType.pack(verAndTxt));
             return { promise };
         };
@@ -1278,8 +1295,8 @@ var vReadTxtFile;
     vReadTxtFile.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('readTxtFile');
-        return path => caller
-            .startPromiseCall(ipcPath, reqWithPathType.pack({ path }))
+        return (path, flags) => caller
+            .startPromiseCall(ipcPath, packRequestWithPathAndFlags(path, flags))
             .then(buf => {
             const { version: v, txt } = file.vReadTxt.replyType.unpack(buf);
             return { version: (0, protobuf_msg_1.fixInt)(v), txt };
@@ -1290,10 +1307,11 @@ var vReadTxtFile;
 Object.freeze(vReadTxtFile);
 var vReadBytes;
 (function (vReadBytes) {
+    const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.VersionedReadBytesRequestBody);
     function wrapService(fn) {
         return buf => {
-            const { path, start, end } = readBytes.requestType.unpack(buf);
-            const promise = fn(path, (0, protobuf_msg_1.valOfOptInt)(start), (0, protobuf_msg_1.valOfOptInt)(end))
+            const { path, start, end, flags } = requestType.unpack(buf);
+            const promise = fn(path, (0, protobuf_msg_1.valOfOptInt)(start), (0, protobuf_msg_1.valOfOptInt)(end), file.versionedReadFlagsFromMsg(flags))
                 .then(file.vReadBytes.packReply);
             return { promise };
         };
@@ -1301,13 +1319,12 @@ var vReadBytes;
     vReadBytes.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('readBytes');
-        return (path, start, end) => {
-            return caller
-                .startPromiseCall(ipcPath, readBytes.requestType.pack({
-                path, start: (0, protobuf_msg_1.toOptVal)(start), end: (0, protobuf_msg_1.toOptVal)(end)
-            }))
-                .then(file.vReadBytes.unpackReply);
-        };
+        return (path, start, end, flags) => caller
+            .startPromiseCall(ipcPath, requestType.pack({
+            path, start: (0, protobuf_msg_1.toOptVal)(start), end: (0, protobuf_msg_1.toOptVal)(end),
+            flags: file.versionedReadFlagsToMsg(flags)
+        }))
+            .then(file.vReadBytes.unpackReply);
     }
     vReadBytes.makeCaller = makeCaller;
 })(vReadBytes || (vReadBytes = {}));
@@ -1316,7 +1333,7 @@ var vGetByteSource;
 (function (vGetByteSource) {
     function wrapService(fn, expServices) {
         return buf => {
-            const { path } = reqWithPathType.unpack(buf);
+            const { path, flags } = unpackRequestWithPathAndFlags(buf);
             const promise = fn(path)
                 .then(({ version, src }) => {
                 const ref = (0, bytes_1.exposeSrcService)(src, expServices);
@@ -1328,8 +1345,8 @@ var vGetByteSource;
     vGetByteSource.wrapService = wrapService;
     function makeCaller(caller, objPath) {
         const ipcPath = objPath.concat('getByteSource');
-        return path => caller
-            .startPromiseCall(ipcPath, reqWithPathType.pack({ path }))
+        return (path, flags) => caller
+            .startPromiseCall(ipcPath, packRequestWithPathAndFlags(path, flags))
             .then(buf => {
             const { version: v, src } = file.vGetByteSource.replyType.unpack(buf);
             return { version: (0, protobuf_msg_1.fixInt)(v), src: (0, bytes_1.makeSrcCaller)(caller, src) };

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

@@ -11,6 +11,7 @@ import { NodePersistance } from './node-persistence';
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
+declare type VersionedReadFlags = web3n.files.VersionedReadFlags;
 interface FileAttrs {
     attrs: CommonAttrs;
     size: number;
@@ -19,14 +20,8 @@ interface FileAttrs {
 declare class FilePersistance extends NodePersistance {
     constructor(zNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
     getAttrs(objSrc: ObjSource): Promise<FileAttrs>;
-    getFileSource(objSrc: ObjSource, getAttrs?: boolean): Promise<{
-        src: FileByteSource;
-        fileAttrs?: FileAttrs;
-    }>;
-    readBytes(objSrc: ObjSource, start: number | undefined, end: number | undefined, getAttrs?: boolean): Promise<{
-        bytes?: Uint8Array;
-        fileAttrs?: FileAttrs;
-    }>;
+    getFileSource(objSrc: ObjSource): Promise<FileByteSource>;
+    readBytes(objSrc: ObjSource, start: number | undefined, end: number | undefined): Promise<Uint8Array | undefined>;
     saveBytes(bytes: Uint8Array | Uint8Array[], version: number, attrs: CommonAttrs, xattrs: XAttrs | undefined): Promise<Subscribe>;
     getFileSink(version: number, attrs: CommonAttrs, xattrs: XAttrs | undefined, base: ObjSource | undefined): Promise<{
         sinkPromise: Promise<FileByteSink>;
@@ -48,11 +43,11 @@ export declare class FileNode extends NodeInFS<FilePersistance> {
     protected setCurrentStateFrom(src: ObjSource): Promise<void>;
     private setUpdatedState;
     get size(): number;
-    readSrc(): Promise<{
+    readSrc(flags: VersionedReadFlags | undefined): Promise<{
         src: FileByteSource;
         version: number;
     }>;
-    readBytes(start: number | undefined, end: number | undefined): Promise<{
+    readBytes(start: number | undefined, end: number | undefined, flags: VersionedReadFlags | undefined): Promise<{
         bytes: Uint8Array | undefined;
         version: number;
     }>;

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

@@ -43,14 +43,11 @@ class FilePersistance extends node_persistence_1.NodePersistance {
         const payload = await super.readonlyPayload(objSrc);
         return await fileAttrsFrom(payload);
     }
-    async getFileSource(objSrc, getAttrs = false) {
+    async getFileSource(objSrc) {
         const payload = await this.readonlyPayload(objSrc);
-        const src = payload.makeFileByteSource();
-        return (getAttrs ?
-            { src, fileAttrs: await fileAttrsFrom(payload) } :
-            { src });
+        return payload.makeFileByteSource();
     }
-    async readBytes(objSrc, start, end, getAttrs = false) {
+    async readBytes(objSrc, start, end) {
         if ((typeof start === 'number') && (start < 0)) {
             throw new Error(`Parameter start has bad value: ${start}`);
         }
@@ -64,22 +61,18 @@ class FilePersistance extends node_persistence_1.NodePersistance {
             end = size;
         }
         else if (start >= size) {
-            return (getAttrs ? { fileAttrs: await fileAttrsFrom(payload) } : {});
+            return;
         }
         if (typeof end === 'number') {
             end = Math.min(size, end);
             if (end <= start) {
-                return (getAttrs ?
-                    { fileAttrs: await fileAttrsFrom(payload) } : {});
+                return;
             }
         }
         else {
             end = size;
         }
-        const bytes = await payload.readSomeContentBytes(start, end);
-        return (getAttrs ?
-            { bytes, fileAttrs: await fileAttrsFrom(payload) } :
-            { bytes });
+        return await payload.readSomeContentBytes(start, end);
     }
     async saveBytes(bytes, version, attrs, xattrs) {
         return super.writeWhole(bytes, version, attrs, xattrs);
@@ -139,45 +132,50 @@ class FileNode extends node_in_fs_1.NodeInFS {
     get size() {
         return this.fileSize;
     }
-    async readSrc() {
-        const objSrc = await this.storage.getObjSrc(this.objId);
-        if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
-            const version = objSrc.version;
-            if (this.version < version) {
-                const { src, fileAttrs } = await this.crypto.getFileSource(objSrc, true);
-                this.setUpdatedState(version, fileAttrs);
-                return { src, version };
-            }
-            else {
-                const { src } = await this.crypto.getFileSource(objSrc);
-                return { src, version };
-            }
+    async readSrc(flags) {
+        const objSrc = await this.getObjSrcOfVersion(flags);
+        let version;
+        if ((this.storage.type === 'synced')
+            || (this.storage.type === 'local')
+            || (this.storage.type === 'share')) {
+            version = objSrc.version;
         }
         else {
-            const { src } = await this.crypto.getFileSource(objSrc);
-            // unversioned storage passes undefined version
-            return { src, version: undefined };
+            version = undefined;
         }
+        const src = await this.crypto.getFileSource(objSrc);
+        return { src, version };
     }
-    async readBytes(start, end) {
-        const objSrc = await this.storage.getObjSrc(this.objId);
-        if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
-            const version = objSrc.version;
-            if (this.version < version) {
-                const { bytes, fileAttrs } = await this.crypto.readBytes(objSrc, start, end, true);
-                this.setUpdatedState(version, fileAttrs);
-                return { bytes, version };
-            }
-            else {
-                const { bytes } = await this.crypto.readBytes(objSrc, start, end);
-                return { bytes, version };
-            }
+    async readBytes(start, end, flags) {
+        const objSrc = await this.getObjSrcOfVersion(flags);
+        let version;
+        if ((this.storage.type === 'synced')
+            || (this.storage.type === 'local')
+            || (this.storage.type === 'share')) {
+            version = objSrc.version;
         }
         else {
-            const { bytes } = await this.crypto.readBytes(objSrc, start, end);
-            // unversioned storage passes undefined version
-            return { bytes, version: undefined };
+            version = undefined;
         }
+        const bytes = await this.crypto.readBytes(objSrc, start, end);
+        return { bytes, version };
+        // if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
+        // 	const version = objSrc.version;
+        // 	if (this.version < version) {
+        // 		const {
+        // 			bytes, fileAttrs
+        // 		} = await this.crypto.readBytes(objSrc, start, end, true);
+        // 		// this.setUpdatedState(version, fileAttrs!);
+        // 		return { bytes, version };
+        // 	} else {
+        // 		const { bytes } = await this.crypto.readBytes(objSrc, start, end);
+        // 		return { bytes, version };
+        // 	}
+        // } else {
+        // 	const { bytes } = await this.crypto.readBytes(objSrc, start, end);
+        // 	// unversioned storage passes undefined version
+        // 	return { bytes, version: (undefined as any) };
+        // }
     }
     async writeSink(truncate, currentVersion, changes) {
         const deferredSink = (0, deferred_1.defer)();

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

@@ -15,6 +15,7 @@ declare type SyncStatus = web3n.files.SyncStatus;
 declare type WritableFileVersionedAPI = web3n.files.WritableFileVersionedAPI;
 declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
+declare type VersionedReadFlags = web3n.files.VersionedReadFlags;
 export declare class FileObject implements WritableFile, Linkable {
     name: string;
     isNew: boolean;
@@ -54,11 +55,11 @@ declare class V implements WritableFileVersionedAPI, N {
     getNode(): Promise<FileNode>;
     ensureIsWritable(): void;
     updateXAttrs(changes: XAttrsChanges): Promise<number>;
-    getXAttr(xaName: string): Promise<{
+    getXAttr(xaName: string, flags?: VersionedReadFlags): Promise<{
         attr: any;
         version: number;
     }>;
-    listXAttrs(): Promise<{
+    listXAttrs(flags?: VersionedReadFlags): Promise<{
         lst: string[];
         version: number;
     }>;
@@ -67,23 +68,23 @@ declare class V implements WritableFileVersionedAPI, N {
         sink: FileByteSink;
         version: number;
     }>;
-    getByteSource(): Promise<{
+    getByteSource(flags?: VersionedReadFlags): Promise<{
         src: FileByteSource;
         version: number;
     }>;
     writeBytes(bytes: Uint8Array): Promise<number>;
     writeTxt(txt: string): Promise<number>;
     writeJSON(json: any): Promise<number>;
-    readBytes(start?: number, end?: number): Promise<{
+    readBytes(start?: number, end?: number, flags?: VersionedReadFlags): Promise<{
         bytes: Uint8Array | undefined;
         version: number;
     }>;
-    readTxt(): Promise<{
+    readTxt(flags?: VersionedReadFlags): Promise<{
         txt: string;
         version: number;
     }>;
     copy(file: File): Promise<number>;
-    readJSON<T>(): Promise<{
+    readJSON<T>(flags?: VersionedReadFlags): Promise<{
         json: T;
         version: number;
     }>;

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

@@ -148,19 +148,13 @@ class V {
         const node = await this.getNode();
         return node.updateXAttrs(changes);
     }
-    async getXAttr(xaName) {
+    async getXAttr(xaName, flags) {
         const node = await this.getNode();
-        return {
-            attr: node.getXAttr(xaName),
-            version: node.version
-        };
+        return await node.getXAttr(xaName, flags);
     }
-    async listXAttrs() {
+    async listXAttrs(flags) {
         const node = await this.getNode();
-        return {
-            lst: node.listXAttrs(),
-            version: node.version
-        };
+        return await node.listXAttrs(flags);
     }
     async getLinkParams() {
         if (!this.node) {
@@ -176,11 +170,11 @@ class V {
         const node = await this.getNode();
         return node.writeSink(truncate, currentVersion);
     }
-    async getByteSource() {
+    async getByteSource(flags) {
         if (!this.node) {
             throw (0, file_1.makeFileException)('notFound', this.name);
         }
-        return this.node.readSrc();
+        return this.node.readSrc(flags);
     }
     async writeBytes(bytes) {
         this.ensureIsWritable();
@@ -194,14 +188,14 @@ class V {
     writeJSON(json) {
         return this.writeTxt(JSON.stringify(json));
     }
-    async readBytes(start, end) {
+    async readBytes(start, end, flags) {
         if (!this.node) {
             throw (0, file_1.makeFileException)('notFound', this.name);
         }
-        return await this.node.readBytes(start, end);
+        return await this.node.readBytes(start, end, flags);
     }
-    async readTxt() {
-        const { bytes, version } = await this.readBytes();
+    async readTxt(flags) {
+        const { bytes, version } = await this.readBytes(undefined, undefined, flags);
         const txt = (bytes ? buffer_utils_1.utf8.open(bytes) : '');
         return { txt, version };
     }
@@ -212,8 +206,8 @@ class V {
         await (0, pipe_1.pipe)(src, sink);
         return version;
     }
-    async readJSON() {
-        const { txt, version } = await this.readTxt();
+    async readJSON(flags) {
+        const { txt, version } = await this.readTxt(flags);
         const json = JSON.parse(txt);
         return { json, version };
     }

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

@@ -12,6 +12,7 @@ declare type FolderDiff = web3n.files.FolderDiff;
 declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 declare type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
 declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
+declare type VersionedReadFlags = web3n.files.VersionedReadFlags;
 export interface NodeInfo {
     /**
      * This is a usual file name.
@@ -80,6 +81,10 @@ export declare class FolderNode extends NodeInFS<FolderPersistance> {
         lst: ListingEntry[];
         version: number;
     };
+    listNonCurrent(flags: VersionedReadFlags): Promise<{
+        lst: ListingEntry[];
+        version: number;
+    }>;
     childExistsInSyncedVersion(childObjId: string): Promise<boolean>;
     getNodeInfo(name: string, undefOnMissing?: boolean): NodeInfo | undefined;
     hasChild(childName: string, throwIfMissing?: boolean): boolean;

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

@@ -224,6 +224,13 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             .map(nodeInfoToListingEntry);
         return { lst, version: this.version };
     }
+    async listNonCurrent(flags) {
+        const src = await this.getObjSrcOfVersion(flags);
+        const { folderInfo } = await this.crypto.read(src);
+        const lst = Object.values(folderInfo)
+            .map(nodeInfoToListingEntry);
+        return { lst, version: src.version };
+    }
     async childExistsInSyncedVersion(childObjId) {
         const { state, synced } = await this.syncStatus();
         if (state === 'synced') {
@@ -783,7 +790,6 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
     }
     async uploadRemovalOf(removedNodes) {
-        const storage = this.syncedStorage();
         const rmObjs = [];
         for (const node of removedNodes) {
             (0, for_arrays_1.appendArray)(rmObjs, await this.listRemovedInTreeToUploadRm(node));

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

@@ -21,6 +21,7 @@ declare type FSCollection = web3n.files.FSCollection;
 declare type FileFlags = web3n.files.FileFlags;
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
+declare type VersionedReadFlags = web3n.files.VersionedReadFlags;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
 declare type WritableFSSyncAPI = web3n.files.WritableFSSyncAPI;
 declare type SyncStatus = web3n.files.SyncStatus;
@@ -39,7 +40,7 @@ export declare class XspFS implements WritableFS {
     private constructor();
     private storage;
     readonlySubRoot(path: string): Promise<ReadonlyFS>;
-    writableSubRoot(path: string, flags?: web3n.files.VersionedFileFlags): Promise<WritableFS>;
+    writableSubRoot(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<WritableFS>;
     /**
      * This creates in a root object in a given storage, returning fs object
      * representing created root.
@@ -88,7 +89,7 @@ export declare class XspFS implements WritableFS {
     watchFile(path: string, observer: Observer<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>;
+    writableFile(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<WritableFile>;
     copyFile(src: string, dst: string, overwrite?: boolean): Promise<void>;
     saveFile(file: File, dst: string, overwrite?: boolean): Promise<void>;
     listFolder(folder: string): Promise<ListingEntry[]>;
@@ -96,10 +97,10 @@ export declare class XspFS implements WritableFS {
     readTxtFile(path: string): Promise<string>;
     readBytes(path: string, start?: number, end?: number): Promise<Uint8Array | undefined>;
     getByteSource(path: string): Promise<FileByteSource>;
-    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileFlags): Promise<void>;
-    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileFlags): Promise<void>;
-    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileFlags): Promise<void>;
-    getByteSink(path: string, flags?: web3n.files.VersionedFileFlags): Promise<FileByteSink>;
+    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileWriteFlags): Promise<void>;
+    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<void>;
+    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileWriteFlags): Promise<void>;
+    getByteSink(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<FileByteSink>;
 }
 interface N {
     get(path: string): Promise<NodeInFS<any>>;
@@ -121,38 +122,38 @@ declare class V implements WritableFSVersionedAPI, N {
     get(path: string): Promise<NodeInFS<any>>;
     ensureIsWritable(): void;
     updateXAttrs(path: string, changes: XAttrsChanges): Promise<number>;
-    getXAttr(path: string, xaName: string): Promise<{
+    getXAttr(path: string, xaName: string, flags?: VersionedReadFlags): Promise<{
         attr: any;
         version: number;
     }>;
-    listXAttrs(path: string): Promise<{
+    listXAttrs(path: string, flags?: VersionedReadFlags): Promise<{
         lst: string[];
         version: number;
     }>;
-    listFolder(path: string): Promise<{
+    listFolder(path: string, flags?: VersionedReadFlags): Promise<{
         lst: ListingEntry[];
         version: number;
     }>;
-    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileFlags): Promise<number>;
-    readBytes(path: string, start?: number, end?: number): Promise<{
+    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileWriteFlags): Promise<number>;
+    readBytes(path: string, start?: number, end?: number, flags?: VersionedReadFlags): Promise<{
         bytes: Uint8Array | undefined;
         version: number;
     }>;
-    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileFlags): Promise<number>;
-    readTxtFile(path: string): Promise<{
+    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<number>;
+    readTxtFile(path: string, flags?: VersionedReadFlags): Promise<{
         txt: string;
         version: number;
     }>;
-    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileFlags): Promise<number>;
-    readJSONFile<T>(path: string): Promise<{
+    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileWriteFlags): Promise<number>;
+    readJSONFile<T>(path: string, flags?: VersionedReadFlags): Promise<{
         json: T;
         version: number;
     }>;
-    getByteSink(path: string, flags?: web3n.files.VersionedFileFlags): Promise<{
+    getByteSink(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<{
         sink: FileByteSink;
         version: number;
     }>;
-    getByteSource(path: string): Promise<{
+    getByteSource(path: string, flags?: VersionedReadFlags): Promise<{
         src: FileByteSource;
         version: number;
     }>;