@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/useSettingsItems-BhZXwMZn.js

@@ -0,0 +1,144 @@
+import { C as computed } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { rt as useI18n } from "./core-CRbPymLT.js";
+import { aa as useUIStore, ms as useSettingsStore, yr as hasPermission } from "./builder.store-Czk2ipDE.js";
+import { v as useRouter } from "./get-BcEmeOxn.js";
+import { Ro as VIEWS } from "./constants-C8OH4tTq.js";
+function useUserHelpers(router) {
+	const canUserAccessRouteByName = (name) => {
+		return canUserAccessRoute(router.resolve({ name }));
+	};
+	const canUserAccessRoute = (route) => {
+		const middleware = route.meta?.middleware;
+		const middlewareOptions = route.meta?.middlewareOptions;
+		if (!middleware) return true;
+		return hasPermission(middleware, middlewareOptions);
+	};
+	return { canUserAccessRouteByName };
+}
+function useSettingsItems() {
+	const router = useRouter();
+	const i18n = useI18n();
+	const uiStore = useUIStore();
+	const settingsStore = useSettingsStore();
+	const { canUserAccessRouteByName } = useUserHelpers(router);
+	const settingsItems = computed(() => {
+		const menuItems = [
+			{
+				id: "settings-usage-and-plan",
+				icon: "chart-column-decreasing",
+				label: i18n.baseText("settings.usageAndPlan.title"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.USAGE),
+				route: { to: { name: VIEWS.USAGE } }
+			},
+			{
+				id: "settings-personal",
+				icon: "circle-user-round",
+				label: i18n.baseText("settings.personal"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.PERSONAL_SETTINGS),
+				route: { to: { name: VIEWS.PERSONAL_SETTINGS } }
+			},
+			{
+				id: "settings-users",
+				icon: "user-round",
+				label: i18n.baseText("settings.users"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.USERS_SETTINGS),
+				route: { to: { name: VIEWS.USERS_SETTINGS } }
+			},
+			{
+				id: "settings-project-roles",
+				icon: "user-round",
+				label: i18n.baseText("settings.projectRoles"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.PROJECT_ROLES_SETTINGS),
+				route: { to: { name: VIEWS.PROJECT_ROLES_SETTINGS } }
+			},
+			{
+				id: "settings-api",
+				icon: "plug",
+				label: i18n.baseText("settings.n8napi"),
+				position: "top",
+				available: settingsStore.isPublicApiEnabled && canUserAccessRouteByName(VIEWS.API_SETTINGS),
+				route: { to: { name: VIEWS.API_SETTINGS } }
+			},
+			{
+				id: "settings-external-secrets",
+				icon: "vault",
+				label: i18n.baseText("settings.externalSecrets.title"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.EXTERNAL_SECRETS_SETTINGS),
+				route: { to: { name: VIEWS.EXTERNAL_SECRETS_SETTINGS } }
+			},
+			{
+				id: "settings-credential-resolvers",
+				icon: "key-round",
+				label: i18n.baseText("credentialResolver.view.title"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.RESOLVERS),
+				route: { to: { name: VIEWS.RESOLVERS } }
+			},
+			{
+				id: "settings-source-control",
+				icon: "git-branch",
+				label: i18n.baseText("settings.sourceControl.title"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.SOURCE_CONTROL),
+				route: { to: { name: VIEWS.SOURCE_CONTROL } }
+			},
+			{
+				id: "settings-sso",
+				icon: "user-lock",
+				label: i18n.baseText("settings.sso"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.SSO_SETTINGS),
+				route: { to: { name: VIEWS.SSO_SETTINGS } }
+			},
+			{
+				id: "settings-ldap",
+				icon: "network",
+				label: i18n.baseText("settings.ldap"),
+				position: "top",
+				available: canUserAccessRouteByName(VIEWS.LDAP_SETTINGS),
+				route: { to: { name: VIEWS.LDAP_SETTINGS } }
+			},
+			{
+				id: "settings-workersview",
+				icon: "waypoints",
+				label: i18n.baseText("mainSidebar.workersView"),
+				position: "top",
+				available: settingsStore.isQueueModeEnabled && hasPermission(["rbac"], { rbac: { scope: "workersView:manage" } }),
+				route: { to: { name: VIEWS.WORKER_VIEW } }
+			}
+		];
+		menuItems.push({
+			id: "settings-log-streaming",
+			icon: "log-in",
+			label: i18n.baseText("settings.log-streaming"),
+			position: "top",
+			available: canUserAccessRouteByName(VIEWS.LOG_STREAMING_SETTINGS),
+			route: { to: { name: VIEWS.LOG_STREAMING_SETTINGS } }
+		});
+		menuItems.push({
+			id: "settings-community-nodes",
+			icon: "box",
+			label: i18n.baseText("settings.communityNodes"),
+			position: "top",
+			available: canUserAccessRouteByName(VIEWS.COMMUNITY_NODES),
+			route: { to: { name: VIEWS.COMMUNITY_NODES } }
+		});
+		menuItems.push({
+			id: "settings-migration-report",
+			icon: "list-checks",
+			label: i18n.baseText("settings.migrationReport"),
+			position: "top",
+			available: canUserAccessRouteByName(VIEWS.MIGRATION_REPORT),
+			route: { to: { name: VIEWS.MIGRATION_REPORT } }
+		});
+		const moduleItems = uiStore.settingsSidebarItems;
+		return menuItems.concat(moduleItems.filter((item) => !menuItems.some((m) => m.id === item.id)));
+	});
+	return { settingsItems: computed(() => settingsItems.value.filter((item) => item.available)) };
+}
+export { useSettingsItems as t };

