@textrp/briij-js-sdk 41.0.0

package/src/randomstring.ts

@@ -0,0 +1,103 @@
+/*
+Copyright 2018 New Vector Ltd
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { encodeUnpaddedBase64Url } from "./base64.ts";
+
+/**
+ * String representing the lowercase latin alphabet for use in {@link secureRandomStringFrom}
+ * (can be combined with other such exports or other characters by appending strings)
+ */
+export const LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+
+/**
+ * String representing the uppercase latin alphabet for use in secureRandomStringFrom
+ * (can be combined with other such exports or other characters by appending strings)
+ */
+export const UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+/**
+ * String representing the arabic numerals for use in secureRandomStringFrom
+ * (can be combined with other such exports or other characters by appending strings)
+ */
+export const DIGITS = "0123456789";
+
+export function secureRandomBase64Url(len: number): string {
+    const key = new Uint8Array(len);
+    globalThis.crypto.getRandomValues(key);
+
+    return encodeUnpaddedBase64Url(key);
+}
+
+/**
+ * Generates a random string of uppercase and lowercase letters plus digits using a
+ * cryptographically secure random number generator.
+ * @param len The length of the string to generate
+ * @returns Random string of uppercase and lowercase letters plus digits of length `len`
+ */
+export function secureRandomString(len: number): string {
+    return secureRandomStringFrom(len, UPPERCASE + LOWERCASE + DIGITS);
+}
+
+/**
+ * Generate a cryptographically secure random string using characters given.
+ *
+ * @param len - The length of the string to generate (must be positive and less than 32768).
+ * @param chars - The characters to use in the random string (between 2 and 256 characters long).
+ * @returns Random string of characters of length `len`.
+ */
+export function secureRandomStringFrom(len: number, chars: string): string {
+    // This is intended for latin strings so 256 possibilities should be more than enough and
+    // means we can use random bytes, minimising the amount of entropy we need to ask for.
+    if (chars.length < 2 || chars.length > 256) {
+        throw new Error("Character set must be between 2 and 256 characters long");
+    }
+
+    if (len < 1 || len > 32768) {
+        throw new Error("Requested random string length must be between 1 and 32768");
+    }
+
+    // We'll generate random unsigned bytes, so get the largest number less than 256 that is a multiple
+    // of the length of the character set: We'll need to discard any random values that are larger than
+    // this as we can't possibly map them onto the character set while keeping each character equally
+    // likely to be chosen (minus 1 to convert to indices in a string). (Essentially, we're using a d8
+    // to choose between 7 possibilities and re-rolling on an 8, keeping all 7 outcomes equally likely.)
+    // Our random values must be strictly less than this
+    const randomValueCutoff = 256 - (256 % chars.length);
+
+    // Grab 30% more entropy than we need. This should be enough that we can discard the values that are
+    // too high without having to go back and grab more unless we're super unlucky.
+    const entropyBuffer = new Uint8Array(Math.floor(len * 1.3));
+    // Mark all of this buffer as used to start with (we haven't populated it with entropy yet) so it will
+    // be filled on the first iteration.
+    let entropyBufferPos = entropyBuffer.length;
+
+    const result = [];
+    while (result.length < len) {
+        if (entropyBufferPos === entropyBuffer.length) {
+            globalThis.crypto.getRandomValues(entropyBuffer);
+            entropyBufferPos = 0;
+        }
+
+        const randomByte = entropyBuffer[entropyBufferPos++];
+
+        if (randomByte < randomValueCutoff) {
+            result.push(chars[randomByte % chars.length]);
+        }
+    }
+
+    return result.join("");
+}

package/src/realtime-callbacks.ts

