core-3nweb-client-lib 0.25.6 → 0.27.0

package/build/core/storage/synced/obj-status.js

@@ -16,196 +16,584 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjStatus = void 0;
-const processes_1 = require("../../../lib-common/processes");
-const fs = require("../../../lib-common/async-fs-node");
+exports.readAndCheckStatus = exports.ObjStatus = exports.STATUS_FILE_NAME = void 0;
 const path_1 = require("path");
 const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
+const json_saving_1 = require("../common/json-saving");
 const obj_info_file_1 = require("../common/obj-info-file");
-const STATUS_FILE_NAME = 'status';
+const assert_1 = require("../../../lib-common/assert");
+function makeVersions() {
+    return {
+        baseToDiff: {},
+        diffToBase: {},
+    };
+}
+function makeObjStatusInfo(objId) {
+    return {
+        objId,
+        remote: makeVersions()
+    };
+}
+function syncStateOf({ local, synced, remote }) {
+    const syncedIsCurrent = isSyncedCurrentWithRemote(synced, remote);
+    if (local) {
+        switch (syncedIsCurrent) {
+            case undefined:
+            case true:
+                return ((local.isArchived && (synced === null || synced === void 0 ? void 0 : synced.isArchived)) ?
+                    'synced' : 'unsynced');
+            case false:
+                return 'conflicting';
+        }
+    }
+    else {
+        switch (syncedIsCurrent) {
+            case undefined:
+                return 'unsynced';
+            case true:
+                return 'synced';
+            case false:
+                return 'behind';
+        }
+    }
+}
+function isSyncedCurrentWithRemote(synced, remote) {
+    if (synced) {
+        return ((synced.version === remote.current)
+            && (synced.isArchived === remote.isArchived));
+    }
+    else {
+        return (isRemoteEmpty(remote) ? undefined : false);
+    }
+}
+function isRemoteEmpty(remote) {
+    return (0, obj_info_file_1.isEmptyVersions)(remote) && !remote.isArchived;
+}
+function nonGarbageWithMaxVer(v) {
+    return {
+        gcMaxVer: v.current,
+        nonGarbage: (0, obj_info_file_1.nonGarbageVersionsIn)(v)
+    };
+}
+function identifyNonGarbage(status) {
+    var _a;
+    let local = undefined;
+    let uploadVersion = undefined;
+    if (status.local) {
+        local = nonGarbageWithMaxVer(status.local);
+        if (status.local.upload) {
+            const { localVersion } = status.local.upload;
+            if (status.local.current !== localVersion) {
+                (0, obj_info_file_1.addWithBasesTo)(local.nonGarbage, localVersion, status.local);
+            }
+            uploadVersion = status.local.upload.uploadVersion;
+        }
+    }
+    const remote = nonGarbageWithMaxVer(status.remote);
+    if ((_a = status.synced) === null || _a === void 0 ? void 0 : _a.version) {
+        remote.nonGarbage.add(status.synced.version);
+        if (status.synced.base) {
+            (0, obj_info_file_1.addWithBasesTo)(remote.nonGarbage, status.synced.base, status.remote);
+        }
+    }
+    return { local, remote, uploadVersion };
+}
+exports.STATUS_FILE_NAME = 'status';
 class ObjStatus {
-    constructor(objFolder, status) {
+    constructor(objFolder, status, logError) {
         this.objFolder = objFolder;
         this.status = status;
-        this.saveProc = new processes_1.DeduppedRunner(() => this.saveFile());
-        Object.freeze(this);
+        this.logError = logError;
+        this.saveProc = new json_saving_1.JSONSavingProc((0, path_1.join)(this.objFolder, exports.STATUS_FILE_NAME), () => this.status);
+        this.updateStateIndicator();
+        Object.seal(this);
     }
-    static async readFrom(objFolder, objId) {
+    static async readFrom(objFolder, objId, logError) {
         const status = await readAndCheckStatus(objFolder, objId);
-        return new ObjStatus(objFolder, status);
+        return new ObjStatus(objFolder, status, logError);
     }
-    static async makeNew(objFolder, objId) {
-        const status = {
-            objId,
-            syncState: 'unsynced',
-            versions: {}
-        };
-        const s = new ObjStatus(objFolder, status);
-        await s.saveProc.trigger();
+    static async makeNew(objFolder, objId, logError) {
+        const status = makeObjStatusInfo(objId);
+        const s = new ObjStatus(objFolder, status, logError);
+        await s.triggerSaveProc();
         return s;
     }
-    static async makeForDownloadedVersion(objFolder, objId, version) {
-        const status = {
-            objId,
-            syncState: 'synced',
-            versions: {
-                current: version
-            }
-        };
-        const s = new ObjStatus(objFolder, status);
-        await s.saveProc.trigger();
+    static async makeForDownloadedVersion(objFolder, objId, version, currentRemote, logError) {
+        const status = makeObjStatusInfo(objId);
+        status.remote.current = currentRemote;
+        status.synced = { version: currentRemote };
+        if (currentRemote > version) {
+            status.remote.archived = [version];
+        }
+        else if (currentRemote !== version) {
+            throw new Error(`Downloaded version can't be greater than current remote`);
+        }
+        const s = new ObjStatus(objFolder, status, logError);
+        await s.triggerSaveProc();
         return s;
     }
     static async fileShowsObjNotInSyncedState(objFolder, objId) {
         const status = await readAndCheckStatus(objFolder, objId);
-        return (status.syncState !== 'synced');
+        return (syncStateOf(status) !== 'synced');
     }
-    async saveFile() {
-        await fs.writeFile(path_1.join(this.objFolder, STATUS_FILE_NAME), JSON.stringify(this.status), { encoding: 'utf8' });
+    updateStateIndicator() {
+        this.stateIndicator = syncStateOf(this.status);
     }
     isArchived() {
-        return !!this.status.isArchived;
+        var _a;
+        return !!((_a = this.status.local) === null || _a === void 0 ? void 0 : _a.isArchived);
     }
-    getCurrentVersionOrThrow() {
-        if (typeof this.status.versions.current !== 'number') {
-            throw new Error(`Object ${this.status.objId} has no current version.`);
+    getCurrentLocalOrSynced() {
+        var _a, _b;
+        const state = this.stateIndicator;
+        const current = (((state === 'unsynced') || (state === 'conflicting')) ?
+            (_a = this.status.local) === null || _a === void 0 ? void 0 : _a.current : (_b = this.status.synced) === null || _b === void 0 ? void 0 : _b.version);
+        if (current) {
+            return current;
+        }
+        else {
+            throw (0, exceptions_1.makeStorageException)({
+                objNotFound: true,
+                message: 'Current version is not found'
+            });
         }
-        return this.status.versions.current;
     }
-    isRemoteVersionGreaterOrEqualTo(newRemoteVersion) {
-        return ((typeof this.status.versions.remote === 'number') ?
-            (this.status.versions.remote >= newRemoteVersion) : false);
+    getNonGarbageVersions() {
+        return identifyNonGarbage(this.status);
     }
-    isDeletedOnRemote() {
-        return !!this.status.deletedOnRemote;
+    async removeCurrentVersion() {
+        let { local, synced } = this.status;
+        if ((synced === null || synced === void 0 ? void 0 : synced.isArchived) || (local === null || local === void 0 ? void 0 : local.isArchived)) {
+            return;
+        }
+        if (local) {
+            (0, obj_info_file_1.rmCurrentVersionIn)(local);
+        }
+        else {
+            local = makeVersions();
+        }
+        local.isArchived = true;
+        this.updateStateIndicator();
+        ;
+        await this.triggerSaveProc().catch((exc) => {
+            var _a;
+            if (exc.notFound && ((_a = this.status.local) === null || _a === void 0 ? void 0 : _a.isArchived)) {
+                return;
+            }
+            else {
+                throw exc;
+            }
+        });
+    }
+    async triggerSaveProc(captureErrors = false, logErr = false) {
+        try {
+            await this.saveProc.trigger();
+        }
+        catch (exc) {
+            if (captureErrors) {
+                if (logErr) {
+                    await this.logError(exc);
+                }
+            }
+            else {
+                throw exc;
+            }
+        }
+    }
+    recordUploadStart(info) {
+        (0, assert_1.assert)(!!this.status.local);
+        const local = this.status.local;
+        if (local.upload) {
+            throw (0, exceptions_1.makeFSSyncException)('obj-status', {
+                alreadyUploading: true,
+                message: `Status already has upload of version ${local.upload.uploadVersion} and can't start another upload with version ${info.uploadVersion}`
+            });
+        }
+        if (info.localVersion === local.current) {
+            local.upload = info;
+        }
+        else {
+            throw (0, exceptions_1.makeFSSyncException)('obj-status', {
+                localVersion: info.localVersion,
+                versionNotFound: true
+            });
+        }
+        return this.triggerSaveProc();
     }
-    syncedVersionGreaterOrEqual(version) {
-        return ((typeof this.status.versions.latestSynced !== 'number') ?
-            false : (version <= this.status.versions.latestSynced));
+    recordUploadInterimState(info) {
+        (0, assert_1.assert)(!!this.status.local);
+        const local = this.status.local;
+        (0, assert_1.assert)(!!local.upload &&
+            (local.upload.uploadVersion === info.uploadVersion));
+        local.upload = info;
+        return this.triggerSaveProc();
     }
-    async removeCurrentVersion(verObjs) {
-        this.status.isArchived = true;
-        if (this.status.versions.current) {
-            verObjs.delete(this.status.versions.current);
-            rmNonArchVersionsIn(this.status, this.status.versions.current);
-            delete this.status.versions.current;
+    recordUploadCancellation(info) {
+        (0, assert_1.assert)(!!this.status.local);
+        const local = this.status.local;
+        (0, assert_1.assert)(!!local.upload &&
+            (local.upload.uploadVersion === info.uploadVersion));
+        local.upload = undefined;
+        return this.triggerSaveProc();
+    }
+    async recordArchVersionRemoval(version) {
+        if ((0, obj_info_file_1.rmArchVersionFrom)(this.status.remote, version)) {
+            return this.triggerSaveProc();
         }
-        await this.saveProc.trigger();
     }
-    async setDeletedOnRemote() {
-        this.status.deletedOnRemote = true;
-        await this.saveProc.trigger();
+    async recordVersionArchival(version) {
+        if ((0, obj_info_file_1.addArchived)(this.status.remote, version)) {
+            return this.triggerSaveProc();
+        }
     }
-    async setRemoteVersion(version) {
-        if (this.status.versions.remote >= version) {
+    async recordRemoteRemoval() {
+        const { local, synced, remote } = this.status;
+        if ((local === null || local === void 0 ? void 0 : local.isArchived) || (synced === null || synced === void 0 ? void 0 : synced.isArchived)) {
             return;
         }
-        this.status.versions.remote = version;
-        if (this.status.syncState === 'synced') {
-            if (this.status.versions.current < this.status.versions.remote) {
-                this.status.syncState = 'behind';
+        remote.isArchived = true;
+        (0, obj_info_file_1.rmCurrentVersionIn)(remote);
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
+    }
+    async recordRemoteChange(version) {
+        const { local, synced, remote } = this.status;
+        if (((local === null || local === void 0 ? void 0 : local.upload) && (local.upload.uploadVersion === version))
+            || ((synced === null || synced === void 0 ? void 0 : synced.version) && (synced.version >= version))) {
+            return;
+        }
+        remote.current = version;
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
+    }
+    recordSyncOfObjRemoval() {
+        this.status.local = undefined;
+        (0, obj_info_file_1.rmCurrentVersionIn)(this.status.remote);
+        this.status.remote.isArchived = true;
+        if (this.status.synced) {
+            this.status.synced.isArchived = true;
+            this.status.synced.version = undefined;
+            if (this.status.synced.base) {
+                (0, obj_info_file_1.rmNonArchVersionsIn)(this.status.remote, this.status.synced.base);
+                this.status.synced.base = undefined;
             }
         }
-        else if (this.status.syncState === 'unsynced') {
-            this.status.syncState = 'conflicting';
+        else {
+            this.status.synced = { isArchived: true };
         }
-        await this.saveProc.trigger();
-    }
-    async setSyncedCurrentVersion(version) {
-        this.status.versions.current = version;
-        this.status.syncState = 'synced';
-        this.status.versions.latestSynced = version;
-        await this.saveProc.trigger();
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
     }
-    async setUnsyncedCurrentVersion(version) {
-        // XXX should this code be like that from commented
-        // setNewCurrentVersionAfterWriteIn, or should we use that function
-        // reused by GC.
-        this.status.versions.current = version;
-        this.status.syncState = 'unsynced';
-        await this.saveProc.trigger();
+    async recordStatusFromServer({ archived, current }) {
+        const remote = this.status.remote;
+        let changedCurrent = false;
+        if (current) {
+            if (!remote.current) {
+                remote.current = current;
+                changedCurrent = true;
+            }
+            else if (remote.current < current) {
+                (0, obj_info_file_1.rmCurrentVersionIn)(remote);
+                remote.current = current;
+                changedCurrent = true;
+            }
+        }
+        else if (remote.current) {
+            (0, obj_info_file_1.rmCurrentVersionIn)(remote);
+            remote.isArchived = true;
+            changedCurrent = true;
+        }
+        const rmArchived = removeArchVersionsNotInList(remote, archived);
+        const addedArchived = addArchVersionsFromList(remote, archived);
+        if (rmArchived || addedArchived || changedCurrent) {
+            this.updateStateIndicator();
+            await this.triggerSaveProc();
+        }
     }
     /**
-     * This method ignores remote conflicting versions.
-     * @param version
+     * When given object version is a diff on some base, this method returns
+     * a whole trace of local base versions up to synced one.
+     * Local bases, if present, are return in an array with highest version
+     * first.
+     * This returns undefined, when given object version is not a diff.
+     * @param version that is local, for which we want to get base versions, if
+     * it is a diff version.
      */
-    isVersionSynced(version) {
-        if (this.status.versions.current === undefined) {
-            return false;
+    baseOfLocalVersion(version) {
+        (0, assert_1.assert)(!!this.status.local);
+        const local = this.status.local;
+        (0, assert_1.assert)((0, obj_info_file_1.isVersionIn)(version, local));
+        let base = local.diffToBase[version];
+        if (!base) {
+            return;
         }
-        if (this.status.syncState == 'synced') {
-            return true;
+        if ((0, obj_info_file_1.isVersionIn)(base, this.status.remote)) {
+            return { syncedBase: base };
         }
-        if (this.status.versions.latestSynced === undefined) {
-            return false;
+        const localBases = [];
+        do {
+            localBases.push(base);
+            base = local.diffToBase[base];
+        } while (base);
+        const lastBase = localBases[localBases.length - 1];
+        if ((0, obj_info_file_1.isVersionIn)(lastBase, this.status.remote)) {
+            return {
+                localBases: localBases.slice(0, localBases.length - 1),
+                syncedBase: lastBase
+            };
         }
-        return (this.status.versions.latestSynced >= version);
+        else {
+            return { localBases };
+        }
+    }
+    markLocalVersionSynced(localVersion, uploadVersion) {
+        const { local, synced, remote } = this.status;
+        (0, assert_1.assert)(!!(local === null || local === void 0 ? void 0 : local.upload) &&
+            ((local === null || local === void 0 ? void 0 : local.upload.uploadVersion) === uploadVersion));
+        const syncedBase = local.upload.baseVersion;
+        if (!remote.current || (remote.current <= uploadVersion)) {
+            (0, obj_info_file_1.setCurrentVersionIn)(remote, uploadVersion, syncedBase);
+        }
+        if (synced) {
+            synced.version = uploadVersion;
+            if (synced.base && (synced.base !== syncedBase)) {
+                (0, obj_info_file_1.rmNonArchVersionsIn)(remote, synced.base);
+            }
+            synced.base = syncedBase;
+        }
+        else {
+            this.status.synced = { version: uploadVersion, base: syncedBase };
+        }
+        if (local.current === localVersion) {
+            this.status.local = undefined;
+        }
+        else {
+            local.upload = undefined;
+        }
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
+    }
+    async setLocalCurrentVersion(version, baseVer) {
+        if (!this.status.local) {
+            this.status.local = makeVersions();
+        }
+        (0, obj_info_file_1.setCurrentVersionIn)(this.status.local, version, baseVer);
+        this.updateStateIndicator();
+        await this.triggerSaveProc();
+    }
+    listVersions() {
+        var _a;
+        const { local, synced, remote } = this.status;
+        switch (this.stateIndicator) {
+            case 'unsynced':
+            case 'conflicting':
+                (0, assert_1.assert)(!!local);
+                return {
+                    current: local.current,
+                    archived: ((synced === null || synced === void 0 ? void 0 : synced.version) ?
+                        versionsToBranch(remote, synced.version, false).archived :
+                        undefined)
+                };
+            case 'synced':
+            case 'behind':
+                (0, assert_1.assert)(!!synced);
+                return {
+                    current: synced.version,
+                    archived: ((synced === null || synced === void 0 ? void 0 : synced.version) ?
+                        versionsToBranch(remote, synced.version, false).archived :
+                        (_a = remote.archived) === null || _a === void 0 ? void 0 : _a.slice())
+                };
+            default:
+                throw new Error(`Unimplemented state ${this.stateIndicator}`);
+        }
+    }
+    async archiveCurrentVersion() {
+        const { synced, remote } = this.status;
+        (0, assert_1.assert)(!!(synced === null || synced === void 0 ? void 0 : synced.version));
+        (0, obj_info_file_1.addArchived)(remote, synced.version);
+        await this.triggerSaveProc();
+    }
+    absorbLocalVersionBase(version, localBase) {
+        (0, assert_1.assert)(!!this.status.local);
+        const local = this.status.local;
+        (0, assert_1.assert)(local.diffToBase[version] === localBase);
+        const lowerBase = local.diffToBase[localBase];
+        if (localBase) {
+            local.diffToBase[version] = lowerBase;
+            local.baseToDiff[lowerBase] = version;
+        }
+        else {
+            delete local.diffToBase[version];
+        }
+        delete local.diffToBase[localBase];
+        delete local.baseToDiff[localBase];
+        return this.triggerSaveProc();
+    }
+    latestSyncedVersion() {
+        var _a;
+        return (_a = this.status.synced) === null || _a === void 0 ? void 0 : _a.version;
+    }
+    syncStatus() {
+        const { remote, synced } = splitVersionsIntoBranches(this.status.remote, this.status.synced);
+        return {
+            state: this.stateIndicator,
+            local: localVersionFromStatus(this.status.local),
+            remote,
+            synced
+        };
+    }
+    neverUploaded() {
+        const synced = this.status.synced;
+        return (!(synced === null || synced === void 0 ? void 0 : synced.version) && !(synced === null || synced === void 0 ? void 0 : synced.isArchived));
+    }
+    async adoptRemoteVersion(version, dropLocalVer = false) {
+        var _a;
+        const { local, remote } = this.status;
+        if (this.stateIndicator !== 'behind') {
+            if (this.stateIndicator === 'synced') {
+                return;
+            }
+            else if (!dropLocalVer) {
+                throw (0, exceptions_1.makeFSSyncException)('', {
+                    localVersion: local === null || local === void 0 ? void 0 : local.current,
+                    remoteVersion: remote.current,
+                    conflict: true,
+                    message: `Can't adopt remote version in '${this.stateIndicator}' state`
+                });
+            }
+        }
+        if (version) {
+            if ((remote.current === version)
+                || ((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(version))) {
+                this.status.synced = { version, base: remote.diffToBase[version] };
+            }
+            else {
+                throw (0, exceptions_1.makeFSSyncException)('', {
+                    remoteVersion: remote.current,
+                    versionNotFound: true,
+                    message: `Remote version ${version} is not in status info`
+                });
+            }
+        }
+        else if (remote.current) {
+            version = remote.current;
+            this.status.synced = { version, base: remote.diffToBase[version] };
+        }
+        else {
+            throw (0, exceptions_1.makeFSSyncException)('', {
+                versionMismatch: true,
+                message: `Current remote version is not set in status info`
+            });
+        }
+        if (local) {
+            this.status.local = undefined;
+        }
+        this.updateStateIndicator();
+        await this.triggerSaveProc();
     }
 }
 exports.ObjStatus = ObjStatus;
 Object.freeze(ObjStatus.prototype);
 Object.freeze(ObjStatus);
 async function readAndCheckStatus(objFolder, objId) {
-    const status = await obj_info_file_1.readJSONInfoFileIn(objFolder, STATUS_FILE_NAME);
+    const status = await (0, obj_info_file_1.readJSONInfoFileIn)(objFolder, exports.STATUS_FILE_NAME);
     if (!status) {
-        throw exceptions_1.makeStorageException({
+        throw (0, exceptions_1.makeStorageException)({
             message: `Obj status file is not found in obj folder ${objFolder}`
         });
     }
     // XXX we may do some checks and sanitization here
     if (objId !== status.objId) {
-        throw exceptions_1.makeStorageException({ message: `Invalid objId in status file for obj ${objId}, in folder ${objFolder}.\nInvalid content:\n${JSON.stringify(status, null, 2)}` });
+        throw (0, exceptions_1.makeStorageException)({
+            message: `Invalid objId in status file for obj ${objId}, in folder ${objFolder}.\nInvalid content:\n${JSON.stringify(status, null, 2)}`
+        });
     }
     return status;
 }
-function rmNonArchVersionsIn(status, ver) {
-    // XXX this is an analog of a function in local storage obj-files
-    //     Should code be structured the same way?
-    if (!status.versions.archived
-        || !status.versions.archived.includes(ver)) {
-        return;
-    }
-    // XXX code below is from local
-    //
-    // if (status.baseToDiff[ver]) { return; }
-    // const base = status.diffToBase[ver];
-    // if (typeof base !== 'number') { return; }
-    // delete status.diffToBase[ver];
-    // const diffs = status.baseToDiff[base];
-    // if (!diffs) { return; }
-    // const diffInd = diffs.indexOf(ver);
-    // if (diffInd < 0) { return; }
-    // diffs.splice(diffInd, 1);
-    // if (diffs.length === 0) {
-    // 	delete status.baseToDiff[base];
-    // 	rmNonArchVersionsIn(status, base);
-    // }
+exports.readAndCheckStatus = readAndCheckStatus;
+function localVersionFromStatus(tagged) {
+    return (tagged ? {
+        latest: tagged.current,
+        isArchived: tagged.isArchived
+    } : undefined);
+}
+function splitVersionsIntoBranches(remote, synced) {
+    if (synced) {
+        if (isSyncedCurrentWithRemote(synced, remote)) {
+            return {
+                synced: versionsToBranch(remote)
+            };
+        }
+        else {
+            (0, assert_1.assert)(!!synced.version);
+            return {
+                synced: versionsToBranch(remote, synced.version, false),
+                remote: versionsToBranch(remote, synced.version, true)
+            };
+        }
+    }
+    else {
+        return (isRemoteEmpty(remote) ? {} : {
+            remote: versionsToBranch(remote)
+        });
+    }
+}
+function versionsToBranch({ current, archived, isArchived }, splitVersion, aboveSplit) {
+    if (splitVersion) {
+        let splitArchived = undefined;
+        if (archived) {
+            const indAboveSplit = archived.findIndex(v => (v > splitVersion));
+            if (aboveSplit) {
+                if (indAboveSplit >= 0) {
+                    splitArchived = archived.slice(indAboveSplit);
+                }
+            }
+            else {
+                if (indAboveSplit > 0) {
+                    splitArchived = archived.slice(0, indAboveSplit);
+                }
+                else {
+                    splitArchived = archived.slice();
+                }
+            }
+        }
+        return {
+            archived: splitArchived,
+            latest: (aboveSplit ? current : splitVersion),
+            isArchived: isArchived
+        };
+    }
+    else {
+        return {
+            archived: archived === null || archived === void 0 ? void 0 : archived.slice(),
+            latest: current,
+            isArchived: isArchived
+        };
+    }
+}
+function removeArchVersionsNotInList(remote, versionsToKeep) {
+    let isAnythingChanged = false;
+    if (remote.archived) {
+        for (const v of remote.archived) {
+            if (!(versionsToKeep === null || versionsToKeep === void 0 ? void 0 : versionsToKeep.includes(v))) {
+                (0, obj_info_file_1.rmArchVersionFrom)(remote, v);
+                isAnythingChanged = true;
+            }
+        }
+    }
+    return isAnythingChanged;
+}
+function addArchVersionsFromList(remote, existingVersions) {
+    var _a;
+    if (!existingVersions) {
+        return false;
+    }
+    let isAnythingChanged = false;
+    for (const v of existingVersions) {
+        if (!((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(v))) {
+            (0, obj_info_file_1.addArchived)(remote, v);
+        }
+    }
+    return isAnythingChanged;
 }
-// export function setNewCurrentVersionAfterWriteIn(
-// 	status: ObjStatusInfo, newVersion: number, baseVer: number|undefined
-// ): void {
-// 	if (status.isArchived) { return; }
-// 	if (status.syncState === 'synced') {
-// 		status.syncState = 'unsynced';
-// 	}
-// 	if (baseVer !== undefined) {
-// 		// base->diff links should be added before removals
-// 		addBaseToDiffLinkInStatus(status, newVersion, baseVer);
-// 	}
-// 	if (status.versions.current) {
-// 		rmNonArchVersionsIn(status, status.versions.current);
-// 	}
-// 	status.versions.current = newVersion;
-// }
-// export function addConflictingRemoteVersionTo(
-// 	status: ObjStatusInfo, conflictVersion: number
-// ): void {
-// 	if (!status.versions.conflictingRemote) {
-// 		status.versions.conflictingRemote = [];
-// 	}
-// 	const conflicts = status.versions.conflictingRemote;
-// 	if (conflicts.find(v => v >= conflictVersion)) { return; }
-// 	status.syncState = 'conflicting';
-// 	status.versions.conflictingRemote.push(conflictVersion);
-// }
 Object.freeze(exports);