core-3nweb-client-lib 0.49.6 → 0.49.8

package/build/lib-common/dataset-sync/per-device-json-array-logs.d.ts

@@ -0,0 +1,58 @@
+import { SingleProc } from '../processes/synced';
+type WritableFS = web3n.files.WritableFS;
+/**
+ * Log entry in synced files that act as broadcast of what operation a particular device has done.
+ * There may be race condition, in which devices may perform and record same operation simultaneously in different
+ * log files.
+ * There will also be situations when operation is recorded only on one device, like when triggered by action on
+ * one device.
+ *
+ * Regular log entry has payload in `p` and `n` with entry number that is an increment counter within a given log.
+ * When data set is synced to server, under some version `v`, a log entry with `syncPoint` is added.
+ * `syncPoint` contains `logSyncedPoints` with last operations on known devices that have been incorporated into
+ * the data set synced state of given version.
+ *
+ * Sync point information allows to ignore log entries, cutting log files accordingly.
+ */
+export interface LogEntry<T> {
+    /**
+     * When data set is synced to server, under some version `v`, this log entry is added.
+     * This contains `logSyncedPoints` with last operations on known devices that have been incorporated into data
+     * set synced state.
+     */
+    syncPoint?: {
+        v: number;
+        logSyncedPoints: {
+            [devId: string]: number;
+        };
+        params: any;
+    };
+    /**
+     * Increasing log entry number, unique to a given device log.
+     */
+    n: number;
+    /**
+     * Timestamp of log helps to somewhat order logs from many device.
+     */
+    ts: number;
+    /**
+     * Payload of regular log entry.
+     */
+    p?: T;
+}
+export declare function makeRecentChangesLogs<T>(logsFS: WritableFS, localLogsFS: WritableFS, areOpsEqual: (a: T, b: T) => boolean, logError: (err: any, msg?: string) => Promise<void>): Promise<{
+    appendLogsAndUpload: (...ops: T[]) => Promise<void> | undefined;
+    watchAndApplyOpsFromOtherDevices: (changeProc: SingleProc, sink: (ops: LogEntry<T>[]) => Promise<void>) => () => void;
+    numOfLogs: () => number;
+    cutLogOnDatasetSyncAndUpload: (syncPointV: number, params?: any) => Promise<void> | undefined;
+}>;
+export type RecentChangesLogs<T> = Awaited<ReturnType<typeof makeRecentChangesLogs<T>>>;
+export interface DatasetInstance<T> {
+    watchAndApplyOpsFromOtherDevices: (changeProc: SingleProc, resetSyncInterval: () => void) => (() => void);
+    absorbOpsFromOtherDevices: (changeProc: SingleProc, ops: LogEntry<T>[]) => Promise<void>;
+}
+export declare function startDatasetSync<T>(periodicCheckAndUploadOfData: () => Promise<void>, millisBeforeNextRun: () => number, logs: Pick<RecentChangesLogs<T>, 'watchAndApplyOpsFromOtherDevices'>, dataset: DatasetInstance<T>): {
+    changeProc: SingleProc;
+    stopSyncing: () => void;
+};
+export {};

package/build/lib-common/dataset-sync/per-device-json-array-logs.js

