n8n-editor-ui 1.119.1 → 1.120.0

package/dist/assets/useWorkflowsCache-legacy-1OAIoSYM.js

@@ -0,0 +1,217 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./constants-legacy-DiqA0Pu_.js"], function (_export, _context) {
+    "use strict";
+
+    var ref, jsonParse;
+    //#region src/app/plugins/cache.ts
+    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
+      };
+    }
+
+    //#endregion
+    //#region src/app/composables/useWorkflowsCache.ts
+    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
+      };
+    }
+
+    //#endregion
+    _export("t", useWorkflowSettingsCache);
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_constantsLegacy00NJs) {
+        jsonParse = _constantsLegacy00NJs.Gi;
+      }],
+      execute: function () {}
+    };
+  });
+})();

package/dist/assets/{versions.store-Dx98n6R_.js → versions.store-Dh42EsAx.js}

@@ -1,7 +1,7 @@
 import { C as computed, It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { Ho as getWhatsNewSection, Lo as useStorage, Ni as useUIStore, Ro as useSettingsStore, Vo as getNextVersions, Ys as useRootStore, bc as STORES, er as useUsersStore, t as useTelemetry, vc as defineStore } from "./useTelemetry-EOV0Llso.js";
-import { t as useToast } from "./useToast-BlMNYwds.js";
-import { $o as LOCAL_STORAGE_DISMISSED_WHATS_NEW_CALLOUT, Bo as VERSIONS_MODAL_KEY, Gi as jsonParse, Vo as WHATS_NEW_MODAL_KEY, ds as LOCAL_STORAGE_READ_WHATS_NEW_ARTICLES } from "./constants-DvlTm3U4.js";
+import { Bo as useSettingsStore, Cc as STORES, Ni as useUIStore, Qs as useRootStore, Uo as getNextVersions, Wo as getWhatsNewSection, er as useUsersStore, t as useTelemetry, xc as defineStore, zo as useStorage } from "./useTelemetry-CWnh4Zlh.js";
+import { t as useToast } from "./useToast-BxclFB6W.js";
+import { $o as LOCAL_STORAGE_DISMISSED_WHATS_NEW_CALLOUT, Bo as VERSIONS_MODAL_KEY, Gi as jsonParse, Vo as WHATS_NEW_MODAL_KEY, ds as LOCAL_STORAGE_READ_WHATS_NEW_ARTICLES } from "./constants-COt-IPHd.js";
 const SEMVER_REGEX = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
 const useVersionsStore = defineStore(STORES.VERSIONS, () => {
 	const versionNotificationSettings = ref({

package/dist/assets/versions.store-legacy-DeA4olF0.js

@@ -0,0 +1,244 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useTelemetry-legacy-BDIroahM.js", "./useToast-legacy-B7FuM_6n.js", "./constants-legacy-DiqA0Pu_.js"], function (_export, _context) {
+    "use strict";
+
+    var computed, ref, useSettingsStore, STORES, useUIStore, useRootStore, getNextVersions, getWhatsNewSection, useUsersStore, useTelemetry, defineStore, useStorage, useToast, LOCAL_STORAGE_DISMISSED_WHATS_NEW_CALLOUT, VERSIONS_MODAL_KEY, jsonParse, WHATS_NEW_MODAL_KEY, LOCAL_STORAGE_READ_WHATS_NEW_ARTICLES, SEMVER_REGEX, useVersionsStore;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        computed = _vueRuntimeEsmBundlerLegacy003Js.C;
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_useTelemetryLegacy00FJs) {
+        useSettingsStore = _useTelemetryLegacy00FJs.Bo;
+        STORES = _useTelemetryLegacy00FJs.Cc;
+        useUIStore = _useTelemetryLegacy00FJs.Ni;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        getNextVersions = _useTelemetryLegacy00FJs.Uo;
+        getWhatsNewSection = _useTelemetryLegacy00FJs.Wo;
+        useUsersStore = _useTelemetryLegacy00FJs.er;
+        useTelemetry = _useTelemetryLegacy00FJs.t;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+        useStorage = _useTelemetryLegacy00FJs.zo;
+      }, function (_useToastLegacy00HJs) {
+        useToast = _useToastLegacy00HJs.t;
+      }, function (_constantsLegacy00NJs) {
+        LOCAL_STORAGE_DISMISSED_WHATS_NEW_CALLOUT = _constantsLegacy00NJs.$o;
+        VERSIONS_MODAL_KEY = _constantsLegacy00NJs.Bo;
+        jsonParse = _constantsLegacy00NJs.Gi;
+        WHATS_NEW_MODAL_KEY = _constantsLegacy00NJs.Vo;
+        LOCAL_STORAGE_READ_WHATS_NEW_ARTICLES = _constantsLegacy00NJs.ds;
+      }],
+      execute: function () {
+        //#region src/app/stores/versions.store.ts
+        /**
+        * Semantic versioning 2.0.0, Regex from https://semver.org/
+        * Capture groups: major, minor, patch, prerelease, buildmetadata
+        */
+        SEMVER_REGEX = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+        _export("t", useVersionsStore = defineStore(STORES.VERSIONS, () => {
+          const versionNotificationSettings = ref({
+            enabled: false,
+            whatsNewEnabled: false,
+            endpoint: "",
+            whatsNewEndpoint: "",
+            infoUrl: ""
+          });
+          const nextVersions = ref([]);
+          const currentVersion = ref();
+          const whatsNew = ref({
+            title: "",
+            createdAt: (/* @__PURE__ */new Date()).toISOString(),
+            updatedAt: null,
+            calloutText: "",
+            footer: "",
+            items: []
+          });
+          const whatsNewCallout = ref();
+          const telemetry = useTelemetry();
+          const {
+            showToast,
+            showMessage
+          } = useToast();
+          const uiStore = useUIStore();
+          const settingsStore = useSettingsStore();
+          const usersStore = useUsersStore();
+          const readWhatsNewArticlesStorage = useStorage(LOCAL_STORAGE_READ_WHATS_NEW_ARTICLES);
+          const lastDismissedWhatsNewCalloutStorage = useStorage(LOCAL_STORAGE_DISMISSED_WHATS_NEW_CALLOUT);
+          const hasVersionUpdates = computed(() => {
+            return settingsStore.settings.releaseChannel === "stable" && nextVersions.value.length > 0;
+          });
+          const hasSignificantUpdates = computed(() => {
+            if (!hasVersionUpdates.value || !currentVersion.value || !latestVersion.value) return false;
+            if (currentVersion.value.hasSecurityIssue) return true;
+            const current = currentVersion.value.name.match(SEMVER_REGEX);
+            const latest = latestVersion.value.name.match(SEMVER_REGEX);
+            if (!current?.groups || !latest?.groups) return false;
+            if (Number(current.groups.major) !== Number(latest.groups.major)) return true;
+            const currentMinor = Number(current.groups.minor);
+            return Number(latest.groups.minor) - currentMinor >= 2;
+          });
+          const latestVersion = computed(() => {
+            return nextVersions.value[0] ?? currentVersion.value;
+          });
+          const areNotificationsEnabled = computed(() => {
+            return versionNotificationSettings.value.enabled;
+          });
+          const infoUrl = computed(() => {
+            return versionNotificationSettings.value.infoUrl;
+          });
+          const readWhatsNewArticles = computed(() => {
+            return readWhatsNewArticlesStorage.value ? jsonParse(readWhatsNewArticlesStorage.value, {
+              fallbackValue: []
+            }) : [];
+          });
+          const lastDismissedWhatsNewCallout = computed(() => {
+            return lastDismissedWhatsNewCalloutStorage.value ? jsonParse(lastDismissedWhatsNewCalloutStorage.value, {
+              fallbackValue: []
+            }) : [];
+          });
+          const whatsNewArticles = computed(() => {
+            return whatsNew.value.items;
+          });
+          const fetchVersions = async () => {
+            try {
+              const {
+                enabled,
+                endpoint
+              } = versionNotificationSettings.value;
+              if (enabled && endpoint) {
+                const rootStore = useRootStore();
+                const current = rootStore.versionCli;
+                const instanceId = rootStore.instanceId;
+                setVersions({
+                  versions: await getNextVersions(endpoint, current, instanceId),
+                  currentVersion: current
+                });
+              }
+            } catch (e) {
+              console.error("Failed to fetch versions:", e);
+            }
+          };
+          const setVersions = params => {
+            nextVersions.value = params.versions.filter(v => v.name !== params.currentVersion);
+            currentVersion.value = params.versions.find(v => v.name === params.currentVersion);
+          };
+          const setWhatsNew = section => {
+            whatsNew.value = section;
+          };
+          const setWhatsNewArticleRead = articleId => {
+            if (!readWhatsNewArticles.value.includes(articleId)) readWhatsNewArticlesStorage.value = JSON.stringify([...readWhatsNewArticles.value, articleId]);
+          };
+          const isWhatsNewArticleRead = articleId => {
+            return readWhatsNewArticles.value.includes(articleId);
+          };
+          const closeWhatsNewCallout = () => {
+            whatsNewCallout.value?.close();
+            whatsNewCallout.value = void 0;
+          };
+          const dismissWhatsNewCallout = () => {
+            lastDismissedWhatsNewCalloutStorage.value = JSON.stringify(whatsNewArticles.value.map(item => item.id));
+          };
+          const shouldShowWhatsNewCallout = () => {
+            const createdAt = usersStore.currentUser?.createdAt;
+            let hasNewArticle = false;
+            if (createdAt) {
+              const userCreatedAt = new Date(createdAt).getTime();
+              hasNewArticle = whatsNewArticles.value.some(item => {
+                return (item.updatedAt ? new Date(item.updatedAt).getTime() : 0) > userCreatedAt;
+              });
+            } else hasNewArticle = true;
+            const allArticlesDismissed = whatsNewArticles.value.every(item => lastDismissedWhatsNewCallout.value.includes(item.id));
+            return hasNewArticle && !allArticlesDismissed;
+          };
+          const fetchWhatsNew = async () => {
+            try {
+              const {
+                enabled,
+                whatsNewEnabled,
+                whatsNewEndpoint
+              } = versionNotificationSettings.value;
+              if (enabled && whatsNewEnabled && whatsNewEndpoint) {
+                const rootStore = useRootStore();
+                const current = rootStore.versionCli;
+                const instanceId = rootStore.instanceId;
+                const section = await getWhatsNewSection(whatsNewEndpoint, current, instanceId);
+                if (section.items?.length > 0) {
+                  setWhatsNew(section);
+                  if (shouldShowWhatsNewCallout()) whatsNewCallout.value = showMessage({
+                    title: whatsNew.value.title,
+                    message: whatsNew.value.calloutText,
+                    duration: 0,
+                    position: "bottom-left",
+                    customClass: "clickable whats-new-notification",
+                    onClick: () => {
+                      const articleId = whatsNew.value.items[0]?.id ?? 0;
+                      telemetry.track("User clicked on what's new notification", {
+                        article_id: articleId
+                      });
+                      uiStore.openModalWithData({
+                        name: WHATS_NEW_MODAL_KEY,
+                        data: {
+                          articleId
+                        }
+                      });
+                    },
+                    onClose: () => {
+                      dismissWhatsNewCallout();
+                    }
+                  });
+                }
+              }
+            } catch (e) {
+              console.error("Failed to fetch Whats New section:", e);
+            }
+          };
+          const initialize = settings => {
+            versionNotificationSettings.value = settings;
+          };
+          const checkForNewVersions = async () => {
+            if (!areNotificationsEnabled.value) return;
+            await Promise.all([fetchVersions(), fetchWhatsNew()]);
+            if (currentVersion.value && currentVersion.value.hasSecurityIssue && nextVersions.value.length) {
+              const fixVersion = currentVersion.value.securityIssueFixVersion;
+              let message = "Please update to latest version.";
+              if (fixVersion) message = `Please update to version ${fixVersion} or higher.`;
+              message = `${message} <a class="primary-color">More info</a>`;
+              showToast({
+                title: "Critical update available",
+                message,
+                onClick: () => {
+                  uiStore.openModal(VERSIONS_MODAL_KEY);
+                },
+                closeOnClick: true,
+                customClass: "clickable",
+                type: "warning",
+                duration: 0
+              });
+            }
+          };
+          return {
+            currentVersion,
+            latestVersion,
+            nextVersions,
+            hasVersionUpdates,
+            hasSignificantUpdates,
+            areNotificationsEnabled,
+            infoUrl,
+            fetchVersions,
+            setVersions,
+            initialize,
+            checkForNewVersions,
+            fetchWhatsNew,
+            whatsNew,
+            whatsNewArticles,
+            isWhatsNewArticleRead,
+            setWhatsNewArticleRead,
+            closeWhatsNewCallout,
+            shouldShowWhatsNewCallout,
+            dismissWhatsNewCallout
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();