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

apps/meteor/client/lib/cachedStores/pipe.ts

@@ -0,0 +1,90 @@
+interface IPipeReturn<D> {
+	slice(skip: number, limit: number): IPipeReturn<D>;
+	sortByField(fieldName: keyof D, direction?: 1 | -1, fallback?: Array<keyof D>): IPipeReturn<D>;
+	sortByField(fieldName: Array<keyof D>, direction?: 1 | -1, fallback?: Array<keyof D>): IPipeReturn<D>;
+	apply(): D[];
+	pipe(p: IPipeReturn<D>): IPipeReturn<D>;
+}
+
+interface IPipeReturnNoInitialData<D> {
+	slice(skip: number, limit: number): IPipeReturnNoInitialData<D>;
+	sortByField(fieldName: keyof D, direction?: 1 | -1, fallback?: Array<keyof D>): IPipeReturnNoInitialData<D>;
+	sortByField(fieldName: Array<keyof D>, direction?: 1 | -1): IPipeReturnNoInitialData<D>;
+	apply(arg: D[]): D[];
+	pipe(p: IPipeReturnNoInitialData<D>): IPipeReturnNoInitialData<D>;
+}
+
+type PipeFunction<D> = (arg: D[]) => D[];
+
+const merge =
+	<D>(fn: PipeFunction<D>, inner: PipeFunction<D>): PipeFunction<D> =>
+	(args) =>
+		fn(inner(args));
+
+export function pipe<D>(): IPipeReturnNoInitialData<D>;
+export function pipe<D>(initialData: D[]): IPipeReturn<D>;
+export function pipe<D>(initialData: D[], acc: PipeFunction<D>): IPipeReturn<D>;
+
+export function pipe<D>(
+	initialData?: any,
+	acc: PipeFunction<D> = (arg) => [...arg],
+): typeof initialData extends undefined ? IPipeReturnNoInitialData<D> : IPipeReturn<D> {
+	return {
+		slice(skip = 0, limit: number) {
+			return pipe<D>(
+				initialData,
+				merge<D>((arr: D[]) => arr.slice(skip, skip + limit), acc),
+			);
+		},
+
+		sortByField(fieldName: keyof D | Array<keyof D>, direction: 1 | -1 = 1, fallback: Array<keyof D> = []) {
+			if (Array.isArray(fieldName)) {
+				return this.sortByField(fieldName[0], direction, fieldName.slice(1));
+			}
+
+			const sort = (fieldName: keyof D, direction: 1 | -1, fallback: Array<keyof D>) => {
+				return (a: D, b: D): number => {
+					const aValue = a[fieldName];
+					const bValue = b[fieldName];
+
+					if (aValue === undefined && bValue === undefined && fallback.length > 0) {
+						const [field, ...rest] = fallback;
+						return sort(field, direction, rest)(a, b);
+					}
+
+					if (aValue === undefined) {
+						return 1;
+					}
+
+					if (bValue === undefined) {
+						return -1;
+					}
+
+					if (aValue instanceof Date && bValue instanceof Date) {
+						return direction * (aValue.getTime() - bValue.getTime());
+					}
+
+					if (typeof aValue === 'string' && typeof bValue === 'string') {
+						return direction * aValue.localeCompare(bValue);
+					}
+					if (typeof aValue === 'number' && typeof bValue === 'number') {
+						return direction * (aValue - bValue);
+					}
+					return 0;
+				};
+			};
+
+			return pipe<D>(
+				initialData,
+				merge((arr: D[]) => [...arr].sort(sort(fieldName, direction, fallback)), acc),
+			);
+		},
+
+		apply: (arg: D[]) => {
+			return acc(initialData ?? arg);
+		},
+		pipe(p: IPipeReturn<D>) {
+			return pipe<D>(initialData, merge(p.apply, acc));
+		},
+	};
+}