move type declarations around to be at more reasonable places

Author: toger5

src/matrixrtc/IMembershipManager.ts

@@ -0,0 +1,88 @@
+/*
+Copyright 2025 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 { CallMembership } from "./CallMembership.ts";
+import type { Focus } from "./focus.ts";
+import type { Status } from "./types.ts";
+
+export enum MembershipManagerEvent {
+    StatusChanged = "StatusChanged",
+}
+
+export type MembershipManagerEventHandlerMap = {
+    [MembershipManagerEvent.StatusChanged]: (prefStatus: Status, newStatus: Status) => void;
+};
+
+/**
+ * This interface defines what a MembershipManager uses and exposes.
+ * This interface is what we use to write tests and allows changing the actual implementation
+ * without breaking tests because of some internal method renaming.
+ *
+ * @internal
+ */
+export interface IMembershipManager {
+    /**
+     * If we are trying to join, or have successfully joined the session.
+     * It does not reflect if the room state is already configured to represent us being joined.
+     * It only means that the Manager should be trying to connect or to disconnect running.
+     * The Manager is still running right after isJoined becomes false to send the disconnect events.
+     * @returns true if we intend to be participating in the MatrixRTC session
+     * @deprecated This name is confusing and replaced by `isActivated()`. (Returns the same as `isActivated()`)
+     */
+    isJoined(): boolean;
+    /**
+     * If the manager is activated. This means it tries to do its job to join the call, resend state events...
+     * It does not imply that the room state is already configured to represent being joined.
+     * It means that the Manager tries to connect or is connected. ("the manager is still active")
+     * Once `leave()` is called the manager is not activated anymore but still running until `leave()` resolves.
+     * @returns `true` if we intend to be participating in the MatrixRTC session
+     */
+    isActivated(): boolean;
+    /**
+     * Get the actual connection status of the manager.
+     */
+    get status(): Status;
+    /**
+     * The current status while the manager is activated
+     */
+    /**
+     * Start sending all necessary events to make this user participate in the RTC session.
+     * @param fociPreferred the list of preferred foci to use in the joined RTC membership event.
+     * @param fociActive the active focus to use in the joined RTC membership event.
+     * @throws can throw if it exceeds a configured maximum retry.
+     */
+    join(fociPreferred: Focus[], fociActive?: Focus, onError?: (error: unknown) => void): void;
+    /**
+     * Send all necessary events to make this user leave the RTC session.
+     * @param timeout the maximum duration in ms until the promise is forced to resolve.
+     * @returns It resolves with true in case the leave was sent successfully.
+     * It resolves with false in case we hit the timeout before sending successfully.
+     */
+    leave(timeout?: number): Promise<boolean>;
+    /**
+     * Call this if the MatrixRTC session members have changed.
+     */
+    onRTCSessionMemberUpdate(memberships: CallMembership[]): Promise<void>;
+    /**
+     * The used active focus in the currently joined session.
+     * @returns the used active focus in the currently joined session or undefined if not joined.
+     */
+    getActiveFocus(): Focus | undefined;
+
+    // TypedEventEmitter methods:
+    on(event: MembershipManagerEvent.StatusChanged, listener: (oldStatus: Status, newStatus: Status) => void): this;
+    off(event: MembershipManagerEvent.StatusChanged, listener: (oldStatus: Status, newStatus: Status) => void): this;
+}

src/matrixrtc/LegacyMembershipManager.ts

@@ -27,7 +27,8 @@ import { type Focus } from "./focus.ts";
 import { isLivekitFocusActive } from "./LivekitFocus.ts";
 import { type MembershipConfig } from "./MatrixRTCSession.ts";
 import { type EmptyObject } from "../@types/common.ts";
