@epam/ai-dial-chat-hooks 1.1.2 → 1.2.0-dev.101

package/scheduled-task/scheduled-task-description.js

@@ -0,0 +1,77 @@
+//#region src/scheduled-task/scheduled-task-description.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.OneTime = "oneTime", e.Hourly = "hourly", e.EveryNMinutes = "everyNMinutes", e.Daily = "daily", e.Weekly = "weekly", e.Monthly = "monthly", e.Custom = "custom", e.Invalid = "invalid", e;
+}({}), t = (e, { timeZone: t = "UTC", referenceDate: n = /* @__PURE__ */ new Date() } = {}) => {
+	let r = (e, t = {}) => ({
+		kind: e,
+		sourceTimezone: "utc",
+		...t
+	});
+	if (e.date && e.cron) return r("invalid");
+	if (e.date) {
+		let t = new Date(e.date);
+		return Number.isNaN(t.getTime()) ? r("invalid") : r("oneTime", { date: t });
+	}
+	let i = e.cron?.fields;
+	if (!i || Object.keys(i).length === 0) return r("invalid");
+	let a = () => r("custom", { expression: JSON.stringify(i) }), o = {
+		hour: [0, 23],
+		minute: [0, 59],
+		day: [1, 31],
+		day_of_week: [0, 6],
+		month: [1, 12],
+		second: [0, 59]
+	};
+	for (let [e, t] of Object.entries(i)) {
+		if (t == null) continue;
+		if (!t.trim()) return r("invalid");
+		let n = o[e];
+		if (n && /^-?\d+$/.test(t) && (Number(t) < n[0] || Number(t) > n[1])) return r("invalid");
+		if (e === "second" && t !== "0" || ![
+			"hour",
+			"minute",
+			"day",
+			"day_of_week"
+		].includes(e) && t !== "*" && !(e === "second" && t === "0")) return a();
+	}
+	let s = i.hour, c = i.minute, l = i.day === "*" ? void 0 : i.day, u = i.day_of_week === "*" ? void 0 : i.day_of_week, d = u ? [
+		"monday",
+		"tuesday",
+		"wednesday",
+		"thursday",
+		"friday",
+		"saturday",
+		"sunday"
+	].findIndex((e) => e === u.toLowerCase() || e.slice(0, 3) === u.toLowerCase()) : -1, f = d >= 0 ? String(d) : u;
+	if (l && f || l && !/^\d+$/.test(l) || f && !/^\d+$/.test(f)) return a();
+	let p = s == null || s === "*", m = c?.match(/^\*\/(\d+)$/);
+	if (p && m && !l && !f) {
+		let e = Number(m[1]);
+		return e > 0 && e <= 59 ? r("everyNMinutes", { intervalMinutes: e }) : r("invalid");
+	}
+	if (!c || !/^\d+$/.test(c) || !p && !/^\d+$/.test(s) || p && (l || f)) return a();
+	let h = new Date(n);
+	if (Number.isNaN(h.getTime())) return r("invalid");
+	if (h.setUTCHours(p ? 0 : Number(s), Number(c), 0, 0), f) {
+		let e = (Number(f) + 1) % 7;
+		h.setUTCDate(h.getUTCDate() + (e - h.getUTCDay() + 7) % 7);
+	}
+	let g = new Intl.DateTimeFormat("en-GB", {
+		timeZone: t,
+		hourCycle: "h23",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit"
+	}).formatToParts(h), _ = (e) => g.find((t) => t.type === e)?.value ?? "", v = new Date(Date.UTC(Number(_("year")), Number(_("month")) - 1, Number(_("day")))), y = Date.UTC(h.getUTCFullYear(), h.getUTCMonth(), h.getUTCDate()), b = Math.round((v.getTime() - y) / 864e5), x = _("hour") + ":" + _("minute");
+	return p ? r("hourly", { time: _("minute") }) : f ? r("weekly", {
+		time: x,
+		dayOfWeek: String((Number(f) + b + 7) % 7)
+	}) : l ? b === 0 || Number(l) <= 28 && Number(l) + b >= 1 && Number(l) + b <= 28 ? r("monthly", {
+		time: x,
+		dayOfMonth: String(Number(l) + b)
+	}) : a() : r("daily", { time: x });
+};
+//#endregion
+export { e as ScheduledTaskTriggerDescriptionKind, t as describeScheduledTaskTrigger };