@@ -0,0 +1,191 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/* A re-implementation of the javascript callback functions (setTimeout,
+ * clearTimeout; setInterval and clearInterval are not yet implemented) which
+ * try to improve handling of large clock jumps (as seen when
+ * suspending/resuming the system).
+ *
+ * In particular, if a timeout would have fired while the system was suspended,
+ * it will instead fire as soon as possible after resume.
+ */
+
+import { logger } from "./logger.ts";
+
+// we schedule a callback at least this often, to check if we've missed out on
+// some wall-clock time due to being suspended.
+const TIMER_CHECK_PERIOD_MS = 1000;
+
+// counter, for making up ids to return from setTimeout
+let count = 0;
+
+// the key for our callback with the real globalThis.setTimeout
+let realCallbackKey: NodeJS.Timeout | number;
+
+type Callback = {
+    runAt: number;
+    func: (...params: any[]) => void;
+    params: any[];
+    key: number;
+};
+
+// a sorted list of the callbacks to be run.
+// each is an object with keys [runAt, func, params, key].
+const callbackList: Callback[] = [];
+
+// var debuglog = logger.log.bind(logger);
+/* istanbul ignore next */
+const debuglog = function (...params: any[]): void {};
+
+/**
+ * reimplementation of window.setTimeout, which will call the callback if
+ * the wallclock time goes past the deadline.
+ *
+ * @param func -   callback to be called after a delay
+ * @param delayMs -  number of milliseconds to delay by
+ *
+ * @returns an identifier for this callback, which may be passed into
+ *                   clearTimeout later.
+ */
+export function setTimeout(func: (...params: any[]) => void, delayMs: number, ...params: any[]): number {
+    delayMs = delayMs || 0;
+    if (delayMs < 0) {
+        delayMs = 0;
+    }
+
+    const runAt = Date.now() + delayMs;
+    const key = count++;
+    debuglog("setTimeout: scheduling cb", key, "at", runAt, "(delay", delayMs, ")");
+    const data = {
+        runAt: runAt,
+        func: func,
+        params: params,
+        key: key,
+    };
+
+    // figure out where it goes in the list
+    const idx = binarySearch(callbackList, function (el) {
+        return el.runAt - runAt;
+    });
+
+    callbackList.splice(idx, 0, data);
+    scheduleRealCallback();
+
+    return key;
+}
+
+/**
+ * reimplementation of window.clearTimeout, which mirrors setTimeout
+ *
+ * @param key -   result from an earlier setTimeout call
+ */
+export function clearTimeout(key: number): void {
+    if (callbackList.length === 0) {
+        return;
+    }
+
+    // remove the element from the list
+    let i: number;
+    for (i = 0; i < callbackList.length; i++) {
+        const cb = callbackList[i];
+        if (cb.key == key) {
+            callbackList.splice(i, 1);
+            break;
+        }
+    }
+
+    // iff it was the first one in the list, reschedule our callback.
+    if (i === 0) {
+        scheduleRealCallback();
+    }
+}
+
+// use the real globalThis.setTimeout to schedule a callback to runCallbacks.
+function scheduleRealCallback(): void {
+    if (realCallbackKey) {
+        globalThis.clearTimeout(realCallbackKey as NodeJS.Timeout);
+    }
+
+    const first = callbackList[0];
+
+    if (!first) {
+        debuglog("scheduleRealCallback: no more callbacks, not rescheduling");
+        return;
+    }
+
+    const timestamp = Date.now();
+    const delayMs = Math.min(first.runAt - timestamp, TIMER_CHECK_PERIOD_MS);
+
+    debuglog("scheduleRealCallback: now:", timestamp, "delay:", delayMs);
+    realCallbackKey = globalThis.setTimeout(runCallbacks, delayMs);
+}
+
+function runCallbacks(): void {
+    const timestamp = Date.now();
+    debuglog("runCallbacks: now:", timestamp);
+
+    // get the list of things to call
+    const callbacksToRun: Callback[] = [];
+    // eslint-disable-next-line
+    while (true) {
+        const first = callbackList[0];
+        if (!first || first.runAt > timestamp) {
+            break;
+        }
+        const cb = callbackList.shift()!;
+        debuglog("runCallbacks: popping", cb.key);
+        callbacksToRun.push(cb);
+    }
+
+    // reschedule the real callback before running our functions, to
+    // keep the codepaths the same whether or not our functions
+    // register their own setTimeouts.
+    scheduleRealCallback();
+
+    for (const cb of callbacksToRun) {
+        try {
+            cb.func.apply(globalThis, cb.params);
+        } catch (e) {
+            logger.error("Uncaught exception in callback function", e);
+        }
+    }
+}
+
+/* search in a sorted array.
+ *
+ * returns the index of the last element for which func returns
+ * greater than zero, or array.length if no such element exists.
+ */
+function binarySearch<T>(array: T[], func: (v: T) => number): number {
+    // min is inclusive, max exclusive.
+    let min = 0;
+    let max = array.length;
+
+    while (min < max) {
+        const mid = (min + max) >> 1;
+        const res = func(array[mid]);
+        if (res > 0) {
+            // the element at 'mid' is too big; set it as the new max.
+            max = mid;
+        } else {
+            // the element at 'mid' is too small. 'min' is inclusive, so +1.
+            min = mid + 1;
+        }
+    }
+    // presumably, min==max now.
+    return min;
+}

