n8n-editor-ui 1.77.3 → 1.79.0

package/dist/assets/{polyfills-DfOJfMlf.js → polyfills-C7eMRNFe.js}

@@ -86,7 +86,7 @@ function requireFunctionCall () {
 	var NATIVE_BIND = requireFunctionBindNative();
 
 	var call = Function.prototype.call;
-
+	// eslint-disable-next-line es/no-function-prototype-bind -- safe
 	functionCall = NATIVE_BIND ? call.bind(call) : function () {
 	  return call.apply(call, arguments);
 	};
@@ -143,6 +143,7 @@ function requireFunctionUncurryThis () {
 
 	var FunctionPrototype = Function.prototype;
 	var call = FunctionPrototype.call;
+	// eslint-disable-next-line es/no-function-prototype-bind -- safe
 	var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
 
 	functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
@@ -548,10 +549,10 @@ function requireSharedStore () {
 	var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
 	(store.versions || (store.versions = [])).push({
-	  version: '3.39.0',
+	  version: '3.40.0',
 	  mode: IS_PURE ? 'pure' : 'global',
-	  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
-	  license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE',
+	  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
+	  license: 'https://github.com/zloirock/core-js/blob/v3.40.0/LICENSE',
 	  source: 'https://github.com/zloirock/core-js'
 	});
 	return sharedStore.exports;
@@ -1653,22 +1654,15 @@ function requireDefineBuiltInAccessor () {
 	return defineBuiltInAccessor;
 }
 
-var functionUncurryThisClause;
-var hasRequiredFunctionUncurryThisClause;
-
-function requireFunctionUncurryThisClause () {
-	if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
-	hasRequiredFunctionUncurryThisClause = 1;
-	var classofRaw = requireClassofRaw();
-	var uncurryThis = requireFunctionUncurryThis();
+var arrayBufferBasicDetection;
+var hasRequiredArrayBufferBasicDetection;
 
-	functionUncurryThisClause = function (fn) {
-	  // Nashorn bug:
-	  //   https://github.com/zloirock/core-js/issues/1128
-	  //   https://github.com/zloirock/core-js/issues/1130
-	  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
-	};
-	return functionUncurryThisClause;
+function requireArrayBufferBasicDetection () {
+	if (hasRequiredArrayBufferBasicDetection) return arrayBufferBasicDetection;
+	hasRequiredArrayBufferBasicDetection = 1;
+	// eslint-disable-next-line es/no-typed-arrays -- safe
+	arrayBufferBasicDetection = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
+	return arrayBufferBasicDetection;
 }
 
 var functionUncurryThisAccessor;
@@ -1719,18 +1713,16 @@ function requireArrayBufferIsDetached () {
 	if (hasRequiredArrayBufferIsDetached) return arrayBufferIsDetached;
 	hasRequiredArrayBufferIsDetached = 1;
 	var globalThis = requireGlobalThis();
-	var uncurryThis = requireFunctionUncurryThisClause();
+	var NATIVE_ARRAY_BUFFER = requireArrayBufferBasicDetection();
 	var arrayBufferByteLength = requireArrayBufferByteLength();
 
-	var ArrayBuffer = globalThis.ArrayBuffer;
-	var ArrayBufferPrototype = ArrayBuffer && ArrayBuffer.prototype;
-	var slice = ArrayBufferPrototype && uncurryThis(ArrayBufferPrototype.slice);
+	var DataView = globalThis.DataView;
 
 	arrayBufferIsDetached = function (O) {
-	  if (arrayBufferByteLength(O) !== 0) return false;
-	  if (!slice) return false;
+	  if (!NATIVE_ARRAY_BUFFER || arrayBufferByteLength(O) !== 0) return false;
 	  try {
-	    slice(O, 0, 0);
+	    // eslint-disable-next-line no-new -- thrower
+	    new DataView(O);
 	    return false;
 	  } catch (error) {
 	    return true;
@@ -2278,7 +2270,19 @@ function requireSetMethodAcceptSetLike () {
 	  };
 	};
 
-	setMethodAcceptSetLike = function (name) {
+	var createSetLikeWithInfinitySize = function (size) {
+	  return {
+	    size: size,
+	    has: function () {
+	      return true;
+	    },
+	    keys: function () {
+	      throw new Error('e');
+	    }
+	  };
+	};
+
+	setMethodAcceptSetLike = function (name, callback) {
 	  var Set = getBuiltIn('Set');
 	  try {
 	    new Set()[name](createSetLike(0));
@@ -2288,7 +2292,18 @@ function requireSetMethodAcceptSetLike () {
 	      new Set()[name](createSetLike(-1));
 	      return false;
 	    } catch (error2) {
-	      return true;
+	      if (!callback) return true;
+	      // early V8 implementation bug
+	      // https://issues.chromium.org/issues/351332634
+	      try {
+	        new Set()[name](createSetLikeWithInfinitySize(-Infinity));
+	        return false;
+	      } catch (error) {
+	        var set = new Set();
+	        set.add(1);
+	        set.add(2);
+	        return callback(set[name](createSetLikeWithInfinitySize(Infinity)));
+	      }
 	    }
 	  } catch (error) {
 	    return false;
@@ -2306,9 +2321,13 @@ function requireEs_set_difference_v2 () {
 	var difference = requireSetDifference();
 	var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
 
+	var INCORRECT = !setMethodAcceptSetLike('difference', function (result) {
+	  return result.size === 0;
+	});
+
 	// `Set.prototype.difference` method
 	// https://tc39.es/ecma262/#sec-set.prototype.difference
-	$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('difference') }, {
+	$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
 	  difference: difference
 	});
 	return es_set_difference_v2;
@@ -2367,8 +2386,10 @@ function requireEs_set_intersection_v2 () {
 	var intersection = requireSetIntersection();
 	var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
 
-	var INCORRECT = !setMethodAcceptSetLike('intersection') || fails(function () {
-	  // eslint-disable-next-line es/no-array-from, es/no-set -- testing
+	var INCORRECT = !setMethodAcceptSetLike('intersection', function (result) {
+	  return result.size === 2 && result.has(1) && result.has(2);
+	}) || fails(function () {
+	  // eslint-disable-next-line es/no-array-from, es/no-set, es/no-set-prototype-intersection -- testing
 	  return String(Array.from(new Set([1, 2, 3]).intersection(new Set([3, 2])))) !== '3,2';
 	});
 
@@ -2455,9 +2476,13 @@ function requireEs_set_isDisjointFrom_v2 () {
 	var isDisjointFrom = requireSetIsDisjointFrom();
 	var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
 
+	var INCORRECT = !setMethodAcceptSetLike('isDisjointFrom', function (result) {
+	  return !result;
+	});
+
 	// `Set.prototype.isDisjointFrom` method
 	// https://tc39.es/ecma262/#sec-set.prototype.isdisjointfrom
-	$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('isDisjointFrom') }, {
+	$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
 	  isDisjointFrom: isDisjointFrom
 	});
 	return es_set_isDisjointFrom_v2;
@@ -2500,9 +2525,13 @@ function requireEs_set_isSubsetOf_v2 () {
 	var isSubsetOf = requireSetIsSubsetOf();
 	var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
 
+	var INCORRECT = !setMethodAcceptSetLike('isSubsetOf', function (result) {
+	  return result;
+	});
+
 	// `Set.prototype.isSubsetOf` method
 	// https://tc39.es/ecma262/#sec-set.prototype.issubsetof
-	$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('isSubsetOf') }, {
+	$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
 	  isSubsetOf: isSubsetOf
 	});
 	return es_set_isSubsetOf_v2;
@@ -2548,9 +2577,13 @@ function requireEs_set_isSupersetOf_v2 () {
 	var isSupersetOf = requireSetIsSupersetOf();
 	var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
 
+	var INCORRECT = !setMethodAcceptSetLike('isSupersetOf', function (result) {
+	  return !result;
+	});
+
 	// `Set.prototype.isSupersetOf` method
 	// https://tc39.es/ecma262/#sec-set.prototype.issupersetof
-	$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('isSupersetOf') }, {
+	$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
 	  isSupersetOf: isSupersetOf
 	});
 	return es_set_isSupersetOf_v2;
@@ -3154,6 +3187,24 @@ requireEsnext_suppressedError_constructor();
 
 var esnext_array_group = {};
 
+var functionUncurryThisClause;
+var hasRequiredFunctionUncurryThisClause;
+
+function requireFunctionUncurryThisClause () {
+	if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
+	hasRequiredFunctionUncurryThisClause = 1;
+	var classofRaw = requireClassofRaw();
+	var uncurryThis = requireFunctionUncurryThis();
+
+	functionUncurryThisClause = function (fn) {
+	  // Nashorn bug:
+	  //   https://github.com/zloirock/core-js/issues/1128
+	  //   https://github.com/zloirock/core-js/issues/1130
+	  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
+	};
+	return functionUncurryThisClause;
+}
+
 var functionBindContext;
 var hasRequiredFunctionBindContext;
 
@@ -3567,12 +3618,13 @@ function requireIteratorCreateProxy () {
 	    next: function next() {
 	      var state = getInternalState(this);
 	      // for simplification:
-	      //   for `%WrapForValidIteratorPrototype%.next` our `nextHandler` returns `IterResultObject`
+	      //   for `%WrapForValidIteratorPrototype%.next` or with `state.returnHandlerResult` our `nextHandler` returns `IterResultObject`
 	      //   for `%IteratorHelperPrototype%.next` - just a value
 	      if (IS_ITERATOR) return state.nextHandler();
+	      if (state.done) return createIterResultObject(undefined, true);
 	      try {
-	        var result = state.done ? undefined : state.nextHandler();
-	        return createIterResultObject(result, state.done);
+	        var result = state.nextHandler();
+	        return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
 	      } catch (error) {
 	        state.done = true;
 	        throw error;
@@ -3602,13 +3654,14 @@ function requireIteratorCreateProxy () {
 
 	createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
 
-	iteratorCreateProxy = function (nextHandler, IS_ITERATOR) {
+	iteratorCreateProxy = function (nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
 	  var IteratorProxy = function Iterator(record, state) {
 	    if (state) {
 	      state.iterator = record.iterator;
 	      state.next = record.next;
 	    } else state = record;
 	    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+	    state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
 	    state.nextHandler = nextHandler;
 	    state.counter = 0;
 	    state.done = false;
@@ -4973,7 +5026,7 @@ function requireFunctionApply () {
 	var apply = FunctionPrototype.apply;
 	var call = FunctionPrototype.call;
 
-	// eslint-disable-next-line es/no-reflect -- safe
+	// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
 	functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
 	  return call.apply(apply, arguments);
 	});

package/dist/assets/pushConnection.store-Z13Buj1P.js

@@ -0,0 +1,238 @@
+import { r as ref, gb as createHeartbeatMessage, R as defineStore, S as STORES, Z as useRootStore, p as useSettingsStore, H as watch, q as computed } from "./index-BgTszcKd.js";
+const useHeartbeat = (options) => {
+  const { interval, onHeartbeat } = options;
+  const heartbeatTimer = ref(null);
+  const startHeartbeat = () => {
+    heartbeatTimer.value = setInterval(onHeartbeat, interval);
+  };
+  const stopHeartbeat = () => {
+    if (heartbeatTimer.value) {
+      clearInterval(heartbeatTimer.value);
+      heartbeatTimer.value = null;
+    }
+  };
+  return {
+    startHeartbeat,
+    stopHeartbeat
+  };
+};
+const useReconnectTimer = ({ onAttempt, onAttemptScheduled }) => {
+  const initialReconnectDelay = 1e3;
+  const maxReconnectDelay = 15e3;
+  const reconnectTimer = ref(null);
+  const reconnectAttempts = ref(0);
+  const scheduleReconnect = () => {
+    const delay = Math.min(initialReconnectDelay * 2 ** reconnectAttempts.value, maxReconnectDelay);
+    reconnectAttempts.value++;
+    onAttemptScheduled(delay);
+    reconnectTimer.value = setTimeout(() => {
+      onAttempt();
+    }, delay);
+  };
+  const stopReconnectTimer = () => {
+    if (reconnectTimer.value) {
+      clearTimeout(reconnectTimer.value);
+      reconnectTimer.value = null;
+    }
+  };
+  const resetConnectionAttempts = () => {
+    reconnectAttempts.value = 0;
+  };
+  return {
+    scheduleReconnect,
+    stopReconnectTimer,
+    resetConnectionAttempts
+  };
+};
+const useWebSocketClient = (options) => {
+  const isConnected = ref(false);
+  const socket = ref(null);
+  const { startHeartbeat, stopHeartbeat } = useHeartbeat({
+    interval: 3e4,
+    onHeartbeat: () => {
+      socket.value?.send(JSON.stringify(createHeartbeatMessage()));
+    }
+  });
+  const onConnected = () => {
+    socket.value?.removeEventListener("open", onConnected);
+    isConnected.value = true;
+    startHeartbeat();
+    reconnectTimer.resetConnectionAttempts();
+  };
+  const onConnectionLost = (event) => {
+    console.warn(`[WebSocketClient] Connection lost, code=${event.code ?? "unknown"}`);
+    disconnect();
+    reconnectTimer.scheduleReconnect();
+  };
+  const onMessage = (event) => {
+    options.onMessage(event.data);
+  };
+  const onError = (error) => {
+    console.warn("[WebSocketClient] Connection error:", error);
+  };
+  const disconnect = () => {
+    if (socket.value) {
+      stopHeartbeat();
+      reconnectTimer.stopReconnectTimer();
+      socket.value.removeEventListener("message", onMessage);
+      socket.value.removeEventListener("error", onError);
+      socket.value.removeEventListener("close", onConnectionLost);
+      socket.value.close(1e3);
+      socket.value = null;
+    }
+    isConnected.value = false;
+  };
+  const connect = () => {
+    disconnect();
+    socket.value = new WebSocket(options.url);
+    socket.value.addEventListener("open", onConnected);
+    socket.value.addEventListener("message", onMessage);
+    socket.value.addEventListener("error", onError);
+    socket.value.addEventListener("close", onConnectionLost);
+  };
+  const reconnectTimer = useReconnectTimer({
+    onAttempt: connect,
+    onAttemptScheduled: (delay) => {
+      console.log(`[WebSocketClient] Attempting to reconnect in ${delay}ms`);
+    }
+  });
+  const sendMessage = (serializedMessage) => {
+    if (!isConnected.value || !socket.value) {
+      throw new Error("Not connected to the server");
+    }
+    socket.value.send(serializedMessage);
+  };
+  return {
+    isConnected,
+    connect,
+    disconnect,
+    sendMessage
+  };
+};
+const useEventSourceClient = (options) => {
+  const isConnected = ref(false);
+  const eventSource = ref(null);
+  const onConnected = () => {
+    isConnected.value = true;
+    reconnectTimer.resetConnectionAttempts();
+  };
+  const onConnectionLost = () => {
+    console.warn("[EventSourceClient] Connection lost");
+    isConnected.value = false;
+    reconnectTimer.scheduleReconnect();
+  };
+  const onMessage = (event) => {
+    options.onMessage(event.data);
+  };
+  const disconnect = () => {
+    if (eventSource.value) {
+      reconnectTimer.stopReconnectTimer();
+      eventSource.value.close();
+      eventSource.value = null;
+    }
+    isConnected.value = false;
+  };
+  const connect = () => {
+    disconnect();
+    eventSource.value = new EventSource(options.url, { withCredentials: true });
+    eventSource.value.addEventListener("open", onConnected);
+    eventSource.value.addEventListener("message", onMessage);
+    eventSource.value.addEventListener("close", onConnectionLost);
+  };
+  const reconnectTimer = useReconnectTimer({
+    onAttempt: connect,
+    onAttemptScheduled: (delay) => {
+      console.log(`[EventSourceClient] Attempting to reconnect in ${delay}ms`);
+    }
+  });
+  const sendMessage = (_) => {
+  };
+  return {
+    isConnected,
+    connect,
+    disconnect,
+    sendMessage
+  };
+};
+const usePushConnectionStore = defineStore(STORES.PUSH, () => {
+  const rootStore = useRootStore();
+  const settingsStore = useSettingsStore();
+  const outgoingQueue = ref([]);
+  const isConnectionRequested = ref(false);
+  const onMessageReceivedHandlers = ref([]);
+  const addEventListener = (handler) => {
+    onMessageReceivedHandlers.value.push(handler);
+    return () => {
+      const index = onMessageReceivedHandlers.value.indexOf(handler);
+      if (index !== -1) {
+        onMessageReceivedHandlers.value.splice(index, 1);
+      }
+    };
+  };
+  const useWebSockets = settingsStore.pushBackend === "websocket";
+  const getConnectionUrl = () => {
+    const restUrl = rootStore.restUrl;
+    const url2 = `/push?pushRef=${rootStore.pushRef}`;
+    if (useWebSockets) {
+      const { protocol, host } = window.location;
+      const baseUrl = restUrl.startsWith("http") ? restUrl.replace(/^http/, "ws") : `${protocol === "https:" ? "wss" : "ws"}://${host + restUrl}`;
+      return `${baseUrl}${url2}`;
+    } else {
+      return `${restUrl}${url2}`;
+    }
+  };
+  async function onMessage(data) {
+    let receivedData;
+    try {
+      receivedData = JSON.parse(data);
+    } catch (error) {
+      return;
+    }
+    onMessageReceivedHandlers.value.forEach((handler) => handler(receivedData));
+  }
+  const url = getConnectionUrl();
+  const client = useWebSockets ? useWebSocketClient({ url, onMessage }) : useEventSourceClient({ url, onMessage });
+  function serializeAndSend(message) {
+    if (client.isConnected.value) {
+      client.sendMessage(JSON.stringify(message));
+    } else {
+      outgoingQueue.value.push(message);
+    }
+  }
+  const pushConnect = () => {
+    isConnectionRequested.value = true;
+    client.connect();
+  };
+  const pushDisconnect = () => {
+    isConnectionRequested.value = false;
+    client.disconnect();
+  };
+  watch(client.isConnected, (didConnect) => {
+    if (!didConnect) {
+      return;
+    }
+    if (outgoingQueue.value.length) {
+      for (const message of outgoingQueue.value) {
+        serializeAndSend(message);
+      }
+      outgoingQueue.value = [];
+    }
+  });
+  const clearQueue = () => {
+    outgoingQueue.value = [];
+  };
+  const isConnected = computed(() => client.isConnected.value);
+  return {
+    isConnected,
+    isConnectionRequested,
+    onMessageReceivedHandlers,
+    addEventListener,
+    pushConnect,
+    pushDisconnect,
+    send: serializeAndSend,
+    clearQueue
+  };
+});
+export {
+  usePushConnectionStore as u
+};

package/dist/assets/{templateActions--1waaCku.js → templateActions-BsBOWAkR.js}

@@ -1,4 +1,4 @@
-import { fB as TEMPLATE_CREDENTIAL_SETUP_EXPERIMENT, dn as assert, V as VIEWS, dR as tryToParseNumber, fF as doesNodeHaveCredentialsToFill, fG as getNewWorkflow, fH as replaceAllTemplateNodeCredentials, dQ as getFixedNodesList } from "./index-DablXALM.js";
+import { fE as TEMPLATE_CREDENTIAL_SETUP_EXPERIMENT, ds as assert, V as VIEWS, dV as tryToParseNumber, fI as doesNodeHaveCredentialsToFill, fJ as getNewWorkflow, fK as replaceAllTemplateNodeCredentials, dU as getFixedNodesList } from "./index-BgTszcKd.js";
 async function createWorkflowFromTemplate(opts) {
   const { credentialOverrides, nodeTypeProvider, rootStore, template, workflowsStore } = opts;
   const workflowData = await getNewWorkflow(rootStore.restApiContext, { name: template.name });

package/dist/assets/{useBeforeUnload-C9Q3IFHU.js → useBeforeUnload-BzdqZUNR.js}

@@ -1,4 +1,4 @@
-import { K as useUIStore, $ as useCanvasStore, r as ref, q as computed, V as VIEWS, g as useI18n } from "./index-DablXALM.js";
+import { K as useUIStore, $ as useCanvasStore, r as ref, q as computed, V as VIEWS, g as useI18n } from "./index-BgTszcKd.js";
 function useBeforeUnload({ route }) {
   const uiStore = useUIStore();
   const canvasStore = useCanvasStore();