core-3nweb-client-lib 0.43.20 → 0.44.0

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

@@ -28,9 +28,11 @@ type SyncStatus = web3n.files.SyncStatus;
 type WritableFSVersionedAPI = web3n.files.WritableFSVersionedAPI;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
-type OptionsToAdoptAllRemoteItems = web3n.files.OptionsToAdoptAllRemoteItems;
+type OptionsToDiffFileVersions = web3n.files.OptionsToDiffFileVersions;
 type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 type FolderDiff = web3n.files.FolderDiff;
+type FileDiff = web3n.files.FileDiff;
+type OptionsToMergeFolderVersions = web3n.files.OptionsToMergeFolderVersions;
 export declare class XspFS implements WritableFS {
     readonly writable: boolean;
     name: string;
@@ -178,11 +180,13 @@ declare class S implements WritableFSSyncAPI {
     adoptRemote(path: string, opts?: OptionsToAdopteRemote): Promise<void>;
     private getFolderNode;
     diffCurrentAndRemoteFolderVersions(path: string, remoteVersion?: number): Promise<FolderDiff | undefined>;
+    private getFileNode;
+    diffCurrentAndRemoteFileVersions(path: string, opts?: OptionsToDiffFileVersions): Promise<FileDiff | undefined>;
     adoptRemoteFolderItem(path: string, itemName: string, opts?: OptionsToAdoptRemoteItem): Promise<number>;
     statRemoteItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<Stats>;
     listRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ListingEntry[]>;
     getRemoteFileItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFile>;
     getRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFS>;
-    adoptAllRemoteItems(path: string, opts?: OptionsToAdoptAllRemoteItems): Promise<number | undefined>;
+    mergeFolderCurrentAndRemoteVersions(path: string, opts?: OptionsToMergeFolderVersions): Promise<number | undefined>;
 }
 export {};

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

@@ -799,6 +799,22 @@ class S {
             throw (0, common_1.setPathInExc)(exc, path);
         }
     }
+    async getFileNode(path) {
+        const node = await this.n.get(path);
+        if (node.type !== 'file') {
+            throw (0, file_1.makeFileException)('notFile', path);
+        }
+        return node;
+    }
+    async diffCurrentAndRemoteFileVersions(path, opts) {
+        const node = await this.getFileNode(path);
+        try {
+            return await node.diffCurrentAndRemote(opts === null || opts === void 0 ? void 0 : opts.remoteVersion, !!(opts === null || opts === void 0 ? void 0 : opts.compareContentIfSameMTime));
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, path);
+        }
+    }
     async adoptRemoteFolderItem(path, itemName, opts) {
         const node = await this.getFolderNode(path);
         try {
@@ -843,9 +859,24 @@ class S {
             throw (0, file_1.makeFileException)('notDirectory', `${path}/${remoteItemName}`);
         }
     }
-    async adoptAllRemoteItems(path, opts) {
+    // async adoptAllRemoteItems(
+    // 	path: string, opts?: OptionsToAdoptAllRemoteItems
+    // ): Promise<number|undefined> {
+    // 	const folderNode = await this.getFolderNode(path);
+    // 	return await folderNode.adoptItemsFromRemoteVersion(opts);
+    // }
+    async mergeFolderCurrentAndRemoteVersions(path, opts) {
         const folderNode = await this.getFolderNode(path);
-        return await folderNode.adoptItemsFromRemoteVersion(opts);
+        const newLocalVersion = await folderNode.mergeCurrentAndRemoteVersions(opts);
+        if (newLocalVersion && (newLocalVersion < 0)) {
+            const { folderPath } = split(path);
+            if (folderPath.length > 0) {
+                const parent = await this.n.get(folderPath.join('/'));
+                // XXX removing folder in parent -- what happens with children?
+                await parent.removeChild(folderNode);
+            }
+        }
+        return newLocalVersion;
     }
 }
 Object.freeze(S.prototype);

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2018, 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2016 - 2018, 2020, 2022, 2025 - 2026 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

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

@@ -11,6 +11,8 @@ type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 type VersionedReadFlags = web3n.files.VersionedReadFlags;
 type Stats = web3n.files.Stats;
+type CommonDiff = web3n.files.CommonDiff;
+type SyncVersionsBranch = web3n.files.SyncVersionsBranch;
 export declare abstract class NodeInFS<P extends NodePersistance> implements Node {
     protected readonly storage: Storage;
     readonly type: NodeType;
@@ -102,6 +104,25 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
         uploadTaskId: number;
     }>;
     private makeHeaderForUploadIfVersionChanges;
+    private diffWithArchivedRemote;
+    protected commonDiffWithRemote(isCurrentLocal: boolean, remoteVersion: number, remote: {
+        attrs: CommonAttrs;
+        xattrs?: XAttrs;
+    }, syncedVersion: number, synced: {
+        attrs: CommonAttrs;
+        xattrs?: XAttrs;
+    }): CommonDiff;
+    protected getRemoteVersionToDiff(remoteVersion: number | undefined): Promise<{
+        rm: false;
+        isCurrentLocal: boolean;
+        remoteVersion: number;
+        syncedVersion?: number;
+    } | {
+        rm: true;
+        rmDiff: CommonDiff;
+    } | undefined>;
 }
 export declare function shouldReadCurrentVersion(flags: VersionedReadFlags | undefined): boolean;
