@epam/ai-dial-chat-hooks 1.3.0-dev.29 → 1.3.0-dev.294

package/project/use-project-artifacts.d.ts

@@ -0,0 +1,24 @@
+import { ProjectArtifactItemDto } from '@epam/ai-dial-chat-api-client';
+import { ProjectsApiClient } from './projects-api-client';
+/**
+ * Loads the files the agents of a project's chats saved under its
+ * `artifacts/` folder, for the project view's Outputs section, and keeps them
+ * in local state. The list is read once per project (and on retry), and
+ * `refresh` silently re-reads it for live updates, keeping the shown outputs
+ * when it fails. A `refresh` that arrives while a read is in flight is not
+ * dropped: that read lists once more before it settles. A retry keeps
+ * `hasError` until its read settles, so the host's error UI stays in place. A
+ * request is aborted by a newer one, a project change or unmount.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`; it must be referentially stable, because a new object reloads the list.
+ * @param projectId - The project's DIAL id, or `null` while none is known.
+ */
+export declare const useProjectArtifacts: (client: Pick<ProjectsApiClient, "listProjectArtifacts">, projectId: string | null) => {
+    retry: () => void;
+    refresh: () => Promise<void>;
+    /** The project's outputs, newest first, as the BFF lists them. */
+    items: ProjectArtifactItemDto[];
+    isLoading: boolean;
+    hasError: boolean;
+};
+//# sourceMappingURL=use-project-artifacts.d.ts.map

package/project/use-project-artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-project-artifacts.d.ts","sourceRoot":"","sources":["../../src/project/use-project-artifacts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAoB/D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,EACvD,WAAW,MAAM,GAAG,IAAI;;;IAhCxB,kEAAkE;WAC3D,sBAAsB,EAAE;eACpB,OAAO;cACR,OAAO;CAyGlB,CAAC"}

package/project/use-project-artifacts.js

@@ -0,0 +1,78 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+//#region src/project/use-project-artifacts.ts
+var i = {
+	items: [],
+	isLoading: !0,
+	hasError: !1
+}, a = {
+	...i,
+	isLoading: !1
+}, o = (o, s) => {
+	let [c, l] = r(i), [u, d] = r(0), f = n(null), p = n(!1), m = n(null), h = n(c);
+	t(() => {
+		h.current = c;
+	}), t(() => {
+		let e = m.current === s;
+		if (m.current = s, s == null) {
+			l(a);
+			return;
+		}
+		let t = new AbortController();
+		return p.current = !1, (async () => {
+			l((t) => e ? {
+				...t,
+				isLoading: !0
+			} : i);
+			try {
+				let e;
+				do
+					if (p.current = !1, {items: e} = await o.listProjectArtifacts(s, t.signal), t.signal.aborted) return;
+				while (p.current);
+				l({
+					items: e,
+					isLoading: !1,
+					hasError: !1
+				});
+			} catch {
+				if (t.signal.aborted) return;
+				l({
+					...a,
+					hasError: !0
+				});
+			}
+		})(), () => {
+			t.abort(), f.current?.abort();
+		};
+	}, [
+		o,
+		s,
+		u
+	]);
+	let g = e(() => d((e) => e + 1), []), _ = e(async () => {
+		let e = h.current;
+		if (s == null) return;
+		if (e.isLoading) {
+			p.current = !0;
+			return;
+		}
+		if (e.hasError) return;
+		f.current?.abort();
+		let t = new AbortController();
+		f.current = t;
+		try {
+			let { items: e } = await o.listProjectArtifacts(s, t.signal);
+			if (t.signal.aborted) return;
+			l((t) => ({
+				...t,
+				items: e
+			}));
+		} catch {}
+	}, [o, s]);
+	return {
+		...c,
+		retry: g,
+		refresh: _
+	};
+};
+//#endregion
+export { o as useProjectArtifacts };

package/project/use-project-conversations.d.ts

