@epam/ai-dial-chat-hooks 1.1.0-dev.383 → 1.1.0-dev.390

package/scheduled-task-trigger-D9RZCk52.js

@@ -0,0 +1,145 @@
+import { n as e } from "./formatting-CZyyxBG3.js";
+import { n as t, t as n } from "./cron-weekday-B4w29eAC.js";
+import { ScheduledTaskRepeat as r } from "@epam/ai-dial-scheduled-tasks";
+//#region src/scheduled-task/scheduled-task-mapping.ts
+var i = /* @__PURE__ */ function(e) {
+	return e.UnsupportedCronShape = "unsupportedCronShape", e.UnsupportedTriggerType = "unsupportedTriggerType", e.MissingRequiredFields = "missingRequiredFields", e;
+}({}), a = new Set([
+	"hour",
+	"minute",
+	"day_of_week",
+	"day"
+]), o = "09:00", s = (e) => {
+	if (e.repeat === r.Hourly) {
+		let t = /* @__PURE__ */ new Date();
+		return t.setHours(0, Number(e.minute), 0, 0), {
+			hour: "*",
+			minute: String(t.getUTCMinutes())
+		};
+	}
+	let [i, a] = e.time.split(":"), o = Number(i), s = Number(a), c = /* @__PURE__ */ new Date();
+	c.setHours(o, s, 0, 0);
+	let l = e.repeat === r.Weekly && !!e.dayOfWeek, u = e.repeat === r.Monthly && !!e.dayOfMonth;
+	if (l) {
+		let t = (n(Number(e.dayOfWeek)) - c.getDay() + 7) % 7;
+		c.setDate(c.getDate() + t);
+	} else u && c.setDate(Number(e.dayOfMonth));
+	let d = {
+		hour: String(c.getUTCHours()),
+		minute: String(c.getUTCMinutes())
+	};
+	return l && (d.day_of_week = String(t(c.getUTCDay()))), u && (d.day = String(c.getUTCDate())), d;
+}, c = (e, t) => {
+	let [n, r, i] = e.split("-").map(Number), a = new Date(n, r - 1, i);
+	return t === "start" ? a.setHours(0, 0, 0, 0) : a.setHours(23, 59, 59, 999), a.toISOString();
+}, l = (e) => {
+	let t = e.repeat === r.OneTime ? { date: new Date(e.runAt ?? "").toISOString() } : { cron: {
+		fields: s(e),
+		...e.startDate ? { startDate: c(e.startDate, "start") } : {},
+		...e.endDate ? { endDate: c(e.endDate, "end") } : {}
+	} }, n = e.description?.trim();
+	return {
+		displayName: e.displayName.trim(),
+		trigger: t,
+		model: e.modelId,
+		prompt: e.prompt.trim(),
+		...n ? { description: n } : {}
+	};
+}, u = (e) => l(e), d = (t) => {
+	let n = new Date(t);
+	return `${n.getFullYear()}-${e(n.getMonth() + 1)}-${e(n.getDate())}T${e(n.getHours())}:${e(n.getMinutes())}`;
+}, f = (t) => {
+	let n = new Date(t);
+	return `${n.getFullYear()}-${e(n.getMonth() + 1)}-${e(n.getDate())}`;
+}, p = (r) => {
+	let i = new Set(Object.entries(r).filter(([, e]) => e != null).map(([e]) => e)), o = [...i].filter((e) => !a.has(e)), s = i.has("day_of_week"), c = i.has("day");
+	if (o.length > 0 || s && c || !i.has("hour") || !i.has("minute")) return { ok: !1 };
+	if (r.hour === "*" && /^\d+$/.test(String(r.minute)) && !s && !c) {
+		let e = /* @__PURE__ */ new Date();
+		return e.setUTCHours(0, Number(r.minute), 0, 0), {
+			ok: !0,
+			isHourly: !0,
+			minute: String(e.getMinutes())
+		};
+	}
+	let l = Number(r.hour), u = Number(r.minute);
+	if (Number.isNaN(l) || Number.isNaN(u)) return { ok: !1 };
+	let d = /* @__PURE__ */ new Date();
+	if (d.setUTCHours(l, u, 0, 0), s) {
+		let e = Number(r.day_of_week);
+		if (Number.isNaN(e)) return { ok: !1 };
+		let t = (n(e) - d.getUTCDay() + 7) % 7;
+		d.setUTCDate(d.getUTCDate() + t);
+	} else if (c) {
+		let e = Number(r.day);
+		if (Number.isNaN(e)) return { ok: !1 };
+		d.setUTCDate(e);
+	}
+	return {
+		ok: !0,
+		isHourly: !1,
+		time: `${e(d.getHours())}:${e(d.getMinutes())}`,
+		...s ? { dayOfWeek: String(t(d.getDay())) } : {},
+		...c ? { dayOfMonth: String(d.getDate()) } : {}
+	};
+}, m = (e) => {
+	if (!e.model || !e.prompt) return {
+		ok: !1,
+		reason: i.MissingRequiredFields
+	};
+	let { date: t, cron: n } = e.trigger, a = !!t;
+	if (a === !!n) return {
+		ok: !1,
+		reason: i.UnsupportedTriggerType
+	};
+	let s = {
+		displayName: e.displayName,
+		modelId: e.model,
+		prompt: e.prompt,
+		...e.description ? { description: e.description } : {}
+	};
+	if (a) return {
+		ok: !0,
+		values: {
+			...s,
+			repeat: r.OneTime,
+			runAt: d(t),
+			time: o
+		}
+	};
+	if (!n) return {
+		ok: !1,
+		reason: i.UnsupportedTriggerType
+	};
+	let c = p(n.fields);
+	if (!c.ok) return {
+		ok: !1,
+		reason: i.UnsupportedCronShape
+	};
+	if (c.isHourly) return {
+		ok: !0,
+		values: {
+			...s,
+			repeat: r.Hourly,
+			time: o,
+			minute: c.minute,
+			...n.startDate ? { startDate: f(n.startDate) } : {},
+			...n.endDate ? { endDate: f(n.endDate) } : {}
+		}
+	};
+	let l = r.Daily;
+	return c.dayOfWeek ? l = r.Weekly : c.dayOfMonth && (l = r.Monthly), {
+		ok: !0,
+		values: {
+			...s,
+			repeat: l,
+			time: c.time,
+			...c.dayOfWeek ? { dayOfWeek: c.dayOfWeek } : {},
+			...c.dayOfMonth ? { dayOfMonth: c.dayOfMonth } : {},
+			...n.startDate ? { startDate: f(n.startDate) } : {},
+			...n.endDate ? { endDate: f(n.endDate) } : {}
+		}
+	};
+};
+//#endregion
+export { i, u as n, m as r, l as t };

