@textrp/briij-js-sdk 41.0.1 → 43.0.0

package/src/extensible_events_v1/ExtensibleEvent.ts

@@ -1,58 +1,58 @@
-/*
-Copyright 2021 - 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 ExtensibleEventType, type IPartialEvent } from "../@types/extensible_events.ts";
-
-/**
- * Represents an Extensible Event in Matrix.
- */
-export abstract class ExtensibleEvent<TContent extends object = object> {
-    protected constructor(public readonly wireFormat: IPartialEvent<TContent>) {}
-
-    /**
-     * Shortcut to wireFormat.content
-     */
-    public get wireContent(): TContent {
-        return this.wireFormat.content;
-    }
-
-    /**
-     * Serializes the event into a format which can be used to send the
-     * event to the room.
-     * @returns The serialized event.
-     */
-    public abstract serialize(): IPartialEvent<object>;
-
-    /**
-     * Determines if this event is equivalent to the provided event type.
-     * This is recommended over `instanceof` checks due to issues in the JS
-     * runtime (and layering of dependencies in some projects).
-     *
-     * Implementations should pass this check off to their super classes
-     * if their own checks fail. Some primary implementations do not extend
-     * fallback classes given they support the primary type first. Thus,
-     * those classes may return false if asked about their fallback
-     * representation.
-     *
-     * Note that this only checks primary event types: legacy events, like
-     * m.room.message, should/will fail this check.
-     * @param primaryEventType - The (potentially namespaced) event
-     * type.
-     * @returns True if this event *could* be represented as the
-     * given type.
-     */
-    public abstract isEquivalentTo(primaryEventType: ExtensibleEventType): boolean;
-}
+/*
+Copyright 2021 - 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 ExtensibleEventType, type IPartialEvent } from "../@types/extensible_events.ts";
+
+/**
+ * Represents an Extensible Event in Matrix.
+ */
+export abstract class ExtensibleEvent<TContent extends object = object> {
+    protected constructor(public readonly wireFormat: IPartialEvent<TContent>) {}
+
+    /**
+     * Shortcut to wireFormat.content
+     */
+    public get wireContent(): TContent {
+        return this.wireFormat.content;
+    }
+
+    /**
+     * Serializes the event into a format which can be used to send the
+     * event to the room.
+     * @returns The serialized event.
+     */
+    public abstract serialize(): IPartialEvent<object>;
+
+    /**
+     * Determines if this event is equivalent to the provided event type.
+     * This is recommended over `instanceof` checks due to issues in the JS
+     * runtime (and layering of dependencies in some projects).
+     *
+     * Implementations should pass this check off to their super classes
+     * if their own checks fail. Some primary implementations do not extend
+     * fallback classes given they support the primary type first. Thus,
+     * those classes may return false if asked about their fallback
+     * representation.
+     *
+     * Note that this only checks primary event types: legacy events, like
+     * m.room.message, should/will fail this check.
+     * @param primaryEventType - The (potentially namespaced) event
+     * type.
+     * @returns True if this event *could* be represented as the
+     * given type.
+     */
+    public abstract isEquivalentTo(primaryEventType: ExtensibleEventType): boolean;
+}

package/src/extensible_events_v1/InvalidEventError.ts

@@ -1,24 +1,24 @@
-/*
-Copyright 2022 - 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.
-*/
-
-/**
- * Thrown when an event is unforgivably unparsable.
- */
-export class InvalidEventError extends Error {
-    public constructor(message: string) {
-        super(message);
-    }
-}
+/*
+Copyright 2022 - 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.
+*/
+
+/**
+ * Thrown when an event is unforgivably unparsable.
+ */
+export class InvalidEventError extends Error {
+    public constructor(message: string) {
+        super(message);
+    }
+}

package/src/extensible_events_v1/MessageEvent.ts