@@ -0,0 +1,29 @@
+import { ProjectConversationListItem } from '@epam/ai-dial-projects';
+import { ProjectsApiClient } from './projects-api-client';
+/**
+ * Loads a project's conversations for its Chats list and keeps them in local
+ * state: the first page is read once per project (and on retry), `loadMore`
+ * appends the next one, `refresh` silently re-reads the rows already shown
+ * for live updates, and rename, delete and `markViewed` update the list in
+ * place. Requests are aborted when the project changes or the view unmounts.
+ * Rename, delete and `loadMore` reject on failure for the caller's toast.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`; it must be referentially stable, because a new object reloads the list.
+ * @param projectId - The project's DIAL id, or `null` while none is known.
+ */
+export declare const useProjectConversations: (client: Pick<ProjectsApiClient, "listProjectConversations" | "renameProjectConversation" | "deleteProjectConversation" | "markProjectConversationViewed">, projectId: string | null) => {
+    retry: () => void;
+    loadMore: () => Promise<void>;
+    rename: (id: string, newTitle: string) => Promise<void>;
+    remove: (id: string) => Promise<void>;
+    refresh: () => Promise<void>;
+    markViewed: (id: string) => void;
+    items: ProjectConversationListItem[];
+    isLoading: boolean;
+    hasError: boolean;
+    /** More conversations exist after `items`. */
+    hasMore: boolean;
+    /** The next page is being read. */
+    isLoadingMore: boolean;
+};
+//# sourceMappingURL=use-project-conversations.d.ts.map

package/project/use-project-conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-project-conversations.d.ts","sourceRoot":"","sources":["../../src/project/use-project-conversations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AA2D/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,GAClC,QAAQ,IAAI,CACV,iBAAiB,EACf,0BAA0B,GAC1B,2BAA2B,GAC3B,2BAA2B,GAC3B,+BAA+B,CAClC,EACD,WAAW,MAAM,GAAG,IAAI;;;iBAyKX,MAAM,YAAY,MAAM;iBAaxB,MAAM;;qBAlCZ,MAAM;WA/NN,2BAA2B,EAAE;eACzB,OAAO;cACR,OAAO;IACjB,8CAA8C;aACrC,OAAO;IAChB,mCAAmC;mBACpB,OAAO;CA8QvB,CAAC"}

package/project/use-project-conversations.js