+export declare function areBytesEqual(b1: Uint8Array, b2: Uint8Array): boolean;
+export declare function versionFromRemoteBranch(remote: SyncVersionsBranch, remoteVersion: number | undefined): number | undefined;
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022, 2025 - 2026 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
@@ -18,6 +18,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeInFS = void 0;
 exports.shouldReadCurrentVersion = shouldReadCurrentVersion;
+exports.areBytesEqual = areBytesEqual;
+exports.versionFromRemoteBranch = versionFromRemoteBranch;
 /**
  * Everything in this module is assumed to be inside of a file system
  * reliance set.
@@ -32,6 +34,7 @@ const operators_1 = require("rxjs/operators");
 const attrs_1 = require("./attrs");
 const assert_1 = require("../../lib-common/assert");
 const runtime_1 = require("../../lib-common/exceptions/runtime");
+const json_utils_1 = require("../../lib-common/json-utils");
 class NodeInFS {
     get version() {
         return this.currentVersion;
@@ -346,8 +349,7 @@ class NodeInFS {
         if (this.parentId) {
             const parent = storage.nodes.get(this.parentId);
             if (parent) {
-                status.existsInSyncedParent =
-                    await parent.childExistsInSyncedVersion(this.objId);
+                status.existsInSyncedParent = await parent.childExistsInSyncedVersion(this.objId);
             }
         }
         return status;
@@ -523,6 +525,46 @@ class NodeInFS {
         const uploadHeader = await this.crypto.reencryptHeader(localHeader, uploadVersion);
         return { localHeader, localVersion, uploadHeader, uploadVersion };
     }
+    diffWithArchivedRemote(isCurrentLocal) {
+        return {
+            currentVersion: this.version,
+            isCurrentLocal,
+            isRemoteRemoved: true,
+        };
+    }
+    commonDiffWithRemote(isCurrentLocal, remoteVersion, remote, syncedVersion, synced) {
+        const { ctime, mtime } = diffAttrs(this.attrs, remote.attrs, synced.attrs);
+        return {
+            currentVersion: this.version,
+            isCurrentLocal,
+            isRemoteRemoved: false,
+            remoteVersion,
+            syncedVersion,
+            ctime,
+            mtime,
+            xattrs: diffXAttrs(this.xattrs, remote.xattrs, synced.xattrs)
+        };
+    }
+    async getRemoteVersionToDiff(remoteVersion) {
+        const { state, remote, synced } = await this.syncStatus();
+        let isCurrentLocal;
+        if (state === 'behind') {
+            isCurrentLocal = false;
+        }
+        else if (state === 'conflicting') {
+            isCurrentLocal = true;
+        }
+        else {
+            return;
+        }
+        remoteVersion = versionFromRemoteBranch(remote, remoteVersion);
+        if (remoteVersion) {
+            return { rm: false, isCurrentLocal, remoteVersion, syncedVersion: synced === null || synced === void 0 ? void 0 : synced.latest };
+        }
+        else {
+            return { rm: true, rmDiff: this.diffWithArchivedRemote(isCurrentLocal) };
+        }
+    }
 }
 exports.NodeInFS = NodeInFS;
 Object.freeze(NodeInFS.prototype);
@@ -558,4 +600,131 @@ function shouldReadCurrentVersion(flags) {
     }
     return true;
 }
+function diffAttrs(current, remote, synced) {
+    return {
+        ctime: {
+            current: new Date(current.ctime),
+            remote: new Date(remote.ctime),
+            synced: new Date(synced.ctime)
+        },
+        mtime: {
+            current: new Date(current.mtime),
+            remote: new Date(remote.mtime),
+            synced: new Date(synced.mtime)
+        }
+    };
+}
+function diffXAttrs(current, remote, synced) {
+    const diff = {};
+    const checkedNames = new Set();
+    if (current) {
+        for (const name of current.list()) {
+            const localValue = current.get(name);
+            const syncedValue = synced === null || synced === void 0 ? void 0 : synced.get(name);
+            const remoteValue = remote === null || remote === void 0 ? void 0 : remote.get(name);
+            if (remoteValue === undefined) {
+                if (syncedValue === undefined) {
+                    diff[name] = { addedIn: 'l' };
+                }
+                else if (areXAttrValuesEqual(localValue, syncedValue)) {
+                    diff[name] = { removedIn: 'r' };
+                }
+                else {
+                    diff[name] = { removedIn: 'r', changedIn: 'l' };
+                }
+            }
+            else if (areXAttrValuesEqual(localValue, remoteValue)) {
+                // no differences between local and remote
+            }
+            else {
+                if (syncedValue === undefined) {
+                    diff[name] = { addedIn: 'l&r', changedIn: 'l&r' };
+                }
+                else if (areXAttrValuesEqual(localValue, syncedValue)) {
+                    diff[name] = { changedIn: 'r' };
+                }
+                else {
+                    diff[name] = { changedIn: 'l&r' };
+                }
+            }
+            checkedNames.add(name);
+        }
+    }
+    if (remote) {
+        for (const name of remote.list()) {
+            if (checkedNames.has(name)) {
+                continue;
+            }
+            const remoteValue = remote.get(name);
+            const syncedValue = synced === null || synced === void 0 ? void 0 : synced.get(name);
+            if (syncedValue === undefined) {
+                diff[name] = { addedIn: 'r' };
+            }
+            else if (areXAttrValuesEqual(remoteValue, syncedValue)) {
+                diff[name] = { removedIn: 'l' };
+            }
+            else {
+                diff[name] = { removedIn: 'l', changedIn: 'r' };
+            }
+        }
+    }
+    return ((Object.keys(diff).length > 0) ? diff : undefined);
+}
+function areXAttrValuesEqual(v1, v2) {
+    if (Buffer.isBuffer(v1) || ArrayBuffer.isView(v1)) {
+        if (Buffer.isBuffer(v2) || ArrayBuffer.isView(v2)) {
+            return areBytesEqual(v1, v2);
+        }
+        {
+            return false;
+        }
+    }
+    else if (typeof v1 === 'string') {
+        if (typeof v2 === 'string') {
+            return (v1 === v2);
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        if (Buffer.isBuffer(v2) || ArrayBuffer.isView(v2)
+            || (typeof v2 === 'string')) {
+            return false;
+        }
+        else {
+            return (0, json_utils_1.deepEqual)(v1, v2);
+        }
+    }
+}
+function areBytesEqual(b1, b2) {
+    if (b1.length !== b2.length) {
+        return false;
+    }
+    for (let i = 0; i < b1.length; i += 1) {
+        if (b1[i] !== b2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function versionFromRemoteBranch(remote, remoteVersion) {
+    var _a;
+    if (remote.isArchived) {
+        return;
+    }
+    if (remoteVersion) {
+        if ((remoteVersion !== remote.latest)
+            && !((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(remoteVersion))) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                versionMismatch: true,
+                message: `Unknown remote version ${remoteVersion}`
+            });
+        }
+        return remoteVersion;
+    }
+    else {
+        return remote.latest;
+    }
+}
 Object.freeze(exports);

package/build/lib-common/exceptions/file.d.ts

@@ -6,4 +6,4 @@ export declare function makeFileException(flag: keyof FileExceptionFlag, path: s
 export declare function maskPathInExc(pathPrefixMaskLen: number, exc: any): FileException;
 export declare function ensureCorrectFS(fs: web3n.files.FS, type: web3n.files.FSType, writable: boolean): void;
 export declare function makeNoAttrsExc(path: string): FileException;
-export declare function makeVersionMismatchExc(path: string): FileException;
+export declare function makeVersionMismatchExc(path: string, message?: string): FileException;

package/build/lib-common/exceptions/file.js

@@ -98,13 +98,14 @@ function makeNoAttrsExc(path) {
         attrsNotEnabledInFS: true
     };
 }
-function makeVersionMismatchExc(path) {
+function makeVersionMismatchExc(path, message) {
     return {
         runtimeException: true,
         type: 'file',
         code: undefined,
         path,
-        versionMismatch: true
+        versionMismatch: true,
+        message
     };
 }
 Object.freeze(exports);