show room search filter by default; fix room hierarchy ordering

Author: aine-etke

REUSE.toml

@@ -2180,6 +2180,11 @@ SPDX-FileCopyrightText = [
 ]
 SPDX-License-Identifier = "Apache-2.0"
 
+[[annotations]]
+path = ["src/components/rooms/RoomHierarchy.test.ts"]
+SPDX-FileCopyrightText = ["2026 Nikita Chernyi <https://etke.cc>"]
+SPDX-License-Identifier = "Apache-2.0"
+
 [[annotations]]
 path = ["src/components/rooms/EventLookupDialog.tsx"]
 SPDX-FileCopyrightText = [

src/components/rooms/RoomHierarchy.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from "vitest";
+
+import { HierarchyRoom } from "../../providers/types";
+import { buildTree, isValidOrder, sortChildren } from "./RoomHierarchy";
+
+const makeChild = (
+  state_key: string,
+  origin_server_ts: number,
+  order?: string
+): HierarchyRoom["children_state"][number] => ({
+  type: "m.space.child",
+  state_key,
+  content: { via: ["example.org"], ...(order !== undefined ? { order } : {}) },
+  sender: "@admin:example.org",
+  origin_server_ts,
+});
+
+const makeRoom = (room_id: string, children: HierarchyRoom["children_state"] = []): HierarchyRoom => ({
+  room_id,
+  num_joined_members: 1,
+  guest_can_join: false,
+  world_readable: false,
+  children_state: children,
+});
+
+describe("isValidOrder", () => {
+  it("accepts printable ASCII strings", () => {
+    expect(isValidOrder("1")).toBe(true);
+    expect(isValidOrder("abc")).toBe(true);
+    expect(isValidOrder(" ")).toBe(true); // 0x20
+    expect(isValidOrder("~")).toBe(true); // 0x7E
+  });
+
+  it("rejects empty string", () => {
+    expect(isValidOrder("")).toBe(false);
+  });
+
+  it("rejects non-strings", () => {
+    expect(isValidOrder(undefined)).toBe(false);
+    expect(isValidOrder(null)).toBe(false);
+    expect(isValidOrder(1)).toBe(false);
+  });
+
+  it("rejects strings with control characters", () => {
+    expect(isValidOrder("\x1F")).toBe(false);
+    expect(isValidOrder("\x7F")).toBe(false);
+  });
+
+  it("rejects non-ASCII Unicode that would pass naive string comparison", () => {
+    expect(isValidOrder("\u0100")).toBe(false); // Ā — codepoint 256, above 0x7E
+    expect(isValidOrder("café")).toBe(false); // é is codepoint 233, above 0x7E
+  });
+});
+
+describe("sortChildren", () => {
+  it("sorts lexicographically by order field", () => {
+    const children = [makeChild("!c", 1, "3"), makeChild("!a", 2, "1"), makeChild("!b", 3, "2")];
+    const sorted = sortChildren(children).map(c => c.state_key);
+    expect(sorted).toEqual(["!a", "!b", "!c"]);
+  });
+
+  it("sorts without order by origin_server_ts ascending", () => {
+    const children = [makeChild("!c", 300), makeChild("!a", 100), makeChild("!b", 200)];
+    const sorted = sortChildren(children).map(c => c.state_key);
+    expect(sorted).toEqual(["!a", "!b", "!c"]);
+  });
+
+  it("places ordered children before unordered", () => {
+    const children = [makeChild("!unordered", 1), makeChild("!ordered", 999, "1")];
+    const sorted = sortChildren(children).map(c => c.state_key);
+    expect(sorted).toEqual(["!ordered", "!unordered"]);
+  });
+
+  it("treats empty string order as no order", () => {
+    const children = [makeChild("!empty-order", 1, ""), makeChild("!ordered", 999, "1")];
+    const sorted = sortChildren(children).map(c => c.state_key);
+    expect(sorted).toEqual(["!ordered", "!empty-order"]);
+  });
+
+  it("falls back to origin_server_ts then state_key when order values are equal", () => {
+    const children = [makeChild("!z", 2, "1"), makeChild("!a", 1, "1")];
+    const sorted = sortChildren(children).map(c => c.state_key);
+    expect(sorted).toEqual(["!a", "!z"]);
+  });
+
+  it("uses state_key as final tiebreaker when origin_server_ts equal and no order", () => {
+    const children = [makeChild("!z", 100), makeChild("!a", 100)];
+    const sorted = sortChildren(children).map(c => c.state_key);
+    expect(sorted).toEqual(["!a", "!z"]);
+  });
+
+  it("does not mutate the original array", () => {
+    const children = [makeChild("!b", 1, "2"), makeChild("!a", 2, "1")];
+    const original = [...children];
+    sortChildren(children);
+    expect(children).toEqual(original);
+  });
+});
+
+describe("buildTree", () => {
+  it("returns empty array for empty input", () => {
+    expect(buildTree([])).toEqual([]);
+  });
+
+  it("respects order field when building children", () => {
+    const root = makeRoom("!root", [makeChild("!c", 1, "3"), makeChild("!a", 2, "1"), makeChild("!b", 3, "2")]);
+    const roomA = makeRoom("!a");
+    const roomB = makeRoom("!b");
+    const roomC = makeRoom("!c");
+    const [rootNode] = buildTree([root, roomC, roomA, roomB]);
+    expect(rootNode.children.map(n => n.room.room_id)).toEqual(["!a", "!b", "!c"]);
+  });
+
+  it("handles cycle detection correctly after sort", () => {
+    const roomA = makeRoom("!a", [makeChild("!b", 1)]);
+    const roomB = makeRoom("!b", [makeChild("!a", 2)]);
+    const [rootNode] = buildTree([roomA, roomB]);
+    expect(rootNode.children).toHaveLength(1);
+    expect(rootNode.children[0].children).toHaveLength(0);
+  });
+
+  it("appends orphan rooms after root", () => {
+    const root = makeRoom("!root");
+    const orphan = makeRoom("!orphan");
+    const nodes = buildTree([root, orphan]);
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0].room.room_id).toBe("!root");
+    expect(nodes[1].room.room_id).toBe("!orphan");
+  });
+});

