@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/nodeIcon-D6X-ENYt.js

@@ -0,0 +1,102 @@
+import { Ci as getThemedValue, P as useWorkflowsStore, Pt as useNodeTypesStore, Yt as removePreviewToken, aa as useUIStore, qt as isNodePreviewKey } from "./builder.store-Czk2ipDE.js";
+import { Mi as isExpression } from "./constants-C8OH4tTq.js";
+import { r as useRootStore } from "./_baseOrderBy-N8Be_6z6.js";
+var resolveIconExpression = (icon, nodeType, node) => {
+	try {
+		const workflowsStore = useWorkflowsStore();
+		const defaults = nodeType.defaults && "parameters" in nodeType.defaults ? nodeType.defaults.parameters : {};
+		const parameters = node?.parameters ?? defaults ?? {};
+		const additionalKeys = {};
+		additionalKeys.$parameter = parameters;
+		const result = workflowsStore.workflowObject.expression.getParameterValue(icon, null, 0, 0, node?.name ?? "", [], "internal", additionalKeys, void 0, false);
+		if (typeof result !== "string") return null;
+		const [prefix] = result.split(":");
+		if (prefix !== "file" && prefix !== "icon") return null;
+		return result;
+	} catch {
+		return null;
+	}
+};
+const getNodeIcon = (nodeType, node) => {
+	const themedIcon = getThemedValue(nodeType.icon, useUIStore().appliedTheme);
+	if (isExpression(themedIcon)) return resolveIconExpression(themedIcon, nodeType, node);
+	return themedIcon;
+};
+const getNodeIconUrl = (nodeType) => {
+	return getThemedValue(nodeType.iconUrl, useUIStore().appliedTheme);
+};
+const getBadgeIconUrl = (nodeType) => {
+	return getThemedValue(nodeType.badgeIconUrl, useUIStore().appliedTheme);
+};
+var getNodeIconColor = (nodeType) => {
+	if ("iconColor" in nodeType && nodeType.iconColor) return `var(--node--icon--color--${nodeType.iconColor})`;
+	const defaultColor = nodeType?.defaults?.color;
+	return typeof defaultColor === "string" ? defaultColor : void 0;
+};
+var prefixBaseUrl = (url) => {
+	const baseUrl = useRootStore().baseUrl;
+	return `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}/${url.startsWith("/") ? url.slice(1) : url}`;
+};
+var getNodeBadgeIconSource = (nodeType) => {
+	if (!("badgeIconUrl" in nodeType) || !nodeType.badgeIconUrl) return void 0;
+	const badgeUrl = getBadgeIconUrl(nodeType);
+	return badgeUrl ? {
+		type: "file",
+		src: prefixBaseUrl(badgeUrl)
+	} : void 0;
+};
+var createFileIconSource = (src, nodeType) => ({
+	type: "file",
+	src,
+	badge: getNodeBadgeIconSource(nodeType)
+});
+var createNamedIconSource = (name, nodeType) => ({
+	type: "icon",
+	name,
+	color: getNodeIconColor(nodeType),
+	badge: getNodeBadgeIconSource(nodeType)
+});
+var getIconFromNodeTypeString = (nodeTypeName) => {
+	const nodeTypeStore = useNodeTypesStore();
+	const cleanedNodeType = removePreviewToken(nodeTypeName);
+	const nodeDescription = nodeTypeStore.communityNodeType(cleanedNodeType)?.nodeDescription ?? nodeTypeStore.getNodeType(cleanedNodeType);
+	const iconUrl = nodeDescription?.iconUrl ? getThemedValue(nodeDescription.iconUrl, useUIStore().appliedTheme) : null;
+	return iconUrl ? {
+		type: "file",
+		src: iconUrl
+	} : void 0;
+};
+function getNodeIconSource(nodeType, node) {
+	if (!nodeType) return void 0;
+	if (typeof nodeType === "string") return getIconFromNodeTypeString(nodeType);
+	if ("iconData" in nodeType && nodeType.iconData) {
+		if (nodeType.iconData.icon) return createNamedIconSource(nodeType.iconData.icon, nodeType);
+		if (nodeType.iconData.fileBuffer) return createFileIconSource(nodeType.iconData.fileBuffer, nodeType);
+	}
+	if (nodeType.name && isNodePreviewKey(nodeType.name)) {
+		const themedUrl = getThemedValue(nodeType.iconUrl, useUIStore().appliedTheme);
+		if (themedUrl) return {
+			type: "file",
+			src: themedUrl,
+			badge: void 0
+		};
+	}
+	const iconUrl = getNodeIconUrl(nodeType);
+	if (iconUrl) return createFileIconSource(prefixBaseUrl(iconUrl), nodeType);
+	if (nodeType.icon) {
+		let fullNodeType = nodeType;
+		if (!("iconBasePath" in nodeType) && "name" in nodeType && nodeType.name) fullNodeType = useNodeTypesStore().getNodeType(nodeType.name) ?? nodeType;
+		const icon = getNodeIcon(fullNodeType, node);
+		if (!icon) return void 0;
+		const [type, iconName] = icon.split(":");
+		if (type === "file") {
+			if ("iconBasePath" in fullNodeType && fullNodeType.iconBasePath) {
+				const iconPath = iconName.replace(/^\//, "");
+				return createFileIconSource(prefixBaseUrl(`${fullNodeType.iconBasePath}/${iconPath}`), fullNodeType);
+			}
+			return;
+		}
+		return createNamedIconSource(iconName, fullNodeType);
+	}
+}
+export { getNodeIconSource as t };

package/dist/assets/nodeTransforms-RzcOM0v2.js

@@ -0,0 +1,42 @@
+import { Pt as useNodeTypesStore } from "./builder.store-Czk2ipDE.js";
+import { $i as getNodeParameters, Ji as displayParameter, Pt as AI_MCP_TOOL_NODE_TYPE, Si as traverseNodeParameters, ct as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, gr as WIKIPEDIA_TOOL_NODE_TYPE } from "./constants-C8OH4tTq.js";
+function getNodeTypeDisplayableCredentials(nodeTypeProvider, node) {
+	const nodeType = nodeTypeProvider.getNodeType(node.type, node.typeVersion);
+	if (!nodeType?.credentials) return [];
+	const nodeTypeCreds = nodeType.credentials;
+	const nodeParameters = getNodeParameters(nodeType.properties, node.parameters, true, false, node, nodeType) ?? node.parameters;
+	return nodeTypeCreds.filter((credentialTypeDescription) => {
+		return displayParameter(nodeParameters, credentialTypeDescription, node, nodeType);
+	});
+}
+function doesNodeHaveCredentialsToFill(nodeTypeProvider, node) {
+	return getNodeTypeDisplayableCredentials(nodeTypeProvider, node).length > 0;
+}
+function hasNodeCredentialFilled(node, credentialName) {
+	if (!node.credentials) return false;
+	return !!node.credentials[credentialName];
+}
+function doesNodeHaveAllCredentialsFilled(nodeTypeProvider, node) {
+	return getNodeTypeDisplayableCredentials(nodeTypeProvider, node).every((cred) => hasNodeCredentialFilled(node, cred.name));
+}
+function needsAgentInput(node) {
+	const nodeTypesNeedModal = [
+		WIKIPEDIA_TOOL_NODE_TYPE,
+		AI_MCP_TOOL_NODE_TYPE,
+		AI_CODE_TOOL_LANGCHAIN_NODE_TYPE
+	];
+	const collectedArgs = [];
+	traverseNodeParameters(node.parameters, collectedArgs);
+	return collectedArgs.length > 0 || nodeTypesNeedModal.includes(node.type) || node.type.includes("vectorStore") && node.parameters?.mode === "retrieve-as-tool";
+}
+function getParameterDisplayableOptions(options, node) {
+	if (!node) return options;
+	const nodeType = node?.type ? useNodeTypesStore().getNodeType(node.type, node.typeVersion) : null;
+	if (!nodeType || !Array.isArray(nodeType.properties)) return options;
+	const nodeParameters = getNodeParameters(nodeType.properties, node.parameters, true, false, node, nodeType) ?? node.parameters;
+	return options.filter((option) => {
+		if (!option.displayOptions && !option.disabledOptions) return true;
+		return displayParameter(nodeParameters, option, node, nodeType, void 0, "displayOptions");
+	});
+}
+export { needsAgentInput as a, getParameterDisplayableOptions as i, doesNodeHaveCredentialsToFill as n, getNodeTypeDisplayableCredentials as r, doesNodeHaveAllCredentialsFilled as t };

package/dist/assets/orderBy-Cu9F9DU_.js

@@ -0,0 +1,15 @@
+import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
+import { m as require_isArray } from "./_MapCache-CcdIl4Ae.js";
+import { t as require__baseOrderBy } from "./_baseOrderBy-N8Be_6z6.js";
+var require_orderBy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseOrderBy = require__baseOrderBy(), isArray = require_isArray();
+	function orderBy(collection, iteratees, orders, guard) {
+		if (collection == null) return [];
+		if (!isArray(iteratees)) iteratees = iteratees == null ? [] : [iteratees];
+		orders = guard ? void 0 : orders;
+		if (!isArray(orders)) orders = orders == null ? [] : [orders];
+		return baseOrderBy(collection, iteratees, orders);
+	}
+	module.exports = orderBy;
+}));
+export { require_orderBy as t };