package/scheduled-task/scheduled-task-preparation.js

@@ -0,0 +1,24 @@
+import { mapFormValuesToCreateBody as e, mapFormValuesToUpdateBody as t } from "./scheduled-task-trigger.js";
+import { validateScheduledTaskFormValues as n } from "@epam/ai-dial-scheduled-tasks/validation";
+//#region src/scheduled-task/scheduled-task-preparation.ts
+var r = (t, r) => {
+	let i = n(t, r);
+	return Object.keys(i).length > 0 ? {
+		ok: !1,
+		errors: i
+	} : {
+		ok: !0,
+		body: e(t)
+	};
+}, i = (e, r) => {
+	let i = n(e, r);
+	return Object.keys(i).length > 0 ? {
+		ok: !1,
+		errors: i
+	} : {
+		ok: !0,
+		body: t(e)
+	};
+};
+//#endregion
+export { r as prepareScheduledTaskCreateBody, i as prepareScheduledTaskUpdateBody };

package/scheduled-task/scheduled-tasks-api-client.js

@@ -0,0 +1,19 @@
+//#region src/scheduled-task/scheduled-tasks-api-client.ts
+var e = (e) => {
+	if (!Array.isArray(e.items)) throw TypeError("Scheduled tasks API returned a malformed page response");
+	return e;
+}, t = (t) => ({
+	listScheduledTasks: async ({ signal: n, ...r } = {}) => e(await t.listScheduledTasks(r, n ? { signal: n } : void 0)),
+	listScheduledTaskRuns: async ({ signal: n, ...r }) => e(await t.listScheduledTaskRuns(r, n ? { signal: n } : void 0)),
+	createScheduledTask: (e) => t.createScheduledTask({ createScheduledTaskBodyDto: e }),
+	getScheduledTask: (e) => t.getScheduledTask({ scheduleId: e }),
+	updateScheduledTask: (e, n) => t.updateScheduledTask({
+		scheduleId: e,
+		updateScheduledTaskBodyDto: n
+	}),
+	pauseScheduledTask: (e) => t.pauseScheduledTask({ scheduleId: e }),
+	resumeScheduledTask: (e) => t.resumeScheduledTask({ scheduleId: e }),
+	deleteScheduledTask: (e) => t.deleteScheduledTask({ scheduleId: e })
+});
+//#endregion
+export { t as createScheduledTasksApiClient };

package/scheduled-task/use-scheduled-task-runs.js

@@ -0,0 +1,82 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+//#region src/scheduled-task/use-scheduled-task-runs.ts
+var i = (i, { scheduleId: a, enabled: o = !0, pageSize: s = 10 }) => {
+	let [c, l] = r([]), [u, d] = r(o), [f, p] = r(!1), [m, h] = r(null), [g, _] = r(null), [v, y] = r(!1), [b, x] = r(0), S = n(0), C = n(0), w = n(!1), T = n(null);
+	t(() => {
+		let e = ++S.current, t = new AbortController();
+		T.current?.abort(), T.current = null, w.current = !1, p(!1), h(null), _(null), l([]), y(!1), C.current = 0;
+		let n = () => {
+			++S.current, t.abort(), T.current?.abort(), T.current = null;
+		};
+		return !o || !a ? (d(!1), l([]), y(!1), n) : ((async () => {
+			d(!0);
+			try {
+				let n = await i.listScheduledTaskRuns({
+					scheduleId: a,
+					limit: s,
+					offset: 0,
+					signal: t.signal
+				});
+				if (S.current !== e) return;
+				l(n.items), C.current = n.items.length, y(n.next != null || (n.count == null ? n.items.length === s : n.items.length < n.count));
+			} catch (t) {
+				S.current === e && h(t instanceof Error ? t : /* @__PURE__ */ Error("Failed to load scheduled task runs"));
+			} finally {
+				S.current === e && d(!1);
+			}
+		})(), n);
+	}, [
+		i,
+		o,
+		s,
+		b,
+		a
+	]);
+	let E = e(() => {
+		if (!o || !a || !v || u || w.current) return;
+		w.current = !0;
+		let e = new AbortController();
+		T.current = e;
+		let t = S.current, n = C.current;
+		(async () => {
+			p(!0), _(null);
+			try {
+				let r = await i.listScheduledTaskRuns({
+					scheduleId: a,
+					limit: s,
+					offset: n,
+					signal: e.signal
+				});
+				if (S.current !== t) return;
+				l((e) => {
+					let t = new Set(e.map(({ id: e }) => e));
+					return [...e, ...r.items.filter(({ id: e }) => t.has(e) ? !1 : (t.add(e), !0))];
+				}), C.current = n + r.items.length, y(r.next != null || (r.count == null ? r.items.length === s : n + r.items.length < r.count));
+			} catch (e) {
+				S.current === t && _(e instanceof Error ? e : /* @__PURE__ */ Error("Failed to load more scheduled task runs"));
+			} finally {
+				S.current === t && (p(!1), w.current = !1, T.current = null);
+			}
+		})();
+	}, [
+		i,
+		o,
+		v,
+		u,
+		s,
+		a
+	]);
+	return {
+		items: c,
+		isLoading: u,
+		isLoadingMore: f,
+		initialError: m,
+		loadMoreError: g,
+		hasMore: v,
+		loadMore: E,
+		retryLoadMore: E,
+		refetch: e(() => x((e) => e + 1), [])
+	};
+};
+//#endregion
+export { i as useScheduledTaskRuns };

