- Register configurable NewThread widget for iOS - Sync recent project shortcuts and deep links into draft threads - Cover widget ordering, pinning, and layout behavior
Unified · Split
| @@ -181,6 +181,32 @@ const config: ExpoConfig = { · 180 unmodified lines | |||
| 181 | description: "Shows the current state of active T3 Code agents.", | 181 | description: "Shows the current state of active T3 Code agents.", |
| 182 | supportedFamilies: ["systemSmall", "systemMedium", "accessoryRectangular"], | 182 | supportedFamilies: ["systemSmall", "systemMedium", "accessoryRectangular"], |
| 183 | }, | 183 | }, |
| 184 | { | ||
| 185 | name: "NewThread", | ||
| 186 | displayName: "New Thread", | ||
| 187 | description: "Start a new T3 Code thread right from your Home Screen.", | ||
| 188 | supportedFamilies: ["systemSmall", "systemMedium", "systemLarge"], | ||
| 189 | // Per-instance options in the long-press "Edit Widget" sheet. Enum | ||
| 190 | // parameters are compiled into Swift at prebuild, so the dynamic | ||
| 191 | // project list cannot be offered as a picker — pins are typed as | ||
| 192 | // text and matched against the synced projects inside the widget. | ||
| 193 | configuration: { | ||
| 194 | title: "New Thread", | ||
| 195 | description: "Pin specific projects; the rest fills with your latest activity.", | ||
| 196 | parameters: { | ||
| 197 | pinnedProjects: { | ||
| 198 | title: "Pinned projects (comma-separated)", | ||
| 199 | type: "string", | ||
| 200 | default: "", | ||
| 201 | }, | ||
| 202 | showRecent: { | ||
| 203 | title: "Fill with recent projects", | ||
| 204 | type: "boolean", | ||
| 205 | default: true, | ||
| 206 | }, | ||
| 207 | }, | ||
| 208 | }, | ||
| 209 | }, | ||
| 184 | ], | 210 | ], |
| 185 | }, | 211 | }, |
| 186 | ], | 212 | ], |
| @@ -40,6 +40,7 @@ import { AddProjectSourceRoute } from "./features/projects/AddProjectSourceRoute · 39 unmodified lines | |||
| 40 | import { NewTaskDraftRouteScreen } from "./features/threads/NewTaskDraftRouteScreen"; | 40 | import { NewTaskDraftRouteScreen } from "./features/threads/NewTaskDraftRouteScreen"; |
| 41 | import { NewTaskFlowProvider } from "./features/threads/new-task-flow-provider"; | 41 | import { NewTaskFlowProvider } from "./features/threads/new-task-flow-provider"; |
| 42 | import { NewTaskRouteScreen } from "./features/threads/NewTaskRouteScreen"; | 42 | import { NewTaskRouteScreen } from "./features/threads/NewTaskRouteScreen"; |
| 43 | import { useNewThreadWidgetSync } from "./features/threads/use-new-thread-widget-sync"; | ||
| 43 | import { SettingsAppearanceRouteScreen } from "./features/settings/SettingsAppearanceRouteScreen"; | 44 | import { SettingsAppearanceRouteScreen } from "./features/settings/SettingsAppearanceRouteScreen"; |
| 44 | import { SettingsAuthRouteScreen } from "./features/settings/SettingsAuthRouteScreen"; | 45 | import { SettingsAuthRouteScreen } from "./features/settings/SettingsAuthRouteScreen"; |
| 45 | import { SettingsEnvironmentsRouteScreen } from "./features/settings/SettingsEnvironmentsRouteScreen"; | 46 | import { SettingsEnvironmentsRouteScreen } from "./features/settings/SettingsEnvironmentsRouteScreen"; |
| @@ -256,6 +257,8 @@ function RootStackLayout(props: { · 210 unmodified lines | |||
| 256 | useThreadOutboxDrain(); | 257 | useThreadOutboxDrain(); |
| 257 | // Presents the T3 Connect onboarding sheet after an in-session sign-in. | 258 | // Presents the T3 Connect onboarding sheet after an in-session sign-in. |
| 258 | useConnectOnboardingNavigation(); | 259 | useConnectOnboardingNavigation(); |
| 260 | // Keeps the NewThread home-screen widget's project shortcuts current. | ||
| 261 | useNewThreadWidgetSync(); | ||
| 259 | // Full pathname (sheets included) for keyboard-command scoping; the | 262 | // Full pathname (sheets included) for keyboard-command scoping; the |
| 260 | // workspace layout only reacts to the underlying non-overlay route. | 263 | // workspace layout only reacts to the underlying non-overlay route. |
| 261 | const path = getPathFromState(props.state, navigationPathConfig); | 264 | const path = getPathFromState(props.state, navigationPathConfig); |
| @@ -0,0 +1,111 @@ | |||
| 1 | import { describe, expect, it } from "vite-plus/test"; | ||
| 2 | import type { | ||
| 3 | EnvironmentProject, | ||
| 4 | EnvironmentThreadShell, | ||
| 5 | } from "@t3tools/client-runtime/state/shell"; | ||
| 6 | |||
| 7 | import { | ||
| 8 | makeNewThreadWidgetProps, | ||
| 9 | NEW_THREAD_WIDGET_PROJECT_SYNC_LIMIT, | ||
| 10 | } from "./new-thread-widget"; | ||
| 11 | |||
| 12 | function makeProject(overrides: { | ||
| 13 | readonly id: string; | ||
| 14 | readonly environmentId?: string; | ||
| 15 | readonly title?: string; | ||
| 16 | readonly updatedAt?: string; | ||
| 17 | }): EnvironmentProject { | ||
| 18 | return { | ||
| 19 | id: overrides.id, | ||
| 20 | environmentId: overrides.environmentId ?? "env-1", | ||
| 21 | title: overrides.title ?? overrides.id, | ||
| 22 | updatedAt: overrides.updatedAt ?? "2026-07-01T00:00:00.000Z", | ||
| 23 | } as unknown as EnvironmentProject; | ||
| 24 | } | ||
| 25 | |||
| 26 | function makeThread(overrides: { | ||
| 27 | readonly projectId: string; | ||
| 28 | readonly environmentId?: string; | ||
| 29 | readonly updatedAt: string; | ||
| 30 | }): EnvironmentThreadShell { | ||
| 31 | return { | ||
| 32 | id: `thread-${overrides.projectId}`, | ||
| 33 | projectId: overrides.projectId, | ||
| 34 | environmentId: overrides.environmentId ?? "env-1", | ||
| 35 | updatedAt: overrides.updatedAt, | ||
| 36 | } as unknown as EnvironmentThreadShell; | ||
| 37 | } | ||
| 38 | |||
| 39 | describe("makeNewThreadWidgetProps", () => { | ||
| 40 | it("orders projects by their newest thread activity", () => { | ||
| 41 | const props = makeNewThreadWidgetProps( | ||
| 42 | [ | ||
| 43 | makeProject({ id: "stale", updatedAt: "2026-07-06T00:00:00.000Z" }), | ||
| 44 | makeProject({ id: "busy", updatedAt: "2026-07-01T00:00:00.000Z" }), | ||
| 45 | ], | ||
| 46 | [makeThread({ projectId: "busy", updatedAt: "2026-07-07T00:00:00.000Z" })], | ||
| 47 | ); | ||
| 48 | expect(props.projects?.map((project) => project.title)).toEqual(["busy", "stale"]); | ||
| 49 | }); | ||
| 50 | |||
| 51 | it("falls back to the project's own updatedAt when it has no threads", () => { | ||
| 52 | const props = makeNewThreadWidgetProps( | ||
| 53 | [ | ||
| 54 | makeProject({ id: "old", updatedAt: "2026-07-01T00:00:00.000Z" }), | ||
| 55 | makeProject({ id: "fresh", updatedAt: "2026-07-07T00:00:00.000Z" }), | ||
| 56 | ], | ||
| 57 | [], | ||
| 58 | ); | ||
| 59 | expect(props.projects?.map((project) => project.title)).toEqual(["fresh", "old"]); | ||
| 60 | }); | ||
| 61 | |||
| 62 | it("ignores thread activity from a same-named project in another environment", () => { | ||
| 63 | const props = makeNewThreadWidgetProps( | ||
| 64 | [ | ||
| 65 | makeProject({ id: "proj", environmentId: "env-1", title: "one" }), | ||
| 66 | makeProject({ | ||
| 67 | id: "proj", | ||
| 68 | environmentId: "env-2", | ||
| 69 | title: "two", | ||
| 70 | updatedAt: "2026-07-02T00:00:00.000Z", | ||
| 71 | }), | ||
| 72 | ], | ||
| 73 | [ | ||
| 74 | makeThread({ | ||
| 75 | projectId: "proj", | ||
| 76 | environmentId: "env-2", | ||
| 77 | updatedAt: "2026-07-07T00:00:00.000Z", | ||
| 78 | }), | ||
| 79 | ], | ||
| 80 | ); | ||
| 81 | expect(props.projects?.map((project) => project.title)).toEqual(["two", "one"]); | ||
| 82 | }); | ||
| 83 | |||
| 84 | it("caps the payload at the widget's sync limit", () => { | ||
| 85 | const props = makeNewThreadWidgetProps( | ||
| 86 | Array.from({ length: NEW_THREAD_WIDGET_PROJECT_SYNC_LIMIT + 5 }, (_, n) => | ||
| 87 | makeProject({ | ||
| 88 | id: `p${n}`, | ||
| 89 | updatedAt: `2026-06-${String(n + 1).padStart(2, "0")}T00:00:00.000Z`, | ||
| 90 | }), | ||
| 91 | ), | ||
| 92 | [], | ||
| 93 | ); | ||
| 94 | expect(props.projects).toHaveLength(NEW_THREAD_WIDGET_PROJECT_SYNC_LIMIT); | ||
| 95 | expect(props.projects?.[0]?.title).toBe(`p${NEW_THREAD_WIDGET_PROJECT_SYNC_LIMIT + 4}`); | ||
| 96 | }); | ||
| 97 | |||
| 98 | it("URL-encodes deep link parameters", () => { | ||
| 99 | const props = makeNewThreadWidgetProps( | ||
| 100 | [makeProject({ id: "p 1", environmentId: "env&1", title: "T3 & friends" })], | ||
| 101 | [], | ||
| 102 | ); | ||
| 103 | expect(props.projects?.[0]?.deepLink).toBe( | ||
| 104 | "/new/draft?environmentId=env%261&projectId=p%201&title=T3%20%26%20friends", | ||
| 105 | ); | ||
| 106 | }); | ||
| 107 | |||
| 108 | it("returns an empty list when there are no projects", () => { | ||
| 109 | expect(makeNewThreadWidgetProps([], []).projects).toEqual([]); | ||
| 110 | }); | ||
| 111 | }); | ||
| @@ -0,0 +1,63 @@ | |||
| 1 | import type { | ||
| 2 | EnvironmentProject, | ||
| 3 | EnvironmentThreadShell, | ||
| 4 | } from "@t3tools/client-runtime/state/shell"; | ||
| 5 | |||
| 6 | import type { NewThreadWidgetProps } from "../../widgets/NewThread"; | ||
| 7 | |||
| 8 | // Candidate pool synced to the widget. Deliberately larger than any family | ||
| 9 | // displays (medium shows 3 rows, large 7): the "pinned projects" widget | ||
| 10 | // configuration is per widget instance and only visible inside the widget | ||
| 11 | // process, so the layout matches pins against this pool — a pin should still | ||
| 12 | // resolve when its project is not among the most recent few. | ||
| 13 | export const NEW_THREAD_WIDGET_PROJECT_SYNC_LIMIT = 20; | ||
| 14 | |||
| 15 | /** | ||
| 16 | * Builds the home-screen widget payload: the most-recently-active projects, | ||
| 17 | * each with a deep link into the new-task draft composer for that project. | ||
| 18 | * | ||
| 19 | * "Recently active" means the newest thread update in the project, falling | ||
| 20 | * back to the project's own updatedAt for projects with no threads — so the | ||
| 21 | * widget surfaces where the user actually works, not what was created last. | ||
| 22 | */ | ||
| 23 | export function makeNewThreadWidgetProps( | ||
| 24 | projects: ReadonlyArray<EnvironmentProject>, | ||
| 25 | threads: ReadonlyArray<EnvironmentThreadShell>, | ||
| 26 | ): NewThreadWidgetProps { | ||
| 27 | const latestThreadActivity = new Map<string, string>(); | ||
| 28 | for (const thread of threads) { | ||
| 29 | const key = projectActivityKey(thread.environmentId, thread.projectId); | ||
| 30 | const previous = latestThreadActivity.get(key); | ||
| 31 | // ISO-8601 timestamps order lexicographically. | ||
| 32 | if (previous === undefined || thread.updatedAt > previous) { | ||
| 33 | latestThreadActivity.set(key, thread.updatedAt); | ||
| 34 | } | ||
| 35 | } | ||
| 36 | |||
| 37 | const lastActivity = (project: EnvironmentProject): string => { | ||
| 38 | const threadActivity = latestThreadActivity.get( | ||
| 39 | projectActivityKey(project.environmentId, project.id), | ||
| 40 | ); | ||
| 41 | return threadActivity !== undefined && threadActivity > project.updatedAt | ||
| 42 | ? threadActivity | ||
| 43 | : project.updatedAt; | ||
| 44 | }; | ||
| 45 | |||
| 46 | const ordered = [...projects].sort((a, b) => lastActivity(b).localeCompare(lastActivity(a))); | ||
| 47 | |||
| 48 | return { | ||
| 49 | projects: ordered.slice(0, NEW_THREAD_WIDGET_PROJECT_SYNC_LIMIT).map((project) => ({ | ||
| 50 | title: project.title, | ||
| 51 | // Matches the NewTaskSheet > NewTaskDraft linking config in Stack.tsx; | ||
| 52 | // the widget layout prefixes the scheme after a safety check. | ||
| 53 | deepLink: | ||
| 54 | `/new/draft?environmentId=${encodeURIComponent(String(project.environmentId))}` + | ||
| 55 | `&projectId=${encodeURIComponent(String(project.id))}` + | ||
| 56 | `&title=${encodeURIComponent(project.title)}`, | ||
| 57 | })), | ||
| 58 | }; | ||
| 59 | } | ||
| 60 | |||
| 61 | function projectActivityKey(environmentId: string, projectId: string): string { | ||
| 62 | return `${environmentId}\u0000${projectId}`; | ||
| 63 | } | ||
| @@ -0,0 +1,43 @@ | |||
| 1 | import { useEffect } from "react"; | ||
| 2 | import { Platform } from "react-native"; | ||
| 3 | |||
| 4 | import { useProjects, useThreadShells } from "../../state/entities"; | ||
| 5 | import NewThreadWidget from "../../widgets/NewThread"; | ||
| 6 | import { makeNewThreadWidgetProps } from "./new-thread-widget"; | ||
| 7 | |||
| 8 | // Last payload written to the widget timeline. Module-level (not React state) | ||
| 9 | // so navigator remounts don't rewrite an unchanged payload: every write ends | ||
| 10 | // in a WidgetCenter reload, and iOS throttles widgets that reload too often. | ||
| 11 | let lastSyncedSignature: string | null = null; | ||
| 12 | |||
| 13 | /** | ||
| 14 | * Keeps the NewThread home-screen widget's project shortcuts in sync with the | ||
| 15 | * workspace. Writing the snapshot also persists the widget layout to the | ||
| 16 | * shared app group, which is what lets the widget render at all — so this | ||
| 17 | * must run on every launch, not only when projects change. | ||
| 18 | */ | ||
| 19 | export function useNewThreadWidgetSync(): void { | ||
| 20 | const projects = useProjects(); | ||
| 21 | const threads = useThreadShells(); | ||
| 22 | |||
| 23 | useEffect(() => { | ||
| 24 | if (Platform.OS !== "ios") { | ||
| 25 | return; | ||
| 26 | } | ||
| 27 | const props = makeNewThreadWidgetProps(projects, threads); | ||
| 28 | const signature = JSON.stringify(props); | ||
| 29 | if (signature === lastSyncedSignature) { | ||
| 30 | return; | ||
| 31 | } | ||
| 32 | lastSyncedSignature = signature; | ||
| 33 | try { | ||
| 34 | NewThreadWidget.updateSnapshot(props); | ||
| 35 | } catch (error) { | ||
| 36 | // Clear the signature so the next data change retries the write. | ||
| 37 | lastSyncedSignature = null; | ||
| 38 | if (__DEV__) { | ||
| 39 | console.warn("[new-thread-widget] snapshot update failed", error); | ||
| 40 | } | ||
| 41 | } | ||
| 42 | }, [projects, threads]); | ||
| 43 | } | ||
| @@ -0,0 +1,227 @@ | |||
| 1 | import { describe, expect, it, vi } from "vite-plus/test"; | ||
| 2 | |||
| 3 | vi.mock("@expo/ui/swift-ui", () => ({ | ||
| 4 | HStack: "HStack", | ||
| 5 | Image: "Image", | ||
| 6 | Link: "Link", | ||
| 7 | Spacer: "Spacer", | ||
| 8 | Text: "Text", | ||
| 9 | VStack: "VStack", | ||
| 10 | })); | ||
| 11 | |||
| 12 | vi.mock("@expo/ui/swift-ui/modifiers", () => ({ | ||
| 13 | containerBackground: (color: unknown) => ({ containerBackground: color }), | ||
| 14 | font: (value: unknown) => value, | ||
| 15 | foregroundStyle: (value: unknown) => value, | ||
| 16 | frame: (value: unknown) => value, | ||
| 17 | lineLimit: (value: unknown) => value, | ||
| 18 | padding: (value: unknown) => value, | ||
| 19 | resizable: (value: unknown) => value, | ||
| 20 | widgetURL: (value: unknown) => ({ widgetURL: value }), | ||
| 21 | })); | ||
| 22 | |||
| 23 | vi.mock("expo-widgets", () => ({ | ||
| 24 | createWidget: vi.fn((name: string, layout: unknown) => ({ layout, name })), | ||
| 25 | })); | ||
| 26 | |||
| 27 | import { | ||
| 28 | NewThread, | ||
| 29 | type NewThreadWidgetConfiguration, | ||
| 30 | type NewThreadWidgetProject, | ||
| 31 | } from "./NewThread"; | ||
| 32 | |||
| 33 | function makeProject(overrides: Partial<NewThreadWidgetProject>): NewThreadWidgetProject { | ||
| 34 | return { | ||
| 35 | title: "Project", | ||
| 36 | deepLink: "/new/draft?environmentId=env-1&projectId=proj-1&title=Project", | ||
| 37 | ...overrides, | ||
| 38 | }; | ||
| 39 | } | ||
| 40 | |||
| 41 | function makeEnvironment(overrides: { | ||
| 42 | readonly widgetFamily: "systemSmall" | "systemMedium" | "systemLarge"; | ||
| 43 | readonly colorScheme?: "light" | "dark"; | ||
| 44 | readonly configuration?: Partial<NewThreadWidgetConfiguration>; | ||
| 45 | }) { | ||
| 46 | return { | ||
| 47 | date: new Date("2026-07-07T12:00:00.000Z"), | ||
| 48 | widgetFamily: overrides.widgetFamily, | ||
| 49 | colorScheme: overrides.colorScheme ?? "dark", | ||
| 50 | configuration: { pinnedProjects: "", showRecent: true, ...overrides.configuration }, | ||
| 51 | } as never; | ||
| 52 | } | ||
| 53 | |||
| 54 | const smallEnvironment = makeEnvironment({ widgetFamily: "systemSmall" }); | ||
| 55 | const mediumEnvironment = makeEnvironment({ widgetFamily: "systemMedium" }); | ||
| 56 | |||
| 57 | describe("NewThread widget layout", () => { | ||
| 58 | it("deep links the whole small widget to the new-task sheet", () => { | ||
| 59 | const layout = JSON.stringify(NewThread({ projects: [] }, smallEnvironment)); | ||
| 60 | expect(layout).toContain('"widgetURL":"t3code://new"'); | ||
| 61 | expect(layout).toContain("New Thread"); | ||
| 62 | }); | ||
| 63 | |||
| 64 | it("renders the small call to action even when projects are present", () => { | ||
| 65 | const layout = JSON.stringify( | ||
| 66 | NewThread({ projects: [makeProject({ title: "t3code" })] }, smallEnvironment), | ||
| 67 | ); | ||
| 68 | expect(layout).not.toContain("t3code://new/draft"); | ||
| 69 | expect(layout).toContain('"widgetURL":"t3code://new"'); | ||
| 70 | }); | ||
| 71 | |||
| 72 | it("tolerates missing props and configuration (WidgetKit placeholder renders with none)", () => { | ||
| 73 | const layout = JSON.stringify( | ||
| 74 | NewThread( | ||
| 75 | {} as never, | ||
| 76 | { | ||
| 77 | date: new Date("2026-07-07T12:00:00.000Z"), | ||
| 78 | widgetFamily: "systemMedium", | ||
| 79 | colorScheme: "light", | ||
| 80 | configuration: undefined, | ||
| 81 | } as never, | ||
| 82 | ), | ||
| 83 | ); | ||
| 84 | expect(layout).toContain('"widgetURL":"t3code://new"'); | ||
| 85 | }); | ||
| 86 | |||
| 87 | it("links each medium row to its project's draft composer", () => { | ||
| 88 | const layout = JSON.stringify( | ||
| 89 | NewThread( | ||
| 90 | { | ||
| 91 | projects: [ | ||
| 92 | makeProject({ title: "t3code", deepLink: "/new/draft?projectId=a" }), | ||
| 93 | makeProject({ title: "marketing", deepLink: "/new/draft?projectId=b" }), | ||
| 94 | ], | ||
| 95 | }, | ||
| 96 | mediumEnvironment, | ||
| 97 | ), | ||
| 98 | ); | ||
| 99 | expect(layout).toContain("t3code"); | ||
| 100 | expect(layout).toContain("marketing"); | ||
| 101 | expect(layout).toContain('"destination":"t3code://new/draft?projectId=a"'); | ||
| 102 | expect(layout).toContain('"destination":"t3code://new/draft?projectId=b"'); | ||
| 103 | // Header link falls back to the plain new-task sheet. | ||
| 104 | expect(layout).toContain('"destination":"t3code://new"'); | ||
| 105 | }); | ||
| 106 | |||
| 107 | it("renders at most three rows on medium and seven on large", () => { | ||
| 108 | const projects = [1, 2, 3, 4, 5, 6, 7, 8].map((n) => | ||
| 109 | makeProject({ title: `Project ${n}`, deepLink: `/new/draft?projectId=p${n}` }), | ||
| 110 | ); | ||
| 111 | const medium = JSON.stringify(NewThread({ projects }, mediumEnvironment)); | ||
| 112 | expect(medium).toContain("Project 3"); | ||
| 113 | expect(medium).not.toContain("Project 4"); | ||
| 114 | const large = JSON.stringify( | ||
| 115 | NewThread({ projects }, makeEnvironment({ widgetFamily: "systemLarge" })), | ||
| 116 | ); | ||
| 117 | expect(large).toContain("Project 7"); | ||
| 118 | expect(large).not.toContain("Project 8"); | ||
| 119 | }); | ||
| 120 | |||
| 121 | it("pins configured projects ahead of recents, in pin order", () => { | ||
| 122 | const layout = JSON.stringify( | ||
| 123 | NewThread( | ||
| 124 | { | ||
| 125 | projects: [ | ||
| 126 | makeProject({ title: "recent" }), | ||
| 127 | makeProject({ title: "beta" }), | ||
| 128 | makeProject({ title: "alpha" }), | ||
| 129 | ], | ||
| 130 | }, | ||
| 131 | makeEnvironment({ | ||
| 132 | widgetFamily: "systemMedium", | ||
| 133 | configuration: { pinnedProjects: "Alpha, Beta" }, | ||
| 134 | }), | ||
| 135 | ), | ||
| 136 | ); | ||
| 137 | expect(layout.indexOf("alpha")).toBeLessThan(layout.indexOf("beta")); | ||
| 138 | expect(layout.indexOf("beta")).toBeLessThan(layout.indexOf("recent")); | ||
| 139 | // Pinned rows carry the pin glyph; the recent row keeps the folder. | ||
| 140 | expect(layout).toContain("pin.fill"); | ||
| 141 | expect(layout).toContain("folder"); | ||
| 142 | }); | ||
| 143 | |||
| 144 | it("matches pins by case-insensitive prefix and skips unmatched pins", () => { | ||
| 145 | const layout = JSON.stringify( | ||
| 146 | NewThread( | ||
| 147 | { | ||
| 148 | projects: [makeProject({ title: "recent" }), makeProject({ title: "T3 Marketing Site" })], | ||
| 149 | }, | ||
| 150 | makeEnvironment({ | ||
| 151 | widgetFamily: "systemMedium", | ||
| 152 | configuration: { pinnedProjects: "t3 mark, no-such-project" }, | ||
| 153 | }), | ||
| 154 | ), | ||
| 155 | ); | ||
| 156 | expect(layout.indexOf("T3 Marketing Site")).toBeLessThan(layout.indexOf("recent")); | ||
| 157 | expect(layout).toContain("pin.fill"); | ||
| 158 | }); | ||
| 159 | |||
| 160 | it("pins can surface projects beyond the visible row budget", () => { | ||
| 161 | const projects = [1, 2, 3, 4, 5].map((n) => makeProject({ title: `Project ${n}` })); | ||
| 162 | const layout = JSON.stringify( | ||
| 163 | NewThread( | ||
| 164 | { projects }, | ||
| 165 | makeEnvironment({ | ||
| 166 | widgetFamily: "systemMedium", | ||
| 167 | configuration: { pinnedProjects: "Project 5" }, | ||
| 168 | }), | ||
| 169 | ), | ||
| 170 | ); | ||
| 171 | expect(layout).toContain("Project 5"); | ||
| 172 | expect(layout).toContain("Project 1"); | ||
| 173 | expect(layout).toContain("Project 2"); | ||
| 174 | expect(layout).not.toContain("Project 3"); | ||
| 175 | }); | ||
| 176 | |||
| 177 | it("hides recents when the fill toggle is off", () => { | ||
| 178 | const layout = JSON.stringify( | ||
| 179 | NewThread( | ||
| 180 | { projects: [makeProject({ title: "pinned-one" }), makeProject({ title: "recent" })] }, | ||
| 181 | makeEnvironment({ | ||
| 182 | widgetFamily: "systemMedium", | ||
| 183 | configuration: { pinnedProjects: "pinned-one", showRecent: false }, | ||
| 184 | }), | ||
| 185 | ), | ||
| 186 | ); | ||
| 187 | expect(layout).toContain("pinned-one"); | ||
| 188 | expect(layout).not.toContain("recent"); | ||
| 189 | }); | ||
| 190 | |||
| 191 | it("falls back to the call to action when recents are off and no pin matches", () => { | ||
| 192 | const layout = JSON.stringify( | ||
| 193 | NewThread( | ||
| 194 | { projects: [makeProject({ title: "recent" })] }, | ||
| 195 | makeEnvironment({ | ||
| 196 | widgetFamily: "systemMedium", | ||
| 197 | configuration: { pinnedProjects: "gone", showRecent: false }, | ||
| 198 | }), | ||
| 199 | ), | ||
| 200 | ); | ||
| 201 | expect(layout).toContain('"widgetURL":"t3code://new"'); | ||
| 202 | expect(layout).not.toContain("recent"); | ||
| 203 | }); | ||
| 204 | |||
| 205 | it("drops the link but keeps the row for unsafe deep links", () => { | ||
| 206 | const layout = JSON.stringify( | ||
| 207 | NewThread( | ||
| 208 | { projects: [makeProject({ title: "sneaky", deepLink: "//evil.example" })] }, | ||
| 209 | mediumEnvironment, | ||
| 210 | ), | ||
| 211 | ); | ||
| 212 | expect(layout).toContain("sneaky"); | ||
| 213 | expect(layout).not.toContain("evil.example"); | ||
| 214 | }); | ||
| 215 | |||
| 216 | it("adapts the container background to the color scheme", () => { | ||
| 217 | const dark = JSON.stringify(NewThread({ projects: [] }, smallEnvironment)); | ||
| 218 | const light = JSON.stringify( | ||
| 219 | NewThread( | ||
| 220 | { projects: [] }, | ||
| 221 | makeEnvironment({ widgetFamily: "systemSmall", colorScheme: "light" }), | ||
| 222 | ), | ||
| 223 | ); | ||
| 224 | expect(dark).toContain('"containerBackground":"#0a0a0a"'); | ||
| 225 | expect(light).toContain('"containerBackground":"#ffffff"'); | ||
| 226 | }); | ||
| 227 | }); | ||
| @@ -0,0 +1,203 @@ | |||
| 1 | import { HStack, Image, Link, Spacer, Text, VStack } from "@expo/ui/swift-ui"; | ||
| 2 | import type { ComponentProps, JSX } from "react"; | ||
| 3 | import { | ||
| 4 | containerBackground, | ||
| 5 | font, | ||
| 6 | foregroundStyle, | ||
| 7 | frame, | ||
| 8 | lineLimit, | ||
| 9 | padding, | ||
| 10 | resizable, | ||
| 11 | widgetURL, | ||
| 12 | } from "@expo/ui/swift-ui/modifiers"; | ||
| 13 | import { createWidget, type WidgetEnvironment } from "expo-widgets"; | ||
| 14 | |||
| 15 | export interface NewThreadWidgetProject { | ||
| 16 | readonly title: string; | ||
| 17 | /** App-relative path to the prefilled draft composer, e.g. "/new/draft?environmentId=…". */ | ||
| 18 | readonly deepLink: string; | ||
| 19 | } | ||
| 20 | |||
| 21 | export interface NewThreadWidgetProps { | ||
| 22 | /** | ||
| 23 | * Candidate projects, most recently active first. The medium/large widgets | ||
| 24 | * render a slice of these as one-tap shortcuts into the draft composer. | ||
| 25 | * More are synced than any family displays: pinned-project matching happens | ||
| 26 | * here in the widget (the configuration is per widget instance, so the app | ||
| 27 | * cannot precompute it), and a pin should resolve even when its project has | ||
| 28 | * fallen out of the top displayed rows. | ||
| 29 | * Optional because WidgetKit renders placeholder/gallery entries with no | ||
| 30 | * props before the app has ever written a timeline. | ||
| 31 | */ | ||
| 32 | readonly projects?: ReadonlyArray<NewThreadWidgetProject>; | ||
| 33 | } | ||
| 34 | |||
| 35 | /** Mirrors the `configuration.parameters` in app.config.ts. */ | ||
| 36 | export interface NewThreadWidgetConfiguration { | ||
| 37 | /** Comma-separated project titles to pin ahead of recent projects. */ | ||
| 38 | readonly pinnedProjects: string; | ||
| 39 | /** Whether to fill the remaining rows with recently active projects. */ | ||
| 40 | readonly showRecent: boolean; | ||
| 41 | } | ||
| 42 | |||
| 43 | // This function is serialized into the widget extension's JS bundle, so it | ||
| 44 | // must stay self-contained: no references to module-scope helpers, only the | ||
| 45 | // imported view/modifier factories. | ||
| 46 | export function NewThread( | ||
| 47 | props: NewThreadWidgetProps, | ||
| 48 | environment: WidgetEnvironment<NewThreadWidgetConfiguration>, | ||
| 49 | ): JSX.Element { | ||
| 50 | "widget"; | ||
| 51 | |||
| 52 | // Semantic label colors adapt to whatever material the OS renders the | ||
| 53 | // widget on (light/dark home screen, tinted iOS 18 mode). | ||
| 54 | const primaryForeground = "primary"; | ||
| 55 | const secondaryForeground = "secondary"; | ||
| 56 | // Home-screen widgets must supply their own container background on iOS 17+; | ||
| 57 | // match the app's splash background per scheme. | ||
| 58 | const containerColor = environment.colorScheme === "dark" ? "#0a0a0a" : "#ffffff"; | ||
| 59 | |||
| 60 | // Any registered scheme variant routes back to this app; taps are delivered | ||
| 61 | // to the widget's containing app, so the prod scheme is safe for all builds. | ||
| 62 | const newThreadUrl = "t3code://new"; | ||
| 63 | const toWidgetUrl = (deepLink: string): string | null => | ||
| 64 | deepLink.startsWith("/") && !deepLink.startsWith("//") ? `t3code://${deepLink.slice(1)}` : null; | ||
| 65 | |||
| 66 | // SF Symbols and the logo ignore frame/foregroundStyle applied directly to | ||
| 67 | // the image; size + tint them through a container the resizable image fills. | ||
| 68 | type SFName = NonNullable<ComponentProps<typeof Image>["systemName"]>; | ||
| 69 | const renderGlyph = (systemName: SFName, size: number, color: string) => ( | ||
| 70 | <HStack modifiers={[frame({ width: size, height: size }), foregroundStyle(color)]}> | ||
| 71 | <Image systemName={systemName} modifiers={[resizable()]} /> | ||
| 72 | </HStack> | ||
| 73 | ); | ||
| 74 | // The 3:2 frame matches the T3 mark's aspect ratio so it never distorts. | ||
| 75 | const renderLogo = (height: number, color: string) => ( | ||
| 76 | <HStack modifiers={[frame({ width: height * 1.5, height }), foregroundStyle(color)]}> | ||
| 77 | <Image assetName="T3Mark" modifiers={[resizable()]} /> | ||
| 78 | </HStack> | ||
| 79 | ); | ||
| 80 | |||
| 81 | const available = props.projects ?? []; | ||
| 82 | const configuration = environment.configuration; | ||
| 83 | |||
| 84 | // Pins are typed titles (see app.config.ts for why there is no picker). | ||
| 85 | // Match case-insensitively, exact title first and then prefix, preserving | ||
| 86 | // the user's pin order. Unmatched pins (typo, deleted project) are skipped. | ||
| 87 | const pinnedQueries = ( | ||
| 88 | typeof configuration?.pinnedProjects === "string" ? configuration.pinnedProjects : "" | ||
| 89 | ) | ||
| 90 | .split(",") | ||
| 91 | .map((title) => title.trim().toLowerCase()) | ||
| 92 | .filter((title) => title.length > 0); | ||
| 93 | const pinned: NewThreadWidgetProject[] = []; | ||
| 94 | for (const query of pinnedQueries) { | ||
| 95 | const match = | ||
| 96 | available.find( | ||
| 97 | (project) => !pinned.includes(project) && project.title.toLowerCase() === query, | ||
| 98 | ) ?? | ||
| 99 | available.find( | ||
| 100 | (project) => !pinned.includes(project) && project.title.toLowerCase().startsWith(query), | ||
| 101 | ); | ||
| 102 | if (match) { | ||
| 103 | pinned.push(match); | ||
| 104 | } | ||
| 105 | } | ||
| 106 | |||
| 107 | // Pinned first, then latest activity — unless recents are configured off. | ||
| 108 | const rows = [...pinned]; | ||
| 109 | if (configuration?.showRecent !== false) { | ||
| 110 | for (const project of available) { | ||
| 111 | if (!rows.includes(project)) { | ||
| 112 | rows.push(project); | ||
| 113 | } | ||
| 114 | } | ||
| 115 | } | ||
| 116 | const rowLimit = environment.widgetFamily === "systemLarge" ? 7 : 3; | ||
| 117 | const visible = rows.slice(0, rowLimit); | ||
| 118 | |||
| 119 | // The whole small widget is one tap target; the medium/large widgets add | ||
| 120 | // per-row links, with the root widgetURL as the fallback for untargeted areas. | ||
| 121 | const rootModifiers = [containerBackground(containerColor, "widget"), widgetURL(newThreadUrl)]; | ||
| 122 | |||
| 123 | // Small family — and the larger families with nothing to list (no sync yet, | ||
| 124 | // or recents off with no pin matched) — render a single centered call to action. | ||
| 125 | if (environment.widgetFamily === "systemSmall" || visible.length === 0) { | ||
| 126 | return ( | ||
| 127 | <VStack spacing={7} modifiers={rootModifiers}> | ||
| 128 | <Spacer minLength={0} /> | ||
| 129 | {renderLogo(20, primaryForeground)} | ||
| 130 | <HStack spacing={5} alignment="center"> | ||
| 131 | {renderGlyph("square.and.pencil", 12, secondaryForeground)} | ||
| 132 | <Text | ||
| 133 | modifiers={[font({ weight: "semibold", size: 13 }), foregroundStyle(primaryForeground)]} | ||
| 134 | > | ||
| 135 | New Thread | ||
| 136 | </Text> | ||
| 137 | </HStack> | ||
| 138 | <Spacer minLength={0} /> | ||
| 139 | </VStack> | ||
| 140 | ); | ||
| 141 | } | ||
| 142 | |||
| 143 | // Project shortcut row: tapping opens the draft composer with that project | ||
| 144 | // preselected. Rows whose deep link fails the safety check still render, | ||
| 145 | // but fall through to the root's plain new-thread tap target. | ||
| 146 | const renderProjectRow = (project: NewThreadWidgetProject, isPinned: boolean) => { | ||
| 147 | const url = toWidgetUrl(project.deepLink); | ||
| 148 | const row = ( | ||
| 149 | <HStack spacing={7} alignment="center"> | ||
| 150 | {renderGlyph(isPinned ? "pin.fill" : "folder", 11, secondaryForeground)} | ||
| 151 | <Text | ||
| 152 | modifiers={[ | ||
| 153 | font({ weight: "semibold", size: 13 }), | ||
| 154 | foregroundStyle(primaryForeground), | ||
| 155 | lineLimit(1), | ||
| 156 | ]} | ||
| 157 | > | ||
| 158 | {project.title} | ||
| 159 | </Text> | ||
| 160 | <Spacer minLength={8} /> | ||
| 161 | {renderGlyph("chevron.forward", 9, secondaryForeground)} | ||
| 162 | </HStack> | ||
| 163 | ); | ||
| 164 | return url ? <Link destination={url}>{row}</Link> : row; | ||
| 165 | }; | ||
| 166 | |||
| 167 | // Pinned rows always precede recents, so index < pinned.length marks them. | ||
| 168 | const renderRow = (index: number) => { | ||
| 169 | const project = visible[index]; | ||
| 170 | return project ? renderProjectRow(project, index < pinned.length) : null; | ||
| 171 | }; | ||
| 172 | |||
| 173 | return ( | ||
| 174 | <VStack alignment="leading" spacing={8} modifiers={rootModifiers}> | ||
| 175 | <Link destination={newThreadUrl}> | ||
| 176 | <HStack spacing={7} alignment="center"> | ||
| 177 | {renderLogo(15, primaryForeground)} | ||
| 178 | <Text | ||
| 179 | modifiers={[font({ weight: "bold", size: 14 }), foregroundStyle(primaryForeground)]} | ||
| 180 | > | ||
| 181 | New Thread | ||
| 182 | </Text> | ||
| 183 | <Spacer minLength={8} /> | ||
| 184 | {renderGlyph("square.and.pencil", 14, secondaryForeground)} | ||
| 185 | </HStack> | ||
| 186 | </Link> | ||
| 187 | <Spacer minLength={0} modifiers={[padding({ vertical: 1 })]} /> | ||
| 188 | {renderRow(0)} | ||
| 189 | {renderRow(1)} | ||
| 190 | {renderRow(2)} | ||
| 191 | {renderRow(3)} | ||
| 192 | {renderRow(4)} | ||
| 193 | {renderRow(5)} | ||
| 194 | {renderRow(6)} | ||
| 195 | <Spacer minLength={0} /> | ||
| 196 | </VStack> | ||
| 197 | ); | ||
| 198 | } | ||
| 199 | |||
| 200 | export default createWidget<NewThreadWidgetProps, NewThreadWidgetConfiguration>( | ||
| 201 | "NewThread", | ||
| 202 | NewThread, | ||
| 203 | ); | ||