Files
kandev/apps/web/hooks/use-ensure-user-settings.ts
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

106 lines
3.3 KiB
TypeScript

"use client";
import { useEffect, useState } from "react";
import { useAppStore } from "@/components/state-provider";
import { readQueuedTaskCreateLastUsedState } from "@/components/task-create-dialog-handlers";
import { fetchUserSettings } from "@/lib/api/domains/settings-api";
import { mapUserSettingsResponse } from "@/lib/ssr/user-settings";
import type { TaskCreateLastUsedState, UserSettingsState } from "@/lib/state/slices/settings/types";
type LoadedUserSettings = {
settings: UserSettingsState;
};
let userSettingsFetchPromise: Promise<LoadedUserSettings | null> | null = null;
function loadUserSettingsOnce() {
if (!userSettingsFetchPromise) {
userSettingsFetchPromise = fetchUserSettings({ cache: "no-store" })
.then((response) => {
if (!response?.settings) return null;
const mapped = mapUserSettingsResponse(response);
return mapped.loaded ? { settings: mapped } : null;
})
.catch(() => null)
.finally(() => {
userSettingsFetchPromise = null;
});
}
return userSettingsFetchPromise;
}
function mergeTaskCreateLastUsedOverlay(
settings: UserSettingsState,
pending: Partial<TaskCreateLastUsedState>,
): UserSettingsState {
const definedPending = compactTaskCreateLastUsedOverlay(pending);
if (Object.keys(definedPending).length === 0) return settings;
return {
...settings,
taskCreateLastUsed: {
...settings.taskCreateLastUsed,
...definedPending,
},
};
}
function compactTaskCreateLastUsedOverlay(pending: Partial<TaskCreateLastUsedState>) {
return Object.fromEntries(
Object.entries(pending).filter(([, value]) => value !== undefined),
) as Partial<TaskCreateLastUsedState>;
}
function mergeTaskCreateLastUsedForFetch(result: LoadedUserSettings): UserSettingsState {
return mergeTaskCreateLastUsedOverlay(result.settings, {
...compactTaskCreateLastUsedOverlay(readQueuedTaskCreateLastUsedState()),
});
}
function mergeTaskCreateLastUsedForLoadedSettings(settings: UserSettingsState): UserSettingsState {
if (!settings.loaded) return settings;
return mergeTaskCreateLastUsedOverlay(settings, readQueuedTaskCreateLastUsedState());
}
export function __resetEnsureUserSettingsForTests() {
userSettingsFetchPromise = null;
}
export function useEnsureUserSettings(enabled = true) {
const userSettings = useAppStore((state) => state.userSettings);
const setUserSettings = useAppStore((state) => state.setUserSettings);
const [fetchSettled, setFetchSettled] = useState(false);
useEffect(() => {
if (!enabled) {
setFetchSettled(false);
return;
}
if (userSettings.loaded) {
setFetchSettled(true);
return;
}
let cancelled = false;
setFetchSettled(false);
loadUserSettingsOnce()
.then((result) => {
if (cancelled || !result) return;
const next = mergeTaskCreateLastUsedForFetch(result);
setUserSettings(next);
})
.finally(() => {
if (!cancelled) setFetchSettled(true);
});
return () => {
cancelled = true;
};
}, [enabled, setUserSettings, userSettings.loaded]);
const effectiveUserSettings = mergeTaskCreateLastUsedForLoadedSettings(userSettings);
return {
loaded: effectiveUserSettings.loaded || fetchSettled,
userSettings: effectiveUserSettings,
};
}