package/scheduled-task/use-scheduled-tasks.js

@@ -0,0 +1,93 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+//#region src/scheduled-task/use-scheduled-tasks.ts
+var i = (i, { enabled: a = !0, pageSize: o = 20, debounceMs: s = 300, initialSearch: c = "", initialSort: l = "first_to_run" } = {}) => {
+	let [u, d] = r([]), [f, p] = r(c), [m, h] = r(l), [g, _] = r(a), [v, y] = r(!1), [b, x] = r(null), [S, C] = r(null), [w, T] = r(!1), [E, D] = r(0), O = n(0), k = n(0), A = n(!1), j = n(null), [M, N] = r(c);
+	t(() => {
+		let e = setTimeout(() => N(f), s);
+		return () => clearTimeout(e);
+	}, [s, f]), t(() => {
+		let e = ++O.current, t = new AbortController();
+		j.current?.abort(), j.current = null, A.current = !1, y(!1), x(null), C(null), d([]), T(!1), k.current = 0;
+		let n = () => {
+			++O.current, t.abort(), j.current?.abort(), j.current = null;
+		};
+		return a ? ((async () => {
+			_(!0);
+			try {
+				let n = await i.listScheduledTasks({
+					limit: o,
+					offset: 0,
+					search: M,
+					sort: m,
+					signal: t.signal
+				});
+				if (O.current !== e) return;
+				d(n.items), k.current = n.items.length, T(n.next != null);
+			} catch (t) {
+				O.current === e && x(t instanceof Error ? t : /* @__PURE__ */ Error("Failed to load scheduled tasks"));
+			} finally {
+				O.current === e && _(!1);
+			}
+		})(), n) : (_(!1), d([]), T(!1), n);
+	}, [
+		i,
+		M,
+		a,
+		o,
+		E,
+		m
+	]);
+	let P = e(() => {
+		if (!a || !w || g || A.current) return;
+		A.current = !0;
+		let e = new AbortController();
+		j.current = e;
+		let t = O.current, n = k.current;
+		(async () => {
+			y(!0), C(null);
+			try {
+				let r = await i.listScheduledTasks({
+					limit: o,
+					offset: n,
+					signal: e.signal,
+					search: M,
+					sort: m
+				});
+				if (O.current !== t) return;
+				d((e) => {
+					let t = new Set(e.map(({ id: e }) => e));
+					return [...e, ...r.items.filter(({ id: e }) => t.has(e) ? !1 : (t.add(e), !0))];
+				}), k.current = n + r.items.length, T(r.next != null);
+			} catch (e) {
+				O.current === t && C(e instanceof Error ? e : /* @__PURE__ */ Error("Failed to load more scheduled tasks"));
+			} finally {
+				O.current === t && (y(!1), A.current = !1, j.current = null);
+			}
+		})();
+	}, [
+		i,
+		M,
+		a,
+		w,
+		g,
+		o,
+		m
+	]);
+	return {
+		items: u,
+		searchQuery: f,
+		setSearchQuery: p,
+		sortKey: m,
+		setSortKey: h,
+		isLoading: g,
+		isLoadingMore: v,
+		initialError: b,
+		loadMoreError: S,
+		hasMore: w,
+		loadMore: P,
+		retryLoadMore: P,
+		refetch: e(() => D((e) => e + 1), [])
+	};
+};
+//#endregion
+export { i as useScheduledTasks };

