fix(mobile): support Hermes collection sorting

Reuses the focused compatibility approach from closed PR #3923 and covers the remaining hardware-keyboard reverse iteration.

Julius Marminge committed 3 months ago

Commit cd2556b1 parent 6c344388 files · +72 −24Browse files

Unified · Split

8 files

apps/mobile/src/features/keyboard/hardwareKeyboardCommands.ts +4 −1
apps/mobile/src/features/threads/ThreadRelationshipsBanner.tsx +4 −2
apps/mobile/src/state/use-thread-selection.ts +16 −2
packages/client-runtime/src/state/threadWorkflows.ts +12 −13
packages/shared/package.json +4 −0
packages/shared/src/Array.test.ts +12 −0
packages/shared/src/Array.ts +6 −0
packages/shared/src/model.ts +14 −6

apps/mobile/src/features/keyboard/hardwareKeyboardCommands.ts+4−1

 export function dispatchHardwareKeyboardCommand(command: HardwareKeyboardCommand): boolean {
   const commandHandlers = handlers.get(command);
   if (!commandHandlers) return false;
-  for (const handler of [...commandHandlers].toReversed()) {
+  const handlersInRegistrationOrder = Array.from(commandHandlers);
+  for (let index = handlersInRegistrationOrder.length - 1; index >= 0; index -= 1) {
+    const handler = handlersInRegistrationOrder[index];
+    if (!handler) continue;
     if (handler() !== false) return true;
   }
   return false;

apps/mobile/src/features/threads/ThreadRelationshipsBanner.tsx+4−2

 } from "@t3tools/client-runtime/state/thread-relationships";
 import { canDetachThreadProviderSession } from "@t3tools/client-runtime/state/thread-workflows";
 import type { EnvironmentId, OrchestrationV2ThreadShell, ThreadId } from "@t3tools/contracts";
-import { useRouter } from "expo-router";
+import { copySorted } from "@t3tools/shared/Array";
+import { useNavigation } from "@react-navigation/native";
 import { useMemo, useState } from "react";
 import { ActivityIndicator, Modal, Pressable, ScrollView, View } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
   const mergeTargetThreadId = resolveMergeBackTargetThreadId(projection);
   const rows = useMemo(
     () =>
-      immediateThreadRelationships(graph, props.threadId).toSorted(
+      copySorted(
+        immediateThreadRelationships(graph, props.threadId),
         (left, right) =>
           Number(right.threadId === mergeTargetThreadId) -
           Number(left.threadId === mergeTargetThreadId),

apps/mobile/src/state/use-thread-selection.ts+16−2

 } from "@t3tools/contracts";
 import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
 import * as Option from "effect/Option";
+import { copySorted } from "@t3tools/shared/Array";
 import { useProject, useThreadShell } from "../state/entities";
 import { useEnvironmentThread } from "../state/threads";
   environmentId: EnvironmentId,
   thread: OrchestrationThread,
 ): EnvironmentThreadShell {
-  return {
+  const thread = projection.thread;
-    environmentId,
+  const runsByOrdinal = copySorted(projection.runs, (left, right) => right.ordinal - left.ordinal);
+  const latestRun = runsByOrdinal[0] ?? null;
+  const activeRun =
+    runsByOrdinal.find(
+      (run) =>
+        run.status === "preparing" ||
+        run.status === "queued" ||
+        run.status === "starting" ||
+        run.status === "running" ||
+        run.status === "waiting",
+    ) ?? null;
+  const pendingRequest =
+    projection.runtimeRequests.find((request) => request.status === "pending") ?? null;
+  return presentThreadShell(environmentId, {
     id: thread.id,
     projectId: thread.projectId,
     title: thread.title,

packages/client-runtime/src/state/threadWorkflows.ts+12−13

@@ -3,6 +3,7 @@ import type { · 2 unmodified lines
3	OrchestrationV2ProviderCapabilities,	3	OrchestrationV2ProviderCapabilities,
4	OrchestrationV2ThreadProjection,	4	OrchestrationV2ThreadProjection,
5	} from "@t3tools/contracts";	5	} from "@t3tools/contracts";
		6	import { copySorted } from "@t3tools/shared/Array";
6		7
7	type Projection = OrchestrationV2ThreadProjection;	8	type Projection = OrchestrationV2ThreadProjection;
8	type Run = Projection["runs"][number];	9	type Run = Projection["runs"][number];
@@ -54,19 +55,17 @@ export function deriveThreadQueueWorkflowState(projection: Projection): ThreadQu · 45 unmodified lines
54	const activeRun = resolveActiveThreadRun(projection);	55	const activeRun = resolveActiveThreadRun(projection);
55	const session = resolveThreadProviderSession(projection);	56	const session = resolveThreadProviderSession(projection);
56	const capabilities = session?.capabilities.turns;	57	const capabilities = session?.capabilities.turns;
57	const queuedRuns = projection.runs	58	const queuedRuns = copySorted(
58	.filter((run) => run.status === "queued")	59	projection.runs.filter((run) => run.status === "queued"),
59	.toSorted(	60	(left, right) =>
60	(left, right) =>	61	(left.queuePosition ?? left.ordinal) - (right.queuePosition ?? right.ordinal) \|\|
61	(left.queuePosition ?? left.ordinal) - (right.queuePosition ?? right.ordinal) \|\|	62	left.ordinal - right.ordinal,
62	left.ordinal - right.ordinal,	63	).map((run) => ({
63	)	64	run,
64	.map((run) => ({	65	text:
65	run,	66	projection.messages.find((message) => message.id === run.userMessageId)?.text ??
66	text:	67	"Queued message",
67	projection.messages.find((message) => message.id === run.userMessageId)?.text ??	68	}));
68	"Queued message",
69	}));
70		69
71	return {	70	return {
72	activeRun,	71	activeRun,

packages/shared/package.json+4−0

   "private": true,
   "type": "module",
   "exports": {
+    "./Array": {
+      "types": "./src/Array.ts",
+      "import": "./src/Array.ts"
+    },
     "./themePalettes": {
       "types": "./src/themePalettes.ts",
       "import": "./src/themePalettes.ts"

packages/shared/src/Array.test.ts+12−0

@@ -0,0 +1,12 @@
	1	import { describe, expect, it } from "vite-plus/test";
	2
	3	import { copySorted } from "./Array.ts";
	4
	5	describe("array copies", () => {
	6	it("sorts a copy without mutating the source", () => {
	7	const source = [3, 1, 2];
	8
	9	expect(copySorted(source, (left: number, right: number) => left - right)).toEqual([1, 2, 3]);
	10	expect(source).toEqual([3, 1, 2]);
	11	});
	12	});

packages/shared/src/Array.ts+6−0

@@ -0,0 +1,6 @@
	1	export function copySorted<T>(
	2	values: ReadonlyArray<T>,
	3	compareFn?: (left: T, right: T) => number,
	4	): T[] {
	5	return [...values].sort(compareFn);
	6	}

packages/shared/src/model.ts+14−6

   type ProviderOptionDescriptor,
   type ProviderOptionSelection,
 } from "@t3tools/contracts";
-import * as Option from "effect/Option";
+import { copySorted } from "./Array.ts";
-import * as Schema from "effect/Schema";
 const DEFAULT_PROVIDER_DRIVER_KIND = ProviderDriverKind.make("codex");
 function canonicalModelSelectionOptions(
   modelSelection: ModelSelection,
 ): ReadonlyArray<readonly [id: string, value: string | boolean]> {
-  return (modelSelection.options ?? [])
+  return copySorted(
-    .map((selection) => [selection.id, selection.value] as const)
+    (modelSelection.options ?? []).map(
-    .toSorted(([leftId, leftValue], [rightId, rightValue]) => {
+      (selection): readonly [id: string, value: string | boolean] => [
+        selection.id,
+        selection.value,
+      ],
+    ),
+    (
+      [leftId, leftValue]: readonly [id: string, value: string | boolean],
+      [rightId, rightValue]: readonly [id: string, value: string | boolean],
+    ) => {
       const idOrder = leftId.localeCompare(rightId);
       return idOrder !== 0 ? idOrder : String(leftValue).localeCompare(String(rightValue));
-    });
+    },
+  );
 }
 /**

fix(mobile): support Hermes collection sorting

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code