Prettier fixes

spec/unit/matrix-client.spec.ts

@@ -220,14 +220,12 @@ describe("MatrixClient", function () {
             return Promise.resolve(next.data);
         }
 
-        const receivedRequestQueryString = new URLSearchParams(
+        const receivedRequestQueryString = new URLSearchParams(convertQueryDictToStringRecord(queryParams)).toString();
-            convertQueryDictToStringRecord(queryParams),
-        ).toString();
         const receivedRequestDebugString = `${method} ${prefix}${path}${receivedRequestQueryString}`;
         const expectedQueryString = new URLSearchParams(
             convertQueryDictToStringRecord(next.expectQueryParams),
         ).toString();
-        const expectedRequestDebugString = `${next.method} ${next.prefix ?? ''}${next.path}${expectedQueryString}`;
+        const expectedRequestDebugString = `${next.method} ${next.prefix ?? ""}${next.path}${expectedQueryString}`;
         // If you're seeing this then you forgot to handle at least 1 pending request.
         throw new Error(
             `A pending request was not handled: ${receivedRequestDebugString} ` +
@@ -317,39 +315,40 @@ describe("MatrixClient", function () {
         client.stopClient();
     });
 
-    describe('timestampToEvent', () => {
+    describe("timestampToEvent", () => {
-        const roomId = '!room:server.org';
+        const roomId = "!room:server.org";
         const eventId = "$eventId:example.org";
         const unstableMSC3030Prefix = "/_matrix/client/unstable/org.matrix.msc3030";
 
-        it('should call stable endpoint', async () => {
+        it("should call stable endpoint", async () => {
-            httpLookups = [{
+            httpLookups = [
+                {
                     method: "GET",
                     path: `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
                     data: { event_id: eventId },
                     expectQueryParams: {
-                    ts: '0',
+                        ts: "0",
-                    dir: 'f',
+                        dir: "f",
                     },
-            }];
+                },
+            ];
 
             await client.timestampToEvent(roomId, 0, Direction.Forward);
 
             expect(mocked(client.http.authedRequest).mock.calls.length).toStrictEqual(1);
-            const [method, path, queryParams,, { prefix }] = mocked(client.http.authedRequest).mock.calls[0];
+            const [method, path, queryParams, , { prefix }] = mocked(client.http.authedRequest).mock.calls[0];
-            expect(method).toStrictEqual('GET');
+            expect(method).toStrictEqual("GET");
             expect(prefix).toStrictEqual(ClientPrefix.V1);
-            expect(path).toStrictEqual(
+            expect(path).toStrictEqual(`/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`);
-                `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
-            );
             expect(queryParams).toStrictEqual({
-                ts: '0',
+                ts: "0",
-                dir: 'f',
+                dir: "f",
             });
         });
 
-        it('should fallback to unstable endpoint when no support for stable endpoint', async () => {
+        it("should fallback to unstable endpoint when no support for stable endpoint", async () => {
-            httpLookups = [{
+            httpLookups = [
+                {
                     method: "GET",
                     path: `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
                     prefix: ClientPrefix.V1,
@@ -358,60 +357,51 @@ describe("MatrixClient", function () {
                         errcode: "M_UNRECOGNIZED",
                     },
                     expectQueryParams: {
-                    ts: '0',
+                        ts: "0",
-                    dir: 'f',
+                        dir: "f",
                     },
-            }, {
+                },
+                {
                     method: "GET",
                     path: `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
                     prefix: unstableMSC3030Prefix,
                     data: { event_id: eventId },
                     expectQueryParams: {
-                    ts: '0',
+                        ts: "0",
-                    dir: 'f',
+                        dir: "f",
                     },
-            }];
+                },
+            ];
 
             await client.timestampToEvent(roomId, 0, Direction.Forward);
 
             expect(mocked(client.http.authedRequest).mock.calls.length).toStrictEqual(2);
-            const [
+            const [stableMethod, stablePath, stableQueryParams, , { prefix: stablePrefix }] = mocked(
-                stableMethod,
+                client.http.authedRequest,
-                stablePath,
+            ).mock.calls[0];
-                stableQueryParams,
+            expect(stableMethod).toStrictEqual("GET");
-                ,
-                { prefix: stablePrefix },
-            ] = mocked(client.http.authedRequest).mock.calls[0];
-            expect(stableMethod).toStrictEqual('GET');
             expect(stablePrefix).toStrictEqual(ClientPrefix.V1);
-            expect(stablePath).toStrictEqual(
+            expect(stablePath).toStrictEqual(`/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`);
-                `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
-            );
             expect(stableQueryParams).toStrictEqual({
-                ts: '0',
+                ts: "0",
-                dir: 'f',
+                dir: "f",
             });
 
-            const [
+            const [unstableMethod, unstablePath, unstableQueryParams, , { prefix: unstablePrefix }] = mocked(
-                unstableMethod,
+                client.http.authedRequest,
-                unstablePath,
+            ).mock.calls[1];
-                unstableQueryParams,
+            expect(unstableMethod).toStrictEqual("GET");
-                ,
-                { prefix: unstablePrefix },
-            ] = mocked(client.http.authedRequest).mock.calls[1];
-            expect(unstableMethod).toStrictEqual('GET');
             expect(unstablePrefix).toStrictEqual(unstableMSC3030Prefix);
-            expect(unstablePath).toStrictEqual(
+            expect(unstablePath).toStrictEqual(`/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`);
-                `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
-            );
             expect(unstableQueryParams).toStrictEqual({
-                ts: '0',
+                ts: "0",
-                dir: 'f',
+                dir: "f",
             });
         });
 
-        it('should not fallback to unstable endpoint when stable endpoint returns an error', async () => {
+        it("should not fallback to unstable endpoint when stable endpoint returns an error", async () => {
-            httpLookups = [{
+            httpLookups = [
+                {
                     method: "GET",
                     path: `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
                     prefix: ClientPrefix.V1,
@@ -420,23 +410,22 @@ describe("MatrixClient", function () {
                         errcode: "Fake response error",
                     },
                     expectQueryParams: {
-                    ts: '0',
+                        ts: "0",
-                    dir: 'f',
+                        dir: "f",
                     },
-            }];
+                },
+            ];
 
             await expect(client.timestampToEvent(roomId, 0, Direction.Forward)).rejects.toBeDefined();
 
             expect(mocked(client.http.authedRequest).mock.calls.length).toStrictEqual(1);
-            const [method, path, queryParams,, { prefix }] = mocked(client.http.authedRequest).mock.calls[0];
+            const [method, path, queryParams, , { prefix }] = mocked(client.http.authedRequest).mock.calls[0];
-            expect(method).toStrictEqual('GET');
+            expect(method).toStrictEqual("GET");
             expect(prefix).toStrictEqual(ClientPrefix.V1);
-            expect(path).toStrictEqual(
+            expect(path).toStrictEqual(`/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`);
-                `/rooms/${encodeURIComponent(roomId)}/timestamp_to_event`,
-            );
             expect(queryParams).toStrictEqual({
-                ts: '0',
+                ts: "0",
-                dir: 'f',
+                dir: "f",
             });
         });
     });

src/client.ts

@@ -480,9 +480,9 @@ export interface ICapability {
     enabled: boolean;
 }
 
-export interface IChangePasswordCapability extends ICapability { }
+export interface IChangePasswordCapability extends ICapability {}
 
-export interface IThreadsCapability extends ICapability { }
+export interface IThreadsCapability extends ICapability {}
 
 interface ICapabilities {
     [key: string]: any;
@@ -9269,38 +9269,25 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         try {
-            return await this.http.authedRequest(
+            return await this.http.authedRequest(Method.Get, path, queryParams, undefined, {
-                Method.Get,
-                path,
-                queryParams,
-                undefined,
-                {
                 prefix: ClientPrefix.V1,
-                },
+            });
-            );
         } catch (err) {
             // Fallback to the prefixed unstable endpoint. Since the stable endpoint is
             // new, we should also try the unstable endpoint before giving up. We can
             // remove this fallback request in a year (remove after 2023-11-28).
             if (
-                (<MatrixError>err).errcode === "M_UNRECOGNIZED" && (
+                (<MatrixError>err).errcode === "M_UNRECOGNIZED" &&
                 // XXX: The 400 status code check should be removed in the future
                 // when Synapse is compliant with MSC3743.
-                    (<MatrixError>err).httpStatus === 400 ||
+                ((<MatrixError>err).httpStatus === 400 ||
                     // This the correct standard status code for an unsupported
                     // endpoint according to MSC3743.
-                    (<MatrixError>err).httpStatus === 404
+                    (<MatrixError>err).httpStatus === 404)
-                )
             ) {
-                return await this.http.authedRequest(
+                return await this.http.authedRequest(Method.Get, path, queryParams, undefined, {
-                    Method.Get,
-                    path,
-                    queryParams,
-                    undefined,
-                    {
                     prefix: "/_matrix/client/unstable/org.matrix.msc3030",
-                    },
+                });
-                );
             }
 
             throw err;