Files
kandev/apps/web/components/state-provider.tsx
T
Carlos Florêncio f5dc6e2322 fix: persist task create last-used selections (#1550)
* fix: persist task create last-used selections

Record final task-create selections server-side.

Make dialog restore wait for backend settings before localStorage fallback.

Update pinned-action verification tests and split dockview rendering for lint.

* fix: address task create PR feedback

* fix: resolve task create review follow-ups

* test: cover task create service recording

* fix: address task create review regressions

* fix: avoid recording generated fresh branches

* fix: skip repo-only last-used task records

* fix: make task create settings updates atomic

* fix: clear stale task create cache

* fix: clear synced task create overlay

* fix: address task create review feedback

* fix: queue cached repository autopick

* fix: preserve partial task create settings

* fix: replace task create queued overlay

* fix: clear branch when recording repository

* test: cover task create queued payload

* test: remove unused user service helper

---------

Co-authored-by: root <root@kandev.ts.net>
2026-06-30 02:35:21 +01:00

124 lines
4.1 KiB
TypeScript

"use client";
import { createContext, useContext, useEffect, useLayoutEffect, useState } from "react";
import type { StoreApi } from "zustand";
import { useStore } from "zustand";
import { isDebug, registerSessionTaskResolver } from "@/lib/debug/log";
import type { AppState, StoreProviderProps } from "@/lib/state/store";
import { createAppStore } from "@/lib/state/store";
import { removeLocalStorage, setLocalStorage } from "@/lib/local-storage";
import { STORAGE_KEYS } from "@/lib/settings/constants";
import { clearQueuedTaskCreateLastUsedIfSynced } from "./task-create-dialog-handlers";
const StoreContext = createContext<StoreApi<AppState> | null>(null);
type E2EWindow = Window & {
__KANDEV_E2E_EXPOSE_STORE__?: boolean;
__KANDEV_E2E_STORE__?: StoreApi<AppState>;
};
export function StateProvider({ children, initialState }: StoreProviderProps) {
const parentStore = useContext(StoreContext);
const [ownStore] = useState(() => createAppStore(parentStore ? undefined : initialState));
const store = parentStore ?? ownStore;
useLayoutEffect(() => {
if (!parentStore || !initialState || Object.keys(initialState).length === 0) return;
store.getState().hydrate(initialState);
}, [initialState, parentStore, store]);
useEffect(() => {
const win = window as E2EWindow;
if (win.__KANDEV_E2E_EXPOSE_STORE__) {
win.__KANDEV_E2E_STORE__ = store;
}
}, [store]);
useLayoutEffect(() => {
syncTaskCreateLastUsedCache(store.getState());
return store.subscribe((state, prevState) => {
if (
state.userSettings.loaded === prevState.userSettings.loaded &&
taskCreateLastUsedEqual(
state.userSettings.taskCreateLastUsed,
prevState.userSettings.taskCreateLastUsed,
)
) {
return;
}
syncTaskCreateLastUsedCache(state);
});
}, [store]);
// In debug builds, let the namespaced debug logger annotate every line that
// carries a sessionId with `task_id=<...>` so console/log filters can scope to
// a single task (see lib/debug/log.ts). No-op in production.
useEffect(() => {
if (!isDebug()) return;
return registerSessionTaskResolver(
(sessionId) => store.getState().taskSessions.items[sessionId]?.task_id,
);
}, [store]);
return <StoreContext.Provider value={store}>{children}</StoreContext.Provider>;
}
function syncTaskCreateLastUsedCache(state: AppState) {
if (!state.userSettings.loaded) return;
const lastUsed = state.userSettings.taskCreateLastUsed;
syncTaskCreateLastUsedCacheField(STORAGE_KEYS.LAST_REPOSITORY_ID, lastUsed?.repositoryId);
syncTaskCreateLastUsedCacheField(STORAGE_KEYS.LAST_BRANCH, lastUsed?.branch);
syncTaskCreateLastUsedCacheField(STORAGE_KEYS.LAST_AGENT_PROFILE_ID, lastUsed?.agentProfileId);
syncTaskCreateLastUsedCacheField(
STORAGE_KEYS.LAST_EXECUTOR_PROFILE_ID,
lastUsed?.executorProfileId,
);
clearQueuedTaskCreateLastUsedIfSynced(lastUsed);
}
function syncTaskCreateLastUsedCacheField(key: string, value: string | null | undefined) {
if (value) {
setLocalStorage(key, value);
return;
}
deferRemoveTaskCreateLastUsedCacheField(key);
}
function deferRemoveTaskCreateLastUsedCacheField(key: string) {
const cachedValue = window.localStorage.getItem(key);
if (cachedValue === null) return;
window.setTimeout(() => {
if (window.localStorage.getItem(key) === cachedValue) {
removeLocalStorage(key);
}
}, 0);
}
function taskCreateLastUsedEqual(
a: AppState["userSettings"]["taskCreateLastUsed"],
b: AppState["userSettings"]["taskCreateLastUsed"],
) {
return (
a?.repositoryId === b?.repositoryId &&
a?.branch === b?.branch &&
a?.agentProfileId === b?.agentProfileId &&
a?.executorProfileId === b?.executorProfileId
);
}
export function useAppStore<T>(selector: (state: AppState) => T) {
const store = useContext(StoreContext);
if (!store) {
throw new Error("useAppStore must be used within StateProvider");
}
return useStore(store, selector);
}
export function useAppStoreApi() {
const store = useContext(StoreContext);
if (!store) {
throw new Error("useAppStoreApi must be used within StateProvider");
}
return store;
}