@textrp/briij-js-sdk 41.0.1 → 42.0.0

package/src/@types/uia.ts

@@ -1,24 +1,24 @@
-/*
-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 AuthDict } from "../interactive-auth.ts";
-
-/**
- * Helper type to represent HTTP request body for a UIA enabled endpoint
- */
-export type UIARequest<T> = T & {
-    auth?: AuthDict;
-};
+/*
+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 AuthDict } from "../interactive-auth.ts";
+
+/**
+ * Helper type to represent HTTP request body for a UIA enabled endpoint
+ */
+export type UIARequest<T> = T & {
+    auth?: AuthDict;
+};

package/src/NamespacedValue.ts

@@ -1,121 +1,121 @@
-/*
-Copyright 2021 - 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.
-*/
-
-/**
- * Represents a simple Matrix namespaced value. This will assume that if a stable prefix
- * is provided that the stable prefix should be used when representing the identifier.
- */
-export class NamespacedValue<S extends string, U extends string> {
-    // Stable is optional, but one of the two parameters is required, hence the weird-looking types.
-    // Goal is to to have developers explicitly say there is no stable value (if applicable).
-    public constructor(stable: S, unstable: U);
-    public constructor(stable: S, unstable: U | null);
-    public constructor(stable: null, unstable: U);
-    public constructor(
-        public readonly stable: S | null,
-        public readonly unstable: U | null,
-    ) {
-        if (!this.unstable && !this.stable) {
-            throw new Error("One of stable or unstable values must be supplied");
-        }
-    }
-
-    public get name(): U | S {
-        if (this.stable) {
-            return this.stable;
-        }
-        return this.unstable!;
-    }
-
-    public get altName(): U | S | null | undefined {
-        if (!this.stable) {
-            return null;
-        }
-        return this.unstable;
-    }
-
-    public get names(): (U | S)[] {
-        const names = [this.name];
-        const altName = this.altName;
-        if (altName) names.push(altName);
-        return names;
-    }
-
-    public matches(val: string): boolean {
-        return this.name === val || this.altName === val;
-    }
-
-    // this desperately wants https://github.com/microsoft/TypeScript/pull/26349 at the top level of the class
-    // so we can instantiate `NamespacedValue<string, _, _>` as a default type for that namespace.
-    public findIn<V>(obj: Partial<Record<NonNullable<S | U>, V>>): V | undefined {
-        let val: V | undefined = undefined;
-        if (this.name) {
-            val = obj?.[this.name];
-        }
-        if (!val && this.altName) {
-            val = obj?.[this.altName];
-        }
-        return val;
-    }
-
-    public includedIn(arr: any[]): boolean {
-        let included = false;
-        if (this.name) {
-            included = arr.includes(this.name);
-        }
-        if (!included && this.altName) {
-            included = arr.includes(this.altName);
-        }
-        return included;
-    }
-}
-
-export class ServerControlledNamespacedValue<S extends string, U extends string> extends NamespacedValue<S, U> {
-    private preferUnstable = false;
-
-    public setPreferUnstable(preferUnstable: boolean): void {
-        this.preferUnstable = preferUnstable;
-    }
-
-    public get name(): U | S {
-        if (this.stable && !this.preferUnstable) {
-            return this.stable;
-        }
-        return this.unstable!;
-    }
-}
-
-/**
- * Represents a namespaced value which prioritizes the unstable value over the stable
- * value.
- */
-export class UnstableValue<S extends string, U extends string> extends NamespacedValue<S, U> {
-    // Note: Constructor difference is that `unstable` is *required*.
-    public constructor(stable: S, unstable: U) {
-        super(stable, unstable);
-        if (!this.unstable) {
-            throw new Error("Unstable value must be supplied");
-        }
-    }
-
-    public get name(): U {
-        return this.unstable!;
-    }
-
-    public get altName(): S {
-        return this.stable!;
-    }
-}
+/*
+Copyright 2021 - 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.
+*/
+
+/**
+ * Represents a simple Matrix namespaced value. This will assume that if a stable prefix
+ * is provided that the stable prefix should be used when representing the identifier.
+ */
+export class NamespacedValue<S extends string, U extends string> {
+    // Stable is optional, but one of the two parameters is required, hence the weird-looking types.
+    // Goal is to to have developers explicitly say there is no stable value (if applicable).
+    public constructor(stable: S, unstable: U);
+    public constructor(stable: S, unstable: U | null);
+    public constructor(stable: null, unstable: U);
+    public constructor(
+        public readonly stable: S | null,
+        public readonly unstable: U | null,
+    ) {
+        if (!this.unstable && !this.stable) {
+            throw new Error("One of stable or unstable values must be supplied");
+        }
+    }
+
+    public get name(): U | S {
+        if (this.stable) {
+            return this.stable;
+        }
+        return this.unstable!;
+    }
+
+    public get altName(): U | S | null | undefined {
+        if (!this.stable) {
+            return null;
+        }
+        return this.unstable;
+    }
+
+    public get names(): (U | S)[] {
+        const names = [this.name];
+        const altName = this.altName;
+        if (altName) names.push(altName);
+        return names;
+    }
+
+    public matches(val: string): boolean {
+        return this.name === val || this.altName === val;
+    }
+
+    // this desperately wants https://github.com/microsoft/TypeScript/pull/26349 at the top level of the class
+    // so we can instantiate `NamespacedValue<string, _, _>` as a default type for that namespace.
+    public findIn<V>(obj: Partial<Record<NonNullable<S | U>, V>>): V | undefined {
+        let val: V | undefined = undefined;
+        if (this.name) {
+            val = obj?.[this.name];
+        }
+        if (!val && this.altName) {
+            val = obj?.[this.altName];
+        }
+        return val;
+    }
+
+    public includedIn(arr: any[]): boolean {
+        let included = false;
+        if (this.name) {
+            included = arr.includes(this.name);
+        }
+        if (!included && this.altName) {
+            included = arr.includes(this.altName);
+        }
+        return included;
+    }
+}
+
+export class ServerControlledNamespacedValue<S extends string, U extends string> extends NamespacedValue<S, U> {
+    private preferUnstable = false;
+
+    public setPreferUnstable(preferUnstable: boolean): void {
+        this.preferUnstable = preferUnstable;
+    }
+
+    public get name(): U | S {
+        if (this.stable && !this.preferUnstable) {
+            return this.stable;
+        }
+        return this.unstable!;
+    }
+}
+
+/**
+ * Represents a namespaced value which prioritizes the unstable value over the stable
+ * value.
+ */
+export class UnstableValue<S extends string, U extends string> extends NamespacedValue<S, U> {
+    // Note: Constructor difference is that `unstable` is *required*.
+    public constructor(stable: S, unstable: U) {
+        super(stable, unstable);
+        if (!this.unstable) {
+            throw new Error("Unstable value must be supplied");
+        }
+    }
+
+    public get name(): U {
+        return this.unstable!;
+    }
+
+    public get altName(): S {
+        return this.stable!;
+    }
+}

