core-3nweb-client-lib 0.43.7 → 0.43.9

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

@@ -145,8 +145,53 @@ class NodeInFS {
             };
         }
     }
-    getAttrs() {
-        return this.attrs;
+    async getStatsAndSize(flags) {
+        var _a;
+        let attrs;
+        let version;
+        if (shouldReadCurrentVersion(flags)) {
+            attrs = this.attrs;
+            version = this.version;
+        }
+        else {
+            const src = await this.getObjSrcOfVersion(flags);
+            attrs = await this.crypto.getAttrs(src);
+            version = src.version;
+        }
+        const stats = {
+            ctime: new Date(attrs.ctime),
+            mtime: new Date(attrs.mtime),
+            version,
+            writable: false,
+        };
+        switch (this.type) {
+            case 'folder':
+                stats.isFolder = true;
+                break;
+            case 'link':
+                stats.isLink = true;
+                break;
+            case 'file':
+                stats.isFile = true;
+                break;
+        }
+        if ((this.storage.type === 'synced')
+            || (this.storage.type === 'share')) {
+            const syncStatus = await this.syncedStorage().status(this.objId);
+            const { synced } = syncStatus.syncStatus();
+            if (synced) {
+                if (synced.latest && (version > synced.latest)) {
+                    stats.versionSyncBranch = (((flags === null || flags === void 0 ? void 0 : flags.remoteVersion) === version) ? 'remote' : 'local');
+                }
+                else if ((version === synced.latest) || ((_a = synced.archived) === null || _a === void 0 ? void 0 : _a.includes(version))) {
+                    stats.versionSyncBranch = 'synced';
+                }
+            }
+            else {
+                stats.versionSyncBranch = (((flags === null || flags === void 0 ? void 0 : flags.remoteVersion) === version) ? 'remote' : 'local');
+            }
+        }
+        return { stats, attrs: (attrs.pack ? undefined : attrs) };
     }
     async listVersions() {
         return (await this.storage.status(this.objId)).listVersions();
@@ -432,29 +477,39 @@ class NodeInFS {
         }
         return { createOnRemote: (uploadVersion === 1), localVersion, uploadVersion };
     }
-    async upload(opts) {
+    async startUpload(opts) {
         try {
             const toUpload = await this.needUpload(opts);
             if (!toUpload) {
                 return;
             }
             const { localVersion, createOnRemote, uploadVersion } = toUpload;
-            const uploadHeader = await this.uploadHeaderChange(localVersion, uploadVersion);
-            const storage = this.syncedStorage();
-            await storage.upload(this.objId, localVersion, uploadVersion, uploadHeader, createOnRemote);
-            return await this.doChange(true, async () => {
-                storage.dropCachedLocalObjVersionsLessOrEqual(this.objId, localVersion);
-                if (this.currentVersion === localVersion) {
-                    this.currentVersion = uploadVersion;
-                }
-                return uploadVersion;
-            });
+            return await this.startUploadProcess(localVersion, createOnRemote, uploadVersion);
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, this.name);
         }
     }
-    async uploadHeaderChange(localVersion, uploadVersion) {
+    async startUploadProcess(localVersion, createOnRemote, uploadVersion) {
+        const uploadHeader = await this.makeHeaderForUploadIfVersionChanges(localVersion, uploadVersion);
+        const storage = this.syncedStorage();
+        const { completion, uploadTaskId } = await storage.startUpload(this.objId, localVersion, uploadVersion, uploadHeader, createOnRemote, event => {
+            event.path = this.name;
+            this.broadcastEvent(event);
+        });
+        return {
+            completion: completion.then(() => this.doChange(true, async () => {
+                if (this.currentVersion === localVersion) {
+                    this.currentVersion = uploadVersion;
+                }
+            })).catch(exc => {
+                throw (0, common_1.setPathInExc)(exc, this.name);
+            }),
+            uploadTaskId,
+            uploadVersion
+        };
+    }
+    async makeHeaderForUploadIfVersionChanges(localVersion, uploadVersion) {
         if (localVersion === uploadVersion) {
             return;
         }

package/build/lib-client/xsp-fs/node-persistence.d.ts

@@ -34,6 +34,7 @@ export declare abstract class NodePersistance {
         sub: Subscribe;
     }>;
     reencryptHeader(initHeader: Uint8Array, newVersion: number): Promise<Uint8Array>;
+    getAttrs(objSrc: ObjSource): Promise<Attrs>;
 }
 type FileByteSource = web3n.files.FileByteSource;
 type FileByteSink = web3n.files.FileByteSink;

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

@@ -175,6 +175,10 @@ class NodePersistance {
         const n = (0, xsp_files_1.calculateNonce)(this.zerothHeaderNonce, newVersion);
         return this.cryptor.formatWN.pack(headerContent, n, this.key, this.workLabel);
     }
+    async getAttrs(objSrc) {
+        const payload = await this.readonlyPayload(objSrc);
+        return payload.getAttrs();
+    }
 }
 exports.NodePersistance = NodePersistance;
 Object.freeze(NodePersistance.prototype);

package/build/lib-common/big-endian.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 3NSoft Inc.
+ Copyright (C) 2020, 2025 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -144,7 +144,7 @@ function uintFrom6Bytes(x, i = 0) {
     // treating intermediate integer as signed, and pulling sign to resulting
     // float number. Hence, we need a bit different operation here.
     const h = (x[i] << 8) | x[i + 1];
-    const l = (x[i] * 0x1000000) + ((x[i + 3] << 16) | (x[i + 4] << 8) | x[i + 5]);
+    const l = (x[i + 2] * 0x1000000) + ((x[i + 3] << 16) | (x[i + 4] << 8) | x[i + 5]);
     return (h * 0x100000000 + l);
 }
 /**

package/build/lib-common/processes/labelled-exec-pools.js

@@ -60,9 +60,7 @@ class ProcessingPool {
             await this.doOnError(err);
         }
         finally {
-            if (proc) {
-                this.inProcess.delete(proc);
-            }
+            this.inProcess.delete(proc);
         }
         return this.processNextQueued();
     }