core-3nweb-client-lib 0.26.1 → 0.27.0

package/build/core/storage/local/obj-files-gc.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2020 3NSoft Inc.
+ Copyright (C) 2016 - 2020, 2022 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
@@ -20,6 +20,7 @@ exports.GC = void 0;
 const fs = require("../../../lib-common/async-fs-node");
 const synced_1 = require("../../../lib-common/processes/synced");
 const path_1 = require("path");
+const utils_1 = require("../common/utils");
 class GC {
     constructor(rmObjFromCache, rmObjFolder) {
         this.rmObjFromCache = rmObjFromCache;
@@ -49,54 +50,65 @@ class GC {
             if (this.wip.size === 0) {
                 [this.wip, this.scheduled] = [this.scheduled, this.wip];
             }
-            const obj = getAndRemoveOneFrom(this.wip);
+            const obj = (0, utils_1.getAndRemoveOneFrom)(this.wip);
             if (!obj) {
                 return;
             }
-            // calculate versions that should not be removed
-            const { gcMaxVer, nonGarbage } = obj.getNonGarbageVersions();
-            // if object is set archived, and there is nothing in it worth keeping,
-            // whole folder can be removed
-            if (obj.isArchived()) {
-                if (nonGarbage.size === 0) {
-                    this.rmObjFromCache(obj);
-                    if (obj.objId) {
-                        await this.rmObjFolder(obj.objId);
-                    }
-                    return;
-                }
-            }
-            // for all other cases, we remove version files that are not worth
-            // keeping.
-            const lst = await fs.readdir(obj.objFolder);
-            const rmProcs = [];
-            for (const f of lst) {
-                const ver = parseInt(f);
-                if (isNaN(ver) || nonGarbage.has(ver)
-                    || (gcMaxVer && (ver >= gcMaxVer))) {
-                    continue;
-                }
-                rmProcs.push(fs.unlink(path_1.join(obj.objFolder, f)).catch(noop));
-            }
-            if (rmProcs.length > 0) {
-                await Promise.all(rmProcs);
+            try {
+                await this.collectIn(obj);
             }
+            catch (err) { }
             return this.objCollecting();
         };
         Object.seal(this);
     }
+    async collectIn(obj) {
+        const nonGarbage = obj.statusObj().getNonGarbageVersions();
+        if (!(await this.checkAndRemoveWholeObjFolder(obj, nonGarbage))) {
+            await removeGarbageFiles(obj, nonGarbage);
+        }
+    }
+    async checkAndRemoveWholeObjFolder(obj, { nonGarbage }) {
+        // if object is set archived, and there is nothing in it worth keeping,
+        // whole folder can be removed
+        if (obj.objId
+            && obj.statusObj().isArchived()
+            && (nonGarbage.size === 0)) {
+            this.rmObjFromCache(obj);
+            await this.rmObjFolder(obj.objId);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 }
 exports.GC = GC;
 Object.freeze(GC.prototype);
 Object.freeze(GC);
-function getAndRemoveOneFrom(set) {
-    const iter = set.values();
-    const { value, done } = iter.next();
-    if (done) {
-        return;
+async function removeGarbageFiles(obj, nonGarbage) {
+    const lst = await fs.readdir(obj.objFolder);
+    const rmProcs = [];
+    for (const f of lst) {
+        if (canGC(f, nonGarbage)) {
+            rmProcs.push(fs.unlink((0, path_1.join)(obj.objFolder, f)).catch(utils_1.noop));
+        }
+    }
+    if (rmProcs.length > 0) {
+        await Promise.all(rmProcs);
+    }
+}
+function canGC(f, { gcMaxVer, nonGarbage }) {
+    const ver = parseInt(f);
+    if (isNaN(ver)) {
+        return false;
+    }
+    else if (!nonGarbage.has(ver)
+        && (!gcMaxVer || (ver < gcMaxVer))) {
+        return true;
+    }
+    else {
+        return false;
     }
-    set.delete(value);
-    return value;
 }
-function noop() { }
 Object.freeze(exports);

package/build/core/storage/local/obj-files.d.ts

@@ -1,6 +1,7 @@
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { LocalObjStatus, ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { ObjSource, Subscribe } from 'xsp-files';
 import { GC } from './obj-files-gc';
+import { ObjStatus } from './obj-status';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 export declare class ObjFiles {
     private readonly folders;
@@ -29,12 +30,8 @@ export declare class LocalObj {
     getObjSrc(version: number): Promise<ObjSource>;
     private objSegsGetterFromDisk;
     saveNewVersion(version: number, encSub: Subscribe): Promise<void>;
-    isArchived(): boolean;
-    getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer?: number;
-        nonGarbage: Set<number>;
-    };
+    localStatus(): LocalObjStatus;
+    statusObj(): ObjStatus;
     removeCurrentVersion(): Promise<void>;
     removeArchivedVersion(version: number): Promise<void>;
 }

package/build/core/storage/local/obj-files.js

@@ -28,7 +28,7 @@ class ObjFiles {
     constructor(folders, logError) {
         this.folders = folders;
         this.logError = logError;
-        this.objs = timed_cache_1.makeTimedCache(60 * 1000);
+        this.objs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
         this.folderAccessSyncProc = new synced_1.NamedProcs();
         this.gc = new obj_files_gc_1.GC(obj => {
             if (this.objs.get(obj.objId) === obj) {
@@ -99,7 +99,7 @@ class LocalObj {
         this.objFolder = objFolder;
         this.status = status;
         this.scheduleGC = scheduleGC;
-        this.verObjs = timed_cache_1.makeTimedCache(60 * 1000);
+        this.verObjs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
         this.objSegsGetterFromDisk = async (ver, ofs, len) => {
             let obj = this.verObjs.get(ver);
             if (!obj) {
@@ -120,7 +120,7 @@ class LocalObj {
         return new LocalObj(objId, objFolder, status, scheduleGC);
     }
     path(version) {
-        return path_1.join(this.objFolder, `${version}.v`);
+        return (0, path_1.join)(this.objFolder, `${version}.v`);
     }
     async getObjSrc(version) {
         let obj = this.verObjs.get(version);
@@ -152,14 +152,11 @@ class LocalObj {
         await this.status.setNewCurrentVersion(version, obj.getBaseVersion());
         this.scheduleGC(this);
     }
-    isArchived() {
-        return this.status.isArchived();
+    localStatus() {
+        return this.status;
     }
-    getCurrentVersionOrThrow() {
-        return this.status.getCurrentVersionOrThrow();
-    }
-    getNonGarbageVersions() {
-        return this.status.getNonGarbageVersions();
+    statusObj() {
+        return this.status;
     }
     async removeCurrentVersion() {
         await this.status.removeCurrentVersion(this.verObjs);

package/build/core/storage/local/obj-status.d.ts

@@ -1,4 +1,4 @@
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { LocalObjStatus, ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { VersionsInfo } from '../common/obj-info-file';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 export interface ObjStatusInfo {
@@ -6,7 +6,7 @@ export interface ObjStatusInfo {
     isArchived?: boolean;
     versions: VersionsInfo;
 }
-export declare class ObjStatus {
+export declare class ObjStatus implements LocalObjStatus {
     private readonly objFolder;
     private readonly status;
     private readonly logError;
@@ -17,13 +17,19 @@ export declare class ObjStatus {
     private triggerSaveProc;
     isArchived(): boolean;
     getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer?: number;
-        nonGarbage: Set<number>;
-    };
+    getNonGarbageVersions(): NonGarbage;
     setNewCurrentVersion(newVersion: number, baseVer: number | undefined): Promise<void>;
     removeCurrentVersion(verObjs: ContainerWithDelete<number>): Promise<void>;
     removeArchivedVersion(version: number, verObjs: ContainerWithDelete<number>): Promise<void>;
+    archiveCurrentVersion(): Promise<void>;
+    listVersions(): {
+        current?: number;
+        archived?: number[];
+    };
+}
+export interface NonGarbage {
+    gcMaxVer?: number;
+    nonGarbage: Set<number>;
 }
 interface ContainerWithDelete<T> {
     delete(key: T): void;

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

@@ -19,15 +19,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjStatus = 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 json_saving_1 = require("../common/json-saving");
+const obj_info_file_2 = require("../common/obj-info-file");
+const assert_1 = require("../../../lib-common/assert");
 const 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, STATUS_FILE_NAME), () => this.status);
+        this.saveProc = new json_saving_1.JSONSavingProc((0, path_1.join)(this.objFolder, STATUS_FILE_NAME), () => this.status);
         Object.freeze(this);
     }
     static async readFrom(objFolder, objId, logError) {
@@ -61,17 +63,17 @@ class ObjStatus {
     }
     getNonGarbageVersions() {
         return {
-            nonGarbage: obj_info_file_1.nonGarbageVersionsIn(this.status.versions),
+            nonGarbage: (0, obj_info_file_2.nonGarbageVersionsIn)(this.status.versions),
             gcMaxVer: this.status.versions.current
         };
     }
     async setNewCurrentVersion(newVersion, baseVer) {
-        obj_info_file_1.setCurrentVersionIn(this.status.versions, newVersion, baseVer);
+        (0, obj_info_file_2.setCurrentVersionIn)(this.status.versions, newVersion, baseVer);
         await this.triggerSaveProc();
     }
     async removeCurrentVersion(verObjs) {
         this.status.isArchived = true;
-        const current = obj_info_file_1.rmCurrentVersionIn(this.status.versions);
+        const current = (0, obj_info_file_2.rmCurrentVersionIn)(this.status.versions);
         if (typeof current === 'number') {
             verObjs.delete(current);
         }
@@ -79,23 +81,36 @@ class ObjStatus {
     }
     async removeArchivedVersion(version, verObjs) {
         verObjs.delete(version);
-        obj_info_file_1.rmArchVersionsIn(this.status.versions, version);
+        (0, obj_info_file_2.rmArchVersionFrom)(this.status.versions, version);
+        await this.triggerSaveProc();
+    }
+    async archiveCurrentVersion() {
+        const versions = this.status.versions;
+        (0, assert_1.assert)(!!versions.current);
+        (0, obj_info_file_1.addArchived)(versions, versions.current);
         await this.triggerSaveProc();
     }
+    listVersions() {
+        const archived = this.status.versions.archived;
+        return {
+            current: this.status.versions.current,
+            archived: (archived ? archived.slice() : [])
+        };
+    }
 }
 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_2.readJSONInfoFileIn)(objFolder, 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;
 }

package/build/core/storage/local/storage.d.ts

@@ -1,26 +1,29 @@
-import { Storage, NodesContainer, StorageGetter, ObjId, NodeEvent } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { Storage, NodesContainer, StorageGetter, ObjId, NodeEvent, LocalObjStatus } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
 import { Observable } from 'rxjs';
 declare type FolderEvent = web3n.files.FolderEvent;
 declare type FileEvent = web3n.files.FileEvent;
+declare type FSType = web3n.files.FSType;
 export declare class LocalStorage implements Storage {
     private readonly files;
     private readonly getStorages;
     readonly cryptor: AsyncSBoxCryptor;
     private readonly logError;
-    readonly type: web3n.files.FSType;
+    readonly type = "local";
     readonly versioned = true;
     readonly nodes: NodesContainer;
+    readonly connect: undefined;
     private readonly events;
     private constructor();
     static makeAndStart(path: string, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, logError: LogError): Promise<Storage>;
     getNodeEvents(): Observable<NodeEvent>;
-    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
-    storageForLinking(type: web3n.files.FSType, location?: string): Storage;
+    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, childObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
+    storageForLinking(type: FSType, location?: string): Storage;
+    private getObjOrThrow;
+    status(objId: ObjId): Promise<LocalObjStatus>;
     generateNewObjId(): Promise<string>;
-    private getObjNonArchOrThrow;
-    getObj(objId: ObjId): Promise<ObjSource>;
+    getObjSrc(objId: ObjId, version?: number): Promise<ObjSource>;
     saveObj(objId: string, version: number, encSub: Subscribe): Promise<void>;
     removeObj(objId: string): Promise<void>;
     close(): Promise<void>;

package/build/core/storage/local/storage.js

@@ -13,7 +13,8 @@
  See the GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>. */
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorage = void 0;
 const common_1 = require("../../../lib-client/3nstorage/xsp-fs/common");
@@ -32,19 +33,20 @@ class LocalStorage {
         this.type = 'local';
         this.versioned = true;
         this.nodes = new common_1.NodesContainer();
+        this.connect = undefined;
         this.events = new utils_for_observables_1.Broadcast();
         Object.seal(this);
     }
     static async makeAndStart(path, getStorages, cryptor, logError) {
         const files = await obj_files_1.ObjFiles.makeFor(path, logError);
         const s = new LocalStorage(files, getStorages, cryptor, logError);
-        return common_1.wrapStorageImplementation(s);
+        return (0, common_1.wrapStorageImplementation)(s);
     }
     getNodeEvents() {
         return this.events.event$;
     }
-    broadcastNodeEvent(objId, parentObjId, event) {
-        this.events.next({ objId, parentObjId, event });
+    broadcastNodeEvent(objId, parentObjId, childObjId, event) {
+        this.events.next({ objId, parentObjId, childObjId, event });
     }
     storageForLinking(type, location) {
         if ((type === 'local') || (type === 'synced')) {
@@ -57,8 +59,22 @@ class LocalStorage {
             throw new Error(`Getting ${type} storage is not implemented in local storage.`);
         }
     }
+    async getObjOrThrow(objId, allowArchived = false) {
+        const obj = await this.files.findObj(objId);
+        if (!obj
+            || (!allowArchived && obj.statusObj().isArchived())) {
+            throw (0, exceptions_1.makeObjNotFoundExc)(objId);
+        }
+        else {
+            return obj;
+        }
+    }
+    async status(objId) {
+        const obj = await this.getObjOrThrow(objId);
+        return obj.localStatus();
+    }
     async generateNewObjId() {
-        const nonce = await random_node_1.bytes(ecma_nacl_1.secret_box.NONCE_LENGTH);
+        const nonce = await (0, random_node_1.bytes)(ecma_nacl_1.secret_box.NONCE_LENGTH);
         const id = buffer_utils_1.base64urlSafe.pack(nonce);
         if (this.nodes.reserveId(id)) {
             return id;
@@ -67,35 +83,30 @@ class LocalStorage {
             return this.generateNewObjId();
         }
     }
-    async getObjNonArchOrThrow(objId) {
-        const obj = await this.files.findObj(objId);
-        if (!obj || obj.isArchived()) {
-            throw exceptions_1.makeObjNotFoundExc(objId);
+    async getObjSrc(objId, version) {
+        const obj = await this.getObjOrThrow(objId);
+        if (!version) {
+            version = obj.statusObj().getCurrentVersionOrThrow();
         }
-        return obj;
-    }
-    async getObj(objId) {
-        const obj = await this.getObjNonArchOrThrow(objId);
-        const currentVer = obj.getCurrentVersionOrThrow();
-        return obj.getObjSrc(currentVer);
+        return obj.getObjSrc(version);
     }
     async saveObj(objId, version, encSub) {
         const obj = await this.files.findObj(objId);
         if (version === 1) {
             if (obj) {
-                throw exceptions_1.makeObjExistsExc(objId);
+                throw (0, exceptions_1.makeObjExistsExc)(objId);
             }
             await this.files.saveFirstVersion(objId, encSub);
         }
         else {
             if (!obj) {
-                throw exceptions_1.makeObjNotFoundExc(objId);
+                throw (0, exceptions_1.makeObjNotFoundExc)(objId);
             }
             await obj.saveNewVersion(version, encSub);
         }
     }
     async removeObj(objId) {
-        const obj = await this.getObjNonArchOrThrow(objId);
+        const obj = await this.getObjOrThrow(objId);
         await obj.removeCurrentVersion();
     }
     async close() {

package/build/core/storage/synced/downloader.js

@@ -64,7 +64,7 @@ class Downloader {
                     chunks.push(chunk);
                     ofs += chunk.length;
                 }
-                return buffer_utils_1.joinByteArrs(chunks);
+                return (0, buffer_utils_1.joinByteArrs)(chunks);
             }
         });
     }

package/build/core/storage/synced/obj-files-gc.d.ts

@@ -1,8 +1,10 @@
 import { SynchronizerOnObjId, SyncedObj } from './obj-files';
+import { StorageOwner as RemoteStorage } from '../../../lib-client/3nstorage/service';
 export declare class GC {
     private readonly sync;
     private readonly rmObjFromCache;
     private readonly rmObjFolder;
+    private readonly remote;
     private isStopped;
     /**
      * All gc steps are done in this process.
@@ -18,9 +20,11 @@ export declare class GC {
      * with wip set.
      */
     private scheduled;
-    constructor(sync: SynchronizerOnObjId, rmObjFromCache: (obj: SyncedObj) => void, rmObjFolder: (objId: string) => Promise<void>);
+    constructor(sync: SynchronizerOnObjId, rmObjFromCache: (obj: SyncedObj) => void, rmObjFolder: (objId: string) => Promise<void>, remote: RemoteStorage);
     scheduleCollection: (obj: SyncedObj) => void;
     stop(): Promise<void>;
     private objCollecting;
     private collectIn;
+    private upsyncObjRemovalWhenNeeded;
+    private checkAndRemoveWholeObjFolder;
 }

package/build/core/storage/synced/obj-files-gc.js

@@ -17,14 +17,18 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GC = void 0;
+const obj_files_1 = require("./obj-files");
 const synced_1 = require("../../../lib-common/processes/synced");
 const fs = require("../../../lib-common/async-fs-node");
 const path_1 = require("path");
+const utils_1 = require("../common/utils");
+const upload_header_file_1 = require("./upload-header-file");
 class GC {
-    constructor(sync, rmObjFromCache, rmObjFolder) {
+    constructor(sync, rmObjFromCache, rmObjFolder, remote) {
         this.sync = sync;
         this.rmObjFromCache = rmObjFromCache;
         this.rmObjFolder = rmObjFolder;
+        this.remote = remote;
         this.isStopped = false;
         /**
          * All gc steps are done in this process.
@@ -54,11 +58,11 @@ class GC {
             if (this.wip.size === 0) {
                 [this.wip, this.scheduled] = [this.scheduled, this.wip];
             }
-            const obj = getAndRemoveOneFrom(this.wip);
+            const obj = (0, utils_1.getAndRemoveOneFrom)(this.wip);
             if (!obj) {
                 return;
             }
-            await this.sync(obj.objId, () => this.collectIn(obj).catch(noop));
+            await this.sync(obj.objId, () => this.collectIn(obj).catch(utils_1.noop));
             return this.objCollecting();
         };
         Object.seal(this);
@@ -67,52 +71,102 @@ class GC {
         this.isStopped = true;
     }
     async collectIn(obj) {
-        // calculate versions that should not be removed
-        const { gcMaxVer, nonGarbage } = obj.getNonGarbageVersions();
-        // if object is set archived, and there is nothing in it worth keeping,
-        // whole folder can be removed
-        if ((nonGarbage.size === 0)
-            && obj.isArchived() && obj.sync().isSyncDone()) {
-            if (!obj.isStatusFileSaved()) {
-                return;
-            }
-            this.rmObjFromCache(obj);
-            if (obj.objId) {
-                await this.rmObjFolder(obj.objId);
-            }
+        if (obj.statusObj().isArchived()) {
+            await this.upsyncObjRemovalWhenNeeded(obj);
+        }
+        const nonGarbage = obj.statusObj().getNonGarbageVersions();
+        if (!(await this.checkAndRemoveWholeObjFolder(obj, nonGarbage))) {
+            await removeGarbageFiles(obj, nonGarbage);
+        }
+    }
+    async upsyncObjRemovalWhenNeeded(obj) {
+        if (!needsUpsyncOfRemoval(obj)) {
             return;
         }
-        // for all other cases, we remove version files that are not worth
-        // keeping.
-        const lst = await fs.readdir(obj.objFolder).catch(noop);
-        if (!lst) {
+        try {
+            await this.remote.deleteObj(obj.objId);
+        }
+        catch (exc) {
+            // XXX will need to schedule other attempt to delete on remote
             return;
         }
-        const rmProcs = [];
-        for (const f of lst) {
-            const ver = parseInt(f);
-            if (isNaN(ver) || nonGarbage.has(ver)
-                || (gcMaxVer && (ver >= gcMaxVer))) {
-                continue;
-            }
-            rmProcs.push(fs.unlink(path_1.join(obj.objFolder, f)).catch(noop));
+        await obj.statusObj().recordSyncOfObjRemoval();
+    }
+    async checkAndRemoveWholeObjFolder(obj, { local, remote }) {
+        if (obj.objId
+            && obj.statusObj().isArchived()
+            && !needsUpsyncOfRemoval(obj)
+            && (!local || (local.nonGarbage.size === 0))
+            && (remote.nonGarbage.size === 0)) {
+            this.rmObjFromCache(obj);
+            await this.rmObjFolder(obj.objId);
+            return true;
         }
-        if (rmProcs.length > 0) {
-            await Promise.all(rmProcs);
+        else {
+            return false;
         }
     }
 }
 exports.GC = GC;
 Object.freeze(GC.prototype);
 Object.freeze(GC);
-function getAndRemoveOneFrom(set) {
-    const iter = set.values();
-    const { value, done } = iter.next();
-    if (done) {
+function needsUpsyncOfRemoval(obj) {
+    const s = obj.statusObj();
+    return !(s.neverUploaded() || (s.syncStatus().state === 'synced'));
+}
+function canRemove(f, { local, remote, uploadVersion }) {
+    if (f.endsWith(obj_files_1.UNSYNCED_FILE_NAME_EXT)) {
+        const verStr = f.slice(0, f.length - 1 - obj_files_1.UNSYNCED_FILE_NAME_EXT.length);
+        return (local ? canGC(verStr, local) : true);
+    }
+    else if (f.endsWith(obj_files_1.REMOTE_FILE_NAME_EXT)) {
+        const verStr = f.slice(0, f.length - 1 - obj_files_1.REMOTE_FILE_NAME_EXT.length);
+        return canGC(verStr, remote);
+    }
+    else if (!!uploadVersion
+        && f.endsWith(upload_header_file_1.UPLOAD_HEADER_FILE_NAME_EXT)) {
+        const verStr = f.slice(0, f.length - 1 - upload_header_file_1.UPLOAD_HEADER_FILE_NAME_EXT.length);
+        return canGCUploadHeader(verStr, uploadVersion);
+    }
+    else {
+        return false;
+    }
+}
+function canGC(verStr, nonGC) {
+    const ver = parseInt(verStr);
+    if (isNaN(ver)) {
+        return true;
+    }
+    else if (!nonGC.nonGarbage.has(ver)
+        && (!nonGC.gcMaxVer || (ver < nonGC.gcMaxVer))) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function canGCUploadHeader(verStr, uploadVersion) {
+    const ver = parseInt(verStr);
+    if (isNaN(ver)) {
+        return true;
+    }
+    else {
+        return (ver === uploadVersion);
+    }
+}
+async function removeGarbageFiles(obj, nonGarbage) {
+    const lst = await fs.readdir(obj.objFolder).catch(utils_1.noop);
+    if (!lst) {
         return;
     }
-    set.delete(value);
-    return value;
+    const rmProcs = [];
+    for (const f of lst) {
+        if (canRemove(f, nonGarbage)) {
+            rmProcs.push(fs.unlink((0, path_1.join)(obj.objFolder, f)).catch(utils_1.noop));
+        }
+    }
+    if (rmProcs.length > 0) {
+        await Promise.all(rmProcs);
+    }
 }
-function noop() { }
 Object.freeze(exports);