@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/useMcp-DoMOIfqT.js

@@ -0,0 +1,27 @@
+import { k as useTelemetry } from "./builder.store-Czk2ipDE.js";
+import { Zn as SCHEDULE_TRIGGER_NODE_TYPE, hr as WEBHOOK_NODE_TYPE, un as FORM_TRIGGER_NODE_TYPE, zt as CHAT_TRIGGER_NODE_TYPE } from "./constants-C8OH4tTq.js";
+function useMcp() {
+	const telemetry = useTelemetry();
+	const mcpTriggerMap = {
+		[SCHEDULE_TRIGGER_NODE_TYPE]: "Schedule Trigger",
+		[WEBHOOK_NODE_TYPE]: "Webhook Trigger",
+		[FORM_TRIGGER_NODE_TYPE]: "Form Trigger",
+		[CHAT_TRIGGER_NODE_TYPE]: "Chat Trigger"
+	};
+	const isEligibleForMcpAccess = (workflow) => {
+		return workflow.nodes.some((node) => Object.keys(mcpTriggerMap).includes(node.type) && node.disabled !== true);
+	};
+	const trackMcpAccessEnabledForWorkflow = (workflowId) => {
+		telemetry.track("User gave MCP access to workflow", { workflow_id: workflowId });
+	};
+	const trackUserToggledMcpAccess = (enabled) => {
+		telemetry.track("User toggled MCP access", { state: enabled });
+	};
+	return {
+		isEligibleForMcpAccess,
+		trackMcpAccessEnabledForWorkflow,
+		trackUserToggledMcpAccess,
+		mcpTriggerMap
+	};
+}
+export { useMcp as t };

package/dist/assets/usePageRedirectionHelper-DjkznpX6.js

@@ -0,0 +1,51 @@
+import { Er as useUsersStore, k as useTelemetry, m as useCloudPlanStore, ms as useSettingsStore } from "./builder.store-Czk2ipDE.js";
+import { y as N8N_PRICING_PAGE_URL } from "./constants-C8OH4tTq.js";
+import { t as useVersionsStore } from "./versions.store-B1z2OrLE.js";
+function usePageRedirectionHelper() {
+	const usersStore = useUsersStore();
+	const cloudPlanStore = useCloudPlanStore();
+	const versionsStore = useVersionsStore();
+	const telemetry = useTelemetry();
+	const settingsStore = useSettingsStore();
+	const goToVersions = async () => {
+		let versionsLink = versionsStore.infoUrl;
+		if (usersStore.isInstanceOwner && settingsStore.isCloudDeployment) versionsLink = await cloudPlanStore.generateCloudDashboardAutoLoginLink({ redirectionPath: "/manage" });
+		location.href = versionsLink;
+	};
+	const goToDashboard = async () => {
+		if (usersStore.isInstanceOwner && settingsStore.isCloudDeployment) {
+			const dashboardLink = await cloudPlanStore.generateCloudDashboardAutoLoginLink({ redirectionPath: "/dashboard" });
+			location.href = dashboardLink;
+		}
+	};
+	const goToUpgrade = async (source, utm_campaign, mode = "open") => {
+		const { usageLeft, trialDaysLeft, userIsTrialing } = cloudPlanStore;
+		const { executionsLeft, workflowsLeft } = usageLeft;
+		const deploymentType = settingsStore.deploymentType;
+		telemetry.track("User clicked upgrade CTA", {
+			source,
+			isTrial: userIsTrialing,
+			deploymentType,
+			trialDaysLeft,
+			executionsLeft,
+			workflowsLeft
+		});
+		const upgradeLink = await generateUpgradeLink(source, utm_campaign);
+		if (mode === "open") window.open(upgradeLink, "_blank");
+		else location.href = upgradeLink;
+	};
+	const generateUpgradeLink = async (source, utm_campaign) => {
+		let upgradeLink = N8N_PRICING_PAGE_URL;
+		if (usersStore.isInstanceOwner && settingsStore.isCloudDeployment) upgradeLink = await cloudPlanStore.generateCloudDashboardAutoLoginLink({ redirectionPath: "/account/change-plan" });
+		const url = new URL(upgradeLink);
+		if (utm_campaign) url.searchParams.set("utm_campaign", utm_campaign);
+		if (source) url.searchParams.set("source", source);
+		return url.toString();
+	};
+	return {
+		goToDashboard,
+		goToVersions,
+		goToUpgrade
+	};
+}
+export { usePageRedirectionHelper as t };

package/dist/assets/usePinnedData-BhZkqttf.js