@@ -0,0 +1,432 @@
+"use strict";
+/*
+ Copyright (C) 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
+ 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.makeRecentChangesLogs = makeRecentChangesLogs;
+exports.startDatasetSync = startDatasetSync;
+const synced_1 = require("../processes/synced");
+const buffer_utils_1 = require("../buffer-utils");
+const rng_def_1 = require("../rng-def");
+const sink_utils_1 = require("../obj-streaming/sink-utils");
+const DEVICE_ID_FILE = 'device-id';
+const DEV_LOGS_PROCESSING_FILE = 'dev-logs-processing';
+const DEV_ID_LEN = 24;
+const LOG_EXT = '.recent-changes';
+function getOrMakeIdForThisDevice(localFS, logsFS) {
+    return localFS.readTxtFile(DEVICE_ID_FILE)
+        .catch(async (exc) => {
+        if (!exc.notFound) {
+            throw exc;
+        }
+        let devId = await (0, rng_def_1.stringOfB64UrlSafeChars)(DEV_ID_LEN, rng_def_1.pseudoRNG);
+        while (await logsFS.checkFilePresence(logsFileName(devId))) {
+            devId = await (0, rng_def_1.stringOfB64UrlSafeChars)(DEV_ID_LEN, rng_def_1.pseudoRNG);
+        }
+        await localFS.writeTxtFile(DEVICE_ID_FILE, devId);
+        return devId;
+    });
+}
+function logsFileName(devId) {
+    return `${devId}${LOG_EXT}`;
+}
+function devIdFromFileName(fName) {
+    if (fName.endsWith(LOG_EXT)) {
+        return fName.slice(0, fName.length - LOG_EXT.length);
+    }
+}
+function serializeLogs(logs) {
+    const json = JSON.stringify(logs);
+    return json.substring(1, json.length - 1);
+}
+function deserializeLogs(choppedJSON) {
+    const json = `[${choppedJSON}]`;
+    return JSON.parse(json);
+}
+/**
+ * This is a catch callback, which returns undefined on file(folder) not found
+ * exception, and re-throws all other exceptions/errors.
+ */
+function notFoundOrReThrow(exc) {
+    if (!exc.notFound) {
+        throw exc;
+    }
+    return;
+}
+async function makeRecentChangesLogs(logsFS, localLogsFS, areOpsEqual, logError) {
+    const thisDevId = await getOrMakeIdForThisDevice(localLogsFS, logsFS);
+    const { logs, thisDevLogsFile } = await (async function readOrCreateLogsFile() {
+        const thisDevLogsFile = await logsFS.writableFile(logsFileName(thisDevId), { create: false })
+            .catch(notFoundOrReThrow);
+        if (thisDevLogsFile) {
+            const logsTxt = await thisDevLogsFile.readTxt();
+            try {
+                const logs = deserializeLogs(logsTxt);
+                return { logs, thisDevLogsFile };
+            }
+            catch (err) {
+                // if there was anything wrong, by ignoring, we'll effectively overwrite file
+                await logError(err, `Fail to parse current changes from log file ${logsFS.name}/${thisDevLogsFile.name}`);
+                return { logs: [], thisDevLogsFile };
+            }
+        }
+        else {
+            const thisDevLogsFile = await logsFS.writableFile(logsFileName(thisDevId));
+            await thisDevLogsFile.writeTxt('');
+            return { logs: [], thisDevLogsFile };
+        }
+    })();
+    let numOfEntriesOnLastSave = logs.length;
+    let needToSave = false;
+    let needToUpload = (await thisDevLogsFile.v.sync.status(true)).state !== 'synced';
+    const { snapshotOpsInfoForSync, shouldProcessOp, addToRecent, addDoneOnThisDeviceRecent } = await makeLogsProcessingState(localLogsFS, thisDevId, areOpsEqual);
+    await saveAndUploadIfNeeded();
+    function watchAndApplyOpsFromOtherDevices(changeProc, sink) {
+        const stopWatching = logsFS.watchTree('.', 1, {
+            next: fsEvent => changeProc.startOrChain(async () => {
+                if (fsEvent.path.endsWith(thisDevLogsFile.name)) {
+                    return;
+                }
+                if (fsEvent.type === 'remote-change') {
+                    if (fsEvent.path === '.') {
+                        await logsFS.v.sync.adoptRemote(fsEvent.path);
+                    }
+                    else {
+                        await doOnNewRemoteVersionOfLog(fsEvent, sink);
+                    }
+                }
+                else if ((fsEvent.type === 'entry-addition') && (fsEvent.src === 'sync') && fsEvent.entry.isFile) {
+                    await doOnAppearanceOfNewDeviceLog(fsEvent.entry.name, sink);
+                }
+            })
+        });
+        changeProc.startOrChain(() => getAndProcessOpsFromOtherDevicesLogs(sink));
+        return stopWatching;
+    }
+    async function doOnAppearanceOfNewDeviceLog(logFile, sink) {
+        const devId = devIdFromFileName(logFile);
+        if (!devId) {
+            return;
+        }
+        try {
+            const content = (await logsFS.readBytes(logFile));
+            if (!content) {
+                return;
+            }
+            const appendedEvents = deserializeLogs(buffer_utils_1.utf8.open(content));
+            processFromLogFile(devId, appendedEvents, sink);
+        }
+        catch (err) {
+            if (err.type !== 'connect') {
+                logError(err);
+            }
+        }
+    }
+    function processFromLogFile(devId, ops, sink) {
+        const newOps = ops.filter(op => shouldProcessOp(devId, op));
+        if (newOps.length > 0) {
+            const recordCompletion = addToRecent(devId, newOps);
+            sink(newOps).finally(recordCompletion);
+        }
+    }
+    async function doOnNewRemoteVersionOfLog({ path, newRemoteVersion }, sink) {
+        const devId = devIdFromFileName(path);
+        if (!devId) {
+            return;
+        }
+        try {
+            const { size: initSize, version: initVersion } = await logsFS.v.stat(path);
+            if (initVersion === newRemoteVersion) {
+                return;
+            }
+            await logsFS.v.sync.adoptRemote(path);
+            const { size: newSize } = await logsFS.v.stat(path);
+            let additionalBytes;
+            if (initSize < newSize) {
+                additionalBytes = (await logsFS.readBytes(path, (initSize > 0) ? initSize + 1 : undefined));
+            }
+            else if (initSize > newSize) {
+                additionalBytes = (await logsFS.readBytes(path));
+            }
+            else {
+                return;
+            }
+            const appendedOps = deserializeLogs(buffer_utils_1.utf8.open(additionalBytes));
+            processFromLogFile(devId, appendedOps, sink);
+        }
+        catch (err) {
+            if (err.type !== 'connect') {
+                logError(err);
+            }
+        }
+    }
+    function numOfLogs() {
+        return logs.length;
+    }
+    function appendLogsAndUpload(...ops) {
+        if (ops.length > 0) {
+            const logEntries = [];
+            const ts = Date.now();
+            let n = ((logs.length === 0) ? 0 : logs[logs.length - 1].n);
+            for (let p of ops) {
+                n += 1;
+                logEntries.push({ n, ts, p });
+            }
+            logs.push(...logEntries);
+            addDoneOnThisDeviceRecent(logEntries);
+            needToSave = true;
+            return saveAndUploadIfNeeded();
+        }
+    }
+    function cutLogOnDatasetSyncAndUpload(syncPointV, params) {
+        if (logs.length === 0) {
+            return;
+        }
+        const lastN = logs[logs.length - 1].n;
+        logs.splice(0, logs.length, {
+            n: lastN + 1,
+            ts: Date.now(),
+            syncPoint: {
+                v: syncPointV,
+                logSyncedPoints: snapshotOpsInfoForSync(lastN),
+                params
+            }
+        });
+        needToSave = true;
+        return saveAndUploadIfNeeded();
+    }
+    async function saveAndUploadIfNeeded() {
+        if (needToSave && (logs.length > numOfEntriesOnLastSave)) {
+            needToSave = false;
+            if (numOfEntriesOnLastSave > 0) {
+                const logsToAppend = logs.slice(numOfEntriesOnLastSave);
+                const logsTxt = serializeLogs(logsToAppend);
+                const sink = await thisDevLogsFile.getByteSink(false);
+                try {
+                    await (0, sink_utils_1.appendFiniteSink)(sink, buffer_utils_1.utf8.pack(','), false);
+                    await (0, sink_utils_1.appendFiniteSink)(sink, buffer_utils_1.utf8.pack(logsTxt), true);
+                }
+                catch (err) {
+                    await sink.done(err);
+                }
+                numOfEntriesOnLastSave += logsToAppend.length;
+            }
+            else {
+                const logsTxt = serializeLogs(logs);
+                const numOfLogs = logs.length;
+                await thisDevLogsFile.writeTxt(logsTxt)
+                    .catch(_exc => {
+                    needToSave = true;
+                });
+                numOfEntriesOnLastSave += numOfLogs;
+            }
+            needToUpload = true;
+        }
+        if (needToUpload) {
+            needToUpload = false;
+            await thisDevLogsFile.v.sync.upload()
+                .catch(_exc => {
+                needToUpload = true;
+            });
+            const { existsInSyncedParent } = await thisDevLogsFile.v.sync.status(true);
+            if (!existsInSyncedParent) {
+                await syncLogsFS().catch((exc) => {
+                    if (exc.type !== 'connect') {
+                        logError(exc, `Fail to sync folder with messages index logs`);
+                    }
+                });
+            }
+        }
+    }
+    async function getAndProcessOpsFromOtherDevicesLogs(sink) {
+        // XXX current code assumes that dataset was brought up from synced point, if any, or has always existed
+        try {
+            await syncLogsFS();
+        }
+        catch (err) {
+            if (err.type === 'connect') {
+                return;
+            }
+            else {
+                logError(err);
+            }
+        }
+        const otherDevs = (await logsFS.listFolder(''))
+            .map(({ name }) => devIdFromFileName(name))
+            .filter(devId => !!devId && (devId !== thisDevId));
+        const opsFromAllDevices = [];
+        const recordCompletions = [];
+        for (const devId of otherDevs) {
+            try {
+                const logContent = await logsFS.readTxtFile(logsFileName(devId));
+                const devOps = deserializeLogs(logContent);
+                const newOps = devOps.filter(op => shouldProcessOp(devId, op));
+                if (newOps.length > 0) {
+                    opsFromAllDevices.push(...newOps);
+                    recordCompletions.push(addToRecent(devId, newOps));
+                }
+            }
+            catch (err) {
+                logError(err);
+            }
+        }
+        if (opsFromAllDevices.length > 0) {
+            opsFromAllDevices.sort((a, b) => (a.ts - b.ts));
+            sink(opsFromAllDevices).finally(() => Promise.all(recordCompletions.map(c => c())));
+        }
+    }
+    async function syncLogsFS() {
+        const { state } = await logsFS.v.sync.status('');
+        if (state === 'behind') {
+            await logsFS.v.sync.absorbRemoteFolderChanges('');
+        }
+        else if (state === 'conflicting') {
+            await logsFS.v.sync.absorbRemoteFolderChanges('');
+            await logsFS.v.sync.upload('');
+        }
+        else if (state === 'unsynced') {
+            await logsFS.v.sync.upload('');
+        }
+    }
+    return {
+        appendLogsAndUpload,
+        watchAndApplyOpsFromOtherDevices,
+        numOfLogs,
+        cutLogOnDatasetSyncAndUpload
+    };
+}
+async function makeLogsProcessingState(localLogsFS, thisDevId, areOpsEqual, maxRecentLen = 50) {
+    const procStateFile = await localLogsFS.writableFile(DEV_LOGS_PROCESSING_FILE);
+    const pState = (procStateFile.isNew ?
+        { logProcessedPoints: {} } : await procStateFile.readJSON());
+    const pStateSavingProc = new synced_1.SingleProc();
+    let needsSaving = false;
+    async function savePState() {
+        needsSaving = true;
+        pStateSavingProc.startOrChain(async () => {
+            if (needsSaving) {
+                needsSaving = false;
+                await procStateFile.writeJSON(pState);
+            }
+        });
+    }
+    async function recordOpAsProcessed(devId, opN) {
+        let lastProcessed = pState.logProcessedPoints[devId];
+        if (lastProcessed === undefined) {
+            pState.logProcessedPoints[devId] = opN;
+        }
+        else if (lastProcessed >= opN) {
+            return;
+        }
+        else {
+            pState.logProcessedPoints[devId] = opN;
+        }
+        await savePState();
+        if (recentOps.length > maxRecentLen) {
+            recentOps.splice(0, recentOps.length - maxRecentLen);
+        }
+    }
+    function snapshotOpsInfoForSync(lastN) {
+        const info = {};
+        for (const [devId, opN] of Object.entries(pState.logProcessedPoints)) {
+            info[devId] = opN;
+        }
+        info[thisDevId] = lastN;
+        return info;
+    }
+    function hasOpBeenProcessed(devId, opN) {
+        const lastProcessed = pState.logProcessedPoints[devId];
+        return ((lastProcessed === undefined) ? false : (lastProcessed >= opN));
+    }
+    // XXX should switch to keeping log entry and devId to trim recents when they get applied
+    //     should trim be done within recordOpAsProcessed() ?
+    //     And may be we should keep recent by ts, so as not to drop too recent, when there is a lot of them.
+    const recentOps = [];
+    const recentSyncPoint = undefined;
+    function shouldProcessOp(devId, op) {
+        if (hasOpBeenProcessed(devId, op.n)) {
+            return false;
+        }
+        if (op.p === undefined) {
+            if (op.syncPoint) {
+                if (pState.lastSyncV >= op.syncPoint.v) {
+                    return false;
+                }
+                else {
+                    return (!recentSyncPoint || (recentSyncPoint.v < op.syncPoint.v));
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return !recentOps.find(ev => areOpsEqual(ev, op.p));
+        }
+    }
+    function addToRecent(devId, newOps) {
+        newOps.sort((a, b) => (a.n - b.n));
+        const lastOpN = newOps[newOps.length - 1].n;
+        const payloads = newOps.map(({ p }) => p).filter(p => (p !== undefined));
+        if (payloads.length > 0) {
+            recentOps.splice(recentOps.length, 0, ...payloads);
+        }
+        return () => recordOpAsProcessed(devId, lastOpN);
+    }
+    function addDoneOnThisDeviceRecent(done) {
+        const payloads = done.map(({ p }) => p).filter(p => (p !== undefined));
+        recentOps.splice(0, 0, ...payloads);
+    }
+    return {
+        snapshotOpsInfoForSync,
+        shouldProcessOp,
+        addToRecent,
+        addDoneOnThisDeviceRecent
+    };
+}
+function startDatasetSync(periodicCheckAndUploadOfData, millisBeforeNextRun, logs, dataset) {
+    // We order fn calls and data-sync operation within single process chain to ensure consistency.
+    // This is simple, and may be good enough.
+    // We pass this single process point out to wrap fn's with it, in an attempt to explicitly keeping it at the
+    // boundary of incoming operations, either from fn calls, or from handling changes passed via fs events.
+    const changeProc = new synced_1.SingleProc();
+    function datasetCheckAndSyncAction() {
+        changeProc.startOrChain(periodicCheckAndUploadOfData);
+    }
+    let interval = undefined;
+    function resetSyncInterval() {
+        if (interval !== undefined) {
+            clearInterval(interval);
+        }
+        interval = setInterval(datasetCheckAndSyncAction, millisBeforeNextRun()).unref();
+    }
+    resetSyncInterval();
+    // XXX we should watch for reconnect events and run similar to start checks of possibly missed ops
+    // watch and absorb ops, coming from logs of other devices
+    const stopLogsWatching = logs.watchAndApplyOpsFromOtherDevices(changeProc, ops => dataset.absorbOpsFromOtherDevices(changeProc, ops));
+    // watch and absorb ops in dataset, coming from places that dataset sets itself
+    const stopDatasetWatching = dataset.watchAndApplyOpsFromOtherDevices(changeProc, resetSyncInterval);
+    function stopSyncing() {
+        if (interval !== undefined) {
+            stopLogsWatching();
+            stopDatasetWatching();
+            clearInterval(interval);
+            interval = undefined;
+        }
+    }
+    return { changeProc, stopSyncing };
+}
+Object.freeze(exports);

package/build/lib-common/dataset-sync/single-file.d.ts

@@ -0,0 +1,10 @@
+import { SingleProc } from "../processes/synced";
+type WritableFS = web3n.files.WritableFS;
+type WritableFile = web3n.files.WritableFile;
+export declare function initSyncedFile(syncedFS: WritableFS, fName: string, initNewFile: (newFile: WritableFile) => Promise<void>): Promise<WritableFile>;
+export declare function watchAndApplyChangesFromOtherDevices(file: WritableFile, onChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>, onConflictingChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>): {
+    changeProc: SingleProc;
+    stopFileWatching: () => void;
+    triggerUpload: () => void;
+};
+export {};

package/build/lib-common/dataset-sync/single-file.js

@@ -0,0 +1,77 @@
+"use strict";
+/*
+ Copyright (C) 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
+ 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.initSyncedFile = initSyncedFile;
+exports.watchAndApplyChangesFromOtherDevices = watchAndApplyChangesFromOtherDevices;
+const synced_1 = require("../processes/synced");
+async function initSyncedFile(syncedFS, fName, initNewFile) {
+    const file = await syncedFS.writableFile(fName);
+    if (file.isNew) {
+        await initNewFile(file);
+        await file.v.sync.upload();
+        await syncedFS.v.sync.upload('.');
+    }
+    // XXX add initial sync no-connection handling
+    return file;
+}
+function watchAndApplyChangesFromOtherDevices(file, onChangeFromOtherDevices, onConflictingChangeFromOtherDevices) {
+    const changeProc = new synced_1.SingleProc();
+    const stopFileWatching = file.watch({
+        next: ev => {
+            if (ev.type === 'remote-change') {
+                changeProc.startOrChain(async () => {
+                    await file.v.sync.adoptRemote({ remoteVersion: ev.newRemoteVersion })
+                        .catch((exc) => {
+                        if (exc.type === 'connect') {
+                            // XXX need to have watcher for connection to continue processing
+                        }
+                    });
+                });
+            }
+            else if ((ev.type === 'file-change') && (ev.src === 'sync')) {
+                onChangeFromOtherDevices(changeProc, file);
+            }
+        }
+    });
+    function triggerUpload() {
+        changeProc.startOrChain(async () => file.v.sync.upload())
+            .catch((exc) => {
+            if (exc.type === 'connect') {
+                // XXX need to have watcher for connection to complete upload
+                //     Should this whole try-to-connect method be generic to reuse it?
+            }
+        });
+    }
+    file.v.sync.status()
+        .then(async ({ state }) => {
+        if (state === 'behind') {
+            await changeProc.startOrChain(() => file.v.sync.adoptRemote());
+        }
+        else if (state === 'conflicting') {
+            await onConflictingChangeFromOtherDevices(changeProc, file);
+        }
+        else if (state === 'unsynced') {
+            triggerUpload();
+        }
+    })
+        .catch(exc => {
+        // XXX need to have watcher for connection to continue processing
+    });
+    return { changeProc, stopFileWatching, triggerUpload };
+}
+Object.freeze(exports);

package/build/lib-common/number-line.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a utility function that adds a number into given number line segments.
+ * Each segment is represented by an array, in which 0-th element is the smallest number in the segment,
+ * while 1-st element is the largest. Segments don't overlap and are ordered as they would on a number line:
+ * segment with smaller numbers go first.
+ * This returns true when segment line was updated, and false, otherwise (then number was in segments already).
+ * @param segments
+ * @param n
+ */
+export declare function addToNumberLineSegments(segments: number[][], n: number): boolean;

package/build/lib-common/number-line.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2017, 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
+ 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.addToNumberLineSegments = addToNumberLineSegments;
+/**
+ * This is a utility function that adds a number into given number line segments.
+ * Each segment is represented by an array, in which 0-th element is the smallest number in the segment,
+ * while 1-st element is the largest. Segments don't overlap and are ordered as they would on a number line:
+ * segment with smaller numbers go first.
+ * This returns true when segment line was updated, and false, otherwise (then number was in segments already).
+ * @param segments
+ * @param n
+ */
+function addToNumberLineSegments(segments, n) {
+    for (let i = (segments.length - 1); i >= 0; i -= 1) {
+        const [low, high] = segments[i];
+        if (high < n) {
+            if ((high + 1) >= n) {
+                // segment should be grown on a high side.
+                // But now bigger segment won't merge with higher segment, cause if
+                // it does, it would've merge from lower side of a higher segment.
+                segments[i][1] = n;
+            }
+            else {
+                // new segment should be added higher than this one
+                segments.splice(i + 1, 0, [n, n]);
+            }
+            return true;
+        }
+        if ((low <= n) && (n <= high)) {
+            // do nothing as number falls into current segment
+            return false;
+        }
+        if (low <= (n + 1)) {
+            // segment should be grown on a lower side
+            segments[i][0] = n;
+            if ((i - 1) >= 0) {
+                // bigger segment may overlap with a lower one
+                const lowerSeg = segments[i - 1];
+                if ((lowerSeg[1] + 1) >= n) {
+                    lowerSeg[1] = high;
+                    segments.splice(i, 1);
+                }
+            }
+            return true;
+        }
+    }
+    segments.unshift([n, n]);
+    return true;
+}
+Object.freeze(exports);

package/build/lib-common/objs-on-disk/obj-version-file.d.ts

@@ -8,7 +8,7 @@ export declare class ObjVersionFile {
     private constructor();
     static forExisting(path: string): Promise<ObjVersionFile>;
     static createNew(path: string): Promise<ObjVersionFile>;
-    private startCreatingFileOnDisk;
+    private creatingFileOnDisk;
     moveFile(newPath: string, newHeader: Uint8Array | undefined): Promise<void>;
     removeFile(): Promise<void>;
     saveLayout(): Promise<void>;

package/build/lib-common/objs-on-disk/obj-version-file.js

@@ -43,11 +43,11 @@ class ObjVersionFile {
     static async createNew(path) {
         const layout = file_layout_1.ObjVersionBytesLayout.forNewFile();
         const objFile = new ObjVersionFile(path, layout);
-        objFile.startCreatingFileOnDisk();
+        await objFile.creatingFileOnDisk();
         return objFile;
     }
-    startCreatingFileOnDisk() {
-        this.writeProc.addStarted(createNewV1File(this.path));
+    async creatingFileOnDisk() {
+        await this.writeProc.addStarted(createNewV1File(this.path));
     }
     moveFile(newPath, newHeader) {
         return this.writeProc.startOrChain(async () => {

package/build/lib-common/rng-def.d.ts

@@ -1,3 +1,4 @@
 export type AsyncRNG = (n: number) => Promise<Uint8Array>;
 export declare function stringOfB64UrlSafeChars(numOfChars: number, random: AsyncRNG): Promise<string>;
 export declare function stringOfB64Chars(numOfChars: number, random: AsyncRNG): Promise<string>;
+export declare function pseudoRNG(n: number): Promise<Uint8Array>;