src/components/rooms/RoomHierarchy.tsx

@@ -35,6 +35,37 @@ interface TreeNode {
 
 let nodeKeyCounter = 0;
 
+// Per MSC2946: a valid order value is a non-empty string of printable ASCII characters (0x20–0x7E).
+// Spread iterates Unicode code points so multi-byte characters are caught correctly.
+export const isValidOrder = (o: unknown): o is string =>
+  typeof o === "string" &&
+  o.length > 0 &&
+  [...o].every(c => {
+    const cp = c.codePointAt(0) ?? 0;
+    return cp >= 0x20 && cp <= 0x7e;
+  });
+
+// Sorts m.space.child events per the Matrix spec (MSC2946):
+// 1. Children with a valid `order` string sort first, lexicographically.
+// 2. Children without a valid `order` sort after, by origin_server_ts ascending.
+// 3. Equal order strings, or equal timestamps, fall back to state_key for a stable result.
+export const sortChildren = <T extends { state_key: string; content: { order?: string }; origin_server_ts: number }>(
+  children: T[]
+): T[] =>
+  [...children].sort((a, b) => {
+    const aOrd = isValidOrder(a.content.order) ? a.content.order : undefined;
+    const bOrd = isValidOrder(b.content.order) ? b.content.order : undefined;
+    if (aOrd !== undefined && bOrd !== undefined) {
+      if (aOrd !== bOrd) return aOrd < bOrd ? -1 : 1;
+      // equal order strings → fall through to ts/state_key tiebreaker below
+    } else if (aOrd !== undefined) {
+      return -1;
+    } else if (bOrd !== undefined) {
+      return 1;
+    }
+    return a.origin_server_ts - b.origin_server_ts || a.state_key.localeCompare(b.state_key);
+  });
+
 const collectChildIds = (rooms: HierarchyRoom[]): Set<string> => {
   const knownIds = new Set(rooms.map(r => r.room_id));
   const missing = new Set<string>();
@@ -48,7 +79,7 @@ const collectChildIds = (rooms: HierarchyRoom[]): Set<string> => {
   return missing;
 };
 
-const buildTree = (rooms: HierarchyRoom[]): TreeNode[] => {
+export const buildTree = (rooms: HierarchyRoom[]): TreeNode[] => {
   if (rooms.length === 0) return [];
   nodeKeyCounter = 0;
 
@@ -63,7 +94,7 @@ const buildTree = (rooms: HierarchyRoom[]): TreeNode[] => {
     const key = `${room.room_id}-${nodeKeyCounter++}`;
     const children: TreeNode[] = [];
     if (room.children_state) {
-      for (const child of room.children_state) {
+      for (const child of sortChildren(room.children_state)) {
         if (visited.has(child.state_key)) continue;
         visited.add(child.state_key);
         const knownRoom = roomMap.get(child.state_key);

src/providers/types/rooms.ts

@@ -87,7 +87,12 @@ export interface HierarchyRoom {
   children_state: {
     type: string;
     state_key: string;
-    content: Record<string, unknown>;
+    content: {
+      via?: string[];
+      suggested?: boolean;
+      order?: string;
+      [key: string]: unknown;
+    };
     sender: string;
     origin_server_ts: number;
   }[];

src/resources/rooms/List.tsx

@@ -261,19 +261,18 @@ export const RoomBulkActionButtons = () => {
   );
 };
 
-const RoomSearchInput = () => {
+const RoomSearchInput = (_props: { alwaysOn?: boolean }) => {
   const translate = useTranslate();
   return (
     <SearchInput
       source="search_term"
-      alwaysOn
       slotProps={{ htmlInput: { "aria-label": translate("ra.action.search") } }}
     />
   );
 };
 
 const roomFilters = [
-  <RoomSearchInput key="search_term" />,
+  <RoomSearchInput key="search_term" alwaysOn />,
   <NullableBooleanInput key="public_rooms" source="public_rooms" label="resources.rooms.filter.public_rooms" />,
   <NullableBooleanInput key="empty_rooms" source="empty_rooms" label="resources.rooms.filter.empty_rooms" />,
 ];