core-3nweb-client-lib 0.25.3 → 0.26.0

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

@@ -31,6 +31,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,32 +56,37 @@ 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);
         Object.seal(this);
     }
+    storage() {
+        if (!this.store) {
+            throw 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;
+        const fs = new XspFS(this.storage(), false, folder, folderName);
         return 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;
+        const fs = new XspFS(this.storage(), true, folder, folderName);
         return files_1.wrapWritableFS(fs);
     }
     /**
@@ -90,8 +96,8 @@ 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);
+        const root = await folder_node_1.FolderNode.newRoot(storage, key);
+        const fs = new XspFS(storage, true, root);
         return files_1.wrapWritableFS(fs);
     }
     /**
@@ -101,35 +107,36 @@ 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);
+        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);
     }
     static fromASMailMsgRootFromJSON(storage, folderJson, rootName) {
-        const fs = new XspFS(storage, false, rootName);
-        fs.v.root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
+        const root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
+        const fs = new XspFS(storage, false, root, rootName);
         return 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)
-            .catch(setExcPath(path));
+        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);
     }
     async deleteFolder(path, removeContent = false) {
         const { fileName: folderName, folderPath: parentPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(parentPath)
-            .catch(setExcPath(parentPath.join('/')));
+        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');
         }
@@ -142,18 +149,17 @@ class XspFS {
     }
     async deleteFile(path) {
         const { fileName, folderPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(folderPath)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
         const file = await parentFolder.getFile(fileName)
             .catch(setExcPath(path));
         await parentFolder.removeChild(file);
     }
     async deleteLink(path) {
         const { fileName, folderPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(folderPath)
-            .catch(setExcPath(path));
-        const link = await parentFolder.getLink(fileName)
-            .catch(setExcPath(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));
         await parentFolder.removeChild(link);
     }
     async move(initPath, newPath) {
@@ -169,10 +175,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) {
@@ -190,11 +197,13 @@ 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') {
@@ -311,21 +320,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 +345,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,25 +367,48 @@ 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);
+        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));
     }
+    getCloseEvent$() {
+        return this.fsObs.event$.pipe(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 = rxjs_1.from(nodeProm)
+            .pipe(operators_1.mergeMap(f => f.event$), operators_1.takeUntil(this.getCloseEvent$()))
+            .subscribe(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 = 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));
         return () => watchSub.unsubscribe();
     }
     watchTree(path, observer) {
-        throw new Error('Not implemented, yet');
+        const folderPath = splitPathIntoParts(path);
+        const root = this.v.getRootIfNotClosed(path);
+        const idToPath = new ObjIdToPathMap();
+        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));
+        return () => watchSub.unsubscribe();
     }
     async readonlyFile(path) {
         const fNode = await this.v.getOrCreateFile(path, {});
@@ -455,15 +489,23 @@ exports.XspFS = XspFS;
 Object.freeze(XspFS.prototype);
 Object.freeze(XspFS);
 class V {
-    constructor() {
-        this.root = undefined;
+    constructor(root) {
+        this.rootNode = root;
         Object.seal(this);
     }
+    close() {
+        this.rootNode = undefined;
+    }
+    getRootIfNotClosed(excPath) {
+        if (!this.rootNode) {
+            throw 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));
@@ -479,10 +521,10 @@ 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));
@@ -505,7 +547,8 @@ 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) {
@@ -555,4 +598,92 @@ class V {
 }
 Object.freeze(V.prototype);
 Object.freeze(V);
+class ObjIdToPathMap {
+    constructor() {
+        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);
+        }
+    }
+    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 });
+                    }
+                }
+            }
+            return path;
+        }
+        const parentPath = this.map.get(parentObjId);
+        if (!parentPath || (event.type === 'removed')) {
+            return;
+        }
+        path = `${parentPath}/${event.path}`;
+        this.map.set(objId, path);
+        return path;
+    }
+    findObjIdByPath(path) {
+        for (const [objId, p] of this.map.entries()) {
+            if (p === path) {
+                return objId;
+            }
+        }
+    }
+}
+Object.freeze(ObjIdToPathMap.prototype);
+Object.freeze(ObjIdToPathMap);
+async function recursiveIdAndPathList(folder, path) {
+    const { lst } = folder.list();
+    const idAndPaths = [[folder.objId, path]];
+    for (const item of lst) {
+        if (item.isFile || item.isLink) {
+        }
+        else if (item.isFolder) {
+            const child = await folder.getFolder(item.name);
+            const childLst = await recursiveIdAndPathList(child, `${path}/${item.name}`);
+            idAndPaths.push(...childLst);
+        }
+    }
+    return idAndPaths;
+}
 Object.freeze(exports);

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

@@ -2,8 +2,10 @@ import { Node, NodeType, Storage, RemoteEvent } from './common';
 import { Observable } from 'rxjs';
 import { CommonAttrs, XAttrs } from './attrs';
 import { NodePersistance } from './node-persistence';
+import { UpSyncTaskInfo } from '../../../core/storage/synced/obj-status';
 export declare type FSEvent = web3n.files.FolderEvent | web3n.files.FileEvent;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
+declare type Stats = web3n.files.Stats;
 export declare abstract class NodeInFS<P extends NodePersistance> implements Node {
     protected readonly storage: Storage;
     readonly type: NodeType;
@@ -34,6 +36,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     private bufferRemoteEvent;
     private getBufferedEvent;
     localDelete(): Promise<void>;
+    broadcastUpSyncEvent(task: UpSyncTaskInfo): void;
     /**
      * This non-synchronized method deletes object from storage, and detaches
      * this node from storage. Make sure to call it inside access synchronization
@@ -71,5 +74,6 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
      */
     private events;
     get event$(): Observable<FSEvent>;
+    sync(): Promise<Stats['sync']>;
 }
 export {};

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