@@ -0,0 +1,182 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+//#region src/project/use-project-conversations.ts
+var i = {
+	items: [],
+	isLoading: !0,
+	hasError: !1,
+	hasMore: !1,
+	isLoadingMore: !1
+}, a = {
+	...i,
+	isLoading: !1
+}, o = 50, s = 100, c = (e, t) => e.map(({ id: e, title: n, author: r, updatedAt: i, isUnread: a }) => {
+	let o = a;
+	if (t.has(e)) {
+		let n = t.get(e);
+		i != null && n != null && i > n ? t.delete(e) : o = !1;
+	}
+	return {
+		id: e,
+		title: n,
+		authorName: r,
+		...o ? { isUnread: !0 } : {}
+	};
+}), l = (l, u) => {
+	let [d, f] = r(i), [p, m] = r(0), h = n(null), g = n(null), _ = n(0), v = n(/* @__PURE__ */ new Map()), y = n(/* @__PURE__ */ new Map()), b = n(d);
+	t(() => {
+		b.current = d;
+	});
+	let x = e((e) => {
+		for (let { id: t, updatedAt: n } of e) y.current.set(t, n);
+	}, []);
+	t(() => {
+		if (v.current = /* @__PURE__ */ new Map(), y.current = /* @__PURE__ */ new Map(), u == null) {
+			f(a);
+			return;
+		}
+		let e = new AbortController();
+		return h.current = e, (async () => {
+			f((e) => ({
+				...e,
+				isLoading: !0,
+				hasError: !1,
+				isLoadingMore: !1
+			}));
+			try {
+				let t = await l.listProjectConversations(u, e.signal);
+				if (e.signal.aborted) return;
+				x(t.items), f({
+					items: c(t.items, v.current),
+					isLoading: !1,
+					hasError: !1,
+					hasMore: t.hasMore,
+					isLoadingMore: !1
+				});
+			} catch {
+				if (e.signal.aborted) return;
+				f({
+					...a,
+					hasError: !0
+				});
+			}
+		})(), () => {
+			e.abort(), g.current?.abort();
+		};
+	}, [
+		l,
+		u,
+		p,
+		x
+	]);
+	let S = e(() => m((e) => e + 1), []), C = e(async () => {
+		let e = h.current;
+		if (u == null || e == null) return;
+		let t = _.current;
+		f((e) => ({
+			...e,
+			isLoadingMore: !0
+		}));
+		try {
+			let n = await l.listProjectConversations(u, e.signal, { offset: d.items.length });
+			if (e.signal.aborted) return;
+			if (t !== _.current) {
+				f((e) => ({
+					...e,
+					isLoadingMore: !1
+				}));
+				return;
+			}
+			x(n.items), f((e) => {
+				let t = new Set(e.items.map((e) => e.id));
+				return {
+					...e,
+					items: [...e.items, ...c(n.items, v.current).filter((e) => !t.has(e.id))],
+					hasMore: n.hasMore,
+					isLoadingMore: !1
+				};
+			});
+		} catch (t) {
+			if (e.signal.aborted) return;
+			throw f((e) => ({
+				...e,
+				isLoadingMore: !1
+			})), t;
+		}
+	}, [
+		l,
+		u,
+		x,
+		d.items.length
+	]), w = e(async () => {
+		let e = b.current;
+		if (u == null || e.isLoading || e.hasError) return;
+		g.current?.abort();
+		let t = new AbortController();
+		g.current = t, _.current += 1;
+		let n = Math.max(e.items.length, o), r = [], i = !0;
+		try {
+			for (; r.length < n && i;) {
+				let e = await l.listProjectConversations(u, t.signal, {
+					offset: r.length,
+					limit: Math.min(s, n - r.length)
+				});
+				if (t.signal.aborted) return;
+				if (r.push(...e.items), i = e.hasMore, e.items.length === 0) break;
+			}
+		} catch {
+			return;
+		}
+		if (t.signal.aborted) return;
+		x(r);
+		let a = /* @__PURE__ */ new Set(), d = c(r, v.current).filter((e) => !a.has(e.id) && (a.add(e.id), !0));
+		f((e) => ({
+			...e,
+			items: d,
+			hasMore: i,
+			isLoadingMore: !1
+		}));
+	}, [
+		l,
+		u,
+		x
+	]);
+	t(() => () => g.current?.abort(), []);
+	let T = e((e) => {
+		v.current.set(e, y.current.get(e)), f((t) => ({
+			...t,
+			items: t.items.map((t) => t.id === e && t.isUnread ? {
+				...t,
+				isUnread: !1
+			} : t)
+		})), (async () => {
+			try {
+				await l.markProjectConversationViewed?.(e);
+			} catch {}
+		})();
+	}, [l]), E = e(async (e, t) => {
+		let { name: n } = await l.renameProjectConversation(e, t);
+		f((t) => ({
+			...t,
+			items: t.items.map((t) => t.id === e ? {
+				...t,
+				title: n
+			} : t)
+		}));
+	}, [l]), D = e(async (e) => {
+		await l.deleteProjectConversation(e), f((t) => ({
+			...t,
+			items: t.items.filter((t) => t.id !== e)
+		}));
+	}, [l]);
+	return {
+		...d,
+		retry: S,
+		loadMore: C,
+		rename: E,
+		remove: D,
+		refresh: w,
+		markViewed: T
+	};
+};
+//#endregion
+export { l as useProjectConversations };

package/project/use-project-submit.d.ts

@@ -0,0 +1,49 @@
+import { CreateProjectResponseDto, UpdateProjectResponseDto } from '@epam/ai-dial-chat-api-client';
+import { ProjectFields, ProjectsApiClient, ProjectUpdateRequest } from './projects-api-client';
+/** A rejected create or save, normalised for the page. */
+export interface ProjectSubmitFailure {
+    /** `true` when the page unmounted mid-request; nothing should be shown. */
+    isAborted: boolean;
+    /** HTTP status of the rejection. */
+    status?: number;
+    /** The BFF's `ProjectCreateErrorCode`, when the rejection carried one. */
+    code?: string;
+    /** Trace id for the error toast. */
+    requestId?: string;
+}
+/** Result of one {@link useCreateProject} `create` call. */
+export type CreateProjectOutcome = {
+    isCreated: true;
+    project: CreateProjectResponseDto;
+} | ({
+    isCreated: false;
+} & ProjectSubmitFailure);
+/** Result of one {@link useSaveProject} `save` call. */
+export type SaveProjectOutcome = {
+    isSaved: true;
+    project: UpdateProjectResponseDto;
+} | ({
+    isSaved: false;
+} & ProjectSubmitFailure);
+/**
+ * Submits the New project form; the page owns the form state and decides
+ * what each outcome means.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`.
+ */
+export declare const useCreateProject: (client: Pick<ProjectsApiClient, "createProject">) => {
+    create: (fields: ProjectFields, files: File[]) => Promise<CreateProjectOutcome>;
+    isSubmitting: boolean;
+};
+/**
+ * Submits the Edit project form as one atomic update, conditioned on the
+ * loaded `contentVersion`; the page owns the draft and decides what each
+ * outcome means.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`.
+ */
+export declare const useSaveProject: (client: Pick<ProjectsApiClient, "updateProject">) => {
+    save: (request: ProjectUpdateRequest) => Promise<SaveProjectOutcome>;
+    isSubmitting: boolean;
+};
+//# sourceMappingURL=use-project-submit.d.ts.map