package/src/ReEmitter.ts

@@ -1,93 +1,93 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2017 New Vector Ltd
-
-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 { type EventEmitter } from "events";
-
-import { type ListenerMap, type TypedEventEmitter } from "./models/typed-event-emitter.ts";
-
-export class ReEmitter {
-    public constructor(private readonly target: EventEmitter) {}
-
-    // Map from emitter to event name to re-emitter
-    private reEmitters = new WeakMap<EventEmitter, Map<string, (...args: any[]) => void>>();
-
-    public reEmit(source: EventEmitter, eventNames: string[]): void {
-        let reEmittersByEvent = this.reEmitters.get(source);
-        if (!reEmittersByEvent) {
-            reEmittersByEvent = new Map();
-            this.reEmitters.set(source, reEmittersByEvent);
-        }
-
-        for (const eventName of eventNames) {
-            if (reEmittersByEvent.has(eventName)) continue;
-
-            // We include the source as the last argument for event handlers which may need it,
-            // such as read receipt listeners on the client class which won't have the context
-            // of the room.
-            const forSource = (...args: any[]): void => {
-                // EventEmitter special cases 'error' to make the emit function throw if no
-                // handler is attached, which sort of makes sense for making sure that something
-                // handles an error, but for re-emitting, there could be a listener on the original
-                // source object so the test doesn't really work. We *could* try to replicate the
-                // same logic and throw if there is no listener on either the source or the target,
-                // but this behaviour is fairly undesireable for us anyway: the main place we throw
-                // 'error' events is for calls, where error events are usually emitted some time
-                // later by a different part of the code where 'emit' throwing because the app hasn't
-                // added an error handler isn't terribly helpful. (A better fix in retrospect may
-                // have been to just avoid using the event name 'error', but backwards compat...)
-                if (eventName === "error" && this.target.listenerCount("error") === 0) return;
-                this.target.emit(eventName, ...args, source);
-            };
-            source.on(eventName, forSource);
-            reEmittersByEvent.set(eventName, forSource);
-        }
-    }
-
-    public stopReEmitting(source: EventEmitter, eventNames: string[]): void {
-        const reEmittersByEvent = this.reEmitters.get(source);
-        if (!reEmittersByEvent) return; // We were never re-emitting these events in the first place
-
-        for (const eventName of eventNames) {
-            source.off(eventName, reEmittersByEvent.get(eventName)!);
-            reEmittersByEvent.delete(eventName);
-        }
-
-        if (reEmittersByEvent.size === 0) this.reEmitters.delete(source);
-    }
-}
-
-export class TypedReEmitter<Events extends string, Arguments extends ListenerMap<Events>> extends ReEmitter {
-    public constructor(target: TypedEventEmitter<Events, Arguments>) {
-        super(target);
-    }
-
-    public reEmit<ReEmittedEvents extends string, T extends Events & ReEmittedEvents>(
-        source: TypedEventEmitter<ReEmittedEvents, any>,
-        eventNames: T[],
-    ): void {
-        super.reEmit(source, eventNames);
-    }
-
-    public stopReEmitting<ReEmittedEvents extends string, T extends Events & ReEmittedEvents>(
-        source: TypedEventEmitter<ReEmittedEvents, any>,
-        eventNames: T[],
-    ): void {
-        super.stopReEmitting(source, eventNames);
-    }
-}
+/*
+Copyright 2015, 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations Ltd
+Copyright 2017 New Vector Ltd
+
+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 { type EventEmitter } from "events";
+
+import { type ListenerMap, type TypedEventEmitter } from "./models/typed-event-emitter.ts";
+
+export class ReEmitter {
+    public constructor(private readonly target: EventEmitter) {}
+
+    // Map from emitter to event name to re-emitter
+    private reEmitters = new WeakMap<EventEmitter, Map<string, (...args: any[]) => void>>();
+
+    public reEmit(source: EventEmitter, eventNames: string[]): void {
+        let reEmittersByEvent = this.reEmitters.get(source);
+        if (!reEmittersByEvent) {
+            reEmittersByEvent = new Map();
+            this.reEmitters.set(source, reEmittersByEvent);
+        }
+
+        for (const eventName of eventNames) {
+            if (reEmittersByEvent.has(eventName)) continue;
+
+            // We include the source as the last argument for event handlers which may need it,
+            // such as read receipt listeners on the client class which won't have the context
+            // of the room.
+            const forSource = (...args: any[]): void => {
+                // EventEmitter special cases 'error' to make the emit function throw if no
+                // handler is attached, which sort of makes sense for making sure that something
+                // handles an error, but for re-emitting, there could be a listener on the original
+                // source object so the test doesn't really work. We *could* try to replicate the
+                // same logic and throw if there is no listener on either the source or the target,
+                // but this behaviour is fairly undesireable for us anyway: the main place we throw
+                // 'error' events is for calls, where error events are usually emitted some time
+                // later by a different part of the code where 'emit' throwing because the app hasn't
+                // added an error handler isn't terribly helpful. (A better fix in retrospect may
+                // have been to just avoid using the event name 'error', but backwards compat...)
+                if (eventName === "error" && this.target.listenerCount("error") === 0) return;
+                this.target.emit(eventName, ...args, source);
+            };
+            source.on(eventName, forSource);
+            reEmittersByEvent.set(eventName, forSource);
+        }
+    }
+
+    public stopReEmitting(source: EventEmitter, eventNames: string[]): void {
+        const reEmittersByEvent = this.reEmitters.get(source);
+        if (!reEmittersByEvent) return; // We were never re-emitting these events in the first place
+
+        for (const eventName of eventNames) {
+            source.off(eventName, reEmittersByEvent.get(eventName)!);
+            reEmittersByEvent.delete(eventName);
+        }
+
+        if (reEmittersByEvent.size === 0) this.reEmitters.delete(source);
+    }
+}
+
+export class TypedReEmitter<Events extends string, Arguments extends ListenerMap<Events>> extends ReEmitter {
+    public constructor(target: TypedEventEmitter<Events, Arguments>) {
+        super(target);
+    }
+
+    public reEmit<ReEmittedEvents extends string, T extends Events & ReEmittedEvents>(
+        source: TypedEventEmitter<ReEmittedEvents, any>,
+        eventNames: T[],
+    ): void {
+        super.reEmit(source, eventNames);
+    }
+
+    public stopReEmitting<ReEmittedEvents extends string, T extends Events & ReEmittedEvents>(
+        source: TypedEventEmitter<ReEmittedEvents, any>,
+        eventNames: T[],
+    ): void {
+        super.stopReEmitting(source, eventNames);
+    }
+}

package/src/base64.ts

@@ -1,86 +1,86 @@
-/*
-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.
-*/
-
-/**
- * Base64 encoding and decoding utilities
- */
-
-function toBase64(uint8Array: Uint8Array, options: Uint8ArrayToBase64Options): string {
-    if (typeof uint8Array.toBase64 === "function") {
-        // Currently this is only supported in Firefox,
-        // but we match the options in the hope in the future we can rely on it for all environments.
-        // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-uint8array.prototype.tobase64
-        return uint8Array.toBase64(options);
-    }
-
-    let base64 = btoa(uint8Array.reduce((acc, current) => acc + String.fromCharCode(current), ""));
-    if (options.omitPadding) {
-        base64 = base64.replace(/={1,2}$/, "");
-    }
-    if (options.alphabet === "base64url") {
-        base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
-    }
-
-    return base64;
-}
-
-/**
- * Encode a typed array of uint8 as base64.
- * @param uint8Array - The data to encode.
- * @returns The base64.
- */
-export function encodeBase64(uint8Array: Uint8Array): string {
-    return toBase64(uint8Array, { alphabet: "base64", omitPadding: false });
-}
-
-/**
- * Encode a typed array of uint8 as unpadded base64.
- * @param uint8Array - The data to encode.
- * @returns The unpadded base64.
- */
-export function encodeUnpaddedBase64(uint8Array: Uint8Array): string {
-    return toBase64(uint8Array, { alphabet: "base64", omitPadding: true });
-}
-
-/**
- * Encode a typed array of uint8 as unpadded base64 using the URL-safe encoding.
- * @param uint8Array - The data to encode.
- * @returns The unpadded base64.
- */
-export function encodeUnpaddedBase64Url(uint8Array: Uint8Array): string {
-    return toBase64(uint8Array, { alphabet: "base64url", omitPadding: true });
-}
-
-function fromBase64(base64: string, options: Uint8ArrayFromBase64Options): Uint8Array<ArrayBuffer> {
-    if (typeof Uint8Array.fromBase64 === "function") {
-        // Currently this is only supported in Firefox,
-        // but we match the options in the hope in the future we can rely on it for all environments.
-        // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-uint8array.frombase64
-        return Uint8Array.fromBase64(base64, options);
-    }
-
-    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
-}
-
-/**
- * Decode a base64 (or base64url) string to a typed array of uint8.
- * @param base64 - The base64 to decode.
- * @returns The decoded data.
- */
-export function decodeBase64(base64: string): Uint8Array<ArrayBuffer> {
-    // The function requires us to select an alphabet, but we don't know if base64url was used so we convert.
-    return fromBase64(base64.replace(/-/g, "+").replace(/_/g, "/"), { alphabet: "base64", lastChunkHandling: "loose" });
-}
+/*
+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.
+*/
+
+/**
+ * Base64 encoding and decoding utilities
+ */
+
+function toBase64(uint8Array: Uint8Array, options: Uint8ArrayToBase64Options): string {
+    if (typeof uint8Array.toBase64 === "function") {
+        // Currently this is only supported in Firefox,
+        // but we match the options in the hope in the future we can rely on it for all environments.
+        // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-uint8array.prototype.tobase64
+        return uint8Array.toBase64(options);
+    }
+
+    let base64 = btoa(uint8Array.reduce((acc, current) => acc + String.fromCharCode(current), ""));
+    if (options.omitPadding) {
+        base64 = base64.replace(/={1,2}$/, "");
+    }
+    if (options.alphabet === "base64url") {
+        base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+    }
+
+    return base64;
+}
+
+/**
+ * Encode a typed array of uint8 as base64.
+ * @param uint8Array - The data to encode.
+ * @returns The base64.
+ */
+export function encodeBase64(uint8Array: Uint8Array): string {
+    return toBase64(uint8Array, { alphabet: "base64", omitPadding: false });
+}
+
+/**
+ * Encode a typed array of uint8 as unpadded base64.
+ * @param uint8Array - The data to encode.
+ * @returns The unpadded base64.
+ */
+export function encodeUnpaddedBase64(uint8Array: Uint8Array): string {
+    return toBase64(uint8Array, { alphabet: "base64", omitPadding: true });
+}
+
+/**
+ * Encode a typed array of uint8 as unpadded base64 using the URL-safe encoding.
+ * @param uint8Array - The data to encode.
+ * @returns The unpadded base64.
+ */
+export function encodeUnpaddedBase64Url(uint8Array: Uint8Array): string {
+    return toBase64(uint8Array, { alphabet: "base64url", omitPadding: true });
+}
+
+function fromBase64(base64: string, options: Uint8ArrayFromBase64Options): Uint8Array<ArrayBuffer> {
+    if (typeof Uint8Array.fromBase64 === "function") {
+        // Currently this is only supported in Firefox,
+        // but we match the options in the hope in the future we can rely on it for all environments.
+        // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-uint8array.frombase64
+        return Uint8Array.fromBase64(base64, options);
+    }
+
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+}
+
+/**
+ * Decode a base64 (or base64url) string to a typed array of uint8.
+ * @param base64 - The base64 to decode.
+ * @returns The decoded data.
+ */
+export function decodeBase64(base64: string): Uint8Array<ArrayBuffer> {
+    // The function requires us to select an alphabet, but we don't know if base64url was used so we convert.
+    return fromBase64(base64.replace(/-/g, "+").replace(/_/g, "/"), { alphabet: "base64", lastChunkHandling: "loose" });
+}

package/src/briij.ts

@@ -49,6 +49,9 @@ export * from "./scheduler.ts";
 export * from "./filter.ts";
 export * from "./timeline-window.ts";
 export * from "./interactive-auth.ts";
+export * from "./xrpl/identity.ts";
+export * from "./xrpl/trust.ts";
+export * from "./xrpl/verification.ts";
 export * from "./version-support.ts";
 export * from "./service-types.ts";
 export * from "./store/memory.ts";