package/dist/assets/useTelemetryContext-V6bv4YRq.js

@@ -0,0 +1,34 @@
+import { D as createElementBlock, P as defineComponent, et as openBlock, nt as provide, st as resolveDirective, vn as normalizeClass, xt as withDirectives, z as inject } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { t as __plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BwBpWJRZ.js";
+import { tc as TelemetryContextSymbol } from "./constants-C8OH4tTq.js";
+var MappingPill_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "MappingPill",
+	props: {
+		html: {},
+		canDrop: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			const _directive_n8n_html = resolveDirective("n8n-html");
+			return withDirectives((openBlock(), createElementBlock("div", { class: normalizeClass([_ctx.$style.dragPill, _ctx.canDrop ? _ctx.$style.droppablePill : _ctx.$style.defaultPill]) }, null, 2)), [[_directive_n8n_html, _ctx.html]]);
+		};
+	}
+});
+var MappingPill_vue_vue_type_style_index_0_lang_module_default = {
+	dragPill: "_dragPill_wasb1_123",
+	droppablePill: "_droppablePill_wasb1_141",
+	defaultPill: "_defaultPill_wasb1_148"
+};
+var MappingPill_default = /* @__PURE__ */ __plugin_vue_export_helper_default(MappingPill_vue_vue_type_script_setup_true_lang_default, [["__cssModules", { "$style": MappingPill_vue_vue_type_style_index_0_lang_module_default }]]);
+function useTelemetryContext(overrides = {}) {
+	const merged = {
+		...inject(TelemetryContextSymbol, {}),
+		...overrides
+	};
+	provide(TelemetryContextSymbol, merged);
+	return merged;
+}
+export { MappingPill_default as n, useTelemetryContext as t };

package/dist/assets/useWorkflowActivate-DeSmDXjI.js