package/project/use-project-submit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-project-submit.d.ts","sourceRoot":"","sources":["../../src/project/use-project-submit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAE/B,0DAA0D;AAC1D,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,SAAS,EAAE,OAAO,CAAC;IACnB,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,4DAA4D;AAC5D,MAAM,MAAM,oBAAoB,GAC5B;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,wBAAwB,CAAA;CAAE,GACtD,CAAC;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,GAAG,oBAAoB,CAAC,CAAC;AAElD,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAC1B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,wBAAwB,CAAA;CAAE,GACpD,CAAC;IAAE,OAAO,EAAE,KAAK,CAAA;CAAE,GAAG,oBAAoB,CAAC,CAAC;AAkDhD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC;qBAMpC,aAAa,SACd,IAAI,EAAE,KACZ,OAAO,CAAC,oBAAoB,CAAC;;CAYnC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC;oBAK9B,oBAAoB,KAAG,OAAO,CAAC,kBAAkB,CAAC;;CAYrE,CAAC"}

package/project/use-project-submit.js

@@ -0,0 +1,73 @@
+import { getApiErrorDetails as e } from "../api-error/api-error.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
+//#region src/project/use-project-submit.ts
+var a = () => {
+	let [a, o] = i(!1), s = r(null);
+	return n(() => () => {
+		s.current?.abort();
+	}, []), {
+		run: t(async (t) => {
+			s.current?.abort();
+			let n = new AbortController();
+			s.current = n, o(!0);
+			try {
+				return {
+					isOk: !0,
+					value: await t(n.signal)
+				};
+			} catch (t) {
+				if (n.signal.aborted) return {
+					isOk: !1,
+					isAborted: !0
+				};
+				let { status: r, code: i, traceId: a } = await e(t);
+				return {
+					isOk: !1,
+					isAborted: !1,
+					status: r,
+					code: i,
+					requestId: a
+				};
+			} finally {
+				n.signal.aborted || o(!1), s.current === n && (s.current = null);
+			}
+		}, []),
+		isSubmitting: a
+	};
+}, o = (e) => {
+	let { run: n, isSubmitting: r } = a();
+	return {
+		create: t(async (t, r) => {
+			let i = await n((n) => e.createProject(t, r, n));
+			if (i.isOk) return {
+				isCreated: !0,
+				project: i.value
+			};
+			let { isOk: a, ...o } = i;
+			return {
+				isCreated: !1,
+				...o
+			};
+		}, [e, n]),
+		isSubmitting: r
+	};
+}, s = (e) => {
+	let { run: n, isSubmitting: r } = a();
+	return {
+		save: t(async (t) => {
+			let r = await n((n) => e.updateProject(t, n));
+			if (r.isOk) return {
+				isSaved: !0,
+				project: r.value
+			};
+			let { isOk: i, ...a } = r;
+			return {
+				isSaved: !1,
+				...a
+			};
+		}, [e, n]),
+		isSubmitting: r
+	};
+};
+//#endregion
+export { o as useCreateProject, s as useSaveProject };

package/project/use-project-watch.d.ts

