core-3nweb-client-lib 0.43.20 → 0.44.1

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

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

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

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

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2018, 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2016 - 2018, 2020, 2022, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software

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

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

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

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

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

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

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

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

package/build/lib-common/ipc/generic-ipc.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2017, 2025 3NSoft Inc.
+ Copyright (C) 2016 - 2017, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -504,6 +504,7 @@ class EventsReceivingSide extends RequestingSide {
      * @param err
      */
     completeEvent(ipcChannel, err) {
+        var _a, _b, _c, _d;
         const listeners = this.listeners.get(ipcChannel);
         if (!listeners) {
             return;
@@ -512,14 +513,10 @@ class EventsReceivingSide extends RequestingSide {
         for (const listener of listeners) {
             try {
                 if (err === undefined) {
-                    if (listener.observer.complete) {
-                        listener.observer.complete();
-                    }
+                    (_b = (_a = listener.observer).complete) === null || _b === void 0 ? void 0 : _b.call(_a);
                 }
                 else {
-                    if (listener.observer.error) {
-                        listener.observer.error(err);
-                    }
+                    (_d = (_c = listener.observer).error) === null || _d === void 0 ? void 0 : _d.call(_c, err);
                 }
             }
             catch (err2) {
@@ -528,7 +525,24 @@ class EventsReceivingSide extends RequestingSide {
         }
     }
     handleCompletion(err) {
+        var _a, _b, _c, _d, _e;
         super.handleCompletion(err);
+        for (const ipcChannel of this.listeners.keys()) {
+            const listeners = (_a = this.listeners.get(ipcChannel)) !== null && _a !== void 0 ? _a : [];
+            for (const listener of listeners) {
+                try {
+                    if (err === undefined) {
+                        (_c = (_b = listener.observer).complete) === null || _c === void 0 ? void 0 : _c.call(_b);
+                    }
+                    else {
+                        (_e = (_d = listener.observer).error) === null || _e === void 0 ? void 0 : _e.call(_d, err);
+                    }
+                }
+                catch (err2) {
+                    console.error(err2);
+                }
+            }
+        }
         this.listeners.clear();
     }
     subscribe(channel, observer) {
@@ -635,37 +649,31 @@ class MultiObserverWrap {
         return () => { this.obs.delete(obs); };
     }
     next(o) {
+        var _a;
         if (this.isDone) {
             return;
         }
         for (const obs of this.obs) {
-            if (!obs.next) {
-                continue;
-            }
-            obs.next(o);
+            (_a = obs.next) === null || _a === void 0 ? void 0 : _a.call(obs, o);
         }
     }
     error(err) {
+        var _a;
         if (this.isDone) {
             return;
         }
         for (const obs of this.obs) {
-            if (!obs.error) {
-                continue;
-            }
-            obs.error(err);
+            (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err);
         }
         this.setDone();
     }
     complete() {
+        var _a;
         if (this.isDone) {
             return;
         }
         for (const obs of this.obs) {
-            if (!obs.complete) {
-                continue;
-            }
-            obs.complete();
+            (_a = obs.complete) === null || _a === void 0 ? void 0 : _a.call(obs);
         }
         this.setDone();
     }
@@ -697,29 +705,26 @@ class SingleObserverWrap {
         this.obs = obs;
     }
     next(o) {
+        var _a, _b;
         if (this.isDone || !this.obs) {
             return;
         }
-        if (this.obs.next) {
-            this.obs.next(o);
-        }
+        (_b = (_a = this.obs) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, o);
     }
     error(err) {
+        var _a, _b;
         if (this.isDone) {
             return;
         }
-        if (this.obs && this.obs.error) {
-            this.obs.error(err);
-        }
+        (_b = (_a = this.obs) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
         this.setDone();
     }
     complete() {
+        var _a, _b;
         if (this.isDone) {
             return;
         }
-        if (this.obs && this.obs.complete) {
-            this.obs.complete();
-        }
+        (_b = (_a = this.obs) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
         this.setDone();
     }
     setDone() {

package/build/lib-common/ipc/ws-ipc.d.ts

@@ -10,6 +10,7 @@ export interface WSException extends web3n.RuntimeException {
 }
 export declare function makeWSException(params: Partial<WSException>, flags?: Partial<WSException>): WSException;
 export interface ConnectionStatus {
+    type: 'heartbeat' | 'heartbeat-skip' | 'disconnected' | 'connected';
     url: string;
     /**
      * ping number is a number of millisecond between previous and current data receiving from server.
@@ -19,6 +20,7 @@ export interface ConnectionStatus {
      * This mirrors a "slow socket" exception, thrown to data sending process.
      */
     slowSocket?: true;
+    missingPongsFromServer?: number;
     socketClosed?: true;
     error?: any;
 }

package/build/lib-common/ipc/ws-ipc.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017, 2025 3NSoft Inc.
+ Copyright (C) 2017, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -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.WebSocketListening = exports.makeEventfulServer = void 0;
 exports.makeWSException = makeWSException;
@@ -30,6 +31,7 @@ function makeWSException(params, flags) {
     return (0, runtime_1.makeRuntimeException)('websocket', params, flags !== null && flags !== void 0 ? flags : {});
 }
 const MAX_TXT_BUFFER = 64 * 1024;
+const CLIENT_SIDE_PING_PERIOD = 10 * 1000;
 /**
  * This creates a json communication point on a given web socket.
  * Point may have many listeners, allowing for single parsing of incoming
@@ -39,6 +41,21 @@ const MAX_TXT_BUFFER = 64 * 1024;
 function makeJsonCommPoint(ws) {
     const observers = new generic_ipc_1.MultiObserverWrap();
     const { heartbeat, healthyBeat, otherBeat } = makeHeartbeat(ws.url);
+    let outstandingPongs = 0;
+    let closedByPingProc = false;
+    const pingRepeat = setInterval(() => {
+        if (outstandingPongs >= 2) {
+            ws.close();
+            closedByPingProc = true;
+            clearInterval(pingRepeat);
+            return;
+        }
+        if (outstandingPongs > 0) {
+            otherBeat('heartbeat-skip', { missingPongsFromServer: outstandingPongs });
+        }
+        ws.ping();
+        outstandingPongs += 1;
+    }, CLIENT_SIDE_PING_PERIOD);
     ws.on('message', data => {
         if (observers.done) {
             return;
@@ -49,7 +66,8 @@ function makeJsonCommPoint(ws) {
         }
         catch (err) {
             ws.close();
-            otherBeat(err, true);
+            clearInterval(pingRepeat);
+            otherBeat('disconnected', err, true);
             observers.error(err);
             return;
         }
@@ -57,12 +75,13 @@ function makeJsonCommPoint(ws) {
         healthyBeat();
     });
     ws.on('close', (code, reason) => {
+        clearInterval(pingRepeat);
         if (code === 1000) {
-            otherBeat({ socketClosed: true }, true);
+            otherBeat('disconnected', { socketClosed: true }, true);
             observers.complete();
         }
         else {
-            otherBeat({ error: { code, reason } }, true);
+            otherBeat('disconnected', { error: { code, reason } }, true);
             observers.error(makeWSException({
                 socketClosed: true,
                 cause: { code, reason }
@@ -70,24 +89,30 @@ function makeJsonCommPoint(ws) {
         }
     });
     ws.on('error', (err) => {
-        otherBeat(err, true);
+        otherBeat('disconnected', err, true);
         observers.error(makeWSException({ cause: err }));
+        clearInterval(pingRepeat);
         ws.close();
     });
     ws.on('ping', () => {
         ws.pong();
         healthyBeat();
     });
+    ws.on('pong', () => {
+        healthyBeat();
+        outstandingPongs = 0;
+    });
     const comm = {
         subscribe: obs => observers.add(obs),
         postMessage(env) {
             if (ws.bufferedAmount > MAX_TXT_BUFFER) {
-                otherBeat({ slowSocket: true });
+                otherBeat('heartbeat', { slowSocket: true });
                 throw makeWSException({ socketSlow: true });
             }
             ws.send(JSON.stringify(env));
         }
     };
+    otherBeat('connected', {});
     return { comm, heartbeat };
 }
 function makeHeartbeat(url) {
@@ -96,13 +121,15 @@ function makeHeartbeat(url) {
     function healthyBeat() {
         const now = Date.now();
         status.next({
+            type: 'heartbeat',
             url,
             ping: now - lastInfo
         });
         lastInfo = now;
     }
-    function otherBeat(params, end = false) {
+    function otherBeat(type, params, end = false) {
         status.next({
+            type,
             url,
             ...params
         });

package/build/lib-common/map-of-sets.d.ts

@@ -6,4 +6,5 @@ export declare class MapOfSets<TKey, TValue> {
     remove(key: TKey, value: TValue): void;
     removeAll(key: TKey): void;
     clear(): void;
+    keys(): MapIterator<TKey>;
 }

package/build/lib-common/map-of-sets.js

@@ -48,6 +48,9 @@ class MapOfSets {
     clear() {
         this.map.clear();
     }
+    keys() {
+        return this.map.keys();
+    }
 }
 exports.MapOfSets = MapOfSets;
 Object.freeze(MapOfSets.prototype);