@@ -1,143 +1,143 @@
-/*
-Copyright 2022 - 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 { ExtensibleEvent } from "./ExtensibleEvent.ts";
-import {
-    type ExtensibleEventType,
-    type IMessageRendering,
-    type IPartialEvent,
-    isEventTypeSame,
-    M_HTML,
-    M_MESSAGE,
-    type ExtensibleAnyMessageEventContent,
-    M_TEXT,
-} from "../@types/extensible_events.ts";
-import { isOptionalAString, isProvided } from "./utilities.ts";
-import { InvalidEventError } from "./InvalidEventError.ts";
-
-/**
- * Represents a message event. Message events are the simplest form of event with
- * just text (optionally of different mimetypes, like HTML).
- *
- * Message events can additionally be an Emote or Notice, though typically those
- * are represented as EmoteEvent and NoticeEvent respectively.
- */
-export class MessageEvent extends ExtensibleEvent<ExtensibleAnyMessageEventContent> {
-    /**
-     * The default text for the event.
-     */
-    public readonly text: string;
-
-    /**
-     * The default HTML for the event, if provided.
-     */
-    public readonly html?: string;
-
-    /**
-     * All the different renderings of the message. Note that this is the same
-     * format as an m.message body but may contain elements not found directly
-     * in the event content: this is because this is interpreted based off the
-     * other information available in the event.
-     */
-    public readonly renderings: IMessageRendering[];
-
-    /**
-     * Creates a new MessageEvent from a pure format. Note that the event is
-     * *not* parsed here: it will be treated as a literal m.message primary
-     * typed event.
-     * @param wireFormat - The event.
-     */
-    public constructor(wireFormat: IPartialEvent<ExtensibleAnyMessageEventContent>) {
-        super(wireFormat);
-
-        const mmessage = M_MESSAGE.findIn(this.wireContent);
-        const mtext = M_TEXT.findIn<string>(this.wireContent);
-        const mhtml = M_HTML.findIn<string>(this.wireContent);
-        if (isProvided(mmessage)) {
-            if (!Array.isArray(mmessage)) {
-                throw new InvalidEventError("m.message contents must be an array");
-            }
-            const text = mmessage.find((r) => !isProvided(r.mimetype) || r.mimetype === "text/plain");
-            const html = mmessage.find((r) => r.mimetype === "text/html");
-
-            if (!text) throw new InvalidEventError("m.message is missing a plain text representation");
-
-            this.text = text.body;
-            this.html = html?.body;
-            this.renderings = mmessage;
-        } else if (isOptionalAString(mtext)) {
-            this.text = mtext;
-            this.html = mhtml ?? undefined;
-            this.renderings = [{ body: mtext, mimetype: "text/plain" }];
-            if (this.html) {
-                this.renderings.push({ body: this.html, mimetype: "text/html" });
-            }
-        } else {
-            throw new InvalidEventError("Missing textual representation for event");
-        }
-    }
-
-    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {
-        return isEventTypeSame(primaryEventType, M_MESSAGE);
-    }
-
-    protected serializeMMessageOnly(): ExtensibleAnyMessageEventContent {
-        let messageRendering: ExtensibleAnyMessageEventContent = {
-            [M_MESSAGE.name]: this.renderings,
-        };
-
-        // Use the shorthand if it's just a simple text event
-        if (this.renderings.length === 1) {
-            const mime = this.renderings[0].mimetype;
-            if (mime === undefined || mime === "text/plain") {
-                messageRendering = {
-                    [M_TEXT.name]: this.renderings[0].body,
-                };
-            }
-        }
-
-        return messageRendering;
-    }
-
-    public serialize(): IPartialEvent<object> {
-        return {
-            type: "m.room.message",
-            content: {
-                ...this.serializeMMessageOnly(),
-                body: this.text,
-                msgtype: "m.text",
-                format: this.html ? "org.matrix.custom.html" : undefined,
-                formatted_body: this.html ?? undefined,
-            },
-        };
-    }
-
-    /**
-     * Creates a new MessageEvent from text and HTML.
-     * @param text - The text.
-     * @param html - Optional HTML.
-     * @returns The representative message event.
-     */
-    public static from(text: string, html?: string): MessageEvent {
-        return new MessageEvent({
-            type: M_MESSAGE.name,
-            content: {
-                [M_TEXT.name]: text,
-                [M_HTML.name]: html,
-            },
-        });
-    }
-}
+/*
+Copyright 2022 - 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 { ExtensibleEvent } from "./ExtensibleEvent.ts";
+import {
+    type ExtensibleEventType,
+    type IMessageRendering,
+    type IPartialEvent,
+    isEventTypeSame,
+    M_HTML,
+    M_MESSAGE,
+    type ExtensibleAnyMessageEventContent,
+    M_TEXT,
+} from "../@types/extensible_events.ts";
+import { isOptionalAString, isProvided } from "./utilities.ts";
+import { InvalidEventError } from "./InvalidEventError.ts";
+
+/**
+ * Represents a message event. Message events are the simplest form of event with
+ * just text (optionally of different mimetypes, like HTML).
+ *
+ * Message events can additionally be an Emote or Notice, though typically those
+ * are represented as EmoteEvent and NoticeEvent respectively.
+ */
+export class MessageEvent extends ExtensibleEvent<ExtensibleAnyMessageEventContent> {
+    /**
+     * The default text for the event.
+     */
+    public readonly text: string;
+
+    /**
+     * The default HTML for the event, if provided.
+     */
+    public readonly html?: string;
+
+    /**
+     * All the different renderings of the message. Note that this is the same
+     * format as an m.message body but may contain elements not found directly
+     * in the event content: this is because this is interpreted based off the
+     * other information available in the event.
+     */
+    public readonly renderings: IMessageRendering[];
+
+    /**
+     * Creates a new MessageEvent from a pure format. Note that the event is
+     * *not* parsed here: it will be treated as a literal m.message primary
+     * typed event.
+     * @param wireFormat - The event.
+     */
+    public constructor(wireFormat: IPartialEvent<ExtensibleAnyMessageEventContent>) {
+        super(wireFormat);
+
+        const mmessage = M_MESSAGE.findIn(this.wireContent);
+        const mtext = M_TEXT.findIn<string>(this.wireContent);
+        const mhtml = M_HTML.findIn<string>(this.wireContent);
+        if (isProvided(mmessage)) {
+            if (!Array.isArray(mmessage)) {
+                throw new InvalidEventError("m.message contents must be an array");
+            }
+            const text = mmessage.find((r) => !isProvided(r.mimetype) || r.mimetype === "text/plain");
+            const html = mmessage.find((r) => r.mimetype === "text/html");
+
+            if (!text) throw new InvalidEventError("m.message is missing a plain text representation");
+
+            this.text = text.body;
+            this.html = html?.body;
+            this.renderings = mmessage;
+        } else if (isOptionalAString(mtext)) {
+            this.text = mtext;
+            this.html = mhtml ?? undefined;
+            this.renderings = [{ body: mtext, mimetype: "text/plain" }];
+            if (this.html) {
+                this.renderings.push({ body: this.html, mimetype: "text/html" });
+            }
+        } else {
+            throw new InvalidEventError("Missing textual representation for event");
+        }
+    }
+
+    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {
+        return isEventTypeSame(primaryEventType, M_MESSAGE);
+    }
+
+    protected serializeMMessageOnly(): ExtensibleAnyMessageEventContent {
+        let messageRendering: ExtensibleAnyMessageEventContent = {
+            [M_MESSAGE.name]: this.renderings,
+        };
+
+        // Use the shorthand if it's just a simple text event
+        if (this.renderings.length === 1) {
+            const mime = this.renderings[0].mimetype;
+            if (mime === undefined || mime === "text/plain") {
+                messageRendering = {
+                    [M_TEXT.name]: this.renderings[0].body,
+                };
+            }
+        }
+
+        return messageRendering;
+    }
+
+    public serialize(): IPartialEvent<object> {
+        return {
+            type: "m.room.message",
+            content: {
+                ...this.serializeMMessageOnly(),
+                body: this.text,
+                msgtype: "m.text",
+                format: this.html ? "org.matrix.custom.html" : undefined,
+                formatted_body: this.html ?? undefined,
+            },
+        };
+    }
+
+    /**
+     * Creates a new MessageEvent from text and HTML.
+     * @param text - The text.
+     * @param html - Optional HTML.
+     * @returns The representative message event.
+     */
+    public static from(text: string, html?: string): MessageEvent {
+        return new MessageEvent({
+            type: M_MESSAGE.name,
+            content: {
+                [M_TEXT.name]: text,
+                [M_HTML.name]: html,
+            },
+        });
+    }
+}

