Skip to content

Commit eeb5a1e

Browse files
fix(mobile): disable thread moves requiring unsupported writes
1 parent a863151 commit eeb5a1e

5 files changed

Lines changed: 167 additions & 65 deletions

File tree

‎apps/mobile/src/features/home/HomeScreen.tsx‎

Lines changed: 29 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import { createThreadMovePlanner } from "../threads/threadOrder";
12
import {
23
LegendList,
34
type LegendListRef,
@@ -646,18 +647,31 @@ export function HomeScreen(props: HomeScreenProps) {
646647
[serverConfigs],
647648
);
648649
const pendingOrder = usePendingThreadOrder(nowMinute, snoozeWakeTick);
649-
const arrangedThreadKeys = useMemo(() => {
650-
const sectionKeys = (section: "pinned" | "active") =>
651-
getThreadListV2OrderedSection({
652-
threads: props.threads,
650+
const threadMovePlanners = useMemo(() => {
651+
const sectionPlanner = (section: "pinned" | "active") =>
652+
createThreadMovePlanner({
653653
section,
654-
pendingOrder,
655-
now: new Date().toISOString(),
656-
settlementEnvironmentIds,
657-
snoozeEnvironmentIds,
658-
}).map((thread) => `${thread.environmentId}:${thread.id}`);
659-
return { pinned: sectionKeys("pinned"), active: sectionKeys("active") };
654+
reorderableEnvironmentIds: new Set(
655+
[...serverConfigs].flatMap(([id, config]) =>
656+
(section === "pinned"
657+
? config.environment.capabilities.threadPinReorder
658+
: config.environment.capabilities.threadActiveReorder) === true
659+
? [id]
660+
: [],
661+
),
662+
),
663+
ordered: getThreadListV2OrderedSection({
664+
threads: props.threads,
665+
section,
666+
pendingOrder,
667+
now: new Date().toISOString(),
668+
settlementEnvironmentIds,
669+
snoozeEnvironmentIds,
670+
}),
671+
});
672+
return { pinned: sectionPlanner("pinned"), active: sectionPlanner("active") };
660673
}, [
674+
serverConfigs,
661675
props.threads,
662676
pendingOrder,
663677
settlementEnvironmentIds,
@@ -810,8 +824,8 @@ export function HomeScreen(props: HomeScreenProps) {
810824
);
811825
}
812826
const thread = item.item.thread;
813-
const sectionKeys = item.item.pinned ? arrangedThreadKeys.pinned : arrangedThreadKeys.active;
814-
const sectionIndex = sectionKeys.indexOf(`${thread.environmentId}:${thread.id}`);
827+
const movePlanner = item.item.pinned ? threadMovePlanners.pinned : threadMovePlanners.active;
828+
const movedId = `${thread.environmentId}:${thread.id}`;
815829
return (
816830
<ThreadListV2Row
817831
thread={thread}
@@ -863,10 +877,8 @@ export function HomeScreen(props: HomeScreenProps) {
863877
? pinReorderEnvironmentIds.has(thread.environmentId)
864878
: activeReorderEnvironmentIds.has(thread.environmentId)
865879
}
866-
canMoveUp={pendingOrder === null && sectionIndex > 0}
867-
canMoveDown={
868-
pendingOrder === null && sectionIndex !== -1 && sectionIndex < sectionKeys.length - 1
869-
}
880+
canMoveUp={pendingOrder === null && movePlanner(movedId, "up") !== null}
881+
canMoveDown={pendingOrder === null && movePlanner(movedId, "down") !== null}
870882
onSnoozeThread={handleSnoozeThread}
871883
onUnsnoozeThread={handleUnsnoozeThread}
872884
onUnsettleThread={handleUnsettleThread}
@@ -884,7 +896,7 @@ export function HomeScreen(props: HomeScreenProps) {
884896
[
885897
handleDeleteThread,
886898
activeReorderEnvironmentIds,
887-
arrangedThreadKeys,
899+
threadMovePlanners,
888900
pendingOrder,
889901
handleMoveThread,
890902
handlePinThread,

‎apps/mobile/src/features/home/useThreadListActions.ts‎

Lines changed: 8 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,13 @@ import { Alert } from "react-native";
88
import { showConfirmDialog } from "../../components/ConfirmDialogHost";
99
import { scopedThreadKey } from "../../lib/scopedEntities";
1010
import { refreshArchivedThreadsForEnvironment } from "../archive/useArchivedThreadSnapshots";
11-
import { pinOrderKeyBetween, planPinnedMove } from "@t3tools/client-runtime/state/thread-sort";
11+
import { pinOrderKeyBetween } from "@t3tools/client-runtime/state/thread-sort";
1212
import { appAtomRegistry } from "../../state/atom-registry";
1313
import { environmentServerConfigsAtom } from "../../state/server";
1414
import { environmentThreadShells, threadEnvironment } from "../../state/threads";
1515
import { useAtomCommand } from "../../state/use-atom-command";
1616
import { beginPendingThreadOrder, getPendingThreadOrder } from "../../state/thread-order";
17-
import { createPendingThreadOrder } from "../threads/threadOrder";
17+
import { createPendingThreadOrder, createThreadMovePlanner } from "../threads/threadOrder";
1818
import { getThreadListV2OrderedSection } from "../threads/threadListV2";
1919

2020
/** Version skew: never send settle/unsettle to a server that predates them
@@ -491,34 +491,15 @@ export function useThreadListActions(): {
491491
),
492492
),
493493
});
494-
const orderedIds = ordered.map((shell) => scopedThreadKey(shell.environmentId, shell.id));
495-
const assignments = planPinnedMove({
496-
orderedIds,
497-
keysById: new Map(
498-
ordered.map((shell) => [
499-
scopedThreadKey(shell.environmentId, shell.id),
500-
(section === "pinned" ? shell.pinOrderKey : shell.activeOrderKey) ?? null,
501-
]),
502-
),
503-
movedId: scopedThreadKey(thread.environmentId, thread.id),
504-
direction,
505-
});
506-
if (assignments === null || assignments.length === 0) return false;
494+
const assignments = createThreadMovePlanner({
495+
ordered,
496+
section,
497+
reorderableEnvironmentIds: new Set([...configs.keys()].filter(supportsReorder)),
498+
})(scopedThreadKey(thread.environmentId, thread.id), direction);
499+
if (assignments === null) return false;
507500
const shellByKey = new Map(
508501
ordered.map((shell) => [scopedThreadKey(shell.environmentId, shell.id), shell]),
509502
);
510-
if (
511-
assignments.some((assignment) => {
512-
const target = shellByKey.get(assignment.id);
513-
return target === undefined || !supportsReorder(target.environmentId);
514-
})
515-
) {
516-
Alert.alert(
517-
"Could not move thread",
518-
"Update the other environments in this list before moving across threads without a saved order.",
519-
);
520-
return false;
521-
}
522503
selectionHaptic();
523504
const pending = beginPendingThreadOrder(
524505
createPendingThreadOrder({

‎apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx‎

Lines changed: 31 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import { createThreadMovePlanner } from "./threadOrder";
12
import type {
23
EnvironmentProject,
34
EnvironmentThreadShell,
@@ -474,18 +475,31 @@ function ThreadNavigationSidebarPane(
474475
[serverConfigs],
475476
);
476477
const pendingOrder = usePendingThreadOrder(nowMinute, snoozeWakeTick);
477-
const arrangedThreadKeys = useMemo(() => {
478-
const sectionKeys = (section: "pinned" | "active") =>
479-
getThreadListV2OrderedSection({
480-
threads,
478+
const threadMovePlanners = useMemo(() => {
479+
const sectionPlanner = (section: "pinned" | "active") =>
480+
createThreadMovePlanner({
481481
section,
482-
pendingOrder,
483-
now: new Date().toISOString(),
484-
settlementEnvironmentIds,
485-
snoozeEnvironmentIds,
486-
}).map((thread) => `${thread.environmentId}:${thread.id}`);
487-
return { pinned: sectionKeys("pinned"), active: sectionKeys("active") };
482+
reorderableEnvironmentIds: new Set(
483+
[...serverConfigs].flatMap(([id, config]) =>
484+
(section === "pinned"
485+
? config.environment.capabilities.threadPinReorder
486+
: config.environment.capabilities.threadActiveReorder) === true
487+
? [id]
488+
: [],
489+
),
490+
),
491+
ordered: getThreadListV2OrderedSection({
492+
threads,
493+
section,
494+
pendingOrder,
495+
now: new Date().toISOString(),
496+
settlementEnvironmentIds,
497+
snoozeEnvironmentIds,
498+
}),
499+
});
500+
return { pinned: sectionPlanner("pinned"), active: sectionPlanner("active") };
488501
}, [
502+
serverConfigs,
489503
threads,
490504
pendingOrder,
491505
settlementEnvironmentIds,
@@ -872,10 +886,10 @@ function ThreadNavigationSidebarPane(
872886
}
873887
case "v2-thread": {
874888
const thread = item.item.thread;
875-
const sectionKeys = item.item.pinned
876-
? arrangedThreadKeys.pinned
877-
: arrangedThreadKeys.active;
878-
const sectionIndex = sectionKeys.indexOf(`${thread.environmentId}:${thread.id}`);
889+
const movePlanner = item.item.pinned
890+
? threadMovePlanners.pinned
891+
: threadMovePlanners.active;
892+
const movedId = `${thread.environmentId}:${thread.id}`;
879893
const scopeKey = scopedProjectKey(thread.environmentId, thread.projectId);
880894
return (
881895
<ThreadListV2Row
@@ -928,12 +942,8 @@ function ThreadNavigationSidebarPane(
928942
? pinReorderEnvironmentIds.has(thread.environmentId)
929943
: activeReorderEnvironmentIds.has(thread.environmentId)
930944
}
931-
canMoveUp={pendingOrder === null && sectionIndex > 0}
932-
canMoveDown={
933-
pendingOrder === null &&
934-
sectionIndex !== -1 &&
935-
sectionIndex < sectionKeys.length - 1
936-
}
945+
canMoveUp={pendingOrder === null && movePlanner(movedId, "up") !== null}
946+
canMoveDown={pendingOrder === null && movePlanner(movedId, "down") !== null}
937947
onSnoozeThread={snoozeThread}
938948
onUnsnoozeThread={unsnoozeThread}
939949
onUnsettleThread={unsettleThread}
@@ -1068,7 +1078,7 @@ function ThreadNavigationSidebarPane(
10681078
[
10691079
archiveThread,
10701080
activeReorderEnvironmentIds,
1071-
arrangedThreadKeys,
1081+
threadMovePlanners,
10721082
pendingOrder,
10731083
confirmDeletePendingTask,
10741084
confirmDeleteThread,

‎apps/mobile/src/features/threads/threadListV2.test.ts‎

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
import { planPinnedMove } from "@t3tools/client-runtime/state/thread-sort";
22
import {
33
createPendingThreadOrder,
4+
createThreadMovePlanner,
45
reconcilePendingThreadOrder,
56
type PendingThreadOrder,
67
} from "./threadOrder";
@@ -1135,3 +1136,72 @@ describe("pending mobile thread moves", () => {
11351136
).toBeNull();
11361137
});
11371138
});
1139+
1140+
describe("mobile move availability", () => {
1141+
const oldEnvironment = EnvironmentId.make("older-server");
1142+
function rows(section: "active" | "pinned", keys: readonly (string | null)[]) {
1143+
return keys.map((key, index) =>
1144+
makeThread({
1145+
id: ThreadId.make(`move-${index}`),
1146+
title: `Move ${index}`,
1147+
environmentId: index === 1 ? oldEnvironment : environmentId,
1148+
activeOrderKey: section === "active" ? key : null,
1149+
pinOrderKey: section === "pinned" ? key : null,
1150+
pinnedAt: section === "pinned" ? NOW : null,
1151+
}),
1152+
);
1153+
}
1154+
1155+
it.each(["active", "pinned"] as const)(
1156+
"keeps unsupported keyed %s neighbors as usable anchors",
1157+
(section) => {
1158+
const ordered = rows(section, ["bb", "dd", "ff"]);
1159+
const plan = createThreadMovePlanner({
1160+
ordered,
1161+
section,
1162+
reorderableEnvironmentIds: new Set([environmentId]),
1163+
});
1164+
const assignments = plan(`${environmentId}:move-0`, "down");
1165+
expect(assignments).toHaveLength(1);
1166+
expect(assignments![0]!.id).toBe(`${environmentId}:move-0`);
1167+
expect(assignments![0]!.orderKey > "dd").toBe(true);
1168+
expect(assignments![0]!.orderKey < "ff").toBe(true);
1169+
expect(plan(`${oldEnvironment}:move-1`, "up")).toBeNull();
1170+
expect(plan(`${environmentId}:move-0`, "up")).toBeNull();
1171+
},
1172+
);
1173+
1174+
it.each(["active", "pinned"] as const)(
1175+
"disables %s moves requiring unsupported keyless materialization",
1176+
(section) => {
1177+
const ordered = rows(section, [null, null, null]);
1178+
const plan = createThreadMovePlanner({
1179+
ordered,
1180+
section,
1181+
reorderableEnvironmentIds: new Set([environmentId]),
1182+
});
1183+
expect(plan(`${environmentId}:move-0`, "down")).toBeNull();
1184+
expect(plan(`${environmentId}:move-2`, "up")).toBeNull();
1185+
const supported = createThreadMovePlanner({
1186+
ordered,
1187+
section,
1188+
reorderableEnvironmentIds: new Set([environmentId, oldEnvironment]),
1189+
});
1190+
expect(supported(`${environmentId}:move-0`, "down")).toHaveLength(3);
1191+
},
1192+
);
1193+
1194+
it("allows an independent keyed move despite an unsupported keyless row elsewhere", () => {
1195+
const ordered = rows("active", [null, null, "bb", "dd", "ff"]);
1196+
const plan = createThreadMovePlanner({
1197+
ordered,
1198+
section: "active",
1199+
reorderableEnvironmentIds: new Set([environmentId]),
1200+
});
1201+
const assignments = plan(`${environmentId}:move-4`, "up");
1202+
expect(assignments).toHaveLength(1);
1203+
expect(assignments![0]!.id).toBe(`${environmentId}:move-4`);
1204+
expect(assignments![0]!.orderKey > "bb").toBe(true);
1205+
expect(assignments![0]!.orderKey < "dd").toBe(true);
1206+
});
1207+
});

‎apps/mobile/src/features/threads/threadOrder.ts‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,6 @@
11
import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
2+
import { planPinnedMove } from "@t3tools/client-runtime/state/thread-sort";
3+
import type { EnvironmentId } from "@t3tools/contracts";
24

35
type OrderRow = Pick<
46
EnvironmentThreadShell,
@@ -31,6 +33,33 @@ function rowOrder(row: OrderRow, section: PendingThreadOrder["section"]) {
3133
};
3234
}
3335

36+
/** Keep every visible row as an anchor, but only offer plans whose key writes
37+
* are supported. Menu availability and execution use this same planner. */
38+
export function createThreadMovePlanner(input: {
39+
readonly ordered: readonly OrderRow[];
40+
readonly section: PendingThreadOrder["section"];
41+
readonly reorderableEnvironmentIds: ReadonlySet<EnvironmentId>;
42+
}) {
43+
const orderedIds = input.ordered.map(rowId);
44+
const keysById = new Map(
45+
input.ordered.map((row) => [rowId(row), rowOrder(row, input.section).key]),
46+
);
47+
const writableIds = new Set(
48+
input.ordered
49+
.filter((row) => input.reorderableEnvironmentIds.has(row.environmentId))
50+
.map(rowId),
51+
);
52+
return (movedId: string, direction: "up" | "down") => {
53+
if (!writableIds.has(movedId)) return null;
54+
const assignments = planPinnedMove({ orderedIds, keysById, movedId, direction });
55+
return assignments === null ||
56+
assignments.length === 0 ||
57+
assignments.some((assignment) => !writableIds.has(assignment.id))
58+
? null
59+
: assignments;
60+
};
61+
}
62+
3463
export function createPendingThreadOrder(input: {
3564
readonly section: PendingThreadOrder["section"];
3665
readonly ordered: readonly OrderRow[];

0 commit comments

Comments
 (0)