@textrp/briij-js-sdk 41.0.0 → 42.0.0

package/src/models/search-result.ts

@@ -1,57 +1,57 @@
-/*
-Copyright 2015 - 2021 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 { EventContext } from "./event-context.ts";
-import { type EventMapper } from "../event-mapper.ts";
-import { type IResultContext, type ISearchResult } from "../@types/search.ts";
-
-export class SearchResult {
-    /**
-     * Create a SearchResponse from the response to /search
-     */
-
-    public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
-        const jsonContext = jsonObj.context || ({} as IResultContext);
-        let eventsBefore = (jsonContext.events_before || []).map(eventMapper);
-        let eventsAfter = (jsonContext.events_after || []).map(eventMapper);
-
-        const context = new EventContext(eventMapper(jsonObj.result));
-
-        // Filter out any contextual events which do not correspond to the same timeline (thread or room)
-        const threadRootId = context.ourEvent.threadRootId;
-        eventsBefore = eventsBefore.filter((e) => e.threadRootId === threadRootId);
-        eventsAfter = eventsAfter.filter((e) => e.threadRootId === threadRootId);
-
-        context.setPaginateToken(jsonContext.start, true);
-        context.addEvents(eventsBefore, true);
-        context.addEvents(eventsAfter, false);
-        context.setPaginateToken(jsonContext.end, false);
-
-        return new SearchResult(jsonObj.rank, context);
-    }
-
-    /**
-     * Construct a new SearchResult
-     *
-     * @param rank -   where this SearchResult ranks in the results
-     * @param context -  the matching event and its
-     *    context
-     */
-    public constructor(
-        public readonly rank: number,
-        public readonly context: EventContext,
-    ) {}
-}
+/*
+Copyright 2015 - 2021 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 { EventContext } from "./event-context.ts";
+import { type EventMapper } from "../event-mapper.ts";
+import { type IResultContext, type ISearchResult } from "../@types/search.ts";
+
+export class SearchResult {
+    /**
+     * Create a SearchResponse from the response to /search
+     */
+
+    public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
+        const jsonContext = jsonObj.context || ({} as IResultContext);
+        let eventsBefore = (jsonContext.events_before || []).map(eventMapper);
+        let eventsAfter = (jsonContext.events_after || []).map(eventMapper);
+
+        const context = new EventContext(eventMapper(jsonObj.result));
+
+        // Filter out any contextual events which do not correspond to the same timeline (thread or room)
+        const threadRootId = context.ourEvent.threadRootId;
+        eventsBefore = eventsBefore.filter((e) => e.threadRootId === threadRootId);
+        eventsAfter = eventsAfter.filter((e) => e.threadRootId === threadRootId);
+
+        context.setPaginateToken(jsonContext.start, true);
+        context.addEvents(eventsBefore, true);
+        context.addEvents(eventsAfter, false);
+        context.setPaginateToken(jsonContext.end, false);
+
+        return new SearchResult(jsonObj.rank, context);
+    }
+
+    /**
+     * Construct a new SearchResult
+     *
+     * @param rank -   where this SearchResult ranks in the results
+     * @param context -  the matching event and its
+     *    context
+     */
+    public constructor(
+        public readonly rank: number,
+        public readonly context: EventContext,
+    ) {}
+}

package/src/models/typed-event-emitter.ts

