@epam/ai-dial-chat-hooks 1.2.0-dev.1 → 1.2.0-dev.102

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 };

package/skill/useSkillEditorLoad.js

@@ -6,12 +6,12 @@ import { SkillFileNodeKind as u } from "@epam/ai-dial-skill-editor";
 //#region src/skill/useSkillEditorLoad.ts
 var d = /* @__PURE__ */ function(e) {
 	return e.Loading = "loading", e.Loaded = "loaded", e.Error = "error", e.Forbidden = "forbidden", e.NotFound = "not-found", e;
-}({}), f = class extends Error {}, p = (e, r) => {
+}({}), f = class extends Error {}, p = class extends Error {}, m = (e, r) => {
 	let i = e.parentPath ? t(e.parentPath) : "", a = `${n(r)}/files`;
 	return i === a ? e.name : i.startsWith(`${a}/`) ? `${i.slice(a.length + 1)}/${e.name}` : i === "files" ? e.name : i.startsWith("files/") ? `${i.slice(6)}/${e.name}` : null;
-}, m = async (e, t, n) => {
+}, h = async (e, t, n) => {
 	let r = await e.downloadSkill(t, n), i = r.headers.get("etag");
-	if (!i) throw new f("Skill ETag is missing");
+	if (!i) throw new p("Skill ETag is missing");
 	try {
 		let e = await r.arrayBuffer(), { manifestText: t, files: n } = o(new Uint8Array(e));
 		return {
@@ -22,17 +22,17 @@ var d = /* @__PURE__ */ function(e) {
 	} catch {
 		throw new f("Skill ZIP is invalid");
 	}
-}, h = async (e, t, n) => {
+}, g = async (e, t, n) => {
 	let [i, a] = await Promise.all([e.downloadSkillFile(t, n, r), e.listSkillFiles({
 		bucket: t,
 		path: n,
 		filePath: "",
 		recursive: !0
-	})]), o = a.items.find((e) => e.nodeType === "item" && p(e, n) === "SKILL.md"), s = i.headers.get("etag") ?? o?.etag;
-	if (!s) throw Error("Skill ETag is missing");
+	})]), o = a.items.find((e) => e.nodeType === "item" && m(e, n) === "SKILL.md"), s = i.headers.get("etag") ?? o?.etag;
+	if (!s) throw new p("Skill ETag is missing");
 	let c = a.items.filter((e) => e.nodeType === "item").map((e) => ({
 		item: e,
-		path: p(e, n)
+		path: m(e, n)
 	})).filter((e) => e.path != null && e.path !== "SKILL.md"), l = await Promise.all(c.map(async ({ path: r }) => {
 		let i = await e.downloadSkillFile(t, n, r);
 		return [r, new Uint8Array(await i.arrayBuffer())];
@@ -42,40 +42,41 @@ var d = /* @__PURE__ */ function(e) {
 		manifestText: await i.text(),
 		files: new Map(l)
 	};
-}, g = ({ isEditMode: t, bucket: n, skillPath: r, client: o }) => {
-	let [d, p] = l(t ? "loading" : "loaded"), [g, _] = l(0), [v, y] = l(), b = c(void 0), x = c({}), S = c(void 0), [C, w] = l([]), T = c(/* @__PURE__ */ new Map());
+}, _ = ({ isEditMode: t, bucket: n, skillPath: r, client: o }) => {
+	let [d, m] = l(t ? "loading" : "loaded"), [_, v] = l(0), [y, b] = l(), x = c(void 0), S = c({}), C = c(void 0), [w, T] = l([]), E = c(/* @__PURE__ */ new Map());
 	return s(() => {
 		if (!t || !n) return;
 		if (r == null) {
-			p("error");
+			m("error");
 			return;
 		}
 		let s = !1;
-		return p("loading"), (async () => {
+		return m("loading"), (async () => {
 			if (await Promise.resolve(), !s) try {
 				let t;
 				try {
-					t = await m(o, n, r);
+					t = await h(o, n, r);
 				} catch (i) {
+					if (i instanceof p) throw i;
 					let a = e(i);
 					if (!(i instanceof f) && a !== 400) throw i;
-					t = await h(o, n, r);
+					t = await g(o, n, r);
 				}
 				let { frontmatter: c, instructions: l } = a(t.manifestText);
 				if (s) return;
-				b.current = t.etag, x.current = c, S.current = r, T.current = new Map([...t.files].map(([e, t]) => [e, { bytes: t }])), w([...t.files.keys()].map((e) => ({
+				x.current = t.etag, S.current = c, C.current = r, E.current = new Map([...t.files].map(([e, t]) => [e, { bytes: t }])), T([...t.files.keys()].map((e) => ({
 					path: e,
 					name: i(e),
 					kind: u.File
-				}))), y({
+				}))), b({
 					name: typeof c.name == "string" ? c.name : "",
 					description: typeof c.description == "string" ? c.description : "",
 					instructions: l
-				}), p("loaded");
+				}), m("loaded");
 			} catch (t) {
 				if (s) return;
 				let n = e(t);
-				p(n === 403 ? "forbidden" : n === 404 ? "not-found" : "error");
+				m(n === 403 ? "forbidden" : n === 404 ? "not-found" : "error");
 			}
 		})(), () => {
 			s = !0;
@@ -84,20 +85,20 @@ var d = /* @__PURE__ */ function(e) {
 		t,
 		n,
 		r,
-		g,
+		_,
 		o
 	]), {
 		loadState: d,
-		loadedValues: v,
-		setLoadedValues: y,
-		files: C,
-		setFiles: w,
-		filesContentRef: T,
-		frontmatterRef: x,
-		etagRef: b,
-		loadedPathRef: S,
-		retryLoad: () => _((e) => e + 1)
+		loadedValues: y,
+		setLoadedValues: b,
+		files: w,
+		setFiles: T,
+		filesContentRef: E,
+		frontmatterRef: S,
+		etagRef: x,
+		loadedPathRef: C,
+		retryLoad: () => v((e) => e + 1)
 	};
 };
 //#endregion
-export { d as SkillEditorLoadState, g as useSkillEditorLoad };
+export { d as SkillEditorLoadState, _ as useSkillEditorLoad };

package/skill/useSkillEditorSubmit.js

@@ -1,135 +1,152 @@
 import { getApiErrorDetails as e, getApiErrorStatus as t } from "../api-error/api-error.js";
-import { buildSkillFilesPayload as n, buildSkillManifestForSubmit as r, isValidSkillRelativePath as i, normalizeSkillName as a } from "./skill.js";
-import { useCallback as o, useRef as s, useState as c } from "react";
-import { NotificationVariant as l } from "@epam/ai-dial-ui-kit";
+import { buildSkillFilesPayload as n, buildSkillManifestForSubmit as r, isValidSkillRelativePath as i, normalizeSkillName as a, startsWithFrontmatterBlock as o } from "./skill.js";
+import { useCallback as s, useRef as c, useState as l } from "react";
+import { NotificationVariant as u } from "@epam/ai-dial-ui-kit";
 //#region src/skill/useSkillEditorSubmit.ts
-var u = (e, t) => JSON.stringify({
+var d = (e, t) => JSON.stringify({
 	values: e,
 	files: [...t].sort((e, t) => e.path.localeCompare(t.path))
-}), d = ({ bucket: d, isEditMode: f, files: p, filesContentRef: m, frontmatterRef: h, loadedPathRef: g, etagRef: _, returnUrl: v, refetchSkills: y, client: b, messages: x, onNavigate: S, onNotify: C }) => {
-	let [w, T] = c({}), [E, D] = c(), [O, k] = c(), [A, j] = c("idle"), M = s(null), N = o(async (n) => {
+}), f = ({ bucket: f, isEditMode: p, files: m, filesContentRef: h, frontmatterRef: g, loadedPathRef: _, etagRef: v, returnUrl: y, refetchSkills: b, client: x, messages: S, onNavigate: C, onNotify: w }) => {
+	let [T, E] = l({}), [D, O] = l(), [k, A] = l(!1), [j, M] = l(), [N, P] = l("idle"), F = c(null), I = c(null), L = s(async (n) => {
 		switch (t(n)) {
 			case 409:
-				T({ name: x.nameConflict });
+				E({ name: S.nameConflict });
 				return;
 			case 412:
-				T({ name: x.nameConflict });
+				E({ name: S.nameConflict });
 				return;
 			case 413:
-				D(x.archiveTooLarge);
+				O(S.archiveTooLarge);
 				return;
 			case 503:
-				D(x.serviceUnavailable);
+				O(S.serviceUnavailable), A(!0);
 				return;
 			case 400: {
 				let { message: t } = await e(n);
-				D(t ?? x.pathInvalid);
+				O(t ?? S.pathInvalid);
 				return;
 			}
 			default: {
 				let { traceId: t } = await e(n);
-				D(x.saveError), C({
-					variant: l.Error,
-					message: x.saveError,
+				O(S.saveError), w({
+					variant: u.Error,
+					message: S.saveError,
 					requestId: t
 				});
 			}
 		}
-	}, [x, C]), P = o(async (e) => {
+	}, [S, w]), R = s(async (e) => {
 		let t = a(e.name);
 		if (!t || !i(t)) {
-			T({ name: x.nameInvalid });
+			E({ name: S.nameInvalid });
 			return;
 		}
-		let o = u(e, p), s = M.current, c = s != null && s.fingerprint === o, f = t, g, _, w;
-		c ? {skillManifest: g, filePaths: _, files: w} = s : (g = r(h.current, t, e.description, e.instructions), {filePaths: _, files: w} = n(p, m.current)), j("submitting"), M.current = {
+		let o = d(e, m), s = F.current, c = s != null && s.fingerprint === o, l = t, p, _, v;
+		c ? {skillManifest: p, filePaths: _, files: v} = s : (p = r(g.current, t, e.description, e.instructions), {filePaths: _, files: v} = n(m, h.current)), P("submitting"), F.current = {
 			fingerprint: o,
-			bucket: d,
-			path: f,
-			skillManifest: g,
+			bucket: f,
+			path: l,
+			skillManifest: p,
 			filePaths: _,
-			files: w
+			files: v
 		};
 		try {
-			await b.createSkill(d, f, g, _, w), await y(), j("success"), C({
-				variant: l.Success,
-				title: x.saveSuccessTitle,
-				message: x.createSuccess(t)
-			}), S(v);
+			await x.createSkill(f, l, p, _, v), await b(), P("success"), w({
+				variant: u.Success,
+				title: S.saveSuccessTitle,
+				message: S.createSuccess(t)
+			}), C(y);
 		} catch (e) {
-			j("failure"), await N(e);
+			P("failure"), await L(e);
 		}
 	}, [
-		d,
-		p,
+		f,
 		m,
 		h,
+		g,
+		S,
 		x,
-		b,
+		w,
 		C,
-		S,
-		v,
 		y,
-		N
-	]), F = o(async (e) => {
-		let i = g.current, a = _.current;
+		b,
+		L
+	]), z = s(async (e) => {
+		let i = _.current, a = v.current;
 		if (!i || !a) {
-			D(x.saveError);
+			O(S.saveError);
 			return;
 		}
-		let o = r(h.current, e.name, e.description, e.instructions), { filePaths: s, files: c } = n(p, m.current);
-		j("submitting");
+		let o = r(g.current, e.name, e.description, e.instructions), { filePaths: s, files: c } = n(m, h.current);
+		P("submitting");
 		try {
-			_.current = (await b.updateSkill(d, i, o, s, c, a)).etag ?? a, await y(), j("success"), C({
-				variant: l.Success,
-				title: x.updateSuccessTitle,
-				message: x.updateSuccess(e.name)
-			}), S(v);
+			v.current = (await x.updateSkill(f, i, o, s, c, a)).etag ?? a, await b(), P("success"), w({
+				variant: u.Success,
+				title: S.updateSuccessTitle,
+				message: S.updateSuccess(e.name)
+			}), C(y);
 		} catch (e) {
-			if (j("failure"), t(e) === 412) {
-				k({ message: x.conflictMessage });
+			if (P("failure"), t(e) === 412) {
+				M({ message: S.conflictMessage });
 				return;
 			}
-			await N(e);
+			await L(e);
 		}
 	}, [
-		d,
-		p,
+		f,
 		m,
 		h,
 		g,
 		_,
+		v,
+		S,
 		x,
-		b,
+		w,
 		C,
-		S,
-		v,
 		y,
-		N
+		b,
+		L
+	]), B = s((e) => {
+		let t = o(e.instructions);
+		E((e) => {
+			if (t === (e.instructions === S.instructionsFrontmatter)) return e;
+			if (t) return {
+				...e,
+				instructions: S.instructionsFrontmatter
+			};
+			let n = { ...e };
+			return delete n.instructions, n;
+		});
+	}, [S]), V = s(async (e) => {
+		if (N === "submitting" || !f) return;
+		let t = {};
+		if (e.name.trim() || (t.name = S.required), e.description.trim() || (t.description = S.required), e.instructions.trim() ? o(e.instructions) && (t.instructions = S.instructionsFrontmatter) : t.instructions = S.required, Object.keys(t).length > 0) {
+			E(t);
+			return;
+		}
+		E({}), O(void 0), A(!1), M(void 0), I.current = e, p ? await z(e) : await R(e);
+	}, [
+		N,
+		f,
+		S,
+		p,
+		z,
+		R
 	]);
 	return {
-		phase: A,
-		errors: w,
-		submitError: E,
-		conflict: O,
-		clearConflict: () => k(void 0),
-		handleSubmit: o(async (e) => {
-			if (A === "submitting" || !d) return;
-			let t = {};
-			if (e.name.trim() || (t.name = x.required), e.description.trim() || (t.description = x.required), e.instructions.trim() || (t.instructions = x.required), Object.keys(t).length > 0) {
-				T(t);
-				return;
-			}
-			T({}), D(void 0), k(void 0), f ? await F(e) : await P(e);
-		}, [
-			A,
-			d,
-			x,
-			f,
-			F,
-			P
-		])
+		phase: N,
+		errors: T,
+		submitError: D,
+		isSubmitErrorRetryable: k,
+		retrySubmit: s(() => {
+			let e = I.current;
+			e != null && V(e);
+		}, [V]),
+		conflict: j,
+		clearConflict: () => M(void 0),
+		handleSubmit: V,
+		handleValuesChange: B
 	};
 };
 //#endregion
-export { d as useSkillEditorSubmit };
+export { f as useSkillEditorSubmit };

package/skill-editor.d.ts

@@ -43,6 +43,13 @@ export declare const buildSkillManifestForSubmit: (frontmatter: Record<string, u
  */
 export declare const buildSkillManifestFromFrontmatter: (baseFrontmatter: Record<string, unknown>, name: string, description: string, instructions: string) => string;
 
+/**
+ * Classifies an import request's HTTP status into a semantic outcome: 400/413/422 are
+ * archive-content problems, 409 is a name collision, 429 is rate limiting, 502/503 mean the
+ * backend is unavailable, and anything else (including no status at all) is generic.
+ */
+export declare const classifySkillArchiveImportError: (status: number | undefined) => SkillArchiveImportErrorKind;
+
 /**
  * Client-side mirror of the backend's `isValidSkillRelativePath`
  * (`apps/chat-api/src/skills/utils/skill-path.util.ts`), used only for
@@ -122,6 +129,28 @@ export declare interface SkillAboutDetails {
     skillPrompt?: string;
 }
 
+/** Semantic classification of an import request failure. */
+export declare enum SkillArchiveImportErrorKind {
+    Validation = "validation",
+    Collision = "collision",
+    RateLimited = "rateLimited",
+    ServiceUnavailable = "serviceUnavailable",
+    Generic = "generic"
+}
+
+/** Phase of a skill-archive import, driving the host's loading/success/error presentation. */
+export declare enum SkillArchiveImportStatus {
+    Idle = "idle",
+    Uploading = "uploading",
+    Success = "success",
+    Error = "error"
+}
+
+/** Reason a selected/dropped file was rejected before any request was made. */
+export declare enum SkillArchiveSelectionRejectionReason {
+    UnsupportedFilename = "unsupportedFilename"
+}
+
 /** Already-configured DIAL Core download operations `useSkillEditorLoad` needs. */
 export declare interface SkillEditorLoadClient {
     /** Downloads the whole-skill ZIP archive. */
@@ -163,6 +192,12 @@ export declare interface SkillEditorSubmitClient {
 export declare interface SkillEditorSubmitMessages {
     /** Shown when a required field is empty. */
     required: string;
+    /**
+     * Shown when the Instructions value opens with its own YAML frontmatter
+     * block — pasting a whole `SKILL.md` in there would otherwise produce a
+     * manifest with two frontmatter blocks.
+     */
+    instructionsFrontmatter: string;
     /** Shown when the normalized skill name fails DIAL's naming rules. */
     nameInvalid: string;
     /** Shown when the skill name already exists (409), or defensively on an unreachable create-mode 412. */
@@ -328,6 +363,28 @@ export declare interface SkillManifestValues {
     instructions: string;
 }
 
+/**
+ * Answers one question: would appending this text after the fence that
+ * `buildSkillManifest` writes produce a *second* frontmatter block?
+ *
+ * That happens when the text's first non-blank line is a bare `---` and some
+ * later line is a bare `---` too — the exact shape of a `SKILL.md` pasted
+ * wholesale into the editor's Instructions field.
+ *
+ * Detection is deliberately structural rather than YAML-based: a pasted block
+ * whose fenced content fails to parse corrupts the stored manifest
+ * identically (and renders as a setext `h2` in the Catalog's Details tab just
+ * the same), so requiring parseable YAML here would let the worst cases
+ * through. Keeping `parseYaml` out also makes this cheap enough to run on
+ * every keystroke.
+ *
+ * A single unclosed fence returns `false`: with no closing fence there is no
+ * second block, matching `FRONTMATTER_PATTERN`'s own requirement. A `---`
+ * appearing later in the body (a horizontal rule, a setext underline) is
+ * likewise not a frontmatter block.
+ */
+export declare const startsWithFrontmatterBlock: (text: string) => boolean;
+
 declare type SubmitPhase = 'idle' | 'submitting' | 'success' | 'failure';
 
 /** A skill archive unpacked into its manifest text and a relative-path → bytes map of every other entry. */
@@ -346,6 +403,46 @@ export declare interface UnpackedSkillArchive {
  */
 export declare const unpackSkillArchive: (bytes: Uint8Array) => UnpackedSkillArchive;
 
+/**
+ * Headless controller for the skill-archive upload flow: dialog visibility, the exact-filename
+ * precheck, in-flight exclusion, and import completion. The host supplies the configured request
+ * and observes completion/failure through the injected callbacks; the hook never imports app
+ * contexts, i18n, or a configured API client.
+ */
+export declare const useSkillArchiveImport: <TResult>({ importArchive, onImported, onError, manifestFileName, }: UseSkillArchiveImportOptions<TResult>) => UseSkillArchiveImportResult;
+
+/** Options accepted by {@link useSkillArchiveImport}. */
+export declare interface UseSkillArchiveImportOptions<TResult> {
+    /** Submits the selected archive; the host owns request configuration and the client. */
+    importArchive: (file: File) => Promise<TResult>;
+    /** Called once after a successful import (and any awaited host follow-up) settles. */
+    onImported: (result: TResult) => void | Promise<void>;
+    /** Called once when the import request, or the host's follow-up in {@link onImported}, fails. */
+    onError: (error: unknown, kind: SkillArchiveImportErrorKind) => void;
+    /** Exact filename treated as the skill manifest. Defaults to `'SKILL.md'`. */
+    manifestFileName?: string;
+}
+
+/** Result returned by {@link useSkillArchiveImport}. */
+export declare interface UseSkillArchiveImportResult {
+    /** Whether the upload dialog is open. */
+    isDialogOpen: boolean;
+    /** Current phase of the import. */
+    status: SkillArchiveImportStatus;
+    /** Reason the current/last selection was rejected locally; `undefined` once cleared. */
+    selectionRejectionReason: SkillArchiveSelectionRejectionReason | undefined;
+    /** Classified failure of the last import request; `undefined` outside a request failure. */
+    errorKind: SkillArchiveImportErrorKind | undefined;
+    /** Opens the dialog, unless an import is already in flight. */
+    openDialog: () => void;
+    /** Closes the dialog and clears any rejection reason. */
+    closeDialog: () => void;
+    /** Wire to the dialog drop zone's `onChange`. */
+    handleFilesSelected: (files: File[]) => void;
+    /** Wire to the dialog drop zone's `onReject`. */
+    handleFilesRejected: () => void;
+}
+
 /**
  * Owns the edit-mode skill download/unpack/parse flow: the in-memory
  * supporting-file map, the loaded manifest values and frontmatter, the
@@ -437,6 +534,10 @@ export declare interface UseSkillEditorSubmitResult {
     errors: SkillEditorErrors;
     /** General submit-time error, distinct from a stale-edit `conflict`. */
     submitError: string | undefined;
+    /** Whether `submitError` was caused by something a plain re-send can clear, rather than by the submission itself. */
+    isSubmitErrorRetryable: boolean;
+    /** Re-submits the values of the attempt that produced `submitError`. No-op before the first submit. */
+    retrySubmit: () => void;
     /** Present when the last save hit a stale-ETag conflict. */
     conflict: {
         message: string;
@@ -445,6 +546,12 @@ export declare interface UseSkillEditorSubmitResult {
     clearConflict: () => void;
     /** Validates and submits the given form values. */
     handleSubmit: (values: SkillEditorValues) => Promise<void>;
+    /**
+     * Re-runs the Instructions frontmatter check against the editor's current
+     * values, so a pasted `SKILL.md` is flagged as the text lands rather than
+     * only on submit. Pass as the editor's `onValuesChange`.
+     */
+    handleValuesChange: (values: SkillEditorValues) => void;
 }
 
 /**

package/skill-editor.js

@@ -1,8 +1,9 @@
-import { SKILL_FILE_UPLOAD_MAX_BYTES as e, SKILL_MANIFEST_FILE as t, SKILL_UPLOAD_MAX_FILES as n, SKILL_UPLOAD_MAX_TOTAL_BYTES as r, buildSkillFilesPayload as i, buildSkillManifest as a, buildSkillManifestForSubmit as o, buildSkillManifestFromFrontmatter as s, isValidSkillRelativePath as c, nameFromPath as l, normalizeSkillName as u, parseSkillManifest as d, skillFileBytesToBlob as f, unpackSkillArchive as p } from "./skill/skill.js";
-import { parseSkillManifestDocument as m } from "./skill/skill-manifest.js";
-import { validateSkillFileBatch as h } from "./skill/skill-file-batch-validation.js";
-import { skillFileToAttachment as g } from "./skill/skill-file-preview.js";
-import { SkillEditorLoadState as _, useSkillEditorLoad as v } from "./skill/useSkillEditorLoad.js";
-import { useSkillEditorSubmit as y } from "./skill/useSkillEditorSubmit.js";
-import { useSkillFileActions as b } from "./skill/useSkillFileActions.js";
-export { e as SKILL_FILE_UPLOAD_MAX_BYTES, t as SKILL_MANIFEST_FILE, n as SKILL_UPLOAD_MAX_FILES, r as SKILL_UPLOAD_MAX_TOTAL_BYTES, _ as SkillEditorLoadState, i as buildSkillFilesPayload, a as buildSkillManifest, o as buildSkillManifestForSubmit, s as buildSkillManifestFromFrontmatter, c as isValidSkillRelativePath, l as nameFromPath, u as normalizeSkillName, d as parseSkillManifest, m as parseSkillManifestDocument, f as skillFileBytesToBlob, g as skillFileToAttachment, p as unpackSkillArchive, v as useSkillEditorLoad, y as useSkillEditorSubmit, b as useSkillFileActions, h as validateSkillFileBatch };
+import { SKILL_FILE_UPLOAD_MAX_BYTES as e, SKILL_MANIFEST_FILE as t, SKILL_UPLOAD_MAX_FILES as n, SKILL_UPLOAD_MAX_TOTAL_BYTES as r, buildSkillFilesPayload as i, buildSkillManifest as a, buildSkillManifestForSubmit as o, buildSkillManifestFromFrontmatter as s, isValidSkillRelativePath as c, nameFromPath as l, normalizeSkillName as u, parseSkillManifest as d, skillFileBytesToBlob as f, startsWithFrontmatterBlock as p, unpackSkillArchive as m } from "./skill/skill.js";
+import { parseSkillManifestDocument as h } from "./skill/skill-manifest.js";
+import { validateSkillFileBatch as g } from "./skill/skill-file-batch-validation.js";
+import { skillFileToAttachment as _ } from "./skill/skill-file-preview.js";
+import { SkillEditorLoadState as v, useSkillEditorLoad as y } from "./skill/useSkillEditorLoad.js";
+import { useSkillEditorSubmit as b } from "./skill/useSkillEditorSubmit.js";
+import { useSkillFileActions as x } from "./skill/useSkillFileActions.js";
+import { SkillArchiveImportErrorKind as S, SkillArchiveImportStatus as C, SkillArchiveSelectionRejectionReason as w, classifySkillArchiveImportError as T, useSkillArchiveImport as E } from "./skill/useSkillArchiveImport/useSkillArchiveImport.js";
+export { e as SKILL_FILE_UPLOAD_MAX_BYTES, t as SKILL_MANIFEST_FILE, n as SKILL_UPLOAD_MAX_FILES, r as SKILL_UPLOAD_MAX_TOTAL_BYTES, S as SkillArchiveImportErrorKind, C as SkillArchiveImportStatus, w as SkillArchiveSelectionRejectionReason, v as SkillEditorLoadState, i as buildSkillFilesPayload, a as buildSkillManifest, o as buildSkillManifestForSubmit, s as buildSkillManifestFromFrontmatter, T as classifySkillArchiveImportError, c as isValidSkillRelativePath, l as nameFromPath, u as normalizeSkillName, d as parseSkillManifest, h as parseSkillManifestDocument, f as skillFileBytesToBlob, _ as skillFileToAttachment, p as startsWithFrontmatterBlock, m as unpackSkillArchive, E as useSkillArchiveImport, y as useSkillEditorLoad, b as useSkillEditorSubmit, x as useSkillFileActions, g as validateSkillFileBatch };

package/usage/map-usage-data-to-dashboard.js

@@ -0,0 +1,66 @@
+import { formatCost as e } from "@epam/ai-dial-chat-shared";
+import { UsageLimitStatus as t } from "@epam/ai-dial-usage-dashboard";
+//#region src/usage/map-usage-data-to-dashboard.ts
+var n = {
+	todayTitle: "usage.todayTitle",
+	todayPeriodDescription: "usage.todayPeriodDescription",
+	thisWeekTitle: "usage.thisWeekTitle",
+	thisWeekPeriodDescription: "usage.thisWeekPeriodDescription",
+	thisMonthTitle: "usage.thisMonthTitle",
+	thisMonthPeriodDescription: "usage.thisMonthPeriodDescription",
+	unlimitedProgressAriaLabel: "usage.unlimitedProgressAriaLabel",
+	progressAriaLabel: "usage.progressAriaLabel"
+}, r = 2 ** 53, i = 75, a = (e) => e != null && Number.isFinite(e.total) && Number.isFinite(e.used), o = (e) => e >= 100 ? t.LimitReached : e >= i ? t.RunningLow : t.Default, s = (e) => e ? {
+	resetLabel: e.label,
+	resetIsoValue: e.isoValue,
+	resetAriaLabel: e.ariaLabel
+} : {}, c = (i, a, c, l, u) => {
+	let d = Math.max(0, i.used), f = e(d), p = s(u);
+	if (i.total >= r) return {
+		title: a,
+		periodDescription: c,
+		used: d,
+		total: i.total,
+		usedLabel: f,
+		isUnlimited: !0,
+		status: t.Default,
+		progressAriaLabel: l(n.unlimitedProgressAriaLabel, { used: f }),
+		...p
+	};
+	let m = Math.max(i.total, 0), h = Math.max(m - d, 0), g = m > 0 ? d / m * 100 : 100, _ = e(m);
+	return {
+		title: a,
+		periodDescription: c,
+		used: d,
+		total: m,
+		usedLabel: f,
+		totalLabel: _,
+		remainingLabel: e(h),
+		usedPercent: g,
+		status: o(g),
+		progressAriaLabel: l(n.progressAriaLabel, {
+			used: f,
+			total: _,
+			percent: Math.round(g)
+		}),
+		...p
+	};
+}, l = (e, t, r) => [
+	{
+		stats: e?.dayCostStats,
+		titleKey: n.todayTitle,
+		periodDescriptionKey: n.todayPeriodDescription
+	},
+	{
+		stats: e?.weekCostStats,
+		titleKey: n.thisWeekTitle,
+		periodDescriptionKey: n.thisWeekPeriodDescription
+	},
+	{
+		stats: e?.monthCostStats,
+		titleKey: n.thisMonthTitle,
+		periodDescriptionKey: n.thisMonthPeriodDescription
+	}
+].flatMap(({ stats: e, titleKey: n, periodDescriptionKey: i }) => a(e) ? [c(e, t(n), t(i), t, r(e.resetsAt))] : []);
+//#endregion
+export { n as USAGE_DATA_I18N_KEYS, l as mapUsageDataToDashboard };