@textrp/briij-js-sdk 41.0.1 → 42.0.0

package/src/extensible_events_v1/PollStartEvent.ts

@@ -1,207 +1,207 @@
-/*
-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 { NamespacedValue } from "matrix-events-sdk";
-
-import { MessageEvent } from "./MessageEvent.ts";
-import { type ExtensibleEventType, type IPartialEvent, isEventTypeSame, M_TEXT } from "../@types/extensible_events.ts";
-import {
-    type KnownPollKind,
-    M_POLL_KIND_DISCLOSED,
-    M_POLL_KIND_UNDISCLOSED,
-    M_POLL_START,
-    type PollStartEventContent,
-    type PollStartSubtype,
-    type PollAnswer,
-} from "../@types/polls.ts";
-import { InvalidEventError } from "./InvalidEventError.ts";
-import { ExtensibleEvent } from "./ExtensibleEvent.ts";
-
-/**
- * Represents a poll answer. Note that this is represented as a subtype and is
- * not registered as a parsable event - it is implied for usage exclusively
- * within the PollStartEvent parsing.
- */
-export class PollAnswerSubevent extends MessageEvent {
-    /**
-     * The answer ID.
-     */
-    public readonly id: string;
-
-    public constructor(wireFormat: IPartialEvent<PollAnswer>) {
-        super(wireFormat);
-
-        const id = wireFormat.content.id;
-        if (!id || typeof id !== "string") {
-            throw new InvalidEventError("Answer ID must be a non-empty string");
-        }
-        this.id = id;
-    }
-
-    public serialize(): IPartialEvent<object> {
-        return {
-            type: "org.matrix.sdk.poll.answer",
-            content: {
-                id: this.id,
-                ...this.serializeMMessageOnly(),
-            },
-        };
-    }
-
-    /**
-     * Creates a new PollAnswerSubevent from ID and text.
-     * @param id - The answer ID (unique within the poll).
-     * @param text - The text.
-     * @returns The representative answer.
-     */
-    public static from(id: string, text: string): PollAnswerSubevent {
-        return new PollAnswerSubevent({
-            type: "org.matrix.sdk.poll.answer",
-            content: {
-                id: id,
-                [M_TEXT.name]: text,
-            },
-        });
-    }
-}
-
-/**
- * Represents a poll start event.
- */
-export class PollStartEvent extends ExtensibleEvent<PollStartEventContent> {
-    /**
-     * The question being asked, as a MessageEvent node.
-     */
-    public readonly question: MessageEvent;
-
-    /**
-     * The interpreted kind of poll. Note that this will infer a value that is known to the
-     * SDK rather than verbatim - this means unknown types will be represented as undisclosed
-     * polls.
-     *
-     * To get the raw kind, use rawKind.
-     */
-    public readonly kind: KnownPollKind;
-
-    /**
-     * The true kind as provided by the event sender. Might not be valid.
-     */
-    public readonly rawKind: string;
-
-    /**
-     * The maximum number of selections a user is allowed to make.
-     */
-    public readonly maxSelections: number;
-
-    /**
-     * The possible answers for the poll.
-     */
-    public readonly answers: PollAnswerSubevent[];
-
-    /**
-     * Creates a new PollStartEvent from a pure format. Note that the event is *not*
-     * parsed here: it will be treated as a literal m.poll.start primary typed event.
-     * @param wireFormat - The event.
-     */
-    public constructor(wireFormat: IPartialEvent<PollStartEventContent>) {
-        super(wireFormat);
-
-        const poll = M_POLL_START.findIn<PollStartSubtype>(this.wireContent);
-
-        if (!poll?.question) {
-            throw new InvalidEventError("A question is required");
-        }
-
-        this.question = new MessageEvent({ type: "org.matrix.sdk.poll.question", content: poll.question });
-
-        this.rawKind = poll.kind;
-        if (M_POLL_KIND_DISCLOSED.matches(this.rawKind)) {
-            this.kind = M_POLL_KIND_DISCLOSED;
-        } else {
-            this.kind = M_POLL_KIND_UNDISCLOSED; // default & assumed value
-        }
-
-        this.maxSelections =
-            Number.isFinite(poll.max_selections) && poll.max_selections! > 0 ? poll.max_selections! : 1;
-
-        if (!Array.isArray(poll.answers)) {
-            throw new InvalidEventError("Poll answers must be an array");
-        }
-        const answers = poll.answers.slice(0, 20).map(
-            (a) =>
-                new PollAnswerSubevent({
-                    type: "org.matrix.sdk.poll.answer",
-                    content: a,
-                }),
-        );
-        if (answers.length <= 0) {
-            throw new InvalidEventError("No answers available");
-        }
-        this.answers = answers;
-    }
-
-    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {
-        return isEventTypeSame(primaryEventType, M_POLL_START);
-    }
-
-    public serialize(): IPartialEvent<object> {
-        return {
-            type: M_POLL_START.name,
-            content: {
-                [M_POLL_START.name]: {
-                    question: this.question.serialize().content,
-                    kind: this.rawKind,
-                    max_selections: this.maxSelections,
-                    answers: this.answers.map((a) => a.serialize().content),
-                },
-                [M_TEXT.name]: `${this.question.text}\n${this.answers.map((a, i) => `${i + 1}. ${a.text}`).join("\n")}`,
-            },
-        };
-    }
-
-    /**
-     * Creates a new PollStartEvent from question, answers, and metadata.
-     * @param question - The question to ask.
-     * @param answers - The answers. Should be unique within each other.
-     * @param kind - The kind of poll.
-     * @param maxSelections - The maximum number of selections. Must be 1 or higher.
-     * @returns The representative poll start event.
-     */
-    public static from(
-        question: string,
-        answers: string[],
-        kind: KnownPollKind | string,
-        maxSelections = 1,
-    ): PollStartEvent {
-        return new PollStartEvent({
-            type: M_POLL_START.name,
-            content: {
-                [M_TEXT.name]: question, // unused by parsing
-                [M_POLL_START.name]: {
-                    question: { [M_TEXT.name]: question },
-                    kind: kind instanceof NamespacedValue ? kind.name : kind,
-                    max_selections: maxSelections,
-                    answers: answers.map((a) => ({ id: makeId(), [M_TEXT.name]: a })),
-                },
-            },
-        });
-    }
-}
-
-const LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-function makeId(): string {
-    return [...Array(16)].map(() => LETTERS.charAt(Math.floor(Math.random() * LETTERS.length))).join("");
-}
+/*
+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 { NamespacedValue } from "matrix-events-sdk";
+
+import { MessageEvent } from "./MessageEvent.ts";
+import { type ExtensibleEventType, type IPartialEvent, isEventTypeSame, M_TEXT } from "../@types/extensible_events.ts";
+import {
+    type KnownPollKind,
+    M_POLL_KIND_DISCLOSED,
+    M_POLL_KIND_UNDISCLOSED,
+    M_POLL_START,
+    type PollStartEventContent,
+    type PollStartSubtype,
+    type PollAnswer,
+} from "../@types/polls.ts";
+import { InvalidEventError } from "./InvalidEventError.ts";
+import { ExtensibleEvent } from "./ExtensibleEvent.ts";
+
+/**
+ * Represents a poll answer. Note that this is represented as a subtype and is
+ * not registered as a parsable event - it is implied for usage exclusively
+ * within the PollStartEvent parsing.
+ */
+export class PollAnswerSubevent extends MessageEvent {
+    /**
+     * The answer ID.
+     */
+    public readonly id: string;
+
+    public constructor(wireFormat: IPartialEvent<PollAnswer>) {
+        super(wireFormat);
+
+        const id = wireFormat.content.id;
+        if (!id || typeof id !== "string") {
+            throw new InvalidEventError("Answer ID must be a non-empty string");
+        }
+        this.id = id;
+    }
+
+    public serialize(): IPartialEvent<object> {
+        return {
+            type: "org.matrix.sdk.poll.answer",
+            content: {
+                id: this.id,
+                ...this.serializeMMessageOnly(),
+            },
+        };
+    }
+
+    /**
+     * Creates a new PollAnswerSubevent from ID and text.
+     * @param id - The answer ID (unique within the poll).
+     * @param text - The text.
+     * @returns The representative answer.
+     */
+    public static from(id: string, text: string): PollAnswerSubevent {
+        return new PollAnswerSubevent({
+            type: "org.matrix.sdk.poll.answer",
+            content: {
+                id: id,
+                [M_TEXT.name]: text,
+            },
+        });
+    }
+}
+
+/**
+ * Represents a poll start event.
+ */
+export class PollStartEvent extends ExtensibleEvent<PollStartEventContent> {
+    /**
+     * The question being asked, as a MessageEvent node.
+     */
+    public readonly question: MessageEvent;
+
+    /**
+     * The interpreted kind of poll. Note that this will infer a value that is known to the
+     * SDK rather than verbatim - this means unknown types will be represented as undisclosed
+     * polls.
+     *
+     * To get the raw kind, use rawKind.
+     */
+    public readonly kind: KnownPollKind;
+
+    /**
+     * The true kind as provided by the event sender. Might not be valid.
+     */
+    public readonly rawKind: string;
+
+    /**
+     * The maximum number of selections a user is allowed to make.
+     */
+    public readonly maxSelections: number;
+
+    /**
+     * The possible answers for the poll.
+     */
+    public readonly answers: PollAnswerSubevent[];
+
+    /**
+     * Creates a new PollStartEvent from a pure format. Note that the event is *not*
+     * parsed here: it will be treated as a literal m.poll.start primary typed event.
+     * @param wireFormat - The event.
+     */
+    public constructor(wireFormat: IPartialEvent<PollStartEventContent>) {
+        super(wireFormat);
+
+        const poll = M_POLL_START.findIn<PollStartSubtype>(this.wireContent);
+
+        if (!poll?.question) {
+            throw new InvalidEventError("A question is required");
+        }
+
+        this.question = new MessageEvent({ type: "org.matrix.sdk.poll.question", content: poll.question });
+
+        this.rawKind = poll.kind;
+        if (M_POLL_KIND_DISCLOSED.matches(this.rawKind)) {
+            this.kind = M_POLL_KIND_DISCLOSED;
+        } else {
+            this.kind = M_POLL_KIND_UNDISCLOSED; // default & assumed value
+        }
+
+        this.maxSelections =
+            Number.isFinite(poll.max_selections) && poll.max_selections! > 0 ? poll.max_selections! : 1;
+
+        if (!Array.isArray(poll.answers)) {
+            throw new InvalidEventError("Poll answers must be an array");
+        }
+        const answers = poll.answers.slice(0, 20).map(
+            (a) =>
+                new PollAnswerSubevent({
+                    type: "org.matrix.sdk.poll.answer",
+                    content: a,
+                }),
+        );
+        if (answers.length <= 0) {
+            throw new InvalidEventError("No answers available");
+        }
+        this.answers = answers;
+    }
+
+    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {
+        return isEventTypeSame(primaryEventType, M_POLL_START);
+    }
+
+    public serialize(): IPartialEvent<object> {
+        return {
+            type: M_POLL_START.name,
+            content: {
+                [M_POLL_START.name]: {
+                    question: this.question.serialize().content,
+                    kind: this.rawKind,
+                    max_selections: this.maxSelections,
+                    answers: this.answers.map((a) => a.serialize().content),
+                },
+                [M_TEXT.name]: `${this.question.text}\n${this.answers.map((a, i) => `${i + 1}. ${a.text}`).join("\n")}`,
+            },
+        };
+    }
+
+    /**
+     * Creates a new PollStartEvent from question, answers, and metadata.
+     * @param question - The question to ask.
+     * @param answers - The answers. Should be unique within each other.
+     * @param kind - The kind of poll.
+     * @param maxSelections - The maximum number of selections. Must be 1 or higher.
+     * @returns The representative poll start event.
+     */
+    public static from(
+        question: string,
+        answers: string[],
+        kind: KnownPollKind | string,
+        maxSelections = 1,
+    ): PollStartEvent {
+        return new PollStartEvent({
+            type: M_POLL_START.name,
+            content: {
+                [M_TEXT.name]: question, // unused by parsing
+                [M_POLL_START.name]: {
+                    question: { [M_TEXT.name]: question },
+                    kind: kind instanceof NamespacedValue ? kind.name : kind,
+                    max_selections: maxSelections,
+                    answers: answers.map((a) => ({ id: makeId(), [M_TEXT.name]: a })),
+                },
+            },
+        });
+    }
+}
+
+const LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function makeId(): string {
+    return [...Array(16)].map(() => LETTERS.charAt(Math.floor(Math.random() * LETTERS.length))).join("");
+}

