snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/client/router/index.tsx

@@ -0,0 +1,343 @@
+import type { RoomType, RoomRouteData } from '@rocket.chat/core-typings';
+import { Emitter } from '@rocket.chat/emitter';
+import type {
+	LocationHash,
+	LocationPathname,
+	LocationSearch,
+	RouteName,
+	RouteObject,
+	RouteParameters,
+	RouterContextValue,
+	SearchParameters,
+	To,
+} from '@rocket.chat/ui-contexts';
+
+import { Context, Page } from './page';
+import { appLayout } from '../lib/appLayout';
+import { getRootUrlPathPrefix } from '../lib/meteorRuntimeConfig';
+import { roomCoordinator } from '../lib/rooms/roomCoordinator';
+
+export class Router implements RouterContextValue {
+	private readonly pathRegExp = /(:[\w\(\)\\\+\*\.\?\[\]\-]+)+/g;
+
+	private readonly queryRegExp = /\?([^\/\r\n].*)/;
+
+	private current:
+		| Readonly<{
+				path: string;
+				params: Map<string, string>;
+				route: Route;
+				context: Context;
+				oldRoute: Route | undefined;
+				queryParams: URLSearchParams;
+		  }>
+		| undefined = undefined;
+
+	private readonly specialChars = ['/', '%', '+'];
+
+	private initialized = false;
+
+	private routes = new Set<Route>();
+
+	private pathDefById = new Map<Route['pathDef'], Route['id']>();
+
+	private readonly basePath = getRootUrlPathPrefix();
+
+	private readonly page = new Page();
+
+	constructor() {
+		this.registerRoute('*', { id: 'not-found' });
+		this.updateCallbacks();
+	}
+
+	private emitter = new Emitter<{ pathChanged: void }>();
+
+	private registerRoute(pathDef: string, options: RouteOptions) {
+		if (!/^\//.test(pathDef) && pathDef !== '*') {
+			throw new Error("route's path must start with '/'");
+		}
+
+		const route = new Route(pathDef, options);
+
+		route.actionHandle = (context: Context) => {
+			const oldRoute = this.current?.route;
+
+			const queryParams = new URLSearchParams(context.querystring);
+			this.current = Object.freeze({
+				path: context.path,
+				params: new Map(Object.entries<string>(context.params)),
+				route,
+				context,
+				oldRoute,
+				queryParams,
+			});
+
+			this.refresh();
+		};
+
+		this.routes.add(route);
+		this.pathDefById.set(options.id, route.pathDef);
+
+		this.updateCallbacks();
+
+		return route;
+	}
+
+	private encodePath(
+		idOrPathDef: string,
+		params: Record<string, string | null> = {},
+		queryParams: Record<string, string | null> = {},
+	): string {
+		if (this.pathDefById.has(idOrPathDef)) {
+			idOrPathDef = this.pathDefById.get(idOrPathDef) ?? idOrPathDef;
+		}
+
+		if (this.queryRegExp.test(idOrPathDef)) {
+			const [pathDefPart, searchPart] = idOrPathDef.split(this.queryRegExp);
+			idOrPathDef = pathDefPart;
+			if (searchPart) {
+				queryParams = Object.assign(Object.fromEntries(new URLSearchParams(searchPart).entries()), queryParams);
+			}
+		}
+
+		let path = '';
+
+		if (this.basePath) {
+			path += `/${this.basePath}/`;
+		}
+
+		path += idOrPathDef.replace(this.pathRegExp, (_key) => {
+			const firstRegexpChar = _key.indexOf('(');
+			let key = _key.substring(1, firstRegexpChar > 0 ? firstRegexpChar : undefined);
+			key = key.replace(/[\+\*\?]+/g, '');
+
+			if (params[key]) {
+				return this.encodeParam(`${params[key]}`);
+			}
+
+			return '';
+		});
+
+		path = path.replace(/\/\/+/g, '/');
+
+		path = path.match(/^\/{1}$/) ? path : path.replace(/\/$/, '');
+
+		const strQueryParams = new URLSearchParams(
+			Object.entries(queryParams).filter((pair): pair is [string, string] => pair[1] !== null && pair[1] !== undefined),
+		).toString();
+		if (strQueryParams) {
+			path += `?${strQueryParams}`;
+		}
+
+		path = path.replace(/\/\/+/g, '/');
+		return path;
+	}
+
+	private encodeParam(param: string) {
+		const paramArr = param.split('');
+		let buffer = '';
+		for (const p of paramArr) {
+			if (this.specialChars.includes(p)) {
+				buffer += encodeURIComponent(encodeURIComponent(p));
+			} else {
+				try {
+					buffer += encodeURIComponent(p);
+				} catch (e) {
+					buffer += p;
+				}
+			}
+		}
+		return buffer;
+	}
+
+	private initialize() {
+		if (this.initialized) {
+			throw new Error('FlowRouter is already initialized');
+		}
+
+		this.updateCallbacks();
+
+		this.page.setBase(this.basePath);
+
+		this.page.start();
+		this.initialized = true;
+
+		queueMicrotask(() => {
+			this.emitter.emit('pathChanged');
+		});
+	}
+
+	private refresh() {
+		if (!this.current?.route) return;
+
+		const currentContext = this.current;
+		const { route } = currentContext;
+
+		let isRouteChange = currentContext.oldRoute !== currentContext.route;
+		if (!currentContext.oldRoute) {
+			isRouteChange = false;
+		}
+
+		if (!isRouteChange) {
+			this.emitter.emit('pathChanged');
+		}
+
+		route.action();
+
+		queueMicrotask(() => {
+			this.emitter.emit('pathChanged');
+		});
+	}
+
+	private updateCallbacks() {
+		this.page.clearRoutes();
+
+		let catchAll: Route | null = null;
+
+		for (const route of this.routes) {
+			if (route.pathDef === '*') {
+				catchAll = route;
+			} else {
+				this.page.registerRoute(route.pathDef, route.actionHandle);
+			}
+		}
+
+		if (catchAll) {
+			this.page.registerRoute(catchAll.pathDef, catchAll.actionHandle);
+		}
+	}
+
+	// router context implementation
+
+	readonly subscribeToRouteChange = (onRouteChange: () => void): (() => void) => {
+		const unsubscribe = this.emitter.on('pathChanged', onRouteChange);
+
+		// FIXME: for some reason this is (and was) necessary to invoke some route actions
+		this.emitter.emit('pathChanged');
+
+		return () => {
+			unsubscribe();
+		};
+	};
+
+	readonly getLocationPathname = () => this.current?.path.replace(/\?.*/, '') as LocationPathname;
+
+	readonly getLocationSearch = () => location.search as LocationSearch;
+
+	readonly getLocationHash = () => location.hash as LocationHash;
+
+	readonly getRouteParameters = () => (this.current?.params ? (Object.fromEntries(this.current.params.entries()) as RouteParameters) : {});
+
+	readonly getSearchParameters = () =>
+		this.current?.queryParams ? (Object.fromEntries(this.current.queryParams.entries()) as SearchParameters) : {};
+
+	readonly getRouteName = () => this.current?.route?.id as RouteName | undefined;
+
+	readonly getPreviousRouteName = () => this.current?.oldRoute?.id as RouteName | undefined;
+
+	private encodeSearchParameters(searchParameters: SearchParameters) {
+		const search = new URLSearchParams();
+
+		for (const [key, value] of Object.entries(searchParameters)) {
+			search.append(key, value);
+		}
+
+		const searchString = search.toString();
+
+		return searchString ? `?${searchString}` : '';
+	}
+
+	readonly buildRoutePath = (to: To): LocationPathname | `${LocationPathname}?${LocationSearch}` => {
+		if (typeof to === 'string') {
+			return to;
+		}
+
+		if ('pathname' in to) {
+			const { pathname, search = {} } = to;
+			return (pathname + this.encodeSearchParameters(search)) as LocationPathname | `${LocationPathname}?${LocationSearch}`;
+		}
+
+		if ('pattern' in to) {
+			const { pattern, params = {}, search = {} } = to;
+			return this.encodePath(pattern, params, search) as LocationPathname | `${LocationPathname}?${LocationSearch}`;
+		}
+
+		if ('name' in to) {
+			const { name, params = {}, search = {} } = to;
+			return this.encodePath(name, params, search) as LocationPathname | `${LocationPathname}?${LocationSearch}`;
+		}
+
+		throw new Error('Invalid route');
+	};
+
+	readonly navigate = (
+		toOrDelta: To | number,
+		options?: {
+			replace?: boolean;
+		},
+	) => {
+		if (typeof toOrDelta === 'number') {
+			history.go(toOrDelta);
+			return;
+		}
+
+		const path = this.buildRoutePath(toOrDelta);
+		const state = { path };
+
+		if (options?.replace) {
+			history.replaceState(state, '', path);
+		} else {
+			history.pushState(state, '', path);
+		}
+
+		dispatchEvent(new PopStateEvent('popstate', { state }));
+	};
+
+	readonly defineRoutes = (routes: readonly RouteObject[]) => {
+		if (!this.initialized) this.initialize();
+
+		const flowRoutes = routes.map((route) =>
+			this.registerRoute(route.path, {
+				id: route.id,
+				action: () => appLayout.render(<>{route.element}</>),
+			}),
+		);
+
+		if (this.current) this.page.dispatch(new Context(this.page, this.current.path));
+
+		return () => {
+			flowRoutes.forEach((flowRoute) => {
+				this.routes.delete(flowRoute);
+				this.pathDefById.delete(flowRoute.id);
+			});
+
+			this.updateCallbacks();
+			if (this.current) this.page.dispatch(new Context(this.page, this.current.path));
+		};
+	};
+
+	readonly getRoomRoute = (roomType: RoomType, routeData: RoomRouteData) => {
+		return { path: roomCoordinator.getRouteLink(roomType, routeData) || '/' };
+	};
+}
+
+type RouteOptions = {
+	id: string;
+	action?: () => void;
+};
+
+class Route {
+	readonly action: () => void | Promise<void>;
+
+	readonly id: string;
+
+	constructor(
+		public readonly pathDef: string,
+		public readonly options: RouteOptions,
+	) {
+		this.action = options.action ?? (() => undefined);
+		this.id = options.id;
+	}
+
+	actionHandle: (ctx: Context) => void;
+}