@@ -0,0 +1,24 @@
+import { ProjectsApiClient } from './projects-api-client';
+/** What `useProjectWatch` reports to the page that shows one project. */
+export interface ProjectWatchOptions {
+    /** The loaded snapshot's aggregate ETag; the watch opens once it is known, and an event carrying it is skipped. */
+    etag: string | undefined;
+    /** Silent refresh of everything the page shows; at most one runs at a time, and a rejection is ignored. */
+    onChange: () => Promise<void>;
+    /** The project was deleted elsewhere; called at most once per project id. */
+    onDelete: () => void;
+}
+/**
+ * Keeps a page showing one project current: it watches that project, runs
+ * `onChange` for each change the page has not loaded yet — one at a time,
+ * plus one trailing run for whatever arrived meanwhile — and `onDelete` once
+ * when the project is deleted. A dropped stream is reopened with a bounded
+ * backoff and followed by one `onChange`; a watch that cannot be opened is
+ * not retried for the rest of the visit.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`; it must be referentially stable, because a new object resubscribes.
+ * @param projectId - The watched project's DIAL id, or `null` while none is known.
+ * @param options - The loaded ETag and the page's callbacks; read at event time, so new identities never resubscribe.
+ */
+export declare const useProjectWatch: (client: Pick<ProjectsApiClient, "watchProjects">, projectId: string | null, options: ProjectWatchOptions) => void;
+//# sourceMappingURL=use-project-watch.d.ts.map

package/project/use-project-watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-project-watch.d.ts","sourceRoot":"","sources":["../../src/project/use-project-watch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,yEAAyE;AACzE,MAAM,WAAW,mBAAmB;IAClC,mHAAmH;IACnH,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,2GAA2G;IAC3G,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EAChD,WAAW,MAAM,GAAG,IAAI,EACxB,SAAS,mBAAmB,KAC3B,IAwEF,CAAC"}

package/project/use-project-watch.js

@@ -0,0 +1,41 @@
+import { runProjectWatch as e } from "./project-watch-stream.js";
+import { ProjectWatchAction as t } from "@epam/ai-dial-chat-api-client";
+import { useEffect as n, useRef as r } from "react";
+//#region src/project/use-project-watch.ts
+var i = (i, a, o) => {
+	let s = r(o);
+	n(() => {
+		s.current = o;
+	});
+	let c = r(null), l = o.etag != null, { watchProjects: u } = i;
+	n(() => {
+		if (u == null || a == null || !l || c.current === a) return;
+		let n = new AbortController(), r = !1, i = !1, o = () => {
+			n.signal.aborted || (r ? i = !0 : (r = !0, (async () => {
+				try {
+					await s.current.onChange();
+				} catch {} finally {
+					r = !1, i && (i = !1, o());
+				}
+			})()));
+		};
+		return e({
+			watchProjects: u,
+			ids: [a],
+			signal: n.signal,
+			onEvent: (e) => {
+				e.id !== a || n.signal.aborted || (e.action === t.Delete ? (i = !1, n.abort(), s.current.onDelete()) : (e.etag == null || e.etag !== s.current.etag) && o());
+			},
+			onReconnected: o,
+			onUnavailable: () => {
+				c.current = a;
+			}
+		}), () => n.abort();
+	}, [
+		u,
+		a,
+		l
+	]);
+};
+//#endregion
+export { i as useProjectWatch };

package/project/use-project.d.ts

@@ -0,0 +1,23 @@
+import { ProjectDetailsDto } from '@epam/ai-dial-chat-api-client';
+import { ProjectRefreshOutcome } from './project-refresh';
+import { ProjectsApiClient } from './projects-api-client';
+/**
+ * Loads one project's details. Loading is derived from whether a result
+ * answers the current id and reload token, so a page never renders a stale
+ * project for a new id. A `404` is a not-found result, every other failure an
+ * error; the request is aborted on unmount and on an id change. `refresh`
+ * re-reads the loaded project without the loading state, for live updates.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`; it must be referentially stable, because a new object reloads.
+ * @param id - The project's DIAL id, or `null` when the route names none.
+ * @param enabled - Whether the page is enabled; no request is sent while `false`.
+ */
+export declare const useProject: (client: Pick<ProjectsApiClient, "getProject">, id: string | null, enabled: boolean) => {
+    project: ProjectDetailsDto | null;
+    isLoading: boolean;
+    hasError: boolean;
+    isNotFound: boolean;
+    retry: () => void;
+    refresh: () => Promise<ProjectRefreshOutcome>;
+};
+//# sourceMappingURL=use-project.d.ts.map