package/src/extensible_events_v1/utilities.ts

@@ -1,35 +1,35 @@
-/*
-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 Optional } from "matrix-events-sdk";
-
-/**
- * Determines if the given optional was provided a value.
- * @param s - The optional to test.
- * @returns True if the value is defined.
- */
-export function isProvided<T>(s: Optional<T>): s is T {
-    return s !== null && s !== undefined;
-}
-
-/**
- * Determines if the given optional string is a defined string.
- * @param s - The input string.
- * @returns True if the input is a defined string.
- */
-export function isOptionalAString(s: Optional<string>): s is string {
-    return isProvided(s) && typeof s === "string";
-}
+/*
+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 Optional } from "matrix-events-sdk";
+
+/**
+ * Determines if the given optional was provided a value.
+ * @param s - The optional to test.
+ * @returns True if the value is defined.
+ */
+export function isProvided<T>(s: Optional<T>): s is T {
+    return s !== null && s !== undefined;
+}
+
+/**
+ * Determines if the given optional string is a defined string.
+ * @param s - The input string.
+ * @returns True if the input is a defined string.
+ */
+export function isOptionalAString(s: Optional<string>): s is string {
+    return isProvided(s) && typeof s === "string";
+}

package/src/feature.ts

@@ -1,88 +1,88 @@
-/*
-Copyright 2022 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 IServerVersions } from "./client.ts";
-
-export enum ServerSupport {
-    Stable,
-    Unstable,
-    Unsupported,
-}
-
-export enum Feature {
-    Thread = "Thread",
-    ThreadUnreadNotifications = "ThreadUnreadNotifications",
-    /**
-     * @deprecated this is now exposed as a capability not a feature
-     */
-    LoginTokenRequest = "LoginTokenRequest",
-    RelationBasedRedactions = "RelationBasedRedactions",
-    AccountDataDeletion = "AccountDataDeletion",
-    RelationsRecursion = "RelationsRecursion",
-    IntentionalMentions = "IntentionalMentions",
-}
-
-type FeatureSupportCondition = {
-    unstablePrefixes?: string[];
-    matrixVersion?: string;
-};
-
-const featureSupportResolver: Record<string, FeatureSupportCondition> = {
-    [Feature.Thread]: {
-        unstablePrefixes: ["org.matrix.msc3440"],
-        matrixVersion: "v1.3",
-    },
-    [Feature.ThreadUnreadNotifications]: {
-        unstablePrefixes: ["org.matrix.msc3771", "org.matrix.msc3773"],
-        matrixVersion: "v1.4",
-    },
-    [Feature.LoginTokenRequest]: {
-        unstablePrefixes: ["org.matrix.msc3882"],
-    },
-    [Feature.RelationBasedRedactions]: {
-        unstablePrefixes: ["org.matrix.msc3912"],
-    },
-    [Feature.AccountDataDeletion]: {
-        unstablePrefixes: ["org.matrix.msc3391"],
-    },
-    [Feature.RelationsRecursion]: {
-        unstablePrefixes: ["org.matrix.msc3981"],
-        matrixVersion: "v1.10",
-    },
-    [Feature.IntentionalMentions]: {
-        unstablePrefixes: ["org.matrix.msc3952_intentional_mentions"],
-        matrixVersion: "v1.7",
-    },
-};
-
-export async function buildFeatureSupportMap(versions: IServerVersions): Promise<Map<Feature, ServerSupport>> {
-    const supportMap = new Map<Feature, ServerSupport>();
-    for (const [feature, supportCondition] of Object.entries(featureSupportResolver)) {
-        const supportMatrixVersion = versions.versions?.includes(supportCondition.matrixVersion || "") ?? false;
-        const supportUnstablePrefixes =
-            supportCondition.unstablePrefixes?.every((unstablePrefix) => {
-                return versions.unstable_features?.[unstablePrefix] === true;
-            }) ?? false;
-        if (supportMatrixVersion) {
-            supportMap.set(feature as Feature, ServerSupport.Stable);
-        } else if (supportUnstablePrefixes) {
-            supportMap.set(feature as Feature, ServerSupport.Unstable);
-        } else {
-            supportMap.set(feature as Feature, ServerSupport.Unsupported);
-        }
-    }
-    return supportMap;
-}
+/*
+Copyright 2022 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 IServerVersions } from "./client.ts";
+
+export enum ServerSupport {
+    Stable,
+    Unstable,
+    Unsupported,
+}
+
+export enum Feature {
+    Thread = "Thread",
+    ThreadUnreadNotifications = "ThreadUnreadNotifications",
+    /**
+     * @deprecated this is now exposed as a capability not a feature
+     */
+    LoginTokenRequest = "LoginTokenRequest",
+    RelationBasedRedactions = "RelationBasedRedactions",
+    AccountDataDeletion = "AccountDataDeletion",
+    RelationsRecursion = "RelationsRecursion",
+    IntentionalMentions = "IntentionalMentions",
+}
+
+type FeatureSupportCondition = {
+    unstablePrefixes?: string[];
+    matrixVersion?: string;
+};
+
+const featureSupportResolver: Record<string, FeatureSupportCondition> = {
+    [Feature.Thread]: {
+        unstablePrefixes: ["org.matrix.msc3440"],
+        matrixVersion: "v1.3",
+    },
+    [Feature.ThreadUnreadNotifications]: {
+        unstablePrefixes: ["org.matrix.msc3771", "org.matrix.msc3773"],
+        matrixVersion: "v1.4",
+    },
+    [Feature.LoginTokenRequest]: {
+        unstablePrefixes: ["org.matrix.msc3882"],
+    },
+    [Feature.RelationBasedRedactions]: {
+        unstablePrefixes: ["org.matrix.msc3912"],
+    },
+    [Feature.AccountDataDeletion]: {
+        unstablePrefixes: ["org.matrix.msc3391"],
+    },
+    [Feature.RelationsRecursion]: {
+        unstablePrefixes: ["org.matrix.msc3981"],
+        matrixVersion: "v1.10",
+    },
+    [Feature.IntentionalMentions]: {
+        unstablePrefixes: ["org.matrix.msc3952_intentional_mentions"],
+        matrixVersion: "v1.7",
+    },
+};
+
+export async function buildFeatureSupportMap(versions: IServerVersions): Promise<Map<Feature, ServerSupport>> {
+    const supportMap = new Map<Feature, ServerSupport>();
+    for (const [feature, supportCondition] of Object.entries(featureSupportResolver)) {
+        const supportMatrixVersion = versions.versions?.includes(supportCondition.matrixVersion || "") ?? false;
+        const supportUnstablePrefixes =
+            supportCondition.unstablePrefixes?.every((unstablePrefix) => {
+                return versions.unstable_features?.[unstablePrefix] === true;
+            }) ?? false;
+        if (supportMatrixVersion) {
+            supportMap.set(feature as Feature, ServerSupport.Stable);
+        } else if (supportUnstablePrefixes) {
+            supportMap.set(feature as Feature, ServerSupport.Unstable);
+        } else {
+            supportMap.set(feature as Feature, ServerSupport.Unsupported);
+        }
+    }
+    return supportMap;
+}