package/src/extensible_events_v1/PollEndEvent.ts

@@ -1,97 +1,97 @@
-/*
-Copyright 2022 - 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 ExtensibleEventType,
-    type IPartialEvent,
-    isEventTypeSame,
-    M_TEXT,
-    REFERENCE_RELATION,
-} from "../@types/extensible_events.ts";
-import { M_POLL_END, type PollEndEventContent } from "../@types/polls.ts";
-import { ExtensibleEvent } from "./ExtensibleEvent.ts";
-import { InvalidEventError } from "./InvalidEventError.ts";
-import { MessageEvent } from "./MessageEvent.ts";
-
-/**
- * Represents a poll end/closure event.
- */
-export class PollEndEvent extends ExtensibleEvent<PollEndEventContent> {
-    /**
-     * The poll start event ID referenced by the response.
-     */
-    public readonly pollEventId: string;
-
-    /**
-     * The closing message for the event.
-     */
-    public readonly closingMessage: MessageEvent;
-
-    /**
-     * Creates a new PollEndEvent from a pure format. Note that the event is *not*
-     * parsed here: it will be treated as a literal m.poll.response primary typed event.
-     * @param wireFormat - The event.
-     */
-    public constructor(wireFormat: IPartialEvent<PollEndEventContent>) {
-        super(wireFormat);
-
-        const rel = this.wireContent["m.relates_to"];
-        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel?.event_id !== "string") {
-            throw new InvalidEventError("Relationship must be a reference to an event");
-        }
-
-        this.pollEventId = rel.event_id;
-        this.closingMessage = new MessageEvent(this.wireFormat);
-    }
-
-    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {
-        return isEventTypeSame(primaryEventType, M_POLL_END);
-    }
-
-    public serialize(): IPartialEvent<object> {
-        return {
-            type: M_POLL_END.name,
-            content: {
-                "m.relates_to": {
-                    rel_type: REFERENCE_RELATION.name,
-                    event_id: this.pollEventId,
-                },
-                [M_POLL_END.name]: {},
-                ...this.closingMessage.serialize().content,
-            },
-        };
-    }
-
-    /**
-     * Creates a new PollEndEvent from a poll event ID.
-     * @param pollEventId - The poll start event ID.
-     * @param message - A closing message, typically revealing the top answer.
-     * @returns The representative poll closure event.
-     */
-    public static from(pollEventId: string, message: string): PollEndEvent {
-        return new PollEndEvent({
-            type: M_POLL_END.name,
-            content: {
-                "m.relates_to": {
-                    rel_type: REFERENCE_RELATION.name,
-                    event_id: pollEventId,
-                },
-                [M_POLL_END.name]: {},
-                [M_TEXT.name]: message,
-            },
-        });
-    }
-}
+/*
+Copyright 2022 - 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 ExtensibleEventType,
+    type IPartialEvent,
+    isEventTypeSame,
+    M_TEXT,
+    REFERENCE_RELATION,
+} from "../@types/extensible_events.ts";
+import { M_POLL_END, type PollEndEventContent } from "../@types/polls.ts";
+import { ExtensibleEvent } from "./ExtensibleEvent.ts";
+import { InvalidEventError } from "./InvalidEventError.ts";
+import { MessageEvent } from "./MessageEvent.ts";
+
+/**
+ * Represents a poll end/closure event.
+ */
+export class PollEndEvent extends ExtensibleEvent<PollEndEventContent> {
+    /**
+     * The poll start event ID referenced by the response.
+     */
+    public readonly pollEventId: string;
+
+    /**
+     * The closing message for the event.
+     */
+    public readonly closingMessage: MessageEvent;
+
+    /**
+     * Creates a new PollEndEvent from a pure format. Note that the event is *not*
+     * parsed here: it will be treated as a literal m.poll.response primary typed event.
+     * @param wireFormat - The event.
+     */
+    public constructor(wireFormat: IPartialEvent<PollEndEventContent>) {
+        super(wireFormat);
+
+        const rel = this.wireContent["m.relates_to"];
+        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel?.event_id !== "string") {
+            throw new InvalidEventError("Relationship must be a reference to an event");
+        }
+
+        this.pollEventId = rel.event_id;
+        this.closingMessage = new MessageEvent(this.wireFormat);
+    }
+
+    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {
+        return isEventTypeSame(primaryEventType, M_POLL_END);
+    }
+
+    public serialize(): IPartialEvent<object> {
+        return {
+            type: M_POLL_END.name,
+            content: {
+                "m.relates_to": {
+                    rel_type: REFERENCE_RELATION.name,
+                    event_id: this.pollEventId,
+                },
+                [M_POLL_END.name]: {},
+                ...this.closingMessage.serialize().content,
+            },
+        };
+    }
+
+    /**
+     * Creates a new PollEndEvent from a poll event ID.
+     * @param pollEventId - The poll start event ID.
+     * @param message - A closing message, typically revealing the top answer.
+     * @returns The representative poll closure event.
+     */
+    public static from(pollEventId: string, message: string): PollEndEvent {
+        return new PollEndEvent({
+            type: M_POLL_END.name,
+            content: {
+                "m.relates_to": {
+                    rel_type: REFERENCE_RELATION.name,
+                    event_id: pollEventId,
+                },
+                [M_POLL_END.name]: {},
+                [M_TEXT.name]: message,
+            },
+        });
+    }
+}