Merge branch 'main' into invite-link

src/clients/Fractal.tsx

@@ -37,9 +37,14 @@ const Fractal: TextClient = {
             case LinkKind.Alias:
             case LinkKind.RoomId:
             case LinkKind.UserId:
-                return <span>Click the '+' button in the top right</span>;
+                return (
+                    <span>
+                        Click the '+' button in the top right and paste the
+                        identifier
+                    </span>
+                );
             default:
-                return <span>Weechat doesn't support this kind of link</span>;
+                return <span>Fractal doesn't support this kind of link</span>;
         }
     },
     copyString: (link) => {
@@ -63,7 +68,7 @@ const Fractal: TextClient = {
         }
     },
 
-    description: 'Command-line Matrix interface using Weechat',
+    description: 'Fractal is a Matrix Client written in Rust',
 };
 
 export default Fractal;

src/components/ClientTile.tsx

@@ -39,19 +39,22 @@ const ClientTile: React.FC<IProps> = ({ client, link }: IProps) => {
         clientTileLink: client.kind === ClientKind.LINKED_CLIENT,
     });
 
-    const inviteButton =
+    let inviteButton: JSX.Element = <></>;
-        client.kind === ClientKind.LINKED_CLIENT ? (
+    if (client.kind === ClientKind.LINKED_CLIENT) {
-            <Button>Accept invite</Button>
+        inviteButton = <Button>Accept invite</Button>;
-        ) : (
+    } else {
-            <Button
+        const copyString = client.copyString(link);
-                onClick={() =>
+        if (copyString !== '') {
-                    navigator.clipboard.writeText(client.copyString(link))
+            inviteButton = (
-                }
+                <Button
-                flashChildren="Invite copied"
+                    onClick={() => navigator.clipboard.writeText(copyString)}
-            >
+                    flashChildren="Invite copied"
-                Copy invite
+                >
-            </Button>
+                    Copy invite
-        );
+                </Button>
+            );
+        }
+    }
 
     let clientTile = (
         <Tile className={className}>

src/components/CreateLinkTile.scss

@@ -35,7 +35,7 @@ limitations under the License.
         color: $foreground;
     }
 
-    h1 {
+    .linkHeader h1 {
         word-break: break-all;
     }
 

src/components/CreateLinkTile.tsx

@@ -128,7 +128,7 @@ const LinkCreatedTile: React.FC<ILinkCreatedTileProps> = (props) => {
                 <div>New link</div>
                 <img src={refreshIcon} alt="Go back to matrix.to home page" />
             </button>
-            <h1>{props.link}</h1>
+            <h1 className="linkHeader">{props.link}</h1>
             <Button
                 flashChildren={'Copied'}
                 icon={copyIcon}

src/matrix-cypher/schemas/EventSchema.ts

@@ -17,14 +17,14 @@ limitations under the License.
 import { object, string, TypeOf } from 'zod';
 
 const EventSchema = object({
-  content: object({}).nonstrict(),
+    content: object({}).nonstrict(),
-  type: string(),
+    type: string(),
-  event_id: string(),
+    event_id: string(),
-  sender: string(),
+    sender: string(),
-  origin_server_ts: string(),
+    origin_server_ts: string(),
-  unsigned: object({}).nonstrict().optional(),
+    unsigned: object({}).nonstrict().optional(),
-  room_id: string(),
+    room_id: string(),
-});
+}).nonstrict();
 
 export type Event = TypeOf<typeof EventSchema>;
 export default EventSchema;

src/matrix-cypher/schemas/PublicRoomsSchema.ts

