core-3nweb-client-lib 0.26.0 → 0.27.1

package/build/core/storage/common/obj-info-file.js

@@ -16,13 +16,13 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addWithBasesTo = exports.nonGarbageVersionsIn = exports.rmCurrentVersionIn = exports.setCurrentVersionIn = exports.rmArchVersionsIn = exports.rmNonArchVersionsIn = exports.addBaseToDiffLinkInStatus = exports.readJSONInfoFileIn = void 0;
+exports.isEmptyVersions = exports.addArchived = exports.addWithBasesTo = exports.nonGarbageVersionsIn = exports.rmVersionIn = exports.rmCurrentVersionIn = exports.setCurrentVersionIn = exports.rmArchVersionFrom = exports.rmNonArchVersionsIn = exports.isVersionIn = exports.addBaseToDiffLinkInVersInfo = exports.readJSONInfoFileIn = void 0;
 const fs = require("../../../lib-common/async-fs-node");
 const path_1 = require("path");
 const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
 async function readJSONInfoFileIn(objFolder, fileName) {
     try {
-        const infoJSONStr = await fs.readFile(path_1.join(objFolder, fileName), { encoding: 'utf8' }).catch((exc) => {
+        const infoJSONStr = await fs.readFile((0, path_1.join)(objFolder, fileName), { encoding: 'utf8' }).catch((exc) => {
             if (!exc.notFound) {
                 throw exc;
             }
@@ -35,7 +35,7 @@ async function readJSONInfoFileIn(objFolder, fileName) {
         return status;
     }
     catch (err) {
-        throw exceptions_1.makeStorageException({
+        throw (0, exceptions_1.makeStorageException)({
             message: `Can't read and parse content of obj info file ${fileName} in obj folder ${objFolder}`,
             cause: err
         });
@@ -48,22 +48,24 @@ exports.readJSONInfoFileIn = readJSONInfoFileIn;
  * @param diffVer
  * @param baseVer
  */
-function addBaseToDiffLinkInStatus(versions, diffVer, baseVer) {
+function addBaseToDiffLinkInVersInfo(versions, diffVer, baseVer) {
     if (diffVer <= baseVer) {
         throw new Error(`Given diff version ${diffVer} is not greater than base version ${baseVer}`);
     }
     versions.diffToBase[diffVer] = baseVer;
-    const diffs = versions.baseToDiff[baseVer];
-    if (diffs) {
-        if (diffs.indexOf(diffVer) < 0) {
-            diffs.push(diffVer);
-        }
+    versions.baseToDiff[baseVer] = diffVer;
+}
+exports.addBaseToDiffLinkInVersInfo = addBaseToDiffLinkInVersInfo;
+function isVersionIn(version, vers) {
+    if (vers.current === version) {
+        return true;
     }
-    else {
-        versions.baseToDiff[baseVer] = [diffVer];
+    if (vers.archived && vers.archived.includes(version)) {
+        return true;
     }
+    return false;
 }
-exports.addBaseToDiffLinkInStatus = addBaseToDiffLinkInStatus;
+exports.isVersionIn = isVersionIn;
 /**
  * This function removes given version from versions info, if it is neither
  * archived, nor is a base for another version. If given version is itself
@@ -73,49 +75,41 @@ exports.addBaseToDiffLinkInStatus = addBaseToDiffLinkInStatus;
  * @param ver
  */
 function rmNonArchVersionsIn(versions, ver) {
-    if (!versions.archived
-        || !versions.archived.includes(ver)) {
+    if (versions.archived
+        && versions.archived.includes(ver)) {
         return;
     }
     if (versions.baseToDiff[ver]) {
         return;
     }
     const base = versions.diffToBase[ver];
-    if (typeof base !== 'number') {
-        return;
-    }
-    delete versions.diffToBase[ver];
-    const diffs = versions.baseToDiff[base];
-    if (!diffs) {
-        return;
-    }
-    const diffInd = diffs.indexOf(ver);
-    if (diffInd < 0) {
-        return;
-    }
-    diffs.splice(diffInd, 1);
-    if (diffs.length === 0) {
+    if (base) {
+        delete versions.diffToBase[ver];
         delete versions.baseToDiff[base];
         rmNonArchVersionsIn(versions, base);
     }
 }
 exports.rmNonArchVersionsIn = rmNonArchVersionsIn;
-function rmArchVersionsIn(versions, ver) {
+function rmArchVersionFrom(versions, ver) {
     if (!versions.archived) {
-        return;
+        return false;
     }
     const vInd = versions.archived.indexOf(ver);
     if (vInd < 0) {
-        return;
+        return false;
     }
     versions.archived.splice(vInd, 1);
+    if (versions.archived.length === 0) {
+        versions.archived = undefined;
+    }
     rmNonArchVersionsIn(versions, ver);
+    return true;
 }
-exports.rmArchVersionsIn = rmArchVersionsIn;
+exports.rmArchVersionFrom = rmArchVersionFrom;
 function setCurrentVersionIn(versions, version, baseVer) {
     if (baseVer !== undefined) {
         // base->diff links should be added before removals
-        addBaseToDiffLinkInStatus(versions, version, baseVer);
+        addBaseToDiffLinkInVersInfo(versions, version, baseVer);
     }
     const initCurrent = versions.current;
     if (typeof initCurrent === 'number') {
@@ -128,11 +122,21 @@ function rmCurrentVersionIn(versions) {
     const current = versions.current;
     if (typeof current === 'number') {
         rmNonArchVersionsIn(versions, current);
-        delete versions.current;
+        versions.current = undefined;
     }
     return current;
 }
 exports.rmCurrentVersionIn = rmCurrentVersionIn;
+function rmVersionIn(version, vers) {
+    if (vers.current === version) {
+        vers.current = undefined;
+        rmNonArchVersionsIn(vers, version);
+    }
+    if (isVersionIn(version, vers)) {
+        rmArchVersionFrom(vers, version);
+    }
+}
+exports.rmVersionIn = rmVersionIn;
 function nonGarbageVersionsIn(versions) {
     const nonGarbage = new Set();
     addWithBasesTo(nonGarbage, versions.current, versions);
@@ -157,4 +161,32 @@ function addWithBasesTo(nonGarbage, ver, versions) {
     }
 }
 exports.addWithBasesTo = addWithBasesTo;
+function addArchived(versions, version) {
+    if (!versions.archived) {
+        versions.archived = [];
+    }
+    else if (versions.archived.includes(version)) {
+        return false;
+    }
+    versions.archived.push(version);
+    versions.archived.sort();
+    return true;
+}
+exports.addArchived = addArchived;
+function isEmptyVersions(versions) {
+    if (versions.current) {
+        return false;
+    }
+    if (!versions.archived) {
+        return true;
+    }
+    else if (versions.archived.length > 0) {
+        return false;
+    }
+    else {
+        versions.archived = undefined;
+        return true;
+    }
+}
+exports.isEmptyVersions = isEmptyVersions;
 Object.freeze(exports);

package/build/core/storage/common/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getAndRemoveOneFrom<T>(set: Set<T>): T | undefined;
+export declare function noop(): void;

package/build/core/storage/common/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2020 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
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ 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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = exports.getAndRemoveOneFrom = void 0;
+function getAndRemoveOneFrom(set) {
+    const iter = set.values();
+    const { value, done } = iter.next();
+    if (done) {
+        return;
+    }
+    set.delete(value);
+    return value;
+}
+exports.getAndRemoveOneFrom = getAndRemoveOneFrom;
+function noop() { }
+exports.noop = noop;
+Object.freeze(exports);

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

@@ -3,24 +3,12 @@ import { GenerateKey } from '../sign-in';
 import { StorageGetter } from '../../lib-client/3nstorage/xsp-fs/common';
 import { ServiceLocator } from '../../lib-client/service-locator';
 import { AsyncSBoxCryptor } from 'xsp-files';
-import { NetClient } from '../../lib-client/request-utils';
 import { StoragePathForUser } from '../app-files';
 import { LogError } from '../../lib-client/logging/log-to-file';
+import { MakeNet } from '..';
 declare type WritableFS = web3n.files.WritableFS;
 declare type StorageType = web3n.storage.StorageType;
 declare type FSItem = web3n.files.FSItem;
-export declare const sysFolders: {
-    appData: string;
-    apps: string;
-    packages: string;
-    sharedLibs: string;
-    userFiles: string;
-};
-/**
- * This function creates initial folder structure in a given root.
- * @param root
- */
-export declare function initSysFolders(root: WritableFS): Promise<void>;
 export declare class Storages implements FactoryOfFSs {
     private cryptor;
     private storageDirForUser;
@@ -42,8 +30,8 @@ export declare class Storages implements FactoryOfFSs {
      * This is a storage getter for links and linking in synced storage.
      */
     private storageGetterForSyncedStorage;
-    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: () => NetClient, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => Promise<boolean>) | undefined>;
-    initFromRemote(user: string, getSigner: GetSigner, keyOrGen: GenerateKey | Uint8Array, makeNet: () => NetClient, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
+    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => Promise<boolean>) | undefined>;
+    initFromRemote(user: string, getSigner: GetSigner, keyOrGen: GenerateKey | Uint8Array, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
     makeSyncedFSForApp(appFolder: string): Promise<WritableFS>;
     makeLocalFSForApp(appFolder: string): Promise<WritableFS>;
     getUserFS(type: StorageType): Promise<FSItem>;
@@ -51,8 +39,6 @@ export declare class Storages implements FactoryOfFSs {
     close(): Promise<void>;
     wrap(): FactoryOfFSs;
 }
-export declare function userFilesOnDevice(): Promise<WritableFS>;
-export declare function sysFilesOnDevice(): Promise<FSItem>;
 export interface FactoryOfFSs {
     makeSyncedFSForApp(appFolder: string): Promise<WritableFS>;
     makeLocalFSForApp(appFolder: string): Promise<WritableFS>;

package/build/core/storage/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2017, 2019 - 2021 3NSoft Inc.
+ Copyright (C) 2015 - 2017, 2019 - 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
@@ -16,17 +16,18 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerAppStorage = exports.reverseDomain = exports.sysFilesOnDevice = exports.userFilesOnDevice = exports.Storages = exports.initSysFolders = exports.sysFolders = void 0;
+exports.PerAppStorage = exports.reverseDomain = exports.Storages = void 0;
 const fs_1 = require("../../lib-client/3nstorage/xsp-fs/fs");
 const storage_1 = require("./synced/storage");
 const storage_2 = require("./local/storage");
 const file_1 = require("../../lib-common/exceptions/file");
 const fs_collection_1 = require("../../lib-client/fs-collection");
 const async_iter_1 = require("../../lib-common/async-iter");
-const device_fs_1 = require("../../lib-client/local-files/device-fs");
 const path_1 = require("path");
 const fs = require("../../lib-common/async-fs-node");
 const error_1 = require("../../lib-common/exceptions/error");
+const system_folders_1 = require("./system-folders");
+const apps_data_1 = require("./system-folders/apps-data");
 function makeBadAppNameExc(appName) {
     return {
         runtimeException: true,
@@ -74,58 +75,45 @@ const SYNCED_STORAGE_DIR = 'synced';
  */
 async function readRootKeyDerivParamsFromCache(folder) {
     try {
-        const str = await fs.readFile(path_1.join(folder, KD_PARAMS_FILE_NAME), { encoding: 'utf8' });
+        const str = await fs.readFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), { encoding: 'utf8' });
         return JSON.parse(str);
     }
     catch (err) {
         if (err.notFound) {
             return undefined;
         }
-        throw error_1.errWithCause(err, `Can't read and parse content of obj status file ${KD_PARAMS_FILE_NAME} in folder ${folder}`);
+        throw (0, error_1.errWithCause)(err, `Can't read and parse content of obj status file ${KD_PARAMS_FILE_NAME} in folder ${folder}`);
     }
 }
 /**
  * This function tries to get key derivation parameters from cache on a disk.
  * If not found, it will ask storage server for it with a provided function.
- * @param fs
+ * @param folder
  * @param getFromServer
  */
 async function getRootKeyDerivParams(folder, getFromServer) {
     let params = await readRootKeyDerivParamsFromCache(folder);
     if (!params) {
         params = await getFromServer();
-        await fs.writeFile(path_1.join(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
+        await fs.writeFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
     }
     return params;
 }
-exports.sysFolders = {
-    appData: 'Apps Data',
-    apps: 'Apps Code',
-    packages: 'App&Lib Packs',
-    sharedLibs: 'Shared Libs',
-    userFiles: 'User Files'
-};
-Object.freeze(exports.sysFolders);
-/**
- * This function creates initial folder structure in a given root.
- * @param root
- */
-async function initSysFolders(root) {
-    for (const sysFolder of Object.values(exports.sysFolders)) {
-        await root.makeFolder(sysFolder);
-    }
-}
-exports.initSysFolders = initSysFolders;
 class StorageAndFS {
     constructor(storage) {
         this.storage = storage;
         this.rootFS = undefined;
+        this.syncedAppDataRoots = undefined;
         Object.seal(this);
     }
     static async existing(storage, key) {
+        var _a;
         const s = new StorageAndFS(storage);
         try {
             s.rootFS = await fs_1.XspFS.fromExistingRoot(s.storage, key);
+            if ((_a = s.rootFS.v) === null || _a === void 0 ? void 0 : _a.sync) {
+                s.syncedAppDataRoots = await apps_data_1.AppDataFolders.make(s.rootFS);
+            }
             return s;
         }
         catch (err) {
@@ -138,15 +126,22 @@ class StorageAndFS {
         }
     }
     static async newOrExisting(storage, key) {
+        var _a, _b;
         const s = new StorageAndFS(storage);
         try {
             s.rootFS = await fs_1.XspFS.fromExistingRoot(s.storage, key);
+            if ((_a = s.rootFS.v) === null || _a === void 0 ? void 0 : _a.sync) {
+                s.syncedAppDataRoots = await apps_data_1.AppDataFolders.make(s.rootFS);
+            }
             return s;
         }
         catch (err) {
             if (err.objNotFound) {
                 s.rootFS = await fs_1.XspFS.makeNewRoot(s.storage, key);
-                await initSysFolders(s.rootFS);
+                await (0, system_folders_1.initSysFolders)(s.rootFS);
+                if ((_b = s.rootFS.v) === null || _b === void 0 ? void 0 : _b.sync) {
+                    s.syncedAppDataRoots = await apps_data_1.AppDataFolders.make(s.rootFS);
+                }
                 return s;
             }
             else if (err.failedCipherVerification) {
@@ -157,27 +152,35 @@ class StorageAndFS {
             }
         }
     }
-    makeAppFS(appFolder) {
-        if (('string' !== typeof appFolder) ||
-            (appFolder.length === 0) ||
-            (appFolder.indexOf('/') >= 0)) {
+    /**
+     * This creates app data folder.
+     * Folder objects are uploaded, if this is a synced storage.
+     * @param appFolder
+     */
+    async makeAppFS(appFolder) {
+        if (('string' !== typeof appFolder) || (appFolder.length === 0)
+            || (appFolder.indexOf('/') >= 0)
+            || (appFolder === '.') || (appFolder === '..')) {
             throw makeBadAppNameExc(appFolder);
         }
         if (!this.rootFS) {
             throw new Error('Storage is not initialized.');
         }
-        return this.rootFS.writableSubRoot(`${exports.sysFolders.appData}/${appFolder}`);
+        const appDataFS = await (this.syncedAppDataRoots ?
+            this.syncedAppDataRoots.getOrMake(appFolder) :
+            this.rootFS.writableSubRoot(`${system_folders_1.sysFolders.appData}/${appFolder}`));
+        return appDataFS;
     }
     userFS() {
-        return this.rootFS.writableSubRoot(exports.sysFolders.userFiles);
+        return this.rootFS.writableSubRoot(system_folders_1.sysFolders.userFiles);
     }
     async sysFSs() {
         const folders = [
-            exports.sysFolders.appData, exports.sysFolders.apps,
-            exports.sysFolders.packages,
-            exports.sysFolders.sharedLibs
+            system_folders_1.sysFolders.appData, system_folders_1.sysFolders.apps,
+            system_folders_1.sysFolders.packages,
+            system_folders_1.sysFolders.sharedLibs
         ];
-        const c = fs_collection_1.makeFSCollection();
+        const c = (0, fs_collection_1.makeFSCollection)();
         for (let fsName of folders) {
             await c.set(fsName, {
                 isFolder: true,
@@ -187,15 +190,20 @@ class StorageAndFS {
         return c;
     }
     async close() {
+        var _a;
         if (!this.rootFS) {
             return;
         }
+        (_a = this.syncedAppDataRoots) === null || _a === void 0 ? void 0 : _a.stopSync();
         await this.rootFS.close();
         await this.storage.close();
+        this.syncedAppDataRoots = undefined;
         this.rootFS = undefined;
         this.storage = undefined;
     }
 }
+Object.freeze(StorageAndFS.prototype);
+Object.freeze(StorageAndFS);
 class Storages {
     constructor(cryptor, storageDirForUser) {
         this.cryptor = cryptor;
@@ -266,7 +274,7 @@ class Storages {
             return;
         }
         const key = await keyGen(params);
-        this.local = await StorageAndFS.existing(await storage_2.LocalStorage.makeAndStart(path_1.join(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
+        this.local = await StorageAndFS.existing(await storage_2.LocalStorage.makeAndStart((0, path_1.join)(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
         if (!this.local) {
             return;
         }
@@ -274,7 +282,7 @@ class Storages {
             if (this.synced) {
                 return true;
             }
-            const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart(path_1.join(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet, logError);
+            const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart((0, path_1.join)(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet(), logError);
             this.synced = await StorageAndFS.existing(syncedStore, key);
             key.fill(0);
             if (!this.synced) {
@@ -286,13 +294,13 @@ class Storages {
     }
     async initFromRemote(user, getSigner, keyOrGen, makeNet, resolver, logError) {
         const storageDir = this.storageDirForUser(user);
-        const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart(path_1.join(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet, logError);
+        const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart((0, path_1.join)(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet(), logError);
         // getting parameters records them locally on a disk
         const params = await getRootKeyDerivParams(storageDir, syncedStore.getRootKeyDerivParamsFromServer);
         const key = ((typeof keyOrGen === 'function') ?
             await keyOrGen(params) : keyOrGen);
         this.synced = await StorageAndFS.newOrExisting(syncedStore, key);
-        this.local = await StorageAndFS.newOrExisting(await storage_2.LocalStorage.makeAndStart(path_1.join(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
+        this.local = await StorageAndFS.newOrExisting(await storage_2.LocalStorage.makeAndStart((0, path_1.join)(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
         key.fill(0);
         startObjProcs();
         return (!!this.synced && !!this.local);
@@ -316,7 +324,7 @@ class Storages {
             fs = await this.local.userFS();
         }
         else if (type === 'device') {
-            fs = await userFilesOnDevice();
+            fs = await (0, system_folders_1.userFilesOnDevice)();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);
@@ -342,7 +350,7 @@ class Storages {
             };
         }
         else if (type === 'device') {
-            return sysFilesOnDevice();
+            return (0, system_folders_1.sysFilesOnDevice)();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);
@@ -372,33 +380,6 @@ class Storages {
 exports.Storages = Storages;
 Object.freeze(Storages.prototype);
 Object.freeze(Storages);
-async function userFilesOnDevice() {
-    if (process.platform === 'win32') {
-        return device_fs_1.DeviceFS.makeWritable(process.env.USERPROFILE);
-    }
-    else {
-        return device_fs_1.DeviceFS.makeWritable(process.env.HOME);
-    }
-}
-exports.userFilesOnDevice = userFilesOnDevice;
-async function sysFilesOnDevice() {
-    const c = fs_collection_1.makeFSCollection();
-    if (process.platform === 'win32') {
-        const sysDrive = process.env.SystemDrive;
-        await c.set(sysDrive, {
-            isFolder: true,
-            item: await device_fs_1.DeviceFS.makeWritable(sysDrive)
-        });
-    }
-    else {
-        await c.set('', {
-            isFolder: true,
-            item: await device_fs_1.DeviceFS.makeWritable('/')
-        });
-    }
-    return { isCollection: true, item: c };
-}
-exports.sysFilesOnDevice = sysFilesOnDevice;
 function reverseDomain(domain) {
     return domain.split('.').reverse().join('.');
 }
@@ -456,8 +437,7 @@ class PerAppStorage {
         if (typeof appFolder !== 'string') {
             throw makeBadAppNameExc(appFolder);
         }
-        if (CORE_APPS_PREFIX ===
-            appFolder.substring(0, CORE_APPS_PREFIX.length)) {
+        if (appFolder.startsWith(CORE_APPS_PREFIX)) {
             throw makeNotAllowedToOpenAppFSExc(appFolder);
         }
         if (!this.policy.canOpenAppFS(appFolder, type)) {
@@ -523,10 +503,10 @@ async function applyPolicyToFS(fs, policy, path) {
 async function applyPolicyToFSCollection(c, policy, path) {
     if (path === undefined) {
         if (policy === 'w') {
-            return fs_collection_1.readonlyWrapFSCollection(c);
+            return (0, fs_collection_1.readonlyWrapFSCollection)(c);
         }
         else {
-            const roFSs = fs_collection_1.makeFSCollection();
+            const roFSs = (0, fs_collection_1.makeFSCollection)();
             for (const v of (await c.getAll())) {
                 const fs = v[1].item;
                 if (!v[1].isFolder || !fs || !fs.listFolder) {
@@ -535,15 +515,15 @@ async function applyPolicyToFSCollection(c, policy, path) {
                 v[1].item = await v[1].item.readonlySubRoot('/');
                 await roFSs.set(v[0], v[1]);
             }
-            return fs_collection_1.readonlyWrapFSCollection(roFSs);
+            return (0, fs_collection_1.readonlyWrapFSCollection)(roFSs);
         }
     }
     if (path.startsWith('/')) {
         path = path.substring(1);
     }
-    const nameAndItem = await async_iter_1.asyncFind(await c.entries(), async (v) => path.startsWith(v[0]));
+    const nameAndItem = await (0, async_iter_1.asyncFind)(await c.entries(), async (v) => path.startsWith(v[0]));
     if (!nameAndItem) {
-        throw file_1.makeFileException(file_1.Code.notFound, path);
+        throw (0, file_1.makeFileException)(file_1.Code.notFound, path);
     }
     const [name, item] = nameAndItem;
     path = path.substring(name.length);

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

@@ -19,4 +19,6 @@ export declare class GC {
     constructor(rmObjFromCache: (obj: LocalObj) => void, rmObjFolder: (objId: string) => Promise<void>);
     scheduleCollection: (obj: LocalObj) => void;
     private objCollecting;
+    private collectIn;
+    private checkAndRemoveWholeObjFolder;
 }