core-3nweb-client-lib 0.26.0 → 0.27.1

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

@@ -21,103 +21,163 @@ 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 json_utils_1 = require("../../../lib-common/json-utils");
+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, logError) {
         this.objFolder = objFolder;
         this.status = status;
         this.logError = logError;
-        this.saveProc = new json_saving_1.JSONSavingProc(path_1.join(this.objFolder, exports.STATUS_FILE_NAME), () => this.status);
-        Object.freeze(this);
+        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, logError) {
         const status = await readAndCheckStatus(objFolder, objId);
         return new ObjStatus(objFolder, status, logError);
     }
     static async makeNew(objFolder, objId, logError) {
-        const status = {
-            objId,
-            sync: {
-                state: 'unsynced'
-            },
-            versions: {
-                baseToDiff: {},
-                diffToBase: {},
-            }
-        };
+        const status = makeObjStatusInfo(objId);
         const s = new ObjStatus(objFolder, status, logError);
         await s.triggerSaveProc();
         return s;
     }
     static async makeForDownloadedVersion(objFolder, objId, version, currentRemote, logError) {
-        const status = {
-            objId,
-            sync: {
-                state: 'synced',
-                remote: currentRemote,
-                latest: currentRemote,
-            },
-            versions: {
-                current: version,
-                baseToDiff: {},
-                diffToBase: {}
-            }
-        };
+        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.sync.state !== 'synced');
+        return (syncStateOf(status) !== 'synced');
+    }
+    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;
         }
-        return this.status.versions.current;
-    }
-    getNonGarbageVersions() {
-        const versions = this.status.versions;
-        const nonGarbage = obj_info_file_1.nonGarbageVersionsIn(versions);
-        if (this.status.syncTasks) {
-            const tasks = this.status.syncTasks;
-            if (tasks.current) {
-                obj_info_file_1.addWithBasesTo(nonGarbage, nonGarbageVersionInTask(tasks.current), versions);
-            }
-            for (const t of tasks.queued) {
-                obj_info_file_1.addWithBasesTo(nonGarbage, nonGarbageVersionInTask(t), versions);
-            }
+        else {
+            throw (0, exceptions_1.makeStorageException)({
+                objNotFound: true,
+                message: 'Current version is not found'
+            });
         }
-        return {
-            nonGarbage,
-            gcMaxVer: versions.current
-        };
     }
-    isRemoteVersionGreaterOrEqualTo(newRemoteVersion) {
-        return ((typeof this.status.sync.remote === 'number') ?
-            (this.status.sync.remote >= newRemoteVersion) : false);
-    }
-    isDeletedOnRemote() {
-        return !!this.status.sync.deletedOnRemote;
-    }
-    syncedVersionGreaterOrEqual(version) {
-        return ((typeof this.status.sync.latest !== 'number') ?
-            false : (version <= this.status.sync.latest));
+    getNonGarbageVersions() {
+        return identifyNonGarbage(this.status);
     }
-    async removeCurrentVersion(verObjs) {
-        this.status.isArchived = true;
-        const current = obj_info_file_1.rmCurrentVersionIn(this.status.versions);
-        if (typeof current === 'number') {
-            verObjs.delete(current);
+    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;
         }
-        this.addRemoveCurrentToQueue();
+        if (local) {
+            (0, obj_info_file_1.rmCurrentVersionIn)(local);
+        }
+        else {
+            local = makeVersions();
+        }
+        local.isArchived = true;
+        this.updateStateIndicator();
+        ;
         await this.triggerSaveProc().catch((exc) => {
-            if (exc.notFound && this.status.isArchived) {
+            var _a;
+            if (exc.notFound && ((_a = this.status.local) === null || _a === void 0 ? void 0 : _a.isArchived)) {
                 return;
             }
             else {
@@ -140,256 +200,400 @@ class ObjStatus {
             }
         }
     }
-    async setDeletedOnRemote() {
-        this.status.sync.deletedOnRemote = true;
-        await this.triggerSaveProc();
+    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();
+    }
+    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();
+    }
+    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();
+        }
+    }
+    async recordVersionArchival(version) {
+        if ((0, obj_info_file_1.addArchived)(this.status.remote, version)) {
+            return this.triggerSaveProc();
+        }
+    }
+    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;
+        }
+        remote.isArchived = true;
+        (0, obj_info_file_1.rmCurrentVersionIn)(remote);
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
     }