package/dist/assets/path-browserify-RUt2u7iT.js

@@ -0,0 +1,328 @@
+import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
+import { D as process$1, E as init_dist } from "./empty-BuGRxzl4.js";
+var require_path_browserify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	init_dist();
+	function assertPath(path) {
+		if (typeof path !== "string") throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+	}
+	function normalizeStringPosix(path, allowAboveRoot) {
+		var res = "";
+		var lastSegmentLength = 0;
+		var lastSlash = -1;
+		var dots = 0;
+		var code;
+		for (var i = 0; i <= path.length; ++i) {
+			if (i < path.length) code = path.charCodeAt(i);
+			else if (code === 47) break;
+			else code = 47;
+			if (code === 47) {
+				if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+					if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+						if (res.length > 2) {
+							var lastSlashIndex = res.lastIndexOf("/");
+							if (lastSlashIndex !== res.length - 1) {
+								if (lastSlashIndex === -1) {
+									res = "";
+									lastSegmentLength = 0;
+								} else {
+									res = res.slice(0, lastSlashIndex);
+									lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+								}
+								lastSlash = i;
+								dots = 0;
+								continue;
+							}
+						} else if (res.length === 2 || res.length === 1) {
+							res = "";
+							lastSegmentLength = 0;
+							lastSlash = i;
+							dots = 0;
+							continue;
+						}
+					}
+					if (allowAboveRoot) {
+						if (res.length > 0) res += "/..";
+						else res = "..";
+						lastSegmentLength = 2;
+					}
+				} else {
+					if (res.length > 0) res += "/" + path.slice(lastSlash + 1, i);
+					else res = path.slice(lastSlash + 1, i);
+					lastSegmentLength = i - lastSlash - 1;
+				}
+				lastSlash = i;
+				dots = 0;
+			} else if (code === 46 && dots !== -1) ++dots;
+			else dots = -1;
+		}
+		return res;
+	}
+	function _format(sep, pathObject) {
+		var dir = pathObject.dir || pathObject.root;
+		var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+		if (!dir) return base;
+		if (dir === pathObject.root) return dir + base;
+		return dir + sep + base;
+	}
+	var posix = {
+		resolve: function resolve() {
+			var resolvedPath = "";
+			var resolvedAbsolute = false;
+			var cwd;
+			for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+				var path;
+				if (i >= 0) path = arguments[i];
+				else {
+					if (cwd === void 0) cwd = process$1.cwd();
+					path = cwd;
+				}
+				assertPath(path);
+				if (path.length === 0) continue;
+				resolvedPath = path + "/" + resolvedPath;
+				resolvedAbsolute = path.charCodeAt(0) === 47;
+			}
+			resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+			if (resolvedAbsolute) if (resolvedPath.length > 0) return "/" + resolvedPath;
+			else return "/";
+			else if (resolvedPath.length > 0) return resolvedPath;
+			else return ".";
+		},
+		normalize: function normalize(path) {
+			assertPath(path);
+			if (path.length === 0) return ".";
+			var isAbsolute = path.charCodeAt(0) === 47;
+			var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+			path = normalizeStringPosix(path, !isAbsolute);
+			if (path.length === 0 && !isAbsolute) path = ".";
+			if (path.length > 0 && trailingSeparator) path += "/";
+			if (isAbsolute) return "/" + path;
+			return path;
+		},
+		isAbsolute: function isAbsolute(path) {
+			assertPath(path);
+			return path.length > 0 && path.charCodeAt(0) === 47;
+		},
+		join: function join() {
+			if (arguments.length === 0) return ".";
+			var joined;
+			for (var i = 0; i < arguments.length; ++i) {
+				var arg = arguments[i];
+				assertPath(arg);
+				if (arg.length > 0) if (joined === void 0) joined = arg;
+				else joined += "/" + arg;
+			}
+			if (joined === void 0) return ".";
+			return posix.normalize(joined);
+		},
+		relative: function relative(from, to) {
+			assertPath(from);
+			assertPath(to);
+			if (from === to) return "";
+			from = posix.resolve(from);
+			to = posix.resolve(to);
+			if (from === to) return "";
+			var fromStart = 1;
+			for (; fromStart < from.length; ++fromStart) if (from.charCodeAt(fromStart) !== 47) break;
+			var fromEnd = from.length;
+			var fromLen = fromEnd - fromStart;
+			var toStart = 1;
+			for (; toStart < to.length; ++toStart) if (to.charCodeAt(toStart) !== 47) break;
+			var toLen = to.length - toStart;
+			var length = fromLen < toLen ? fromLen : toLen;
+			var lastCommonSep = -1;
+			var i = 0;
+			for (; i <= length; ++i) {
+				if (i === length) {
+					if (toLen > length) {
+						if (to.charCodeAt(toStart + i) === 47) return to.slice(toStart + i + 1);
+						else if (i === 0) return to.slice(toStart + i);
+					} else if (fromLen > length) {
+						if (from.charCodeAt(fromStart + i) === 47) lastCommonSep = i;
+						else if (i === 0) lastCommonSep = 0;
+					}
+					break;
+				}
+				var fromCode = from.charCodeAt(fromStart + i);
+				if (fromCode !== to.charCodeAt(toStart + i)) break;
+				else if (fromCode === 47) lastCommonSep = i;
+			}
+			var out = "";
+			for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) if (i === fromEnd || from.charCodeAt(i) === 47) if (out.length === 0) out += "..";
+			else out += "/..";
+			if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
+			else {
+				toStart += lastCommonSep;
+				if (to.charCodeAt(toStart) === 47) ++toStart;
+				return to.slice(toStart);
+			}
+		},
+		_makeLong: function _makeLong(path) {
+			return path;
+		},
+		dirname: function dirname(path) {
+			assertPath(path);
+			if (path.length === 0) return ".";
+			var code = path.charCodeAt(0);
+			var hasRoot = code === 47;
+			var end = -1;
+			var matchedSlash = true;
+			for (var i = path.length - 1; i >= 1; --i) {
+				code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						end = i;
+						break;
+					}
+				} else matchedSlash = false;
+			}
+			if (end === -1) return hasRoot ? "/" : ".";
+			if (hasRoot && end === 1) return "//";
+			return path.slice(0, end);
+		},
+		basename: function basename(path, ext) {
+			if (ext !== void 0 && typeof ext !== "string") throw new TypeError("\"ext\" argument must be a string");
+			assertPath(path);
+			var start = 0;
+			var end = -1;
+			var matchedSlash = true;
+			var i;
+			if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+				if (ext.length === path.length && ext === path) return "";
+				var extIdx = ext.length - 1;
+				var firstNonSlashEnd = -1;
+				for (i = path.length - 1; i >= 0; --i) {
+					var code = path.charCodeAt(i);
+					if (code === 47) {
+						if (!matchedSlash) {
+							start = i + 1;
+							break;
+						}
+					} else {
+						if (firstNonSlashEnd === -1) {
+							matchedSlash = false;
+							firstNonSlashEnd = i + 1;
+						}
+						if (extIdx >= 0) if (code === ext.charCodeAt(extIdx)) {
+							if (--extIdx === -1) end = i;
+						} else {
+							extIdx = -1;
+							end = firstNonSlashEnd;
+						}
+					}
+				}
+				if (start === end) end = firstNonSlashEnd;
+				else if (end === -1) end = path.length;
+				return path.slice(start, end);
+			} else {
+				for (i = path.length - 1; i >= 0; --i) if (path.charCodeAt(i) === 47) {
+					if (!matchedSlash) {
+						start = i + 1;
+						break;
+					}
+				} else if (end === -1) {
+					matchedSlash = false;
+					end = i + 1;
+				}
+				if (end === -1) return "";
+				return path.slice(start, end);
+			}
+		},
+		extname: function extname(path) {
+			assertPath(path);
+			var startDot = -1;
+			var startPart = 0;
+			var end = -1;
+			var matchedSlash = true;
+			var preDotState = 0;
+			for (var i = path.length - 1; i >= 0; --i) {
+				var code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						startPart = i + 1;
+						break;
+					}
+					continue;
+				}
+				if (end === -1) {
+					matchedSlash = false;
+					end = i + 1;
+				}
+				if (code === 46) {
+					if (startDot === -1) startDot = i;
+					else if (preDotState !== 1) preDotState = 1;
+				} else if (startDot !== -1) preDotState = -1;
+			}
+			if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) return "";
+			return path.slice(startDot, end);
+		},
+		format: function format(pathObject) {
+			if (pathObject === null || typeof pathObject !== "object") throw new TypeError("The \"pathObject\" argument must be of type Object. Received type " + typeof pathObject);
+			return _format("/", pathObject);
+		},
+		parse: function parse(path) {
+			assertPath(path);
+			var ret = {
+				root: "",
+				dir: "",
+				base: "",
+				ext: "",
+				name: ""
+			};
+			if (path.length === 0) return ret;
+			var code = path.charCodeAt(0);
+			var isAbsolute = code === 47;
+			var start;
+			if (isAbsolute) {
+				ret.root = "/";
+				start = 1;
+			} else start = 0;
+			var startDot = -1;
+			var startPart = 0;
+			var end = -1;
+			var matchedSlash = true;
+			var i = path.length - 1;
+			var preDotState = 0;
+			for (; i >= start; --i) {
+				code = path.charCodeAt(i);
+				if (code === 47) {
+					if (!matchedSlash) {
+						startPart = i + 1;
+						break;
+					}
+					continue;
+				}
+				if (end === -1) {
+					matchedSlash = false;
+					end = i + 1;
+				}
+				if (code === 46) {
+					if (startDot === -1) startDot = i;
+					else if (preDotState !== 1) preDotState = 1;
+				} else if (startDot !== -1) preDotState = -1;
+			}
+			if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+				if (end !== -1) if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
+				else ret.base = ret.name = path.slice(startPart, end);
+			} else {
+				if (startPart === 0 && isAbsolute) {
+					ret.name = path.slice(1, startDot);
+					ret.base = path.slice(1, end);
+				} else {
+					ret.name = path.slice(startPart, startDot);
+					ret.base = path.slice(startPart, end);
+				}
+				ret.ext = path.slice(startDot, end);
+			}
+			if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+			else if (isAbsolute) ret.dir = "/";
+			return ret;
+		},
+		sep: "/",
+		delimiter: ":",
+		win32: null,
+		posix: null
+	};
+	posix.posix = posix;
+	module.exports = posix;
+}));
+export { require_path_browserify as t };