package/scheduled-tasks.d.ts

@@ -1,8 +1,33 @@
+import { CreatedScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
 import { CreateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
+import { Dispatch } from 'react';
+import { ListScheduledTaskRunsResponseDto } from '@epam/ai-dial-chat-api-client';
+import { ListScheduledTasksResponseDto } from '@epam/ai-dial-chat-api-client';
+import { ListScheduledTasksSortEnum } 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 { ScheduledTaskRunDto } from '@epam/ai-dial-chat-api-client';
+import { ScheduledTaskValidationErrors } from '../../libs/scheduled-tasks/validation';
+import { ScheduledTaskValidationOptions } from '../../libs/scheduled-tasks/validation';
+import { ScheduleTriggerDto } from '@epam/ai-dial-chat-api-client';
+import { SetStateAction } from 'react';
+import { UpdatedScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
 import { UpdateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
 
+/**
+ * Composes scheduler operations over an already configured generated client.
+ * Authentication, base URL, CSRF, and retries remain host responsibilities.
+ */
+export declare const createScheduledTasksApiClient: (client: ScheduledTasksConfiguredClient) => ScheduledTasksApiClient;
+
+/**
+ * Describes the complete trigger without requiring unrelated task metadata.
+ * Unsupported constraints remain Custom, with the full source expression.
+ * Calendar-month shifts crossing month boundaries or days 29–31 remain
+ * Custom because a shifted monthly day is not equivalent around short months.
+ */
+export declare const describeScheduledTaskTrigger: (trigger: ScheduleTriggerDto, { timeZone, referenceDate, }?: ScheduledTaskTriggerDescriptionOptions) => ScheduledTaskTriggerDescription;
+
 /**
  * Maps validated create-form values to the `POST /api/v1/scheduled-tasks`
  * request body, building `trigger.date` for a one-shot schedule or
@@ -29,6 +54,15 @@ export declare const mapFormValuesToUpdateBody: (values: ScheduledTaskCreateForm
  */
 export declare const mapScheduledTaskDtoToFormValues: (dto: ScheduledTaskDto) => ScheduledTaskDtoMappingResult;
 
+/**
+ * Validates form values before creating a request body. Hosts translate the
+ * returned field codes and must not issue a write when `ok` is false.
+ */
+export declare const prepareScheduledTaskCreateBody: (values: ScheduledTaskCreateFormValues, options: ScheduledTaskValidationOptions) => ScheduledTaskPreparationResult<CreateScheduledTaskBodyDto>;
+
+/** Validates form values before preparing an update request body. */
+export declare const prepareScheduledTaskUpdateBody: (values: ScheduledTaskCreateFormValues, options: ScheduledTaskValidationOptions) => ScheduledTaskPreparationResult<UpdateScheduledTaskBodyDto>;
+
 /** Result of mapping a scheduled task DTO back to editable form values. */
 export declare type ScheduledTaskDtoMappingResult = {
     ok: true;
@@ -38,6 +72,106 @@ export declare type ScheduledTaskDtoMappingResult = {
     reason: UnsupportedTriggerReason;
 };
 
+/** A checked request preparation result that never serializes invalid values. */
+export declare type ScheduledTaskPreparationResult<TBody> = {
+    ok: true;
+    body: TBody;
+} | {
+    ok: false;
+    errors: ScheduledTaskValidationErrors;
+};
+
+export declare interface ScheduledTaskRunsListRequest {
+    scheduleId: string;
+    limit?: number;
+    offset?: number;
+    signal?: AbortSignal;
+}
+
+export declare interface ScheduledTasksApiClient {
+    listScheduledTasks: (request?: ScheduledTasksListRequest) => Promise<ListScheduledTasksResponseDto>;
+    listScheduledTaskRuns: (request: ScheduledTaskRunsListRequest) => Promise<ListScheduledTaskRunsResponseDto>;
+    createScheduledTask: (body: CreateScheduledTaskBodyDto) => Promise<CreatedScheduledTaskDto>;
+    getScheduledTask: (scheduleId: string) => Promise<ScheduledTaskDto>;
+    updateScheduledTask: (scheduleId: string, body: UpdateScheduledTaskBodyDto) => Promise<UpdatedScheduledTaskDto>;
+    pauseScheduledTask: (scheduleId: string) => Promise<ScheduledTaskDto>;
+    resumeScheduledTask: (scheduleId: string) => Promise<ScheduledTaskDto>;
+    deleteScheduledTask: (scheduleId: string) => Promise<void>;
+}
+
+/** Narrow configured generated-client surface required by scheduler hooks. */
+export declare interface ScheduledTasksConfiguredClient {
+    listScheduledTasks: (request: {
+        limit?: number;
+        offset?: number;
+        search?: string;
+        sort?: ListScheduledTasksSortEnum;
+    }, options?: RequestInit) => Promise<ListScheduledTasksResponseDto>;
+    listScheduledTaskRuns: (request: {
+        scheduleId: string;
+        limit?: number;
+        offset?: number;
+    }, options?: RequestInit) => Promise<ListScheduledTaskRunsResponseDto>;
+    createScheduledTask: (request: {
+        createScheduledTaskBodyDto: CreateScheduledTaskBodyDto;
+    }) => Promise<CreatedScheduledTaskDto>;
+    getScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<ScheduledTaskDto>;
+    updateScheduledTask: (request: {
+        scheduleId: string;
+        updateScheduledTaskBodyDto: UpdateScheduledTaskBodyDto;
+    }) => Promise<UpdatedScheduledTaskDto>;
+    pauseScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<ScheduledTaskDto>;
+    resumeScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<ScheduledTaskDto>;
+    deleteScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<void>;
+}
+
+/** App-agnostic request options accepted by the scheduler facade. */
+export declare interface ScheduledTasksListRequest {
+    limit?: number;
+    offset?: number;
+    search?: string;
+    sort?: ListScheduledTasksSortEnum;
+    signal?: AbortSignal;
+}
+
+export declare interface ScheduledTaskTriggerDescription {
+    kind: ScheduledTaskTriggerDescriptionKind;
+    time?: string;
+    dayOfWeek?: string;
+    dayOfMonth?: string;
+    intervalMinutes?: number;
+    date?: Date;
+    expression?: string;
+    sourceTimezone: 'utc';
+}
+
+/** Display categories are independent of task editability. */
+export declare enum ScheduledTaskTriggerDescriptionKind {
+    OneTime = "oneTime",
+    Hourly = "hourly",
+    EveryNMinutes = "everyNMinutes",
+    Daily = "daily",
+    Weekly = "weekly",
+    Monthly = "monthly",
+    Custom = "custom",
+    Invalid = "invalid"
+}
+
+export declare interface ScheduledTaskTriggerDescriptionOptions {
+    /** Display timezone; defaults to UTC for backwards compatibility. */
+    timeZone?: string;
+    /** Date whose timezone offset is used. Defaults to now (the existing UTC-storage policy). */
+    referenceDate?: Date;
+}
+
 /** 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. */
@@ -48,4 +182,48 @@ export declare enum UnsupportedTriggerReason {
     MissingRequiredFields = "missingRequiredFields"
 }
 
+/** Shared, cancellation-safe pagination for one schedule's run history. */
+export declare const useScheduledTaskRuns: (client: ScheduledTasksApiClient, { scheduleId, enabled, pageSize }: UseScheduledTaskRunsOptions) => {
+    items: ScheduledTaskRunDto[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    initialError: Error | null;
+    loadMoreError: Error | null;
+    hasMore: boolean;
+    loadMore: () => void;
+    retryLoadMore: () => void;
+    refetch: () => void;
+};
+
+export declare interface UseScheduledTaskRunsOptions {
+    scheduleId: string;
+    enabled?: boolean;
+    pageSize?: number;
+}
+
+/** Shared scheduler-list lifecycle with generation-scoped stale-response guards. */
+export declare const useScheduledTasks: (client: ScheduledTasksApiClient, { enabled, pageSize, debounceMs, initialSearch, initialSort, }?: UseScheduledTasksOptions) => {
+    items: ScheduledTaskDto[];
+    searchQuery: string;
+    setSearchQuery: Dispatch<SetStateAction<string>>;
+    sortKey: "firstToRun" | "lastToRun" | "newest" | "nameAZ";
+    setSortKey: Dispatch<SetStateAction<"firstToRun" | "lastToRun" | "newest" | "nameAZ">>;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    initialError: Error | null;
+    loadMoreError: Error | null;
+    hasMore: boolean;
+    loadMore: () => void;
+    retryLoadMore: () => void;
+    refetch: () => void;
+};
+
+export declare interface UseScheduledTasksOptions {
+    enabled?: boolean;
+    pageSize?: number;
+    debounceMs?: number;
+    initialSearch?: string;
+    initialSort?: ListScheduledTasksSortEnum;
+}
+
 export { }

package/scheduled-tasks.js

@@ -1,3 +1,8 @@
 import { UnsupportedTriggerReason as e } from "./scheduled-task/scheduled-task-mapping.js";
-import { mapFormValuesToCreateBody as t, mapFormValuesToUpdateBody as n, mapScheduledTaskDtoToFormValues as r } from "./scheduled-task/scheduled-task-trigger.js";
-export { e as UnsupportedTriggerReason, t as mapFormValuesToCreateBody, n as mapFormValuesToUpdateBody, r as mapScheduledTaskDtoToFormValues };
+import { ScheduledTaskTriggerDescriptionKind as t, describeScheduledTaskTrigger as n } from "./scheduled-task/scheduled-task-description.js";
+import { mapFormValuesToCreateBody as r, mapFormValuesToUpdateBody as i, mapScheduledTaskDtoToFormValues as a } from "./scheduled-task/scheduled-task-trigger.js";
+import { prepareScheduledTaskCreateBody as o, prepareScheduledTaskUpdateBody as s } from "./scheduled-task/scheduled-task-preparation.js";
+import { createScheduledTasksApiClient as c } from "./scheduled-task/scheduled-tasks-api-client.js";
+import { useScheduledTasks as l } from "./scheduled-task/use-scheduled-tasks.js";
+import { useScheduledTaskRuns as u } from "./scheduled-task/use-scheduled-task-runs.js";
+export { t as ScheduledTaskTriggerDescriptionKind, e as UnsupportedTriggerReason, c as createScheduledTasksApiClient, n as describeScheduledTaskTrigger, r as mapFormValuesToCreateBody, i as mapFormValuesToUpdateBody, a as mapScheduledTaskDtoToFormValues, o as prepareScheduledTaskCreateBody, s as prepareScheduledTaskUpdateBody, u as useScheduledTaskRuns, l as useScheduledTasks };

package/skill/skill.js

@@ -13,7 +13,10 @@ var i = "SKILL.md", a = 1048576, o = 16777216, s = 100, c = new Set([".dial-reso
 	...e,
 	name: t,
 	description: n
-}).trimEnd()}\n---\n\n${i}`, g = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/, _ = (e) => {
+}).trimEnd()}\n---\n\n${i}`, g = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/, _ = /^---[ \t]*$/, v = (e) => {
+	let t = e.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").split("\n"), n = t.findIndex((e) => e.trim() !== "");
+	return n === -1 || !_.test(t[n]) ? !1 : t.some((e, t) => t > n && _.test(e));
+}, y = (e) => {
 	let t = g.exec(e);
 	if (!t) throw Error("SKILL.md is missing its YAML frontmatter block");
 	let [, r, i] = t;
@@ -21,7 +24,7 @@ var i = "SKILL.md", a = 1048576, o = 16777216, s = 100, c = new Set([".dial-reso
 		frontmatter: n(r) ?? {},
 		instructions: i.replace(/^\r?\n/, "")
 	};
-}, v = (e) => {
+}, b = (e) => {
 	let n = t(e), r = n[i];
 	if (r == null) throw Error(`Skill archive is missing a root ${i} file`);
 	let a = /* @__PURE__ */ new Map();
@@ -30,19 +33,19 @@ var i = "SKILL.md", a = 1048576, o = 16777216, s = 100, c = new Set([".dial-reso
 		manifestText: new TextDecoder().decode(r),
 		files: a
 	};
-}, y = (e) => {
+}, x = (e) => {
 	let t = e.lastIndexOf("/");
 	return t === -1 ? e : e.slice(t + 1);
-}, b = (e) => new Blob([new Uint8Array(e)]), x = (e, t, n, r) => Object.keys(e).length > 0 ? h(e, t, n, r) : m({
+}, S = (e) => new Blob([new Uint8Array(e)]), C = (e, t, n, r) => Object.keys(e).length > 0 ? h(e, t, n, r) : m({
 	name: t,
 	description: n,
 	instructions: r
-}), S = (t, n) => {
+}), w = (t, n) => {
 	let r = t.filter((t) => t.kind === e.File);
 	return {
 		filePaths: r.map((e) => e.path),
-		files: r.map((e) => b(n.get(e.path)?.bytes ?? new Uint8Array()))
+		files: r.map((e) => S(n.get(e.path)?.bytes ?? new Uint8Array()))
 	};
 };
 //#endregion
-export { a as SKILL_FILE_UPLOAD_MAX_BYTES, i as SKILL_MANIFEST_FILE, s as SKILL_UPLOAD_MAX_FILES, o as SKILL_UPLOAD_MAX_TOTAL_BYTES, S as buildSkillFilesPayload, m as buildSkillManifest, x as buildSkillManifestForSubmit, h as buildSkillManifestFromFrontmatter, f as isValidSkillRelativePath, y as nameFromPath, p as normalizeSkillName, _ as parseSkillManifest, b as skillFileBytesToBlob, v as unpackSkillArchive };
+export { a as SKILL_FILE_UPLOAD_MAX_BYTES, i as SKILL_MANIFEST_FILE, s as SKILL_UPLOAD_MAX_FILES, o as SKILL_UPLOAD_MAX_TOTAL_BYTES, w as buildSkillFilesPayload, m as buildSkillManifest, C as buildSkillManifestForSubmit, h as buildSkillManifestFromFrontmatter, f as isValidSkillRelativePath, x as nameFromPath, p as normalizeSkillName, y as parseSkillManifest, S as skillFileBytesToBlob, v as startsWithFrontmatterBlock, b as unpackSkillArchive };

package/skill/useSkillArchiveImport/useSkillArchiveImport.js

@@ -0,0 +1,75 @@
+import { getApiErrorStatus 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/skill/useSkillArchiveImport/useSkillArchiveImport.ts
+var a = "SKILL.md", o = /* @__PURE__ */ function(e) {
+	return e.Idle = "idle", e.Uploading = "uploading", e.Success = "success", e.Error = "error", e;
+}({}), s = /* @__PURE__ */ function(e) {
+	return e.Validation = "validation", e.Collision = "collision", e.RateLimited = "rateLimited", e.ServiceUnavailable = "serviceUnavailable", e.Generic = "generic", e;
+}({}), c = /* @__PURE__ */ function(e) {
+	return e.UnsupportedFilename = "unsupportedFilename", e;
+}({}), l = (e) => {
+	switch (e) {
+		case 400:
+		case 413:
+		case 422: return "validation";
+		case 409: return "collision";
+		case 429: return "rateLimited";
+		case 502:
+		case 503: return "serviceUnavailable";
+		default: return "generic";
+	}
+}, u = (e, t) => e.toLowerCase().endsWith(".md") && e !== t, d = ({ importArchive: o, onImported: s, onError: c, manifestFileName: d = a }) => {
+	let [f, p] = i(!1), [m, h] = i("idle"), [g, _] = i(void 0), [v, y] = i(void 0), b = r(!1), x = r(!0);
+	n(() => (x.current = !0, () => {
+		x.current = !1;
+	}), []);
+	let S = t(async (t) => {
+		b.current = !0, h("uploading"), y(void 0);
+		try {
+			let e = await o(t);
+			if (!x.current || (await s(e), !x.current)) return;
+			h("success");
+		} catch (t) {
+			if (!x.current) return;
+			let n = l(e(t));
+			h("error"), y(n), c(t, n);
+		} finally {
+			b.current = !1;
+		}
+	}, [
+		o,
+		s,
+		c
+	]), C = t(() => {
+		b.current || (_(void 0), p(!0));
+	}, []), w = t(() => {
+		p(!1), _(void 0);
+	}, []), T = t(() => {
+		h("error"), _("unsupportedFilename");
+	}, []);
+	return {
+		isDialogOpen: f,
+		status: m,
+		selectionRejectionReason: g,
+		errorKind: v,
+		openDialog: C,
+		closeDialog: w,
+		handleFilesSelected: t((e) => {
+			let t = e[0];
+			if (!(!t || b.current)) {
+				if (u(t.name, d)) {
+					T();
+					return;
+				}
+				_(void 0), p(!1), S(t);
+			}
+		}, [
+			d,
+			T,
+			S
+		]),
+		handleFilesRejected: T
+	};
+};
+//#endregion
+export { s as SkillArchiveImportErrorKind, o as SkillArchiveImportStatus, c as SkillArchiveSelectionRejectionReason, l as classifySkillArchiveImportError, d as useSkillArchiveImport };