package/project/use-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-project.d.ts","sourceRoot":"","sources":["../../src/project/use-project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAU/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,EAC7C,IAAI,MAAM,GAAG,IAAI,EACjB,SAAS,OAAO;;;;;;mBA2CsB,OAAO,CAAC,qBAAqB,CAAC;CA8BrE,CAAC"}

package/project/use-project.js

@@ -0,0 +1,73 @@
+import { getApiErrorStatus as e } from "../api-error/api-error.js";
+import { ProjectRefreshOutcome as t } from "./project-refresh.js";
+import { useCallback as n, useEffect as r, useRef as i, useState as a } from "react";
+//#region src/project/use-project.ts
+var o = (o, s, c) => {
+	let [l, u] = a(0), [d, f] = a(), p = `${l}:${s ?? ""}`;
+	r(() => {
+		if (!c || s == null) return;
+		let t = new AbortController();
+		return (async () => {
+			try {
+				let e = await o.getProject(s, t.signal);
+				if (t.signal.aborted) return;
+				f({
+					key: p,
+					project: e,
+					hasError: !1,
+					isNotFound: !1
+				});
+			} catch (n) {
+				if (t.signal.aborted) return;
+				let r = e(n) === 404;
+				f({
+					key: p,
+					project: null,
+					hasError: !r,
+					isNotFound: r
+				});
+			}
+		})(), () => t.abort();
+	}, [
+		o,
+		c,
+		s,
+		p
+	]);
+	let m = n(() => {
+		u((e) => e + 1);
+	}, []), h = d?.key === p ? d : void 0, g = h?.project ?? null, _ = i(null);
+	r(() => () => {
+		_.current?.abort(), _.current = null;
+	}, [p]);
+	let v = n(async () => {
+		if (g == null || s == null) return t.Skipped;
+		_.current?.abort();
+		let n = new AbortController();
+		_.current = n;
+		try {
+			let e = await o.getProject(s, n.signal);
+			return n.signal.aborted ? t.Skipped : (f((t) => t?.key === p ? {
+				...t,
+				project: e
+			} : t), t.Updated);
+		} catch (r) {
+			return n.signal.aborted ? t.Skipped : e(r) === 404 ? t.NotFound : t.Failed;
+		}
+	}, [
+		o,
+		s,
+		p,
+		g
+	]);
+	return {
+		project: g,
+		isLoading: c && s != null && h == null,
+		hasError: h?.hasError ?? !1,
+		isNotFound: h?.isNotFound ?? !1,
+		retry: m,
+		refresh: v
+	};
+};
+//#endregion
+export { o as useProject };

package/project/use-projects.d.ts

@@ -0,0 +1,27 @@
+import { ProjectItem, ProjectSource } from '@epam/ai-dial-projects';
+import { ProjectsApiClient } from './projects-api-client';
+/**
+ * Loads the projects the session user can see, mapped to the Projects lib's
+ * cards, and keeps them current while mounted. Loading is derived from
+ * whether a result answers the current reload token, so an enabled page is
+ * loading from its very first render. The request is aborted on unmount or
+ * when `enabled` turns false.
+ *
+ * When the client offers `watchProjects`, a successful load opens one watch
+ * stream for the listed projects: an update moves a card's `updatedAt`
+ * forward and a delete removes it. A stream that drops is reopened with a
+ * bounded backoff and followed by a silent reload, so changes made during
+ * the gap are not lost; a watch that cannot be opened at all is not retried
+ * for the rest of the visit.
+ *
+ * @param client - Configured project requests, from `createProjectsApiClient`; it must be referentially stable, because a new object reloads.
+ * @param enabled - Whether the page is enabled; no request is sent while `false`.
+ */
+export declare const useProjects: (client: Pick<ProjectsApiClient, "listProjects" | "watchProjects">, enabled: boolean) => {
+    projects: ProjectItem[];
+    incompleteSources: ProjectSource[];
+    isLoading: boolean;
+    hasError: boolean;
+    retry: () => void;
+};
+//# sourceMappingURL=use-projects.d.ts.map

package/project/use-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-projects.d.ts","sourceRoot":"","sources":["../../src/project/use-projects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAKzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAoC/D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,IAAI,CAAC,iBAAiB,EAAE,cAAc,GAAG,eAAe,CAAC,EACjE,SAAS,OAAO;;;;;;CAmGjB,CAAC"}