@morscherlab/mint-sdk 1.0.63 → 1.1.0-beta.2

package/dist/EmptyState-D1c4RdC7.js

@@ -0,0 +1,638 @@
+import { p as BaseButton_default } from "./experiment-utils-CxkruZ3G.js";
+import { r as useSettingsStore, t as useAuthStore } from "./auth-B87xM--s.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, normalizeStyle, openBlock, ref, renderList, renderSlot, toDisplayString, withCtx } from "vue";
+import axios from "axios";
+//#region src/components/BaseInput.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$3 = [
+	"type",
+	"value",
+	"placeholder",
+	"disabled",
+	"readonly",
+	"autocomplete",
+	"autofocus",
+	"min",
+	"max",
+	"step",
+	"list",
+	"aria-invalid",
+	"aria-describedby"
+];
+//#endregion
+//#region src/components/BaseInput.vue
+var BaseInput_default = /* @__PURE__ */ defineComponent({
+	__name: "BaseInput",
+	props: {
+		modelValue: {},
+		type: { default: "text" },
+		placeholder: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		readonly: {
+			type: Boolean,
+			default: false
+		},
+		error: {
+			type: Boolean,
+			default: false
+		},
+		size: { default: "md" },
+		autocomplete: {},
+		autofocus: { type: Boolean },
+		min: {},
+		max: {},
+		step: {},
+		list: {},
+		ariaDescribedby: {}
+	},
+	emits: [
+		"update:modelValue",
+		"focus",
+		"blur",
+		"keydown"
+	],
+	setup(__props, { emit: __emit }) {
+		/** Renders a styled `<input>` supporting text/number/email types, size, error, and readonly states. */
+		const props = __props;
+		const emit = __emit;
+		function handleInput(event) {
+			const target = event.target;
+			emit("update:modelValue", props.type === "number" ? target.value === "" ? null : Number(target.value) : target.value);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("input", {
+				type: __props.type,
+				value: __props.modelValue,
+				placeholder: __props.placeholder,
+				disabled: __props.disabled,
+				readonly: __props.readonly,
+				autocomplete: __props.autocomplete,
+				autofocus: __props.autofocus,
+				min: __props.min,
+				max: __props.max,
+				step: __props.step,
+				list: __props.list,
+				"aria-invalid": __props.error || void 0,
+				"aria-describedby": __props.ariaDescribedby || void 0,
+				class: normalizeClass([
+					"mint-input",
+					`mint-input--${__props.size}`,
+					__props.error ? "mint-input--error" : "",
+					__props.disabled ? "mint-input--disabled" : ""
+				]),
+				onInput: handleInput,
+				onFocus: _cache[0] || (_cache[0] = ($event) => emit("focus", $event)),
+				onBlur: _cache[1] || (_cache[1] = ($event) => emit("blur", $event)),
+				onKeydown: _cache[2] || (_cache[2] = ($event) => emit("keydown", $event))
+			}, null, 42, _hoisted_1$3);
+		};
+	}
+});
+//#endregion
+//#region src/utils/options.ts
+function normalizeOptionInput(option) {
+	if (typeof option === "object") return option;
+	return {
+		value: option,
+		label: String(option)
+	};
+}
+function findOptionByDomValue(options, value) {
+	return options.find((option) => String(option.value) === value);
+}
+//#endregion
+//#region src/components/BaseSelect.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$2 = { class: "mint-select" };
+var _hoisted_2$2 = [
+	"value",
+	"disabled",
+	"aria-invalid",
+	"aria-describedby"
+];
+var _hoisted_3$1 = {
+	key: 0,
+	value: "",
+	disabled: ""
+};
+var _hoisted_4$1 = ["value", "disabled"];
+//#endregion
+//#region src/components/BaseSelect.vue
+var BaseSelect_default = /* @__PURE__ */ defineComponent({
+	__name: "BaseSelect",
+	props: {
+		modelValue: {},
+		options: {},
+		placeholder: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		error: {
+			type: Boolean,
+			default: false
+		},
+		size: { default: "md" },
+		ariaDescribedby: {}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		/** Renders a native `<select>` element with size, error, and disabled states. */
+		const props = __props;
+		const emit = __emit;
+		const normalizedOptions = computed(() => props.options.map(normalizeOptionInput));
+		function handleChange(event) {
+			const target = event.target;
+			emit("update:modelValue", findOptionByDomValue(normalizedOptions.value, target.value)?.value ?? target.value);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$2, [createElementVNode("select", {
+				value: __props.modelValue,
+				disabled: __props.disabled,
+				"aria-invalid": __props.error || void 0,
+				"aria-describedby": __props.ariaDescribedby || void 0,
+				class: normalizeClass([
+					"mint-select__control",
+					`mint-select__control--${__props.size}`,
+					__props.error ? "mint-select__control--error" : "",
+					__props.disabled ? "mint-select__control--disabled" : ""
+				]),
+				onChange: handleChange
+			}, [__props.placeholder ? (openBlock(), createElementBlock("option", _hoisted_3$1, toDisplayString(__props.placeholder), 1)) : createCommentVNode("", true), (openBlock(true), createElementBlock(Fragment, null, renderList(normalizedOptions.value, (option) => {
+				return openBlock(), createElementBlock("option", {
+					key: String(option.value),
+					value: option.value,
+					disabled: option.disabled
+				}, toDisplayString(option.label), 9, _hoisted_4$1);
+			}), 128))], 42, _hoisted_2$2), _cache[0] || (_cache[0] = createElementVNode("div", { class: "mint-select__icon" }, [createElementVNode("svg", {
+				fill: "none",
+				stroke: "currentColor",
+				"stroke-width": "2",
+				"stroke-linecap": "round",
+				"stroke-linejoin": "round",
+				viewBox: "0 0 24 24"
+			}, [createElementVNode("path", { d: "m6 9 6 6 6-6" })])], -1))]);
+		};
+	}
+});
+//#endregion
+//#region src/components/BasePill.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = {
+	key: 0,
+	class: "mint-pill__icon"
+};
+var _hoisted_2$1 = { class: "mint-pill__label" };
+//#endregion
+//#region src/components/BasePill.vue
+var BasePill_default = /* @__PURE__ */ defineComponent({
+	__name: "BasePill",
+	props: {
+		variant: { default: "default" },
+		color: { default: void 0 },
+		size: { default: "md" },
+		removable: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		icon: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: ["remove"],
+	setup(__props, { emit: __emit }) {
+		/** Compact label for tags, status indicators, and badges; supports removable and icon slots. */
+		const props = __props;
+		/**
+		* @event remove - Emitted when the remove button is clicked
+		*/
+		const emit = __emit;
+		function handleRemove(event) {
+			event.stopPropagation();
+			if (!props.disabled) emit("remove");
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", { class: normalizeClass([
+				"mint-pill",
+				`mint-pill--${__props.variant}`,
+				__props.color && `mint-pill--${__props.color}`,
+				`mint-pill--${__props.size}`,
+				{
+					"mint-pill--disabled": __props.disabled,
+					"mint-pill--with-icon": __props.icon
+				}
+			]) }, [
+				__props.icon ? (openBlock(), createElementBlock("span", _hoisted_1$1, [renderSlot(_ctx.$slots, "icon")])) : createCommentVNode("", true),
+				createElementVNode("span", _hoisted_2$1, [renderSlot(_ctx.$slots, "default")]),
+				__props.removable && !__props.disabled ? (openBlock(), createElementBlock("button", {
+					key: 1,
+					type: "button",
+					class: "mint-pill__remove",
+					"aria-label": "Remove",
+					onClick: handleRemove
+				}, [..._cache[0] || (_cache[0] = [createElementVNode("svg", {
+					class: "mint-pill__remove-icon",
+					fill: "none",
+					stroke: "currentColor",
+					"stroke-width": "2",
+					"stroke-linecap": "round",
+					"stroke-linejoin": "round",
+					viewBox: "0 0 24 24"
+				}, [createElementVNode("path", { d: "M18 6 6 18" }), createElementVNode("path", { d: "m6 6 12 12" })], -1)])])) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+//#region src/composables/useApi.ts
+var apiClientInstance = null;
+var interceptorAttached = false;
+function joinUrlPath(baseUrl, path) {
+	if (/^https?:\/\//i.test(path)) return path;
+	if (!path) return baseUrl;
+	if (path.startsWith("?") || path.startsWith("#")) return `${baseUrl.replace(/\/+$/, "")}${path}`;
+	const normalizedBase = baseUrl.replace(/\/+$/, "");
+	const normalizedPath = path.replace(/^\/+/, "/");
+	return `${normalizedBase}${normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`}`;
+}
+function getBasePath(baseUrl) {
+	if (!baseUrl) return "/";
+	try {
+		const origin = typeof window !== "undefined" ? window.location.origin : "http://localhost";
+		return new URL(baseUrl, origin).pathname.replace(/\/+$/, "") || "/";
+	} catch {
+		return baseUrl.replace(/^https?:\/\/[^/]+/i, "").replace(/\/+$/, "") || "/";
+	}
+}
+function normalizeRequestUrl(baseUrl, url) {
+	if (!url || /^https?:\/\//.test(url)) return url;
+	const basePath = getBasePath(baseUrl);
+	if (basePath === "/") return url;
+	const normalizedUrl = url.startsWith("/") ? url : `/${url}`;
+	if (normalizedUrl === basePath || normalizedUrl.startsWith(`${basePath}?`) || normalizedUrl.startsWith(`${basePath}#`)) return normalizedUrl.slice(basePath.length);
+	if (normalizedUrl.startsWith(`${basePath}/`)) return normalizedUrl.slice(basePath.length) || "";
+	return url;
+}
+function asMutableHeaders(headers) {
+	return headers ? headers : null;
+}
+function hasAuthorizationHeader(headers) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return false;
+	if (typeof bag.has === "function") return bag.has("Authorization");
+	return Object.keys(bag).some((key) => key.toLowerCase() === "authorization");
+}
+function setAuthorizationHeader(headers, value) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return;
+	if (typeof bag.set === "function") {
+		bag.set("Authorization", value);
+		return;
+	}
+	bag.Authorization = value;
+}
+function deleteAuthorizationHeader(headers) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return;
+	if (typeof bag.delete === "function") {
+		bag.delete("Authorization");
+		return;
+	}
+	for (const key of Object.keys(bag)) if (key.toLowerCase() === "authorization") delete bag[key];
+}
+function getAuthorizationHeader(headers) {
+	const bag = asMutableHeaders(headers);
+	if (!bag) return void 0;
+	if (typeof bag.get === "function") return bag.get("Authorization");
+	const key = Object.keys(bag).find((candidate) => candidate.toLowerCase() === "authorization");
+	return key ? bag[key] : void 0;
+}
+/** Raised when an authenticated SDK request is rejected because the login is no longer valid. */
+var AuthenticationRequiredError = class extends Error {
+	code = "AUTHENTICATION_REQUIRED";
+	status = 401;
+	constructor(cause) {
+		super("Authentication required. Please sign in again.");
+		this.cause = cause;
+		this.name = "AuthenticationRequiredError";
+	}
+};
+/** @internal Convert a rejected authenticated request into the SDK's public auth error. */
+function authenticationRequiredError(cause, rejectedToken) {
+	const currentAuthStore = useAuthStore();
+	if (rejectedToken && currentAuthStore.token === rejectedToken) currentAuthStore.clearToken();
+	return new AuthenticationRequiredError(cause);
+}
+function getApiClient() {
+	if (!apiClientInstance) apiClientInstance = axios.create({ headers: { "Content-Type": "application/json" } });
+	return apiClientInstance;
+}
+/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. */
+function useApi(options = {}) {
+	const settingsStore = useSettingsStore();
+	const authStore = useAuthStore();
+	const apiClient = getApiClient();
+	if (!authStore.isInitialized) authStore.initialize();
+	if (!interceptorAttached) {
+		apiClient.interceptors.request.use((config) => {
+			const request = config;
+			if (request._mintSkipAuth) {
+				deleteAuthorizationHeader(request.headers);
+				return request;
+			}
+			const currentAuthStore = useAuthStore();
+			if (currentAuthStore.token && config.headers && !hasAuthorizationHeader(config.headers)) setAuthorizationHeader(config.headers, `Bearer ${currentAuthStore.token}`);
+			if (getAuthorizationHeader(config.headers) === `Bearer ${currentAuthStore.token}`) request._mintAuthToken = currentAuthStore.token ?? void 0;
+			return config;
+		});
+		apiClient.interceptors.response.use((response) => response, (error) => {
+			if (axios.isAxiosError(error) && error.response?.status === 401) {
+				const request = error.config;
+				if (request?._mintSkipAuth !== true) return Promise.reject(authenticationRequiredError(error, request?._mintAuthToken));
+			}
+			return Promise.reject(error);
+		});
+		interceptorAttached = true;
+	}
+	function getBaseUrl() {
+		return options.baseUrl ?? settingsStore.getApiBaseUrl();
+	}
+	function normalizeUrl(url) {
+		return normalizeRequestUrl(getBaseUrl(), url);
+	}
+	function requestConfig(config) {
+		const base = {
+			baseURL: getBaseUrl(),
+			timeout: options.timeout ?? settingsStore.requestTimeout,
+			...config
+		};
+		if (options.withAuth === false) {
+			base._mintSkipAuth = true;
+			deleteAuthorizationHeader(base.headers);
+		}
+		return base;
+	}
+	async function get(url, config) {
+		return (await apiClient.get(normalizeUrl(url), requestConfig(config))).data;
+	}
+	async function post(url, data, config) {
+		return (await apiClient.post(normalizeUrl(url), data, requestConfig(config))).data;
+	}
+	async function put(url, data, config) {
+		return (await apiClient.put(normalizeUrl(url), data, requestConfig(config))).data;
+	}
+	async function patch(url, data, config) {
+		return (await apiClient.patch(normalizeUrl(url), data, requestConfig(config))).data;
+	}
+	async function del(url, config) {
+		return (await apiClient.delete(normalizeUrl(url), requestConfig(config))).data;
+	}
+	async function upload(url, file, fieldName = "file", additionalData) {
+		const formData = new FormData();
+		formData.append(fieldName, file);
+		if (additionalData) Object.entries(additionalData).forEach(([key, value]) => {
+			if (value !== void 0 && value !== null) formData.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+		});
+		return (await apiClient.post(normalizeUrl(url), formData, requestConfig({ headers: { "Content-Type": void 0 } }))).data;
+	}
+	async function download(url, filename) {
+		const response = await apiClient.get(normalizeUrl(url), requestConfig({ responseType: "blob" }));
+		const blob = new Blob([response.data]);
+		const blobUrl = URL.createObjectURL(blob);
+		if (filename) {
+			const link = document.createElement("a");
+			link.href = blobUrl;
+			link.download = filename;
+			document.body.appendChild(link);
+			link.click();
+			document.body.removeChild(link);
+			setTimeout(() => URL.revokeObjectURL(blobUrl), 100);
+			return "";
+		}
+		return blobUrl;
+	}
+	function buildUrl(path) {
+		const baseUrl = getBaseUrl();
+		return joinUrlPath(baseUrl, normalizeRequestUrl(baseUrl, path));
+	}
+	function buildWsUrl(path) {
+		return joinUrlPath(settingsStore.getWsBaseUrl(), path);
+	}
+	return {
+		client: apiClient,
+		get,
+		post,
+		put,
+		patch,
+		delete: del,
+		upload,
+		download,
+		buildUrl,
+		buildWsUrl
+	};
+}
+//#endregion
+//#region src/composables/useRequestSyncState.ts
+/** Shared loading/error/timestamp state for generated plugin request helpers. */
+function useRequestSyncState(defaultErrorMessage = "Request failed.") {
+	const loading = ref(false);
+	const error = ref(null);
+	const lastLoadedAt = ref(null);
+	const lastSavedAt = ref(null);
+	const lastRunAt = ref(null);
+	function clearError() {
+		error.value = null;
+	}
+	function readErrorMessage(value, fallback = defaultErrorMessage) {
+		if (value instanceof Error && value.message) return value.message;
+		if (typeof value === "string" && value.trim()) return value;
+		if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string" && value.message) return value.message;
+		return fallback;
+	}
+	function setError(value, fallback) {
+		const message = readErrorMessage(value, fallback);
+		error.value = message;
+		return message;
+	}
+	function markLoaded(date = /* @__PURE__ */ new Date()) {
+		lastLoadedAt.value = date;
+	}
+	function markSaved(date = /* @__PURE__ */ new Date()) {
+		lastSavedAt.value = date;
+	}
+	function markRun(date = /* @__PURE__ */ new Date()) {
+		lastRunAt.value = date;
+	}
+	async function run(operation, options = {}) {
+		loading.value = true;
+		clearError();
+		try {
+			const response = await operation();
+			if (options.success === "load") markLoaded();
+			else if (options.success === "save") markSaved();
+			else if (options.success === "run") markRun();
+			return response;
+		} catch (err) {
+			setError(err, options.errorMessage);
+			throw err;
+		} finally {
+			loading.value = false;
+		}
+	}
+	return {
+		loading,
+		error,
+		lastLoadedAt,
+		lastSavedAt,
+		lastRunAt,
+		clearError,
+		readErrorMessage,
+		setError,
+		markLoaded,
+		markSaved,
+		markRun,
+		run
+	};
+}
+//#endregion
+//#region src/components/Skeleton.vue
+var Skeleton_default = /* @__PURE__ */ defineComponent({
+	__name: "Skeleton",
+	props: {
+		variant: { default: "text" },
+		width: {},
+		height: {},
+		animation: { default: "wave" }
+	},
+	setup(__props) {
+		/** Animated loading placeholder in text, circular, rectangular, or rounded variants with pulse or wave animation. */
+		const props = __props;
+		const style = computed(() => {
+			const s = {};
+			if (props.width) s.width = typeof props.width === "number" ? `${props.width}px` : props.width;
+			if (props.height) s.height = typeof props.height === "number" ? `${props.height}px` : props.height;
+			return s;
+		});
+		const classes = computed(() => {
+			const base = ["bg-bg-hover"];
+			switch (props.variant) {
+				case "circular":
+					base.push("rounded-full");
+					if (!props.width && !props.height) base.push("w-10 h-10");
+					break;
+				case "rectangular":
+					base.push("rounded-none");
+					if (!props.height) base.push("h-24");
+					break;
+				case "rounded":
+					base.push("rounded-mint");
+					if (!props.height) base.push("h-24");
+					break;
+				default:
+					base.push("rounded");
+					if (!props.height) base.push("h-4");
+					if (!props.width) base.push("w-full");
+			}
+			switch (props.animation) {
+				case "pulse":
+					base.push("animate-pulse");
+					break;
+				case "wave":
+					base.push("skeleton-wave");
+					break;
+			}
+			return base;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: normalizeClass(classes.value),
+				style: normalizeStyle(style.value)
+			}, null, 6);
+		};
+	}
+});
+//#endregion
+//#region src/components/EmptyState.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["d"];
+var _hoisted_2 = ["d"];
+var _hoisted_3 = { class: "mint-empty-state__body" };
+var _hoisted_4 = {
+	key: 0,
+	class: "mint-empty-state__title"
+};
+var _hoisted_5 = {
+	key: 1,
+	class: "mint-empty-state__description"
+};
+var _hoisted_6 = {
+	key: 0,
+	class: "mint-empty-state__action"
+};
+//#endregion
+//#region src/components/EmptyState.vue
+var EmptyState_default = /* @__PURE__ */ defineComponent({
+	__name: "EmptyState",
+	props: {
+		title: {},
+		description: {},
+		iconPath: {},
+		color: { default: "primary" },
+		size: { default: "md" },
+		variant: { default: "illustrated" },
+		actionLabel: {}
+	},
+	emits: ["action"],
+	setup(__props, { emit: __emit }) {
+		/** Empty-state placeholder with icon badge, headline, description, default slot, and optional CTA button. */
+		const emit = __emit;
+		const defaultIconPaths = [
+			"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
+			"M7 11h10",
+			"M7 15h6",
+			"M7 7h8"
+		];
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass([
+				"mint-empty-state",
+				`mint-empty-state--${__props.variant}`,
+				`mint-empty-state--${__props.size}`
+			]) }, [
+				createElementVNode("div", { class: normalizeClass(["mint-empty-state__icon-wrapper", `mint-empty-state__icon-wrapper--${__props.color}`]) }, [renderSlot(_ctx.$slots, "icon", {}, () => [(openBlock(), createElementBlock("svg", {
+					class: normalizeClass(["mint-empty-state__icon", `mint-empty-state__icon--${__props.color}`]),
+					viewBox: "0 0 24 24",
+					fill: "none",
+					stroke: "currentColor",
+					"stroke-width": "2",
+					"stroke-linecap": "round",
+					"stroke-linejoin": "round"
+				}, [__props.iconPath ? (openBlock(), createElementBlock("path", {
+					key: 0,
+					d: __props.iconPath
+				}, null, 8, _hoisted_1)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, renderList(defaultIconPaths, (d, i) => {
+					return createElementVNode("path", {
+						key: i,
+						d
+					}, null, 8, _hoisted_2);
+				}), 64))], 2))])], 2),
+				createElementVNode("div", _hoisted_3, [
+					__props.title ? (openBlock(), createElementBlock("h3", _hoisted_4, toDisplayString(__props.title), 1)) : createCommentVNode("", true),
+					__props.description ? (openBlock(), createElementBlock("p", _hoisted_5, toDisplayString(__props.description), 1)) : createCommentVNode("", true),
+					renderSlot(_ctx.$slots, "default")
+				]),
+				__props.actionLabel ? (openBlock(), createElementBlock("div", _hoisted_6, [createVNode(BaseButton_default, { onClick: _cache[0] || (_cache[0] = ($event) => emit("action")) }, {
+					default: withCtx(() => [createTextVNode(toDisplayString(__props.actionLabel), 1)]),
+					_: 1
+				})])) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+export { authenticationRequiredError as a, BaseSelect_default as c, AuthenticationRequiredError as i, normalizeOptionInput as l, Skeleton_default as n, useApi as o, useRequestSyncState as r, BasePill_default as s, EmptyState_default as t, BaseInput_default as u };
+
+//# sourceMappingURL=EmptyState-D1c4RdC7.js.map