-import { type IMembershipManager, type MembershipManagerEvent, Status } from "./types.ts";
+import { Status } from "./types.ts";
+import type { IMembershipManager, MembershipManagerEvent } from "./IMembershipManager.ts";
 
 /**
  * This internal class is used by the MatrixRTCSession to manage the local user's own membership of the session.

src/matrixrtc/MatrixRTCSession.ts

@@ -28,34 +28,12 @@ import { MembershipManager } from "./NewMembershipManager.ts";
 import { EncryptionManager, type IEncryptionManager } from "./EncryptionManager.ts";
 import { LegacyMembershipManager } from "./LegacyMembershipManager.ts";
 import { logDurationSync } from "../utils.ts";
-import type { IMembershipManager } from "./types.ts";
 import { RoomKeyTransport } from "./RoomKeyTransport.ts";
+import { type IMembershipManager } from "./IMembershipManager.ts";
+import { type Statistics } from "./types.ts";
 
 const logger = rootLogger.getChild("MatrixRTCSession");
 
-/**
- * A type collecting call encryption statistics for a session.
- */
-export type Statistics = {
-    counters: {
-        /**
-         * The number of times we have sent a room event containing encryption keys.
-         */
-        roomEventEncryptionKeysSent: number;
-        /**
-         * The number of times we have received a room event containing encryption keys.
-         */
-        roomEventEncryptionKeysReceived: number;
-    };
-    totals: {
-        /**
-         * The total age (in milliseconds) of all room events containing encryption keys that we have received.
-         * We track the total age so that we can later calculate the average age of all keys received.
-         */
-        roomEventEncryptionKeysReceivedTotalAge: number;
-    };
-};
-
 export enum MatrixRTCSessionEvent {
     // A member joined, left, or updated a property of their membership.
     MembershipsChanged = "memberships_changed",

src/matrixrtc/RoomKeyTransport.ts

@@ -15,16 +15,15 @@ limitations under the License.
 */
 
 import type { MatrixClient } from "../client.ts";
-import type { EncryptionKeysEventContent } from "./types.ts";
+import type { EncryptionKeysEventContent, Statistics } from "./types.ts";
 import { EventType } from "../@types/event.ts";
 import { type MatrixError } from "../http-api/errors.ts";
 import { logger, type Logger } from "../logger.ts";
-import { KeyTransportEvents, KeyTransportEventsHandlerMap, type IKeyTransport } from "./IKeyTransport.ts";
+import { KeyTransportEvents, type KeyTransportEventsHandlerMap, type IKeyTransport } from "./IKeyTransport.ts";
 import { type MatrixEvent } from "../models/event.ts";
 import { type CallMembership } from "./CallMembership.ts";
-import { Room, RoomEvent } from "../matrix.ts";
+import { type Room, RoomEvent } from "../matrix.ts";
 import { TypedEventEmitter } from "../models/typed-event-emitter.ts";
-import { Statistics } from "./MatrixRTCSession.ts";
 
 export class RoomKeyTransport
     extends TypedEventEmitter<KeyTransportEvents, KeyTransportEventsHandlerMap>
@@ -44,10 +43,10 @@ export class RoomKeyTransport
         this.prefixedLogger = logger.getChild(`[RTC: ${room.roomId} RoomKeyTransport]`);
     }
     public start(): void {
-        this.room.on(RoomEvent.Timeline, (ev) => this.consumeCallEncryptionEvent(ev));
+        this.room.on(RoomEvent.Timeline, (ev) => void this.consumeCallEncryptionEvent(ev));
     }
     public stop(): void {
-        this.room.off(RoomEvent.Timeline, (ev) => this.consumeCallEncryptionEvent(ev));
+        this.room.off(RoomEvent.Timeline, (ev) => void this.consumeCallEncryptionEvent(ev));
     }
 
     private async consumeCallEncryptionEvent(event: MatrixEvent, isRetry = false): Promise<void> {

src/matrixrtc/index.ts

@@ -20,4 +20,5 @@ export * from "./LivekitFocus.ts";
 export * from "./MatrixRTCSession.ts";
 export * from "./MatrixRTCSessionManager.ts";
 export type * from "./types.ts";
-export { Status, MembershipManagerEvent } from "./types.ts";
+export { Status } from "./types.ts";
+export { MembershipManagerEvent } from "./IMembershipManager.ts";

src/matrixrtc/types.ts

@@ -15,7 +15,6 @@ limitations under the License.
 */
 import type { IMentions } from "../matrix.ts";
 import type { CallMembership } from "./CallMembership.ts";
-import type { Focus } from "./focus.ts";
 
 export interface EncryptionKeyEntry {
     index: number;
@@ -49,71 +48,28 @@ export enum Status {
     Unknown = "Unknown",
 }
 
-export enum MembershipManagerEvent {
-    StatusChanged = "StatusChanged",
-}
-
-export type MembershipManagerEventHandlerMap = {
-    [MembershipManagerEvent.StatusChanged]: (prefStatus: Status, newStatus: Status) => void;
-};
-
 /**
- * This interface defines what a MembershipManager uses and exposes.
- * This interface is what we use to write tests and allows changing the actual implementation
- * without breaking tests because of some internal method renaming.
- *
- * @internal
+ * A type collecting call encryption statistics for a session.
  */
-export interface IMembershipManager {
-    /**
-     * If we are trying to join, or have successfully joined the session.
-     * It does not reflect if the room state is already configured to represent us being joined.
-     * It only means that the Manager should be trying to connect or to disconnect running.
-     * The Manager is still running right after isJoined becomes false to send the disconnect events.
-     * @returns true if we intend to be participating in the MatrixRTC session
-     * @deprecated This name is confusing and replaced by `isActivated()`. (Returns the same as `isActivated()`)
-     */
-    isJoined(): boolean;
-    /**
-     * If the manager is activated. This means it tries to do its job to join the call, resend state events...
-     * It does not imply that the room state is already configured to represent being joined.
-     * It means that the Manager tries to connect or is connected. ("the manager is still active")
-     * Once `leave()` is called the manager is not activated anymore but still running until `leave()` resolves.
-     * @returns `true` if we intend to be participating in the MatrixRTC session
-     */
-    isActivated(): boolean;
-    /**
-     * Get the actual connection status of the manager.
-     */
-    get status(): Status;
-    /**
-     * The current status while the manager is activated
-     */
-    /**
-     * Start sending all necessary events to make this user participate in the RTC session.
-     * @param fociPreferred the list of preferred foci to use in the joined RTC membership event.
-     * @param fociActive the active focus to use in the joined RTC membership event.
-     * @throws can throw if it exceeds a configured maximum retry.
-     */
-    join(fociPreferred: Focus[], fociActive?: Focus, onError?: (error: unknown) => void): void;
-    /**
-     * Send all necessary events to make this user leave the RTC session.
-     * @param timeout the maximum duration in ms until the promise is forced to resolve.
-     * @returns It resolves with true in case the leave was sent successfully.
-     * It resolves with false in case we hit the timeout before sending successfully.
-     */
-    leave(timeout?: number): Promise<boolean>;
-    /**
-     * Call this if the MatrixRTC session members have changed.
-     */
-    onRTCSessionMemberUpdate(memberships: CallMembership[]): Promise<void>;
-    /**
-     * The used active focus in the currently joined session.
-     * @returns the used active focus in the currently joined session or undefined if not joined.
-     */
-    getActiveFocus(): Focus | undefined;
+export type Statistics = {
+    counters: {
+        /**
+         * The number of times we have sent a room event containing encryption keys.
+         */
+        roomEventEncryptionKeysSent: number;
+        /**
+         * The number of times we have received a room event containing encryption keys.
+         */
+        roomEventEncryptionKeysReceived: number;
+    };
+    totals: {
+        /**
+         * The total age (in milliseconds) of all room events containing encryption keys that we have received.
+         * We track the total age so that we can later calculate the average age of all keys received.
+         */
+        roomEventEncryptionKeysReceivedTotalAge: number;
+    };
+};
 
-    // TypedEventEmitter methods:
-    on(event: MembershipManagerEvent.StatusChanged, listener: (oldStatus: Status, newStatus: Status) => void): this;
-    off(event: MembershipManagerEvent.StatusChanged, listener: (oldStatus: Status, newStatus: Status) => void): this;
-}
+export const isMyMembership = (m: CallMembership, userId: string, deviceId: string): boolean =>
+    m.sender === userId && m.deviceId === deviceId;