package/{scheduled-task/scheduled-task-trigger.d.ts → scheduled-tasks.d.ts}

@@ -1,27 +1,51 @@
-import { CreateScheduledTaskBodyDto, ScheduledTaskDto, UpdateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
-import { ScheduledTaskCreateFormValues } from '@epam/ai-dial-scheduled-tasks';
-import { ScheduledTaskDtoMappingResult } from './scheduled-task-mapping';
-/**
- * Maps validated create-form values to the `POST /api/v1/scheduled-tasks`
- * request body, building `trigger.date` for a one-shot schedule or
- * `trigger.cron.fields` for a recurring one. Assumes the caller has already
- * validated required fields (name, model, prompt, and the active schedule
- * section's fields) — this function does not re-validate.
- */
-export declare const mapFormValuesToCreateBody: (values: ScheduledTaskCreateFormValues) => CreateScheduledTaskBodyDto;
-/**
- * Maps validated edit-form values to the `PUT /api/v1/scheduled-tasks/:scheduleId`
- * request body. `UpdateScheduledTaskBodyDto` has the same shape as
- * `CreateScheduledTaskBodyDto`, so this reuses the same trigger-building logic.
- */
-export declare const mapFormValuesToUpdateBody: (values: ScheduledTaskCreateFormValues) => UpdateScheduledTaskBodyDto;
-/**
- * Attempts to map a {@link ScheduledTaskDto} back to editable
- * {@link ScheduledTaskCreateFormValues}, inverting {@link buildCronFields}/
- * {@link buildCronWindowBoundary}. Fails closed — returning a reason instead
- * of a value — whenever the task's trigger or required fields cannot be
- * represented losslessly by the editor, so an unsupported schedule is never
- * silently coerced and re-submitted.
- */
-export declare const mapScheduledTaskDtoToFormValues: (dto: ScheduledTaskDto) => ScheduledTaskDtoMappingResult;
-//# sourceMappingURL=scheduled-task-trigger.d.ts.map
+import { CreateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
+import { ScheduledTaskCreateFormValues } from '@epam/ai-dial-scheduled-tasks';
+import { ScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
+import { UpdateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
+
+/**
+ * Maps validated create-form values to the `POST /api/v1/scheduled-tasks`
+ * request body, building `trigger.date` for a one-shot schedule or
+ * `trigger.cron.fields` for a recurring one. Assumes the caller has already
+ * validated required fields (name, model, prompt, and the active schedule
+ * section's fields) — this function does not re-validate.
+ */
+export declare const mapFormValuesToCreateBody: (values: ScheduledTaskCreateFormValues) => CreateScheduledTaskBodyDto;
+
+/**
+ * Maps validated edit-form values to the `PUT /api/v1/scheduled-tasks/:scheduleId`
+ * request body. `UpdateScheduledTaskBodyDto` has the same shape as
+ * `CreateScheduledTaskBodyDto`, so this reuses the same trigger-building logic.
+ */
+export declare const mapFormValuesToUpdateBody: (values: ScheduledTaskCreateFormValues) => UpdateScheduledTaskBodyDto;
+
+/**
+ * Attempts to map a {@link ScheduledTaskDto} back to editable
+ * {@link ScheduledTaskCreateFormValues}, inverting {@link buildCronFields}/
+ * {@link buildCronWindowBoundary}. Fails closed — returning a reason instead
+ * of a value — whenever the task's trigger or required fields cannot be
+ * represented losslessly by the editor, so an unsupported schedule is never
+ * silently coerced and re-submitted.
+ */
+export declare const mapScheduledTaskDtoToFormValues: (dto: ScheduledTaskDto) => ScheduledTaskDtoMappingResult;
+
+/** Result of mapping a scheduled task DTO back to editable form values. */
+export declare type ScheduledTaskDtoMappingResult = {
+    ok: true;
+    values: ScheduledTaskCreateFormValues;
+} | {
+    ok: false;
+    reason: UnsupportedTriggerReason;
+};
+
+/** Why a scheduled task DTO could not be mapped back to editable form values. */
+export declare enum UnsupportedTriggerReason {
+    /** `trigger.cron.fields` uses a shape (extra keys, or both `day_of_week` and `day`) the editor's schedule controls cannot represent. */
+    UnsupportedCronShape = "unsupportedCronShape",
+    /** Neither or both of `trigger.date`/`trigger.cron` are set, so the schedule type cannot be determined. */
+    UnsupportedTriggerType = "unsupportedTriggerType",
+    /** The task is missing `model` or `prompt`, so it cannot be represented as a valid update payload. */
+    MissingRequiredFields = "missingRequiredFields"
+}
+
+export { }

package/scheduled-tasks.js

@@ -0,0 +1,2 @@
+import { i as e, n as t, r as n, t as r } from "./scheduled-task-trigger-D9RZCk52.js";
+export { e as UnsupportedTriggerReason, r as mapFormValuesToCreateBody, t as mapFormValuesToUpdateBody, n as mapScheduledTaskDtoToFormValues };

package/{conversation/useConversationScroll/useConversationScroll.d.ts → scroll-anchoring.d.ts}

@@ -1,46 +1,50 @@
-import { RefObject } from 'react';
-/** Parameters for {@link useConversationScroll}. `T` is never read — only `messages.length` is used to detect growth/reset. */
-export interface UseConversationScrollParams<T> {
-    /** Messages currently rendered in the list. */
-    messages: T[];
-    /** Whether an assistant response is currently streaming in. */
-    isAssistantTyping: boolean;
-    /** Identifier of the conversation being displayed. */
-    conversationId: string;
-}
-/** Return value of {@link useConversationScroll}. */
-export interface UseConversationScrollResult {
-    /** Attach to the scrollable message-list element. */
-    containerRef: RefObject<HTMLDivElement | null>;
-    /** Attach to the element wrapping all rendered messages (used to detect content growth). */
-    contentRef: RefObject<HTMLDivElement | null>;
-    /**
-     * Attach to a spacer element, a sibling rendered right after `contentRef`
-     * inside `containerRef`. Its height is set imperatively, not via React
-     * state. Render it with `shrink-0` and an initial `style={{ height: 0 }}`.
-     */
-    spacerRef: RefObject<HTMLDivElement | null>;
-    /** Callback ref to register/unregister a rendered message's DOM node by index. */
-    setMessageRef: (index: number, el: HTMLDivElement | null) => void;
-    /** Whether the scroll-to-bottom button should be shown. */
-    isScrollButtonVisible: boolean;
-    /** Smoothly scrolls to the current bottom of the actual message content. */
-    scrollToBottom: () => void;
-    /**
-     * Arms the message at `index` to be scrolled near the top of the viewport
-     * on the next render — call right before triggering a send, regenerate,
-     * or edit-and-resubmit so the resulting message anchors near the top.
-     */
-    armAnchor: (index: number) => void;
-}
-/**
- * Owns chat-list scrolling: anchors a new turn near the viewport top, keeps
- * the position stable while the response streams, and reports whether the
- * scroll-to-bottom button should be shown.
- *
- * The temporary spacer is technical scroll room, not user-visible content:
- * it is sized to the minimum required to make the anchor reachable and manual
- * scrolling is clamped before the user can move past the real message content.
- */
-export declare const useConversationScroll: <T>({ messages, isAssistantTyping, conversationId, }: UseConversationScrollParams<T>) => UseConversationScrollResult;
-//# sourceMappingURL=useConversationScroll.d.ts.map
+import { RefObject } from 'react';
+
+/**
+ * Owns chat-list scrolling: anchors a new turn near the viewport top, keeps
+ * the position stable while the response streams, and reports whether the
+ * scroll-to-bottom button should be shown.
+ *
+ * The temporary spacer is technical scroll room, not user-visible content:
+ * it is sized to the minimum required to make the anchor reachable and manual
+ * scrolling is clamped before the user can move past the real message content.
+ */
+export declare const useConversationScroll: <T>({ messages, isAssistantTyping, conversationId, }: UseConversationScrollParams<T>) => UseConversationScrollResult;
+
+/** Parameters for {@link useConversationScroll}. `T` is never read — only `messages.length` is used to detect growth/reset. */
+export declare interface UseConversationScrollParams<T> {
+    /** Messages currently rendered in the list. */
+    messages: T[];
+    /** Whether an assistant response is currently streaming in. */
+    isAssistantTyping: boolean;
+    /** Identifier of the conversation being displayed. */
+    conversationId: string;
+}
+
+/** Return value of {@link useConversationScroll}. */
+export declare interface UseConversationScrollResult {
+    /** Attach to the scrollable message-list element. */
+    containerRef: RefObject<HTMLDivElement | null>;
+    /** Attach to the element wrapping all rendered messages (used to detect content growth). */
+    contentRef: RefObject<HTMLDivElement | null>;
+    /**
+     * Attach to a spacer element, a sibling rendered right after `contentRef`
+     * inside `containerRef`. Its height is set imperatively, not via React
+     * state. Render it with `shrink-0` and an initial `style={{ height: 0 }}`.
+     */
+    spacerRef: RefObject<HTMLDivElement | null>;
+    /** Callback ref to register/unregister a rendered message's DOM node by index. */
+    setMessageRef: (index: number, el: HTMLDivElement | null) => void;
+    /** Whether the scroll-to-bottom button should be shown. */
+    isScrollButtonVisible: boolean;
+    /** Smoothly scrolls to the current bottom of the actual message content. */
+    scrollToBottom: () => void;
+    /**
+     * Arms the message at `index` to be scrolled near the top of the viewport
+     * on the next render — call right before triggering a send, regenerate,
+     * or edit-and-resubmit so the resulting message anchors near the top.
+     */
+    armAnchor: (index: number) => void;
+}
+
+export { }

package/scroll-anchoring.js

@@ -0,0 +1,2 @@
+import { t as e } from "./useConversationScroll-CliIMnjP.js";
+export { e as useConversationScroll };

package/{useShareRecipientsCount/useShareRecipientsCount.d.ts → sharing.d.ts}

@@ -1,36 +1,65 @@
-import { ShareApi } from '@epam/ai-dial-chat-api-client';
-/** Lifecycle of an on-demand recipient-count lookup for one resource. */
-export declare enum RecipientsCountStatus {
-    /** Nothing requested yet for this resource. */
-    Idle = "idle",
-    /** A lookup is in flight. */
-    Loading = "loading",
-    /** A count came back and is known exactly. */
-    Resolved = "resolved",
-    /** The lookup failed, so the count is unknown. */
-    Unknown = "unknown"
-}
-/** State of one resource's recipient-count lookup. */
-export interface RecipientsCountEntry {
-    /** Where the lookup for this resource currently stands. */
-    status: RecipientsCountStatus;
-    /** Number of users holding access; present only once the status is `Resolved`. */
-    count?: number;
-}
-/** Per-resource recipient-count lookups resolved on demand. */
-export interface UseShareRecipientsCountResult {
-    /** Starts a lookup for the resource unless one already ran for it. */
-    requestRecipientsCount: (itemId: string) => void;
-    /** Current lookup state for the resource. */
-    getRecipientsCount: (itemId: string) => RecipientsCountEntry;
-    /** Drops the resource's cached result so the next request fetches it again. */
-    invalidateRecipientsCount: (itemId: string) => void;
-}
-/**
- * Resolves how many users hold shared access to a resource, one resource at
- * a time and only when asked. Accepts an already-configured `ShareApi`
- * instance — this hook owns only the dedup/cache state machine, not the
- * client's base URL, auth, or CSRF setup.
- */
-export declare const useShareRecipientsCount: (shareApi: Pick<ShareApi, "getShareRecipientsCount">) => UseShareRecipientsCountResult;
-//# sourceMappingURL=useShareRecipientsCount.d.ts.map
+import { ShareApi } from '@epam/ai-dial-chat-api-client';
+import { ShareLinkAccess } from '@epam/ai-dial-share';
+import { ShareLinkData } from '@epam/ai-dial-share';
+
+/** State of one resource's recipient-count lookup. */
+export declare interface RecipientsCountEntry {
+    /** Where the lookup for this resource currently stands. */
+    status: RecipientsCountStatus;
+    /** Number of users holding access; present only once the status is `Resolved`. */
+    count?: number;
+}
+
+/** Lifecycle of an on-demand recipient-count lookup for one resource. */
+export declare enum RecipientsCountStatus {
+    /** Nothing requested yet for this resource. */
+    Idle = "idle",
+    /** A lookup is in flight. */
+    Loading = "loading",
+    /** A count came back and is known exactly. */
+    Resolved = "resolved",
+    /** The lookup failed, so the count is unknown. */
+    Unknown = "unknown"
+}
+
+/**
+ * Resolves and manages share-link data for a DIAL Core resource.
+ *
+ * Accepts an already-configured `ShareApi` instance — this hook owns only
+ * the request lifecycle (loading/error, a stale-response guard, and
+ * re-fetch on access change), not the client's base URL, auth, or CSRF
+ * setup, which stay the caller's responsibility.
+ */
+export declare const useShareLink: (shareApi: Pick<ShareApi, "createShareLink">, itemId: string, origin?: string) => UseShareLinkResult;
+
+/** Result returned by {@link useShareLink}. */
+export declare interface UseShareLinkResult {
+    /** Resolved share-link data, or `undefined` while loading or on error. */
+    data: ShareLinkData | undefined;
+    /** Whether the share link is still being created. */
+    isLoading: boolean;
+    /** Set when the share link could not be created. */
+    error: Error | null;
+    /** Requests a new share link for the given access levels. */
+    setAccess: (access: ShareLinkAccess[]) => void;
+}
+
+/**
+ * Resolves how many users hold shared access to a resource, one resource at
+ * a time and only when asked. Accepts an already-configured `ShareApi`
+ * instance — this hook owns only the dedup/cache state machine, not the
+ * client's base URL, auth, or CSRF setup.
+ */
+export declare const useShareRecipientsCount: (shareApi: Pick<ShareApi, "getShareRecipientsCount">) => UseShareRecipientsCountResult;
+
+/** Per-resource recipient-count lookups resolved on demand. */
+export declare interface UseShareRecipientsCountResult {
+    /** Starts a lookup for the resource unless one already ran for it. */
+    requestRecipientsCount: (itemId: string) => void;
+    /** Current lookup state for the resource. */
+    getRecipientsCount: (itemId: string) => RecipientsCountEntry;
+    /** Drops the resource's cached result so the next request fetches it again. */
+    invalidateRecipientsCount: (itemId: string) => void;
+}
+
+export { }

package/sharing.js

@@ -0,0 +1,3 @@
+import { n as e, t } from "./useShareRecipientsCount-BgwCLKY0.js";
+import { t as n } from "./useShareLink-xkiaxATt.js";
+export { t as RecipientsCountStatus, n as useShareLink, e as useShareRecipientsCount };