package/src/receipt-accumulator.ts

@@ -0,0 +1,189 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { type IMinimalEvent } from "./sync-accumulator.ts";
+import { EventType } from "./@types/event.ts";
+import { isSupportedReceiptType, MapWithDefault, recursiveMapToObject } from "./utils.ts";
+import { type IContent } from "./models/event.ts";
+import { type ReceiptContent, type ReceiptType } from "./@types/read_receipts.ts";
+
+interface AccumulatedReceipt {
+    data: IMinimalEvent;
+    type: ReceiptType;
+    eventId: string;
+}
+
+/**
+ * Summarises the read receipts within a room. Used by the sync accumulator.
+ *
+ * Given receipts for users, picks the most recently-received one and provides
+ * the results in a new fake receipt event returned from
+ * buildAccumulatedReceiptEvent().
+ *
+ * Handles unthreaded receipts and receipts in each thread separately, so the
+ * returned event contains the most recently received unthreaded receipt, and
+ * the most recently received receipt in each thread.
+ */
+export class ReceiptAccumulator {
+    /** user_id -\> most-recently-received unthreaded receipt */
+    private unthreadedReadReceipts: Map<string, AccumulatedReceipt> = new Map();
+
+    /** thread_id -\> user_id -\> most-recently-received receipt for this thread */
+    private threadedReadReceipts: MapWithDefault<string, Map<string, AccumulatedReceipt>> = new MapWithDefault(
+        () => new Map(),
+    );
+
+    /**
+     * Provide an unthreaded receipt for this user. Overwrites any other
+     * unthreaded receipt we have for this user.
+     */
+    private setUnthreaded(userId: string, receipt: AccumulatedReceipt): void {
+        this.unthreadedReadReceipts.set(userId, receipt);
+    }
+
+    /**
+     * Provide a receipt for this user in this thread. Overwrites any other
+     * receipt we have for this user in this thread.
+     */
+    private setThreaded(threadId: string, userId: string, receipt: AccumulatedReceipt): void {
+        this.threadedReadReceipts.getOrCreate(threadId).set(userId, receipt);
+    }
+
+    /**
+     * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the
+     *          most recently-received unthreaded receipts for each user.
+     */
+    private allUnthreaded(): IterableIterator<[string, AccumulatedReceipt]> {
+        return this.unthreadedReadReceipts.entries();
+    }
+
+    /**
+     * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the
+     *          most recently-received threaded receipts for each user, in all
+     *          threads.
+     */
+    private *allThreaded(): IterableIterator<[string, AccumulatedReceipt]> {
+        for (const receiptsForThread of this.threadedReadReceipts.values()) {
+            for (const e of receiptsForThread.entries()) {
+                yield e;
+            }
+        }
+    }
+
+    /**
+     * Given a list of ephemeral events, find the receipts and store the
+     * relevant ones to be returned later from buildAccumulatedReceiptEvent().
+     */
+    public consumeEphemeralEvents(events: IMinimalEvent[] | undefined): void {
+        events?.forEach((e) => {
+            if (e.type !== EventType.Receipt || !e.content) {
+                // This means we'll drop unknown ephemeral events but that
+                // seems okay.
+                return;
+            }
+
+            // Handle m.receipt events. They clobber based on:
+            //   (user_id, receipt_type)
+            // but they are keyed in the event as:
+            //   content:{ $event_id: { $receipt_type: { $user_id: {json} }}}
+            // so store them in the former so we can accumulate receipt deltas
+            // quickly and efficiently (we expect a lot of them). Fold the
+            // receipt type into the key name since we only have 1 at the
+            // moment (m.read) and nested JSON objects are slower and more
+            // of a hassle to work with. We'll inflate this back out when
+            // getJSON() is called.
+            Object.keys(e.content).forEach((eventId) => {
+                Object.entries<ReceiptContent>(e.content[eventId]).forEach(([key, value]) => {
+                    if (!isSupportedReceiptType(key)) return;
+
+                    for (const userId of Object.keys(value)) {
+                        const data = e.content[eventId][key][userId];
+
+                        const receipt = {
+                            data: e.content[eventId][key][userId],
+                            type: key as ReceiptType,
+                            eventId,
+                        };
+
+                        // In a world that supports threads, read receipts normally have
+                        // a `thread_id` which is either the thread they belong in or
+                        // `MAIN_ROOM_TIMELINE`, so we normally use `setThreaded(...)`
+                        // here. The `MAIN_ROOM_TIMELINE` is just treated as another
+                        // thread.
+                        //
+                        // We still encounter read receipts that are "unthreaded"
+                        // (missing the `thread_id` property). These come from clients
+                        // that don't support threads, and from threaded clients that
+                        // are doing a "Mark room as read" operation. Unthreaded
+                        // receipts mark everything "before" them as read, in all
+                        // threads, where "before" means in Sync Order i.e. the order
+                        // the events were received from the homeserver in a sync.
+                        // [Note: we have some bugs where we use timestamp order instead
+                        // of Sync Order, because we don't correctly remember the Sync
+                        // Order. See #3325.]
+                        //
+                        // Calling the wrong method will cause incorrect behavior like
+                        // messages re-appearing as "new" when you already read them
+                        // previously.
+                        if (!data.thread_id) {
+                            this.setUnthreaded(userId, receipt);
+                        } else {
+                            this.setThreaded(data.thread_id, userId, receipt);
+                        }
+                    }
+                });
+            });
+        });
+    }
+
+    /**
+     * Build a receipt event that contains all relevant information for this
+     * room, taking the most recently received receipt for each user in an
+     * unthreaded context, and in each thread.
+     */
+    public buildAccumulatedReceiptEvent(roomId: string): IMinimalEvent | null {
+        const receiptEvent: IMinimalEvent = {
+            type: EventType.Receipt,
+            room_id: roomId,
+            content: {
+                // $event_id: { "m.read": { $user_id: $json } }
+            } as IContent,
+        };
+
+        const receiptEventContent: MapWithDefault<
+            string,
+            MapWithDefault<ReceiptType, Map<string, object>>
+        > = new MapWithDefault(() => new MapWithDefault(() => new Map()));
+
+        for (const [userId, receiptData] of this.allUnthreaded()) {
+            receiptEventContent
+                .getOrCreate(receiptData.eventId)
+                .getOrCreate(receiptData.type)
+                .set(userId, receiptData.data);
+        }
+
+        for (const [userId, receiptData] of this.allThreaded()) {
+            receiptEventContent
+                .getOrCreate(receiptData.eventId)
+                .getOrCreate(receiptData.type)
+                .set(userId, receiptData.data);
+        }
+
+        receiptEvent.content = recursiveMapToObject(receiptEventContent);
+
+        return receiptEventContent.size > 0 ? receiptEvent : null;
+    }
+}