@@ -0,0 +1,203 @@
+import { C as computed, Gt as unref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+import { rt as useI18n } from "./core-CRbPymLT.js";
+import { Ji as toMegaBytes, P as useWorkflowsStore, Pt as useNodeTypesStore, Sn as useDataSchema, k as useTelemetry, qi as stringSizeInBytes, x as useExternalHooks, y as useToast } from "./builder.store-Czk2ipDE.js";
+import { Da as jsonParse, Js as MAX_PINNED_DATA_SIZE, Oa as jsonStringify, Qi as getNodeOutputs, Ua as NodeConnectionTypes, Wn as PIN_DATA_NODE_TYPES_DENYLIST, Ys as MAX_WORKFLOW_SIZE, la as isSubNodeType, qs as MAX_EXPECTED_REQUEST_SIZE } from "./constants-C8OH4tTq.js";
+import { r as useRootStore } from "./_baseOrderBy-N8Be_6z6.js";
+function useNodeType(options = {}) {
+	const nodeTypesStore = useNodeTypesStore();
+	const nodeType = computed(() => {
+		if (options.nodeType) return unref(options.nodeType);
+		const activeNode = unref(options.node);
+		if (activeNode) return nodeTypesStore.getNodeType(activeNode.type, activeNode.typeVersion);
+		return null;
+	});
+	return {
+		nodeType,
+		isSubNodeType: computed(() => isSubNodeType(nodeType.value)),
+		isMultipleOutputsNodeType: computed(() => {
+			const outputs = nodeType.value?.outputs;
+			if (typeof outputs === "string") return false;
+			return (outputs ?? []).length > 1;
+		})
+	};
+}
+function usePinnedData(node, options = {}) {
+	const rootStore = useRootStore();
+	const workflowsStore = useWorkflowsStore();
+	const toast = useToast();
+	const i18n = useI18n();
+	const telemetry = useTelemetry();
+	const externalHooks = useExternalHooks();
+	const { getInputDataWithPinned } = useDataSchema();
+	const workflowObject = computed(() => workflowsStore.workflowObject);
+	const { isSubNodeType: isSubNodeType$1, isMultipleOutputsNodeType } = useNodeType({ node });
+	const data = computed(() => {
+		const targetNode = unref(node);
+		return targetNode ? workflowsStore.pinDataByNodeName(targetNode.name) : void 0;
+	});
+	const hasData = computed(() => {
+		return !!unref(node) && typeof data.value !== "undefined";
+	});
+	const isValidNodeType = computed(() => {
+		const targetNode = unref(node);
+		return !!targetNode && !isSubNodeType$1.value && !isMultipleOutputsNodeType.value && !PIN_DATA_NODE_TYPES_DENYLIST.includes(targetNode.type);
+	});
+	function canPinNode(checkDataEmpty = false, outputIndex) {
+		const targetNode = unref(node);
+		if (targetNode === null || PIN_DATA_NODE_TYPES_DENYLIST.includes(targetNode.type)) return false;
+		const nodeType = useNodeTypesStore().getNodeType(targetNode.type, targetNode.typeVersion);
+		const dataToPin = getInputDataWithPinned(targetNode);
+		if (!nodeType || checkDataEmpty && dataToPin.length === 0) return false;
+		const outputs = getNodeOutputs(workflowObject.value, targetNode, nodeType).map((output) => typeof output === "string" ? { type: output } : output);
+		const mainOutputs = outputs.filter((output) => output.type === NodeConnectionTypes.Main && output.category !== "error");
+		let indexAcceptable = true;
+		if (outputIndex !== void 0) {
+			const output = outputs[outputIndex];
+			if (outputs[outputIndex] === void 0) return false;
+			indexAcceptable = output.type === NodeConnectionTypes.Main && output.category !== "error";
+		}
+		return mainOutputs.length === 1 && indexAcceptable;
+	}
+	function isValidJSON(data$1) {
+		try {
+			JSON.parse(data$1);
+			return true;
+		} catch (error) {
+			const title = i18n.baseText("runData.editOutputInvalid");
+			const toRemove = new RegExp(/JSON\.parse:|of the JSON data/, "g");
+			const message = error.message.replace(toRemove, "").trim();
+			const positionMatchRegEx = /at position (\d+)/;
+			const positionMatch = error.message.match(positionMatchRegEx);
+			error.message = message.charAt(0).toUpperCase() + message.slice(1);
+			error.message = error.message.replace("Unexpected token ' in JSON", i18n.baseText("runData.editOutputInvalid.singleQuote"));
+			if (positionMatch) {
+				const position = parseInt(positionMatch[1], 10);
+				const lineBreaksUpToPosition = (data$1.slice(0, position).match(/\n/g) || []).length;
+				error.message = error.message.replace(positionMatchRegEx, i18n.baseText("runData.editOutputInvalid.atPosition", { interpolate: { position: `${position}` } }));
+				error.message = `${i18n.baseText("runData.editOutputInvalid.onLine", { interpolate: { line: `${lineBreaksUpToPosition + 1}` } })} ${error.message}`;
+			}
+			toast.showError(error, title);
+			return false;
+		}
+	}
+	function getMaxPinnedDataSize() {
+		return window.maxPinnedDataSize ?? 12582912;
+	}
+	function isValidSize(data$1) {
+		const targetNode = unref(node);
+		if (!targetNode) return false;
+		if (typeof data$1 === "object") data$1 = JSON.stringify(data$1);
+		const { pinData: currentPinData,...workflowObjectWithoutPinData } = workflowObject.value;
+		const workflowJson = jsonStringify(workflowObjectWithoutPinData, { replaceCircularRefs: true });
+		const newPinData = {
+			...currentPinData,
+			[targetNode.name]: data$1
+		};
+		const newPinDataSize = workflowsStore.getPinDataSize(newPinData);
+		if (newPinDataSize > getMaxPinnedDataSize()) {
+			toast.showError(new Error(i18n.baseText("ndv.pinData.error.tooLarge.description", { interpolate: {
+				size: toMegaBytes(newPinDataSize),
+				limit: toMegaBytes(getMaxPinnedDataSize())
+			} })), i18n.baseText("ndv.pinData.error.tooLarge.title"));
+			return false;
+		}
+		const workflowSize = stringSizeInBytes(workflowJson) + newPinDataSize;
+		const limit = MAX_WORKFLOW_SIZE - MAX_EXPECTED_REQUEST_SIZE;
+		if (workflowSize > limit) {
+			toast.showError(new Error(i18n.baseText("ndv.pinData.error.tooLargeWorkflow.description", { interpolate: {
+				size: toMegaBytes(workflowSize),
+				limit: toMegaBytes(limit)
+			} })), i18n.baseText("ndv.pinData.error.tooLargeWorkflow.title"));
+			return false;
+		}
+		return true;
+	}
+	function onSetDataSuccess({ source }) {
+		const targetNode = unref(node);
+		const displayMode = unref(options.displayMode);
+		const runIndex = unref(options.runIndex);
+		const telemetryPayload = {
+			pinning_source: source,
+			node_type: targetNode?.type,
+			push_ref: rootStore.pushRef,
+			data_size: stringSizeInBytes(data.value),
+			view: displayMode,
+			run_index: runIndex,
+			workflow_id: workflowsStore.workflowId,
+			node_id: targetNode?.id
+		};
+		externalHooks.run("runData.onDataPinningSuccess", telemetryPayload);
+		telemetry.track("Ndv data pinning success", telemetryPayload);
+	}
+	function onSetDataError({ errorType, source }) {
+		const targetNode = unref(node);
+		const displayMode = unref(options.displayMode);
+		const runIndex = unref(options.runIndex);
+		telemetry.track("Ndv data pinning failure", {
+			pinning_source: source,
+			node_type: targetNode?.type,
+			push_ref: rootStore.pushRef,
+			data_size: stringSizeInBytes(data.value),
+			view: displayMode,
+			run_index: runIndex,
+			error_type: errorType
+		});
+	}
+	function setData(data$1, source) {
+		const targetNode = unref(node);
+		if (!targetNode) return;
+		if (typeof data$1 === "string") {
+			if (!isValidJSON(data$1)) {
+				onSetDataError({
+					errorType: "invalid-json",
+					source
+				});
+				throw new Error("Invalid JSON");
+			}
+			data$1 = jsonParse(data$1);
+		}
+		if (!isValidSize(data$1)) {
+			onSetDataError({
+				errorType: "data-too-large",
+				source
+			});
+			throw new Error("Data too large");
+		}
+		workflowsStore.pinData({
+			node: targetNode,
+			data: data$1
+		});
+		onSetDataSuccess({ source });
+	}
+	function onUnsetData({ source }) {
+		const targetNode = unref(node);
+		const runIndex = unref(options.runIndex);
+		telemetry.track("User unpinned ndv data", {
+			node_type: targetNode?.type,
+			push_ref: rootStore.pushRef,
+			run_index: runIndex,
+			source,
+			data_size: stringSizeInBytes(data.value)
+		});
+	}
+	function unsetData(source) {
+		const targetNode = unref(node);
+		if (!targetNode) return;
+		onUnsetData({ source });
+		workflowsStore.unpinData({ node: targetNode });
+	}
+	return {
+		data,
+		hasData,
+		isValidNodeType,
+		canPinNode,
+		setData,
+		onSetDataSuccess,
+		onSetDataError,
+		unsetData,
+		onUnsetData,
+		isValidJSON,
+		isValidSize
+	};
+}
+export { useNodeType as n, usePinnedData as t };