@@ -1,246 +1,246 @@
-/*
-Copyright 2021 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.
-*/
-
-// eslint-disable-next-line no-restricted-imports
-import { EventEmitter } from "events";
-
-/** Events emitted by EventEmitter itself */
-export enum EventEmitterEvents {
-    NewListener = "newListener",
-    RemoveListener = "removeListener",
-    Error = "error",
-}
-
-type AnyListener = (...args: any) => any;
-
-/** Base class for types mapping from event name to the type of listeners to that event */
-export type ListenerMap<E extends string> = { [eventName in E]: AnyListener };
-
-type EventEmitterEventListener = (eventName: string, listener: AnyListener) => void;
-type EventEmitterErrorListener = (error: Error) => void;
-
-/**
- * The expected type of a listener function for a particular event.
- *
- * Type parameters:
- *   * `E` - List of all events emitted by the `TypedEventEmitter`. Normally an enum type.
- *   * `A` - A type providing mappings from event names to listener types.
- *   * `T` - The name of the actual event that this listener is for. Normally one of the types in `E` or
- *           {@link EventEmitterEvents}.
- */
-export type Listener<E extends string, A extends ListenerMap<E>, T extends E | EventEmitterEvents> = T extends E
-    ? A[T]
-    : T extends EventEmitterEvents
-      ? EventEmitterErrorListener
-      : EventEmitterEventListener;
-
-/**
- * Typed Event Emitter class which can act as a Base Model for all our model
- * and communication events.
- * This makes it much easier for us to distinguish between events, as we now need
- * to properly type this, so that our events are not stringly-based and prone
- * to silly typos.
- *
- * Type parameters:
- *  * `Events` - List of all events emitted by this `TypedEventEmitter`. Normally an enum type.
- *  * `Arguments` - A {@link ListenerMap} type providing mappings from event names to listener types.
- *  * `SuperclassArguments` - TODO: not really sure. Alternative listener mappings, I think? But only honoured for `.emit`?
- */
-export class TypedEventEmitter<
-    Events extends string,
-    Arguments extends ListenerMap<Events>,
-    SuperclassArguments extends ListenerMap<any> = Arguments,
-> extends EventEmitter {
-    /**
-     * Alias for {@link on}.
-     */
-    public addListener<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
-        return super.addListener(event, listener);
-    }
-
-    /**
-     * Synchronously calls each of the listeners registered for the event named
-     * `event`, in the order they were registered, passing the supplied arguments
-     * to each.
-     *
-     * @param event - The name of the event to emit
-     * @param args - Arguments to pass to the listener
-     * @returns `true` if the event had listeners, `false` otherwise.
-     */
-    public emit<T extends Events>(event: T, ...args: Parameters<SuperclassArguments[T]>): boolean;
-    public emit<T extends Events>(event: T, ...args: Parameters<Arguments[T]>): boolean;
-    public emit<T extends Events>(event: T, ...args: any[]): boolean {
-        return super.emit(event, ...args);
-    }
-
-    /**
-     * Similar to `emit` but calls all listeners within a `Promise.all` and returns the promise chain
-     * @param event - The name of the event to emit
-     * @param args - Arguments to pass to the listener
-     * @returns `true` if the event had listeners, `false` otherwise.
-     */
-    public async emitPromised<T extends Events>(
-        event: T,
-        ...args: Parameters<SuperclassArguments[T]>
-    ): Promise<boolean>;
-    public async emitPromised<T extends Events>(event: T, ...args: Parameters<Arguments[T]>): Promise<boolean>;
-    public async emitPromised<T extends Events>(event: T, ...args: any[]): Promise<boolean> {
-        const listeners = this.listeners(event);
-        return Promise.allSettled(listeners.map((l) => l(...args))).then(() => {
-            return listeners.length > 0;
-        });
-    }
-
-    /**
-     * Returns the number of listeners listening to the event named `event`.
-     *
-     * @param event - The name of the event being listened for
-     */
-    public listenerCount(event: Events | EventEmitterEvents): number {
-        return super.listenerCount(event);
-    }
-
-    /**
-     * Returns a copy of the array of listeners for the event named `event`.
-     */
-    public listeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter["listeners"]> {
-        return super.listeners(event);
-    }
-
-    /**
-     * Alias for {@link removeListener}
-     */
-    public off<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
-        return super.off(event, listener);
-    }
-
-    /**
-     * Adds the `listener` function to the end of the listeners array for the
-     * event named `event`.
-     *
-     * No checks are made to see if the `listener` has already been added. Multiple calls
-     * passing the same combination of `event` and `listener` will result in the `listener`
-     * being added, and called, multiple times.
-     *
-     * By default, event listeners are invoked in the order they are added. The
-     * {@link prependListener} method can be used as an alternative to add the
-     * event listener to the beginning of the listeners array.
-     *
-     * @param event - The name of the event.
-     * @param listener - The callback function
-     *
-     * @returns a reference to the `EventEmitter`, so that calls can be chained.
-     */
-    public on<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
-        return super.on(event, listener);
-    }
-
-    /**
-     * Adds a **one-time** `listener` function for the event named `event`. The
-     * next time `event` is triggered, this listener is removed and then invoked.
-     *
-     * Returns a reference to the `EventEmitter`, so that calls can be chained.
-     *
-     * By default, event listeners are invoked in the order they are added.
-     * The {@link prependOnceListener} method can be used as an alternative to add the
-     * event listener to the beginning of the listeners array.
-     *
-     * @param event - The name of the event.
-     * @param listener - The callback function
-     *
-     * @returns a reference to the `EventEmitter`, so that calls can be chained.
-     */
-    public once<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
-        return super.once(event, listener);
-    }
-
-    /**
-     * Adds the `listener` function to the _beginning_ of the listeners array for the
-     * event named `event`.
-     *
-     * No checks are made to see if the `listener` has already been added. Multiple calls
-     * passing the same combination of `event` and `listener` will result in the `listener`
-     * being added, and called, multiple times.
-     *
-     * @param event - The name of the event.
-     * @param listener - The callback function
-     *
-     * @returns a reference to the `EventEmitter`, so that calls can be chained.
-     */
-    public prependListener<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
-        return super.prependListener(event, listener);
-    }
-
-    /**
-     * Adds a **one-time**`listener` function for the event named `event` to the _beginning_ of the listeners array.
-     * The next time `event` is triggered, this listener is removed, and then invoked.
-     *
-     * @param event - The name of the event.
-     * @param listener - The callback function
-     *
-     * @returns a reference to the `EventEmitter`, so that calls can be chained.
-     */
-    public prependOnceListener<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
-        return super.prependOnceListener(event, listener);
-    }
-
-    /**
-     * Removes all listeners, or those of the specified `event`.
-     *
-     * It is bad practice to remove listeners added elsewhere in the code,
-     * particularly when the `EventEmitter` instance was created by some other
-     * component or module (e.g. sockets or file streams).
-     *
-     * @param event - The name of the event. If undefined, all listeners everywhere are removed.
-     * @returns a reference to the `EventEmitter`, so that calls can be chained.
-     */
-    public removeAllListeners(event?: Events | EventEmitterEvents): this {
-        // EventEmitter::removeAllListeners uses `arguments.length` to determine undefined case
-        if (event === undefined) {
-            return super.removeAllListeners();
-        }
-        return super.removeAllListeners(event);
-    }
-
-    /**
-     * Removes the specified `listener` from the listener array for the event named `event`.
-     *
-     * @returns a reference to the `EventEmitter`, so that calls can be chained.
-     */
-    public removeListener<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
-        return super.removeListener(event, listener);
-    }
-
-    /**
-     * Returns a copy of the array of listeners for the event named `eventName`,
-     * including any wrappers (such as those created by `.once()`).
-     */
-    public rawListeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter["rawListeners"]> {
-        return super.rawListeners(event);
-    }
-}
+/*
+Copyright 2021 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.
+*/
+
+// eslint-disable-next-line no-restricted-imports
+import { EventEmitter } from "events";
+
+/** Events emitted by EventEmitter itself */
+export enum EventEmitterEvents {
+    NewListener = "newListener",
+    RemoveListener = "removeListener",
+    Error = "error",
+}
+
+type AnyListener = (...args: any) => any;
+
+/** Base class for types mapping from event name to the type of listeners to that event */
+export type ListenerMap<E extends string> = { [eventName in E]: AnyListener };
+
+type EventEmitterEventListener = (eventName: string, listener: AnyListener) => void;
+type EventEmitterErrorListener = (error: Error) => void;
+
+/**
+ * The expected type of a listener function for a particular event.
+ *
+ * Type parameters:
+ *   * `E` - List of all events emitted by the `TypedEventEmitter`. Normally an enum type.
+ *   * `A` - A type providing mappings from event names to listener types.
+ *   * `T` - The name of the actual event that this listener is for. Normally one of the types in `E` or
+ *           {@link EventEmitterEvents}.
+ */
+export type Listener<E extends string, A extends ListenerMap<E>, T extends E | EventEmitterEvents> = T extends E
+    ? A[T]
+    : T extends EventEmitterEvents
+      ? EventEmitterErrorListener
+      : EventEmitterEventListener;
+
+/**
+ * Typed Event Emitter class which can act as a Base Model for all our model
+ * and communication events.
+ * This makes it much easier for us to distinguish between events, as we now need
+ * to properly type this, so that our events are not stringly-based and prone
+ * to silly typos.
+ *
+ * Type parameters:
+ *  * `Events` - List of all events emitted by this `TypedEventEmitter`. Normally an enum type.
+ *  * `Arguments` - A {@link ListenerMap} type providing mappings from event names to listener types.
+ *  * `SuperclassArguments` - TODO: not really sure. Alternative listener mappings, I think? But only honoured for `.emit`?
+ */
+export class TypedEventEmitter<
+    Events extends string,
+    Arguments extends ListenerMap<Events>,
+    SuperclassArguments extends ListenerMap<any> = Arguments,
+> extends EventEmitter {
+    /**
+     * Alias for {@link on}.
+     */
+    public addListener<T extends Events | EventEmitterEvents>(
+        event: T,
+        listener: Listener<Events, Arguments, T>,
+    ): this {
+        return super.addListener(event, listener);
+    }
+
+    /**
+     * Synchronously calls each of the listeners registered for the event named
+     * `event`, in the order they were registered, passing the supplied arguments
+     * to each.
+     *
+     * @param event - The name of the event to emit
+     * @param args - Arguments to pass to the listener
+     * @returns `true` if the event had listeners, `false` otherwise.
+     */
+    public emit<T extends Events>(event: T, ...args: Parameters<SuperclassArguments[T]>): boolean;
+    public emit<T extends Events>(event: T, ...args: Parameters<Arguments[T]>): boolean;
+    public emit<T extends Events>(event: T, ...args: any[]): boolean {
+        return super.emit(event, ...args);
+    }
+
+    /**
+     * Similar to `emit` but calls all listeners within a `Promise.all` and returns the promise chain
+     * @param event - The name of the event to emit
+     * @param args - Arguments to pass to the listener
+     * @returns `true` if the event had listeners, `false` otherwise.
+     */
+    public async emitPromised<T extends Events>(
+        event: T,
+        ...args: Parameters<SuperclassArguments[T]>
+    ): Promise<boolean>;
+    public async emitPromised<T extends Events>(event: T, ...args: Parameters<Arguments[T]>): Promise<boolean>;
+    public async emitPromised<T extends Events>(event: T, ...args: any[]): Promise<boolean> {
+        const listeners = this.listeners(event);
+        return Promise.allSettled(listeners.map((l) => l(...args))).then(() => {
+            return listeners.length > 0;
+        });
+    }
+
+    /**
+     * Returns the number of listeners listening to the event named `event`.
+     *
+     * @param event - The name of the event being listened for
+     */
+    public listenerCount(event: Events | EventEmitterEvents): number {
+        return super.listenerCount(event);
+    }
+
+    /**
+     * Returns a copy of the array of listeners for the event named `event`.
+     */
+    public listeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter["listeners"]> {
+        return super.listeners(event);
+    }
+
+    /**
+     * Alias for {@link removeListener}
+     */
+    public off<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
+        return super.off(event, listener);
+    }
+
+    /**
+     * Adds the `listener` function to the end of the listeners array for the
+     * event named `event`.
+     *
+     * No checks are made to see if the `listener` has already been added. Multiple calls
+     * passing the same combination of `event` and `listener` will result in the `listener`
+     * being added, and called, multiple times.
+     *
+     * By default, event listeners are invoked in the order they are added. The
+     * {@link prependListener} method can be used as an alternative to add the
+     * event listener to the beginning of the listeners array.
+     *
+     * @param event - The name of the event.
+     * @param listener - The callback function
+     *
+     * @returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    public on<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
+        return super.on(event, listener);
+    }
+
+    /**
+     * Adds a **one-time** `listener` function for the event named `event`. The
+     * next time `event` is triggered, this listener is removed and then invoked.
+     *
+     * Returns a reference to the `EventEmitter`, so that calls can be chained.
+     *
+     * By default, event listeners are invoked in the order they are added.
+     * The {@link prependOnceListener} method can be used as an alternative to add the
+     * event listener to the beginning of the listeners array.
+     *
+     * @param event - The name of the event.
+     * @param listener - The callback function
+     *
+     * @returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    public once<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
+        return super.once(event, listener);
+    }
+
+    /**
+     * Adds the `listener` function to the _beginning_ of the listeners array for the
+     * event named `event`.
+     *
+     * No checks are made to see if the `listener` has already been added. Multiple calls
+     * passing the same combination of `event` and `listener` will result in the `listener`
+     * being added, and called, multiple times.
+     *
+     * @param event - The name of the event.
+     * @param listener - The callback function
+     *
+     * @returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    public prependListener<T extends Events | EventEmitterEvents>(
+        event: T,
+        listener: Listener<Events, Arguments, T>,
+    ): this {
+        return super.prependListener(event, listener);
+    }
+
+    /**
+     * Adds a **one-time**`listener` function for the event named `event` to the _beginning_ of the listeners array.
+     * The next time `event` is triggered, this listener is removed, and then invoked.
+     *
+     * @param event - The name of the event.
+     * @param listener - The callback function
+     *
+     * @returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    public prependOnceListener<T extends Events | EventEmitterEvents>(
+        event: T,
+        listener: Listener<Events, Arguments, T>,
+    ): this {
+        return super.prependOnceListener(event, listener);
+    }
+
+    /**
+     * Removes all listeners, or those of the specified `event`.
+     *
+     * It is bad practice to remove listeners added elsewhere in the code,
+     * particularly when the `EventEmitter` instance was created by some other
+     * component or module (e.g. sockets or file streams).
+     *
+     * @param event - The name of the event. If undefined, all listeners everywhere are removed.
+     * @returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    public removeAllListeners(event?: Events | EventEmitterEvents): this {
+        // EventEmitter::removeAllListeners uses `arguments.length` to determine undefined case
+        if (event === undefined) {
+            return super.removeAllListeners();
+        }
+        return super.removeAllListeners(event);
+    }
+
+    /**
+     * Removes the specified `listener` from the listener array for the event named `event`.
+     *
+     * @returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    public removeListener<T extends Events | EventEmitterEvents>(
+        event: T,
+        listener: Listener<Events, Arguments, T>,
+    ): this {
+        return super.removeListener(event, listener);
+    }
+
+    /**
+     * Returns a copy of the array of listeners for the event named `eventName`,
+     * including any wrappers (such as those created by `.once()`).
+     */
+    public rawListeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter["rawListeners"]> {
+        return super.rawListeners(event);
+    }
+}