@epam/ai-dial-chat-hooks 1.2.0-dev.3 → 1.2.0-dev.303

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

@@ -0,0 +1,194 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+import { ScheduledTaskRunDtoStatusEnum as i } from "@epam/ai-dial-chat-api-client";
+//#region src/scheduled-task/use-scheduled-task-runs.ts
+var a = 15e3, o = 20, s = 5e3, c = 2147483647, l = (e, t) => {
+	if (e <= c) {
+		let n = setTimeout(t, Math.max(e, 0));
+		return () => clearTimeout(n);
+	}
+	let n, r = setTimeout(() => {
+		n = l(e - c, t);
+	}, c);
+	return n = () => clearTimeout(r), () => n();
+}, u = (e, t) => {
+	let n = new Map(t.map((e) => [e.id, e])), r = new Set(e.map((e) => e.id)), i = e.map((e) => n.get(e.id) ?? e);
+	return [...t.filter((e) => !r.has(e.id)), ...i];
+}, d = (e, t) => {
+	if (e.length !== t.length) return !0;
+	let n = new Map(e.map((e) => [e.id, e]));
+	return t.some((e) => {
+		let t = n.get(e.id);
+		return !t || JSON.stringify(t) !== JSON.stringify(e);
+	});
+}, f = (c, { scheduleId: f, enabled: p = !0, pageSize: m = 10, nextRunTime: h }) => {
+	let [g, _] = r([]), [v, y] = r(p), [b, x] = r(!1), [S, C] = r(null), [w, T] = r(null), [E, D] = r(!1), [O, k] = r(0), A = n(0), j = n(0), M = n(!1), N = n(null), P = n(g), F = n(v), I = n(b), L = n(null), R = n(0), z = n(null), B = n(!1);
+	P.current = g, F.current = v, I.current = b;
+	let V = g.some((e) => e.status === i.InProgress);
+	t(() => {
+		let e = ++A.current, t = new AbortController();
+		N.current?.abort(), N.current = null, L.current?.abort(), L.current = null, M.current = !1, R.current = 0, z.current = null, B.current = !1, x(!1), C(null), T(null), _([]), D(!1), j.current = 0;
+		let n = () => {
+			++A.current, t.abort(), N.current?.abort(), N.current = null, L.current?.abort(), L.current = null;
+		};
+		return !p || !f ? (y(!1), _([]), D(!1), n) : ((async () => {
+			y(!0);
+			try {
+				let n = await c.listScheduledTaskRuns({
+					scheduleId: f,
+					limit: m,
+					offset: 0,
+					signal: t.signal
+				});
+				if (A.current !== e) return;
+				_(n.items), j.current = n.items.length, D(n.next != null || (n.count == null ? n.items.length === m : n.items.length < n.count));
+			} catch (t) {
+				A.current === e && C(t instanceof Error ? t : /* @__PURE__ */ Error("Failed to load scheduled task runs"));
+			} finally {
+				A.current === e && y(!1);
+			}
+		})(), n);
+	}, [
+		c,
+		p,
+		m,
+		O,
+		f
+	]);
+	let H = e(() => {
+		if (!p || !f || !E || v || M.current) return;
+		M.current = !0;
+		let e = new AbortController();
+		N.current = e;
+		let t = A.current, n = j.current;
+		(async () => {
+			x(!0), T(null);
+			try {
+				let r = await c.listScheduledTaskRuns({
+					scheduleId: f,
+					limit: m,
+					offset: n,
+					signal: e.signal
+				});
+				if (A.current !== t) return;
+				_((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))];
+				}), j.current = n + r.items.length, D(r.next != null || (r.count == null ? r.items.length === m : n + r.items.length < r.count));
+			} catch (e) {
+				A.current === t && T(e instanceof Error ? e : /* @__PURE__ */ Error("Failed to load more scheduled task runs"));
+			} finally {
+				A.current === t && (x(!1), M.current = !1, N.current = null);
+			}
+		})();
+	}, [
+		c,
+		p,
+		E,
+		v,
+		m,
+		f
+	]), U = e(async () => {
+		if (F.current || I.current) return "skipped";
+		let e = A.current, t = new AbortController();
+		L.current?.abort(), L.current = t;
+		try {
+			let n = await c.listScheduledTaskRuns({
+				scheduleId: f,
+				limit: m,
+				offset: 0,
+				signal: t.signal
+			});
+			if (A.current !== e || F.current || I.current) return "skipped";
+			let r = P.current, i = u(r, n.items), a = d(r, i);
+			return a && (P.current = i, _(i)), a ? "changed" : "unchanged";
+		} catch {
+			return "error";
+		} finally {
+			L.current === t && (L.current = null);
+		}
+	}, [
+		c,
+		f,
+		m
+	]), W = e(() => {
+		if (document.visibilityState !== "visible") {
+			B.current = !0;
+			return;
+		}
+		U();
+	}, [U]);
+	return t(() => {
+		if (!p || !f || !V) return;
+		R.current = 0;
+		let e = setInterval(() => {
+			if (document.visibilityState !== "visible") {
+				B.current = !0;
+				return;
+			}
+			(async () => {
+				let t = await U();
+				if (t === "changed") {
+					R.current = 0;
+					return;
+				}
+				(t === "unchanged" || t === "error") && (R.current += 1, R.current >= o && e !== null && (clearInterval(e), e = null));
+			})();
+		}, a);
+		return () => {
+			e !== null && clearInterval(e);
+		};
+	}, [
+		p,
+		f,
+		V,
+		U
+	]), t(() => {
+		if (!p || !f || !h) return;
+		let e = new Date(h).getTime();
+		if (!(Number.isNaN(e) || e <= Date.now())) return l(e - Date.now() + s, () => {
+			z.current = h, W();
+		});
+	}, [
+		p,
+		f,
+		h,
+		W
+	]), t(() => {
+		if (!p || !f) return;
+		let e = () => {
+			document.visibilityState !== "visible" || !B.current || (async () => {
+				await U() !== "skipped" && (B.current = !1);
+			})();
+		};
+		return document.addEventListener("visibilitychange", e), () => {
+			document.removeEventListener("visibilitychange", e);
+		};
+	}, [
+		p,
+		f,
+		U
+	]), t(() => {
+		if (!p || !f || !h || v || b) return;
+		let e = new Date(h).getTime();
+		Number.isNaN(e) || e > Date.now() || z.current !== h && (z.current = h, W());
+	}, [
+		p,
+		f,
+		h,
+		v,
+		b,
+		W
+	]), {
+		items: g,
+		isLoading: v,
+		isLoadingMore: b,
+		initialError: S,
+		loadMoreError: w,
+		hasMore: E,
+		loadMore: H,
+		retryLoadMore: H,
+		refetch: e(() => k((e) => e + 1), [])
+	};
+};
+//#endregion
+export { u as mergeRunsById, f 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,35 @@
+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.
+ * The one exception is `day: 'last'` one day behind local time, which is
+ * exactly the local 1st.
+ */
+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
@@ -13,9 +40,8 @@ import { UpdateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
 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.
+ * Maps a complete, validated edit draft to an update body. An unset skill
+ * emits null to remove the saved reference; hydrate from detail before editing.
  */
 export declare const mapFormValuesToUpdateBody: (values: ScheduledTaskCreateFormValues) => UpdateScheduledTaskBodyDto;
 
@@ -29,6 +55,24 @@ export declare const mapFormValuesToUpdateBody: (values: ScheduledTaskCreateForm
  */
 export declare const mapScheduledTaskDtoToFormValues: (dto: ScheduledTaskDto) => ScheduledTaskDtoMappingResult;
 
+/**
+ * Merges a freshly-fetched page 0 into the currently-loaded run list: an
+ * already-known id is replaced in place at its existing array position, an
+ * unseen id is prepended (upstream order is `created_at desc`, so it is the
+ * newest), and an id absent from `incoming` is left untouched — a background
+ * refresh never removes a loaded run.
+ */
+export declare const mergeRunsById: (current: ScheduledTaskRunDto[], incoming: ScheduledTaskRunDto[]) => ScheduledTaskRunDto[];
+
+/**
+ * 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 +82,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 +192,54 @@ export declare enum UnsupportedTriggerReason {
     MissingRequiredFields = "missingRequiredFields"
 }
 
+/** Shared, cancellation-safe pagination and background refresh for one schedule's run history. */
+export declare const useScheduledTaskRuns: (client: ScheduledTasksApiClient, { scheduleId, enabled, pageSize, nextRunTime, }: 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;
+    /**
+     * The task's next scheduled run time (ISO string), when known. Drives the
+     * one-shot background refresh described on {@link useScheduledTaskRuns}.
+     * The caller already holds the task DTO — this hook never fetches it.
+     */
+    nextRunTime?: string | null;
+}
+
+/** 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 { mergeRunsById as u, useScheduledTaskRuns as d } 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, u as mergeRunsById, o as prepareScheduledTaskCreateBody, s as prepareScheduledTaskUpdateBody, d as useScheduledTaskRuns, l as useScheduledTasks };

package/shared/application-schema.js

@@ -1,4 +1,7 @@
 //#region src/shared/application-schema.ts
-var e = "custom_app", t = (t) => !!t && t.id === e, n = (e) => !!e && (!!e.id?.endsWith("quickapps2") || e.displayName === "Quick app 2.0");
+var e = "custom_app", t = (t) => !!t && t.id === e, n = (e) => !!e && (!!e.id?.endsWith("quickapps2") || e.displayName === "Quick app 2.0"), r = (e) => {
+	let n = /* @__PURE__ */ new Set();
+	return e.filter((e) => !e.id || t(e) || n.has(e.id) ? !1 : (n.add(e.id), !0));
+};
 //#endregion
-export { t as isCustomAppSchema, n as isQuickAppSchema };
+export { r as getRunnerSchemas, t as isCustomAppSchema, n as isQuickAppSchema };

package/shared/cron-day-of-month.js

@@ -0,0 +1,13 @@
+//#region src/shared/cron-day-of-month.ts
+var e = "last", t = 31, n = 864e5, r = (e) => Math.round((Date.UTC(e.getUTCFullYear(), e.getUTCMonth(), e.getUTCDate()) - Date.UTC(e.getFullYear(), e.getMonth(), e.getDate())) / n), i = (n, r) => {
+	let i = n + r;
+	return i < 1 ? e : i > t ? "1" : String(i);
+}, a = (e, n) => {
+	if (e === "last") return n === -1 ? "1" : void 0;
+	let r = Number(e);
+	if (!/^\d+$/.test(e) || r < 1 || r > t) return;
+	let i = r - n;
+	return i < 1 ? String(t) : i > t ? "1" : String(i);
+};
+//#endregion
+export { e as CRON_LAST_DAY_OF_MONTH, r as getUtcDayShift, a as toLocalDayOfMonth, i as toUtcCronDayOfMonth };

package/skill/skill-archive.js

@@ -0,0 +1,19 @@
+import { SKILL_FOLDER_MARKER as e, nameFromPath as t } from "./skill.js";
+import { inferMimeTypeFromPath as n } from "@epam/ai-dial-chat-shared";
+import { unzipSync as r } from "fflate";
+//#region src/skill/skill-archive.ts
+var i = "__MACOSX/", a = ".DS_Store", o = (n) => n.endsWith("/") || n.startsWith(i) || t(n) === a || t(n) === e, s = (e) => new Promise((t, n) => {
+	let r = new FileReader();
+	r.onload = () => t(new Uint8Array(r.result)), r.onerror = () => n(r.error), r.readAsArrayBuffer(e);
+}), c = async (e) => {
+	let i = r(await s(e));
+	return Object.entries(i).flatMap(([e, r]) => {
+		let i = e.replace(/\\/g, "/");
+		return o(i) ? [] : [{
+			path: i,
+			file: new File([r], t(i), { type: n(i) ?? "" })
+		}];
+	});
+};
+//#endregion
+export { c as extractSkillArchive };

package/skill/skill-types.js

@@ -1,15 +1,16 @@
+import { PUBLIC_BUCKET as e } from "@epam/ai-dial-chat-shared";
 //#region src/skill/skill-types.ts
-var e = /* @__PURE__ */ function(e) {
+var t = /* @__PURE__ */ function(e) {
 	return e.Personal = "personal", e.SharedWithMe = "sharedWithMe", e.Public = "public", e;
-}({}), t = "public", n = "skills/", r = 256 * 1024, i = 1e3, a = 10, o = (e) => {
-	if (!e.startsWith(n)) return null;
-	let t = e.slice(7), r = t.indexOf("/");
-	if (r <= 0) return null;
-	let i = t.slice(0, r), a = t.slice(r + 1);
+}({}), n = e, r = "skills/", i = 256 * 1024, a = 1e3, o = 10, s = (e) => {
+	if (!e.startsWith(r)) return null;
+	let t = e.slice(7), n = t.indexOf("/");
+	if (n <= 0) return null;
+	let i = t.slice(0, n), a = t.slice(n + 1);
 	return i === "" || a === "" ? null : {
 		bucket: i,
 		path: a
 	};
 };
 //#endregion
-export { t as PUBLIC_SKILL_BUCKET, a as SKILL_LISTING_MAX_PAGES, i as SKILL_LISTING_PAGE_SIZE, r as SKILL_MANIFEST_MAX_BYTES, e as SkillSource, o as parseSkillResourceUrl };
+export { n as PUBLIC_SKILL_BUCKET, o as SKILL_LISTING_MAX_PAGES, a as SKILL_LISTING_PAGE_SIZE, i as SKILL_MANIFEST_MAX_BYTES, t as SkillSource, s as parseSkillResourceUrl };