@@ -0,0 +1,152 @@
+import { It as ref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { rt as useI18n } from "./core-CRbPymLT.js";
+import { P as useWorkflowsStore, aa as useUIStore, g as useNpsSurveyStore, k as useTelemetry, n as useWorkflowSaving, os as activateWorkflow, ps as useStorage, ss as deactivateWorkflow, x as useExternalHooks, y as useToast, zn as useWorkflowHelpers } from "./builder.store-Czk2ipDE.js";
+import { v as useRouter } from "./get-BcEmeOxn.js";
+import { Cs as LOCAL_STORAGE_ACTIVATION_FLAG, ps as WORKFLOW_ACTIVE_MODAL_KEY } from "./constants-C8OH4tTq.js";
+import { r as useRootStore } from "./_baseOrderBy-N8Be_6z6.js";
+function useWorkflowActivate() {
+	const updatingWorkflowActivation = ref(false);
+	const router = useRouter();
+	const workflowHelpers = useWorkflowHelpers();
+	const workflowSaving = useWorkflowSaving({ router });
+	const workflowsStore = useWorkflowsStore();
+	const uiStore = useUIStore();
+	const telemetry = useTelemetry();
+	const toast = useToast();
+	const i18n = useI18n();
+	const npsSurveyStore = useNpsSurveyStore();
+	const rootStore = useRootStore();
+	const updateWorkflowActivation = async (workflowId, newActiveState, telemetrySource) => {
+		updatingWorkflowActivation.value = true;
+		const nodesIssuesExist = workflowsStore.nodesIssuesExist;
+		let currWorkflowId = workflowId;
+		const existingWorkflow = currWorkflowId ? workflowsStore.workflowsById[currWorkflowId] : null;
+		if (!currWorkflowId || !existingWorkflow?.id) {
+			if (!await workflowSaving.saveCurrentWorkflow()) {
+				updatingWorkflowActivation.value = false;
+				return false;
+			}
+			currWorkflowId = workflowsStore.workflowId;
+		}
+		const isCurrentWorkflow = currWorkflowId === workflowsStore.workflowId;
+		const isWorkflowActive = workflowsStore.activeWorkflows.includes(currWorkflowId);
+		const telemetryPayload = {
+			workflow_id: currWorkflowId,
+			is_active: newActiveState,
+			previous_status: isWorkflowActive,
+			ndv_input: telemetrySource === "ndv"
+		};
+		telemetry.track("User set workflow active status", telemetryPayload);
+		useExternalHooks().run("workflowActivate.updateWorkflowActivation", telemetryPayload);
+		try {
+			if (isWorkflowActive && newActiveState) {
+				toast.showMessage({
+					title: i18n.baseText("workflowActivator.workflowIsActive"),
+					type: "success"
+				});
+				updatingWorkflowActivation.value = false;
+				return true;
+			}
+			if (isCurrentWorkflow && nodesIssuesExist && newActiveState) {
+				toast.showMessage({
+					title: i18n.baseText("workflowActivator.showMessage.activeChangedNodesIssuesExistTrue.title"),
+					message: i18n.baseText("workflowActivator.showMessage.activeChangedNodesIssuesExistTrue.message"),
+					type: "error"
+				});
+				updatingWorkflowActivation.value = false;
+				return false;
+			}
+			if (uiStore.stateIsDirty) await workflowHelpers.updateWorkflow({ workflowId: currWorkflowId }, false);
+			let workflow;
+			if (newActiveState) workflow = await activateWorkflow(rootStore.restApiContext, currWorkflowId, { versionId: workflowsStore.workflow.versionId });
+			else workflow = await deactivateWorkflow(rootStore.restApiContext, currWorkflowId);
+			if (!workflow.checksum) throw new Error("Failed to activate or deactivate workflow");
+			if (workflow.activeVersion) workflowsStore.setWorkflowActive(currWorkflowId, workflow.activeVersion, true);
+			else workflowsStore.setWorkflowInactive(currWorkflowId);
+		} catch (error) {
+			const newStateName = newActiveState ? "activated" : "deactivated";
+			toast.showError(error, i18n.baseText("workflowActivator.showError.title", { interpolate: { newStateName } }) + ":");
+			updatingWorkflowActivation.value = false;
+			return false;
+		}
+		const activationEventName = isCurrentWorkflow ? "workflow.activeChangeCurrent" : "workflow.activeChange";
+		useExternalHooks().run(activationEventName, {
+			workflowId: currWorkflowId,
+			active: newActiveState
+		});
+		updatingWorkflowActivation.value = false;
+		if (isCurrentWorkflow) if (newActiveState && useStorage("N8N_HIDE_ACTIVATION_ALERT").value !== "true") uiStore.openModal(WORKFLOW_ACTIVE_MODAL_KEY);
+		else await npsSurveyStore.fetchPromptsData();
+		return newActiveState;
+	};
+	const activateCurrentWorkflow = async (telemetrySource) => {
+		const workflowId = workflowsStore.workflowId;
+		return await updateWorkflowActivation(workflowId, true, telemetrySource);
+	};
+	const publishWorkflow = async (workflowId, versionId, options) => {
+		updatingWorkflowActivation.value = true;
+		const hadPublishedVersion = !!workflowsStore.getWorkflowById(workflowId).activeVersion;
+		if (!hadPublishedVersion) {
+			const telemetryPayload = {
+				workflow_id: workflowId,
+				is_active: true,
+				previous_status: false,
+				ndv_input: false
+			};
+			useExternalHooks().run("workflowActivate.updateWorkflowActivation", telemetryPayload);
+		}
+		try {
+			const expectedChecksum = workflowId === workflowsStore.workflowId ? workflowsStore.workflowChecksum : void 0;
+			const updatedWorkflow = await workflowsStore.publishWorkflow(workflowId, {
+				versionId,
+				name: options?.name,
+				description: options?.description,
+				expectedChecksum
+			});
+			if (!updatedWorkflow.activeVersion || !updatedWorkflow.checksum) throw new Error("Failed to publish workflow");
+			workflowsStore.setWorkflowActive(workflowId, updatedWorkflow.activeVersion, true);
+			if (workflowId === workflowsStore.workflowId) workflowsStore.setWorkflowVersionId(updatedWorkflow.versionId, updatedWorkflow.checksum);
+			useExternalHooks().run("workflow.published", {
+				workflowId,
+				versionId: updatedWorkflow.activeVersion.versionId
+			});
+			if (!hadPublishedVersion && useStorage("N8N_HIDE_ACTIVATION_ALERT").value !== "true") uiStore.openModal(WORKFLOW_ACTIVE_MODAL_KEY);
+			return true;
+		} catch (error) {
+			toast.showError(error, i18n.baseText("workflowActivator.showError.title", { interpolate: { newStateName: "published" } }) + ":");
+			if (!error.meta?.validationError) workflowsStore.setWorkflowInactive(workflowId);
+			return false;
+		} finally {
+			updatingWorkflowActivation.value = false;
+		}
+	};
+	const unpublishWorkflowFromHistory = async (workflowId) => {
+		updatingWorkflowActivation.value = true;
+		const telemetryPayload = {
+			workflow_id: workflowId,
+			is_active: false,
+			previous_status: !!workflowsStore.getWorkflowById(workflowId).activeVersion,
+			ndv_input: false
+		};
+		telemetry.track("User set workflow active status", telemetryPayload);
+		useExternalHooks().run("workflowActivate.updateWorkflowActivation", telemetryPayload);
+		try {
+			await workflowsStore.deactivateWorkflow(workflowId);
+			useExternalHooks().run("workflow.unpublished", { workflowId });
+			return true;
+		} catch (error) {
+			toast.showError(error, i18n.baseText("workflowActivator.showError.title", { interpolate: { newStateName: "deactivated" } }) + ":");
+			return false;
+		} finally {
+			updatingWorkflowActivation.value = false;
+		}
+	};
+	return {
+		activateCurrentWorkflow,
+		updateWorkflowActivation,
+		updatingWorkflowActivation,
+		publishWorkflow,
+		unpublishWorkflowFromHistory
+	};
+}
+export { useWorkflowActivate as t };

package/dist/assets/useWorkflowsCache-DtcEEAIR.js

@@ -0,0 +1,179 @@
+import { It as ref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { Da as jsonParse } from "./constants-C8OH4tTq.js";
+async function indexedDbCache(dbName, storeName) {
+	let cache = {};
+	await loadCache();
+	async function loadCache() {
+		await transaction("readonly", async (store, db) => {
+			return await new Promise((resolve, reject) => {
+				const request = store.openCursor();
+				request.onsuccess = (event) => {
+					const cursor = event.target.result;
+					if (cursor) {
+						cache[cursor.key] = cursor.value.value;
+						cursor.continue();
+					} else {
+						db.close();
+						resolve();
+					}
+				};
+				request.onerror = (event) => {
+					db.close();
+					reject(event);
+				};
+			});
+		});
+	}
+	async function openDb() {
+		return await new Promise((resolve, reject) => {
+			const request = indexedDB.open(dbName, 1);
+			request.onupgradeneeded = () => {
+				request.result.createObjectStore(storeName, { keyPath: "key" });
+			};
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error);
+		});
+	}
+	function setItem(key, value) {
+		cache[key] = value;
+		persistToIndexedDB(key, value);
+	}
+	function getItem(key) {
+		return cache[key] ?? null;
+	}
+	function removeItem(key) {
+		delete cache[key];
+		deleteFromIndexedDB(key);
+	}
+	function clear() {
+		cache = {};
+		clearIndexedDB();
+	}
+	async function getAllWithPrefix(prefix) {
+		const keyRange = IDBKeyRange.bound(prefix, prefix + "￿", false, false);
+		const results = {};
+		return await transaction("readonly", async (store) => {
+			return await new Promise((resolve, reject) => {
+				const request = store.openCursor(keyRange);
+				request.onsuccess = (event) => {
+					const cursor = event.target.result;
+					if (cursor) {
+						results[cursor.key] = cursor.value.value;
+						cursor.continue();
+					} else resolve(results);
+				};
+				request.onerror = () => {
+					reject(request.error);
+				};
+			});
+		});
+	}
+	async function transaction(mode, action) {
+		const db = await openDb();
+		const tx = db.transaction(storeName, mode);
+		const result = await action(tx.objectStore(storeName), db);
+		return await new Promise((resolve, reject) => {
+			tx.oncomplete = () => {
+				db.close();
+				resolve(result);
+			};
+			tx.onerror = () => {
+				db.close();
+				reject(tx.error);
+			};
+		});
+	}
+	async function persistToIndexedDB(key, value) {
+		await transaction("readwrite", (store) => {
+			store.put({
+				key,
+				value
+			});
+		});
+	}
+	async function deleteFromIndexedDB(key) {
+		await transaction("readwrite", (store) => {
+			store.delete(key);
+		});
+	}
+	async function clearIndexedDB() {
+		await transaction("readwrite", (store) => {
+			store.clear();
+		});
+	}
+	return {
+		getItem,
+		removeItem,
+		setItem,
+		clear,
+		getAllWithPrefix
+	};
+}
+function useWorkflowSettingsCache() {
+	const isCacheLoading = ref(true);
+	const cachePromise = ref(indexedDbCache("n8n-local", "workflows").finally(() => {
+		isCacheLoading.value = false;
+	}));
+	async function getWorkflowsCache() {
+		return await cachePromise.value;
+	}
+	async function getWorkflowSettings(workflowId) {
+		return jsonParse((await getWorkflowsCache()).getItem(workflowId) ?? "", { fallbackValue: {} });
+	}
+	async function getMergedWorkflowSettings(workflowId) {
+		const workflowSettings = await getWorkflowSettings(workflowId);
+		const globalPreferences = jsonParse((await getWorkflowsCache()).getItem("*") ?? "", { fallbackValue: {} });
+		workflowSettings.suggestedActions = {
+			...workflowSettings.suggestedActions ?? {},
+			...globalPreferences.suggestedActions ?? {}
+		};
+		return workflowSettings;
+	}
+	async function upsertWorkflowSettings(workflowId, updates) {
+		const cache = await getWorkflowsCache();
+		const existingSettings = await getWorkflowSettings(workflowId);
+		const updatedSettings = {
+			...existingSettings,
+			...updates
+		};
+		if (updates.suggestedActions) updatedSettings.suggestedActions = {
+			...existingSettings.suggestedActions ?? {},
+			...updates.suggestedActions
+		};
+		cache.setItem(workflowId, JSON.stringify(updatedSettings));
+	}
+	async function updateFirstActivatedAt(workflowId) {
+		if (!(await getWorkflowSettings(workflowId))?.firstActivatedAt) await upsertWorkflowSettings(workflowId, { firstActivatedAt: Date.now() });
+	}
+	async function ignoreSuggestedAction(workflowId, action) {
+		await upsertWorkflowSettings(workflowId, { suggestedActions: { [action]: { ignored: true } } });
+	}
+	async function getEvaluationPreferences(workflowId) {
+		return (await getWorkflowSettings(workflowId))?.evaluationRuns ?? {
+			order: [],
+			visibility: {}
+		};
+	}
+	async function saveEvaluationPreferences(workflowId, evaluationRuns) {
+		await upsertWorkflowSettings(workflowId, { evaluationRuns });
+	}
+	async function ignoreAllSuggestedActionsForAllWorkflows(actionsToIgnore) {
+		await upsertWorkflowSettings("*", actionsToIgnore.reduce((accu, key) => {
+			accu.suggestedActions = accu.suggestedActions ?? {};
+			accu.suggestedActions[key] = { ignored: true };
+			return accu;
+		}, {}));
+	}
+	return {
+		getWorkflowSettings,
+		getMergedWorkflowSettings,
+		upsertWorkflowSettings,
+		updateFirstActivatedAt,
+		ignoreSuggestedAction,
+		ignoreAllSuggestedActionsForAllWorkflows,
+		getEvaluationPreferences,
+		saveEvaluationPreferences,
+		isCacheLoading
+	};
+}
+export { useWorkflowSettingsCache as t };

package/dist/assets/userRoleProvisioning.store-kkSIdeTo.js

@@ -0,0 +1,33 @@
+import { Ft as readonly, It as ref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { Rs as getProvisioningConfig, zs as saveProvisioningConfig } from "./builder.store-Czk2ipDE.js";
+import { k as defineStore, r as useRootStore } from "./_baseOrderBy-N8Be_6z6.js";
+const useUserRoleProvisioningStore = defineStore("userRoleProvisioning", () => {
+	const rootStore = useRootStore();
+	const provisioningConfig = ref();
+	const getProvisioningConfig$1 = async () => {
+		try {
+			const config = await getProvisioningConfig(rootStore.restApiContext);
+			provisioningConfig.value = config;
+			return config;
+		} catch (error) {
+			console.error("Failed to fetch provisioning config:", error);
+			throw error;
+		}
+	};
+	const saveProvisioningConfig$1 = async (config) => {
+		try {
+			const updatedConfig = await saveProvisioningConfig(rootStore.restApiContext, config);
+			provisioningConfig.value = updatedConfig;
+			return updatedConfig;
+		} catch (error) {
+			console.error("Failed to save provisioning config:", error);
+			throw error;
+		}
+	};
+	return {
+		provisioningConfig: readonly(provisioningConfig),
+		getProvisioningConfig: getProvisioningConfig$1,
+		saveProvisioningConfig: saveProvisioningConfig$1
+	};
+});
+export { useUserRoleProvisioningStore as t };

package/dist/assets/utils-DI7dLldp.js

@@ -0,0 +1,54 @@
+import { o as __toESM } from "./chunk-6z4oVpB-.js";
+import { t as require_dateformat } from "./dateformat-hG8NERse.js";
+var import_dateformat = /* @__PURE__ */ __toESM(require_dateformat());
+const getLastPublishedVersion = (workflowPublishHistory) => {
+	return workflowPublishHistory.findLast((history) => history.event === "activated");
+};
+const generateVersionName = (versionId) => {
+	return `Version ${versionId.substring(0, 8)}`;
+};
+const formatTimestamp = (value) => {
+	const currentYear = (/* @__PURE__ */ new Date()).getFullYear().toString();
+	const [date, time] = (0, import_dateformat.default)(value, `${value.startsWith(currentYear) ? "" : "yyyy "}mmm d"#"HH:MM:ss`).split("#");
+	return {
+		date,
+		time
+	};
+};
+const computeTimelineEntries = (items) => {
+	const entries = [];
+	let currentGroup = [];
+	let groupCounter = 0;
+	const flushGroup = () => {
+		if (currentGroup.length > 0) {
+			entries.push({
+				type: "group-header",
+				groupId: `group-${groupCounter++}`,
+				count: currentGroup.length,
+				versions: [...currentGroup]
+			});
+			currentGroup = [];
+		}
+	};
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (!(i === 0) && !item.name?.trim()) currentGroup.push({
+			type: "version",
+			item,
+			originalIndex: i,
+			isGrouped: true
+		});
+		else {
+			flushGroup();
+			entries.push({
+				type: "version",
+				item,
+				originalIndex: i,
+				isGrouped: false
+			});
+		}
+	}
+	flushGroup();
+	return entries;
+};
+export { getLastPublishedVersion as i, formatTimestamp as n, generateVersionName as r, computeTimelineEntries as t };