-    async setRemoteVersion(version) {
-        if (this.status.sync.remote >= version) {
+    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;
         }
-        this.status.sync.remote = version;
-        if (this.status.sync.state === 'synced') {
-            if (this.status.versions.current < this.status.sync.remote) {
-                this.status.sync.state = 'behind';
+        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.sync.state === 'unsynced') {
-            this.status.sync.state = 'conflicting';
-        }
-        await this.triggerSaveProc();
-    }
-    async markVersionSynced(version) {
-        if (!this.status.sync.latest
-            || (this.status.sync.latest < version)) {
-            this.status.sync.latest = version;
-            if (this.status.versions.current === version) {
-                this.status.sync.state = 'synced';
+        else {
+            this.status.synced = { isArchived: true };
+        }
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
+    }
+    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();
         }
     }
-    async setUnsyncedCurrentVersion(version, baseVer) {
-        obj_info_file_1.setCurrentVersionIn(this.status.versions, version, baseVer);
-        this.status.sync.state = 'unsynced';
-        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;
-        }
-        if (this.status.sync.state == 'synced') {
-            return true;
+    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.sync.latest === undefined) {
-            return false;
+        if ((0, obj_info_file_1.isVersionIn)(base, this.status.remote)) {
+            return { syncedBase: base };
+        }
+        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.sync.latest >= version);
-    }
-    isVersionArchived(version) {
-        if (!this.status.versions.archived) {
-            return false;
+        else {
+            return { localBases };
         }
-        return this.status.versions.archived.includes(version);
     }
-    queueTask(t) {
-        if (t.type === 'upload') {
-            this.addUploadToQueue(t);
+    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);
         }
-        else if (t.type === 'removal') {
-            if (t.currentVersion) {
-                throw new Error(`Removal of current task needs other method`);
+        if (synced) {
+            synced.version = uploadVersion;
+            if (synced.base && (synced.base !== syncedBase)) {
+                (0, obj_info_file_1.rmNonArchVersionsIn)(remote, synced.base);
             }
-            else if (t.archivedVersions) {
-                this.addRemoveArchivedToQueue(t.archivedVersions);
-            }
-        }
-        else if (t.type === 'archiving') {
-            this.addArchivalToQueue(t);
+            synced.base = syncedBase;
         }
         else {
-            throw new Error(`Unsupported upsync task type`);
+            this.status.synced = { version: uploadVersion, base: syncedBase };
         }
-    }
-    addUploadToQueue(u) {
-        if (!this.status.syncTasks) {
-            this.status.syncTasks = { queued: [u] };
+        if (local.current === localVersion) {
+            this.status.local = undefined;
         }
         else {
-            const q = this.status.syncTasks.queued;
-            const last = lastIn(q);
-            if (last) {
-                if (last.type === 'upload') {
-                    if (!this.isVersionArchived(last.version)) {
-                        if (last.createObj) {
-                            u.createObj = true;
-                        }
-                        q[q.length - 1] = u;
-                    }
-                    else {
-                        q.push(u);
-                    }
-                }
-                else if (last.type === 'archiving') {
-                    q.push(u);
-                }
-                else if ((last.type === 'removal') && last.archivedVersions) {
-                    q.push(u);
-                }
-            }
-            else {
-                q.push(u);
-            }
+            local.upload = undefined;
         }
-        this.triggerSaveProc(true);
+        this.updateStateIndicator();
+        return this.triggerSaveProc();
     }
-    addRemoveCurrentToQueue() {
-        const r = { type: 'removal', currentVersion: true };
-        if (this.status.syncTasks) {
-            const q = this.status.syncTasks.queued;
-            const last = lastIn(q);
-            if (last) {
-                if (last.type === 'archiving') {
-                    q.push(r);
-                }
-                else if (last.type === 'upload') {
-                    if (this.isVersionArchived(last.version)) {
-                        q.push(r);
-                    }
-                    else if (this.status.sync.latest
-                        || this.status.syncTasks.current) {
-                        q[q.length - 1] = r;
-                    }
-                    else {
-                        q.splice(q.length - 1, 1);
-                        this.addRemoveCurrentToQueue();
-                        return;
-                    }
-                }
-            }
-            else if (this.status.sync.latest
-                || this.status.syncTasks.current) {
-                q.push(r);
-            }
-            else {
-                this.status.syncTasks = undefined;
-            }
-        }
-        else {
-            if (this.status.sync.latest) {
-                this.status.syncTasks = { queued: [r] };
-            }
+    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();
     }
-    addRemoveArchivedToQueue(archVer) {
-        const r = { type: 'removal', archivedVersions: archVer };
-        if (this.status.syncTasks) {
-            this.status.syncTasks.queued.push(r);
-        }
-        else {
-            this.status.syncTasks = { queued: [r] };
-        }
-        this.triggerSaveProc(true);
+    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();
     }
-    addArchivalToQueue(a) {
-        if (!this.status.syncTasks) {
-            this.status.syncTasks = { queued: [a] };
+    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 {
-            this.status.syncTasks.queued.push(a);
+            delete local.diffToBase[version];
         }
-        this.triggerSaveProc(true);
+        delete local.diffToBase[localBase];
+        delete local.baseToDiff[localBase];
+        return this.triggerSaveProc();
     }
-    async getTaskForProcessing() {
-        const syncTasks = this.status.syncTasks;
-        if (!syncTasks) {
-            return;
-        }
-        if (syncTasks.current) {
-            return syncTasks.current;
-        }
-        syncTasks.current = syncTasks.queued.shift();
-        if (syncTasks.current) {
-            await this.triggerSaveProc();
-        }
-        return syncTasks.current;
+    latestSyncedVersion() {
+        var _a;
+        return (_a = this.status.synced) === null || _a === void 0 ? void 0 : _a.version;
     }
-    glanceOnNextTask() {
-        const syncTasks = this.status.syncTasks;
-        if (!syncTasks) {
-            return;
-        }
-        if (syncTasks.current) {
-            return syncTasks.current;
-        }
-        else if (syncTasks.queued.length > 0) {
-            return syncTasks.queued[0];
-        }
+    syncStatus() {
+        const { remote, synced } = splitVersionsIntoBranches(this.status.remote, this.status.synced);
+        return {
+            state: this.stateIndicator,
+            local: localVersionFromStatus(this.status.local),
+            remote,
+            synced
+        };
     }
-    async recordInterimStateOfCurrentTask(t) {
-        const syncTasks = this.status.syncTasks;
-        if (!syncTasks) {
-            throw new Error(`This method is called too early.`);
-        }
-        if (syncTasks.current === t) {
-            await this.triggerSaveProc();
-        }
-        else {
-            throw new Error(`Can save interim state of a current task only`);
-        }
+    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 recordTaskCompletion(t) {
-        const syncTasks = this.status.syncTasks;
-        if (!syncTasks) {
-            throw new Error(`This method is called too early.`);
+    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 (syncTasks.current === t) {
-            if (syncTasks.queued.length > 0) {
-                syncTasks.current = undefined;
+        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 {
-                this.status.syncTasks = undefined;
+                throw (0, exceptions_1.makeFSSyncException)('', {
+                    remoteVersion: remote.current,
+                    versionNotFound: true,
+                    message: `Remote version ${version} is not in status info`
+                });
             }
-            await this.triggerSaveProc();
         }
-    }
-    isSyncDone() {
-        return !this.status.syncTasks;
-    }
-    isFileSaved() {
-        return this.saveProc.isSaved();
-    }
-    stat() {
-        return json_utils_1.copy(this.status.sync);
+        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, exports.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;
 }
 exports.readAndCheckStatus = readAndCheckStatus;
-function lastIn(arr) {
-    return ((arr.length > 0) ? arr[arr.length - 1] : undefined);
+function localVersionFromStatus(tagged) {
+    return (tagged ? {
+        latest: tagged.current,
+        isArchived: tagged.isArchived
+    } : undefined);
 }
-function nonGarbageVersionInTask(task) {
-    if (task.type === 'upload') {
-        return task.version;
+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;
 }
 Object.freeze(exports);