@@ -17,27 +17,25 @@ limitations under the License.
 import { object, array, string, boolean, number, TypeOf } from 'zod';
 
 export const RoomSchema = object({
-  aliases: array(string()).optional(),
+    aliases: array(string()).optional(),
-  canonical_alias: string().optional(),
+    canonical_alias: string().optional(),
-  name: string().optional(),
+    name: string().optional(),
-  num_joined_members: number(),
+    num_joined_members: number(),
-  room_id: string(),
+    room_id: string(),
-  topic: string().optional(),
+    topic: string().optional(),
-  world_readable: boolean(),
+    world_readable: boolean(),
-  guest_can_join: boolean(),
+    guest_can_join: boolean(),
-  avatar_url: string().optional(),
+    avatar_url: string().optional(),
-});
+}).nonstrict();
-
 
 const PublicRoomsSchema = object({
-  chunk: array(RoomSchema),
+    chunk: array(RoomSchema),
-  next_batch: string().optional(),
+    next_batch: string().optional(),
-  prev_batch: string().optional(),
+    prev_batch: string().optional(),
-  total_room_count_estimate: number().optional(),
+    total_room_count_estimate: number().optional(),
-});
+}).nonstrict();
 
 export type Room = TypeOf<typeof RoomSchema>;
 export type PublicRooms = TypeOf<typeof PublicRoomsSchema>;
 
 export default PublicRoomsSchema;
-

src/matrix-cypher/schemas/RoomAliasSchema.ts

@@ -17,10 +17,9 @@ limitations under the License.
 import { object, array, string, TypeOf } from 'zod';
 
 const RoomAliasSchema = object({
-  room_id: string(),
+    room_id: string(),
-  servers: array(string()),
+    servers: array(string()),
-});
+}).nonstrict();
 
 export type RoomAlias = TypeOf<typeof RoomAliasSchema>;
 export default RoomAliasSchema;
-

src/matrix-cypher/schemas/UserSchema.ts

@@ -17,10 +17,9 @@ limitations under the License.
 import { object, string, TypeOf } from 'zod';
 
 const UserSchema = object({
-  avatar_url: string().optional(),
+    avatar_url: string().optional(),
-  displayname: string().optional(),
+    displayname: string().optional(),
-})
+}).nonstrict();
 
 export type User = TypeOf<typeof UserSchema>;
 export default UserSchema;
-

src/matrix-cypher/schemas/WellKnownSchema.ts

@@ -17,13 +17,13 @@ limitations under the License.
 import { object, string, TypeOf } from 'zod';
 
 const WellKnownSchema = object({
-  'm.homeserver': object({
+    'm.homeserver': object({
-    'base_url': string().url(),
+        base_url: string().url(),
-  }),
+    }),
-  'm.identity_server': object({
+    'm.identity_server': object({
-    'base_url': string().url(),
+        base_url: string().url(),
-  }),
+    }).optional(),
-});
+}).nonstrict();
 
 export type WellKnown = TypeOf<typeof WellKnownSchema>;
 export default WellKnownSchema;

src/parser/parser.ts

@@ -16,13 +16,13 @@ import {
  */
 type Verifier<A> = [RegExp, A];
 export const roomVerifiers: Verifier<LinkKind.Alias | LinkKind.RoomId>[] = [
-    [/^#([^/:]+?):(.+)$/, LinkKind.Alias],
+    [/^#([^:]*):(.+)$/, LinkKind.Alias],
-    [/^!([^/:]+?):(.+)$/, LinkKind.RoomId],
+    [/^!([^:]*):(.+)$/, LinkKind.RoomId],
 ];
 export const verifiers: Verifier<LinkKind>[] = [
-    [/^[!#]([^/:]+?):(.+?)\/\$([^/:]+?)$/, LinkKind.Permalink],
+    [/^[!#]([^:]*):(.+)\/\$([^:]+):(.+)$/, LinkKind.Permalink],
-    [/^@([^/:]+?):(.+)$/, LinkKind.UserId],
+    [/^@([^:]+):(.+)$/, LinkKind.UserId],
-    [/^\+([^/:]+?):(.+)$/, LinkKind.GroupId],
+    [/^\+([^:]+):(.+)$/, LinkKind.GroupId],
     ...roomVerifiers,
 ];