@@ -21,7 +21,7 @@ exports.NodeInFS = void 0;
  * Everything in this module is assumed to be inside of a file system
  * reliance set.
  */
-const processes_1 = require("../../../lib-common/processes");
+const synced_1 = require("../../../lib-common/processes/synced");
 const file_1 = require("../../../lib-common/exceptions/file");
 const error_1 = require("../../../lib-common/exceptions/error");
 const rxjs_1 = require("rxjs");
@@ -96,7 +96,7 @@ class NodeInFS {
     getAttrs() {
         return this.attrs;
     }
-    processRemoteEvent(event) {
+    async processRemoteEvent(event) {
         this.bufferRemoteEvent(event);
         return this.doChange(true, async () => {
             const event = this.getBufferedEvent();
@@ -104,6 +104,10 @@ class NodeInFS {
                 return;
             }
             if (event.type === 'remote-change') {
+                // TODO
+                // uploader should show if there is process for this obj uploads with version
+                // in the event, and if so, wait for completion of that process to either ignore
+                // remote event, or to set conflict, or whatever
                 // XXX should we use here synced storage methods here?
                 //     This method is called only in synced storage.
                 // XXX detect if there is a conflict
@@ -127,6 +131,9 @@ class NodeInFS {
             this.remoteEvents = [];
         }
         this.remoteEvents.push(event);
+        if (this.remoteEvents.length > 1) {
+            // XXX attempt to compress events
+        }
     }
     getBufferedEvent() {
         if (!this.remoteEvents) {
@@ -141,13 +148,27 @@ class NodeInFS {
     localDelete() {
         return this.doChange(true, () => this.delete());
     }
+    broadcastUpSyncEvent(task) {
+        if (task.type === 'upload') {
+            this.broadcastEvent({
+                type: 'sync-upload',
+                path: this.name,
+                current: this.version,
+                uploaded: task.version
+            });
+        }
+    }
     /**
      * This non-synchronized method deletes object from storage, and detaches
      * this node from storage. Make sure to call it inside access synchronization
      * construct.
      */
     async delete(remoteEvent) {
-        if (!remoteEvent) {
+        if (remoteEvent) {
+            // XXX
+            throw Error(`Removal from remote side is not implemented, yet.`);
+        }
+        else {
             await this.storage.removeObj(this.objId);
         }
         this.storage.nodes.delete(this);
@@ -173,34 +194,32 @@ class NodeInFS {
      */
     async doChange(awaitPrevChange, change) {
         if (!this.writeProc) {
-            this.writeProc = new processes_1.SingleProc();
+            this.writeProc = new synced_1.SingleProc();
         }
         if (!awaitPrevChange && this.writeProc.isProcessing()) {
             throw file_1.makeFileException(file_1.Code.concurrentUpdate, this.name + ` type ${this.type}`);
         }
-        try {
-            const res = await this.writeProc.startOrChain(() => {
-                if (this.currentVersion < 0) {
-                    throw file_1.makeFileException(file_1.Code.notFound, this.name);
-                }
-                return change();
-            });
-            return res;
-        }
-        catch (exc) {
-            if (!exc.runtimeException) {
-                throw error_1.errWithCause(exc, `Cannot save changes to ${this.type} ${this.name}, version ${this.version}`);
+        const res = await this.writeProc.startOrChain(() => {
+            if (this.currentVersion < 0) {
+                throw file_1.makeFileException(file_1.Code.notFound, this.name, `Object is marked removed`);
             }
-            if (exc.type === 'storage') {
-                if (exc.concurrentTransaction) {
-                    throw file_1.makeFileException(file_1.Code.concurrentUpdate, this.name, exc);
+            return change()
+                .catch((exc) => {
+                if (!exc.runtimeException) {
+                    throw error_1.errWithCause(exc, `Cannot save changes to ${this.type} ${this.name}, version ${this.version}`);
                 }
-                else if (exc.objNotFound) {
-                    throw file_1.makeFileException(file_1.Code.notFound, this.name, exc);
+                if (exc.type === 'storage') {
+                    if (exc.concurrentTransaction) {
+                        throw file_1.makeFileException(file_1.Code.concurrentUpdate, this.name, exc);
+                    }
+                    else if (exc.objNotFound) {
+                        throw file_1.makeFileException(file_1.Code.notFound, this.name, exc);
+                    }
                 }
-            }
-            throw file_1.makeFileException(file_1.Code.ioError, this.name, exc);
-        }
+                throw file_1.makeFileException(file_1.Code.ioError, this.name, exc);
+            });
+        });
+        return res;
     }
     /**
      * This method is called on conflict with remote version. This method
@@ -238,12 +257,14 @@ class NodeInFS {
         this.broadcastEvent(event);
     }
     broadcastEvent(event, complete) {
+        this.storage.broadcastNodeEvent(this.objId, this.parentId, event);
         if (!this.events) {
             return;
         }
         this.events.next(event);
         if (complete) {
             this.events.complete();
+            this.events = undefined;
         }
     }
     get event$() {
@@ -252,6 +273,12 @@ class NodeInFS {
         }
         return this.events.asObservable().pipe(operators_1.share());
     }
+    async sync() {
+        if ((this.storage.type === 'synced')
+            || (this.storage.type === 'share')) {
+            return this.storage.getObjSyncInfo(this.objId);
+        }
+    }
 }
 exports.NodeInFS = NodeInFS;
 Object.freeze(NodeInFS.prototype);

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

@@ -23,7 +23,7 @@ exports.NodePersistance = void 0;
  */
 const xsp_files_1 = require("xsp-files");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
-const processes_1 = require("../../../lib-common/processes");
+const deferred_1 = require("../../../lib-common/processes/deferred");
 const random = require("../../../lib-common/random-node");
 const pv1 = require("./xsp-payload-v1");
 const pv2 = require("./xsp-payload-v2");
@@ -148,7 +148,7 @@ class NodePersistance {
             this.segWriterWithBase(newVersion, base) :
             this.segWriter(newVersion));
         const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
-        const defSink = processes_1.defer();
+        const defSink = deferred_1.defer();
         return {
             sinkPromise: defSink.promise,
             sub: (obs, backpressure) => {

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

@@ -19,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeReadonlyPayload = void 0;
 const assert_1 = require("../../../lib-common/assert");
 const file_1 = require("../../../lib-common/exceptions/file");
-const processes_1 = require("../../../lib-common/processes");
+const synced_1 = require("../../../lib-common/processes/synced");
 const attrs_1 = require("./attrs");
 async function makeReadonlyPayload(src) {
     const payload = await ReadonlyPayloadV1.makeFor(src);
@@ -31,7 +31,7 @@ class ReadonlyPayloadV1 {
         this.src = src;
         this.size = size;
         this.isEndless = isEndless;
-        this.syncProc = new processes_1.SingleProc();
+        this.syncProc = new synced_1.SingleProc();
         this.xattrs = undefined;
         this.isEndless = (this.size === undefined);
         Object.seal(this);

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

@@ -20,7 +20,7 @@ exports.makeWritablePayloadFromBase = exports.makeWritablePayload = exports.make
 const assert_1 = require("../../../lib-common/assert");
 const big_endian_1 = require("../../../lib-common/big-endian");
 const attrs_1 = require("./attrs");
-const processes_1 = require("../../../lib-common/processes");
+const synced_1 = require("../../../lib-common/processes/synced");
 const wrapping_1 = require("../../../lib-common/byte-streaming/wrapping");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 async function makeReadonlyPayload(src) {
@@ -47,7 +47,7 @@ class ReadonlyPayloadV2 {
         this.attrs = attrs;
         this.contentSections = contentSections;
         this.xattrsSections = xattrsSections;
-        this.syncProc = new processes_1.SingleProc();
+        this.syncProc = new synced_1.SingleProc();
         this.xattrs = undefined;
         this.size = sizeOfContent(this.contentSections);
         Object.seal(this);
@@ -247,7 +247,7 @@ class WritablePayloadV2 {
         this.attrs = attrs;
         this.contentSections = contentSections;
         this.xattrsSections = xattrsSections;
-        this.syncProc = new processes_1.SingleProc();
+        this.syncProc = new synced_1.SingleProc();
         this.completionErr = undefined;
         assert_1.assert(!!this.sink);
         if ((this.contentSections.length + this.xattrsSections.length) === 0) {