n8n-editor-ui 1.78.0 → 1.79.0

package/dist/assets/{index-DFFkAkMx.css → index-xKO0gQfI.css}

@@ -32694,13 +32694,13 @@ code[class^=language-] {
  -------------------------- */
 /* BEM
  -------------------------- */
-[data-v-b4b07b46] .cm-editor {
+[data-v-03c698a0] .cm-editor {
   padding-left: 0;
 }
-[data-v-b4b07b46] .cm-content {
+[data-v-03c698a0] .cm-content {
   padding-left: var(--spacing-2xs);
 }
-[data-v-b4b07b46] .cm-content[aria-readonly=true] {
+[data-v-03c698a0] .cm-content[aria-readonly=true] {
   background-color: var(--disabled-fill, var(--color-background-light));
   border-color: var(--disabled-border, var(--border-color-base));
   color: var(--disabled-color, var(--color-text-base));
@@ -36673,34 +36673,34 @@ code[class^=language-] {
  -------------------------- */
 /* BEM
  -------------------------- */
-.readonly-code[data-v-aea273b0] {
+.readonly-code[data-v-0ce25612] {
   font-size: var(--font-size-xs);
 }
-.switch-input[data-v-aea273b0] {
+.switch-input[data-v-0ce25612] {
   margin: var(--spacing-5xs) 0 var(--spacing-2xs) 0;
 }
-.parameter-value-container[data-v-aea273b0] {
+.parameter-value-container[data-v-0ce25612] {
   display: flex;
   align-items: center;
 }
-.parameter-actions[data-v-aea273b0] {
+.parameter-actions[data-v-0ce25612] {
   display: inline-flex;
   align-items: center;
 }
-.parameter-switch[data-v-aea273b0] {
+.parameter-switch[data-v-0ce25612] {
   display: inline-flex;
   align-self: flex-start;
   justify-items: center;
   gap: var(--spacing-xs);
 }
-.parameter-input[data-v-aea273b0] {
+.parameter-input[data-v-0ce25612] {
   display: inline-block;
   position: relative;
 }
-.parameter-input[data-v-aea273b0] .color-input {
+.parameter-input[data-v-0ce25612] .color-input {
   display: flex;
 }
-.parameter-input[data-v-aea273b0] .color-input .el-color-picker__trigger {
+.parameter-input[data-v-0ce25612] .color-input .el-color-picker__trigger {
   border: none;
 }/* BEM support Func
  -------------------------- */
@@ -45802,30 +45802,34 @@ tr:hover ._ops_p819s_133:not(._disabled_p819s_123) {
  -------------------------- */
 /* BEM
  -------------------------- */
-._parameterItem_be015_123 {
+._parameterItem_1yw1o_123 {
+  --delete-option-width: 22px;
   display: flex;
   padding: 0 0 0 var(--spacing-s);
 }
-._parameterItem_be015_123 ._parameterInput_be015_127 {
+._parameterItem_1yw1o_123 ._parameterInput_1yw1o_128 {
   width: 100%;
 }
-._parameterItem_be015_123._hasIssues_be015_130 ._parameterIssues_be015_130 {
+._parameterItem_1yw1o_123 ._parameterInput_1yw1o_128:first-child {
+  margin-left: var(--delete-option-width);
+}
+._parameterItem_1yw1o_123._hasIssues_1yw1o_134 ._parameterIssues_1yw1o_134 {
   float: none;
   padding-top: var(--spacing-xl);
 }
-._parameterItem_be015_123._hasIssues_be015_130 input,
-._parameterItem_be015_123._hasIssues_be015_130 input:focus {
+._parameterItem_1yw1o_123._hasIssues_1yw1o_134 input,
+._parameterItem_1yw1o_123._hasIssues_1yw1o_134 input:focus {
   --input-border-color: var(--color-danger);
   border-color: var(--color-danger);
 }
-._parameterTooltipIcon_be015_140 {
+._parameterTooltipIcon_1yw1o_144 {
   color: var(--color-text-light) !important;
 }
-._addOption_be015_144 {
+._addOption_1yw1o_148 {
   margin-top: var(--spacing-l);
   padding: 0 0 0 var(--spacing-s);
 }
-._staleDataWarning_be015_149 {
+._staleDataWarning_1yw1o_153 {
   display: flex;
   height: var(--spacing-m);
   align-items: baseline;

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-CDiqnge9.js → templateActions-BsBOWAkR.js}

@@ -1,4 +1,4 @@
-import { fG as TEMPLATE_CREDENTIAL_SETUP_EXPERIMENT, ds as assert, V as VIEWS, dV as tryToParseNumber, fK as doesNodeHaveCredentialsToFill, fL as getNewWorkflow, fM as replaceAllTemplateNodeCredentials, dU as getFixedNodesList } from "./index-BwoviwZU.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-BQCxN-bM.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-BwoviwZU.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();