n8n-editor-ui 1.119.1 → 1.120.1

package/dist/assets/{nodeIcon-ry_JIpAT.js → nodeIcon-ChI78z3o.js}

@@ -1,5 +1,5 @@
-import { Ni as useUIStore, Ys as useRootStore, Zr as getThemedValue, gt as isNodePreviewKey, o as useWorkflowsStore, rt as useNodeTypesStore, vt as removePreviewToken } from "./useTelemetry-EOV0Llso.js";
-import { ni as isExpression } from "./constants-DvlTm3U4.js";
+import { Ni as useUIStore, Qs as useRootStore, Zr as getThemedValue, gt as isNodePreviewKey, o as useWorkflowsStore, rt as useNodeTypesStore, vt as removePreviewToken } from "./useTelemetry-DedEakwK.js";
+import { ni as isExpression } from "./constants-C5Tj3dXQ.js";
 var resolveIconExpression = (icon, nodeType, node) => {
 	try {
 		const workflowsStore = useWorkflowsStore();

package/dist/assets/nodeIcon-legacy-DD6sIN5e.js

@@ -0,0 +1,122 @@
+;
+(function () {
+  System.register(["./useTelemetry-legacy-Bu_8SoSm.js", "./constants-legacy-CLA25gM9.js"], function (_export, _context) {
+    "use strict";
+
+    var useUIStore, useRootStore, getThemedValue, isNodePreviewKey, useWorkflowsStore, useNodeTypesStore, removePreviewToken, isExpression, resolveIconExpression, getNodeIcon, getNodeIconUrl, getBadgeIconUrl, getNodeIconColor, prefixBaseUrl, getNodeBadgeIconSource, createFileIconSource, createNamedIconSource, getIconFromNodeTypeString;
+    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);
+      }
+    }
+
+    //#endregion
+    _export("t", getNodeIconSource);
+    return {
+      setters: [function (_useTelemetryLegacy00FJs) {
+        useUIStore = _useTelemetryLegacy00FJs.Ni;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        getThemedValue = _useTelemetryLegacy00FJs.Zr;
+        isNodePreviewKey = _useTelemetryLegacy00FJs.gt;
+        useWorkflowsStore = _useTelemetryLegacy00FJs.o;
+        useNodeTypesStore = _useTelemetryLegacy00FJs.rt;
+        removePreviewToken = _useTelemetryLegacy00FJs.vt;
+      }, function (_constantsLegacy00NJs) {
+        isExpression = _constantsLegacy00NJs.ni;
+      }],
+      execute: function () {
+        //#region src/app/utils/nodeIcon.ts
+        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;
+          }
+        };
+        getNodeIcon = (nodeType, node) => {
+          const themedIcon = getThemedValue(nodeType.icon, useUIStore().appliedTheme);
+          if (isExpression(themedIcon)) return resolveIconExpression(themedIcon, nodeType, node);
+          return themedIcon;
+        };
+        getNodeIconUrl = nodeType => {
+          return getThemedValue(nodeType.iconUrl, useUIStore().appliedTheme);
+        };
+        getBadgeIconUrl = nodeType => {
+          return getThemedValue(nodeType.badgeIconUrl, useUIStore().appliedTheme);
+        };
+        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;
+        };
+        prefixBaseUrl = url => useRootStore().baseUrl + url;
+        getNodeBadgeIconSource = nodeType => {
+          if (!("badgeIconUrl" in nodeType) || !nodeType.badgeIconUrl) return void 0;
+          const badgeUrl = getBadgeIconUrl(nodeType);
+          return badgeUrl ? {
+            type: "file",
+            src: prefixBaseUrl(badgeUrl)
+          } : void 0;
+        };
+        createFileIconSource = (src, nodeType) => ({
+          type: "file",
+          src,
+          badge: getNodeBadgeIconSource(nodeType)
+        });
+        createNamedIconSource = (name, nodeType) => ({
+          type: "icon",
+          name,
+          color: getNodeIconColor(nodeType),
+          badge: getNodeBadgeIconSource(nodeType)
+        });
+        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;
+        };
+      }
+    };
+  });
+})();

package/dist/assets/{nodeTransforms-PeZUYiCs.js → nodeTransforms-C7fmOXNl.js}

@@ -1,5 +1,5 @@
-import { rt as useNodeTypesStore } from "./useTelemetry-EOV0Llso.js";
-import { Ga as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, Ur as traverseNodeParameters, kn as WIKIPEDIA_TOOL_NODE_TYPE, mi as displayParameter, q as AI_MCP_TOOL_NODE_TYPE, yi as getNodeParameters } from "./constants-DvlTm3U4.js";
+import { rt as useNodeTypesStore } from "./useTelemetry-DedEakwK.js";
+import { Ga as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, Ur as traverseNodeParameters, kn as WIKIPEDIA_TOOL_NODE_TYPE, mi as displayParameter, q as AI_MCP_TOOL_NODE_TYPE, yi as getNodeParameters } from "./constants-C5Tj3dXQ.js";
 function getNodeTypeDisplayableCredentials(nodeTypeProvider, node) {
 	const nodeType = nodeTypeProvider.getNodeType(node.type, node.typeVersion);
 	if (!nodeType?.credentials) return [];

package/dist/assets/nodeTransforms-legacy-BI0GkY5n.js

@@ -0,0 +1,86 @@
+;
+(function () {
+  System.register(["./useTelemetry-legacy-Bu_8SoSm.js", "./constants-legacy-CLA25gM9.js"], function (_export, _context) {
+    "use strict";
+
+    var useNodeTypesStore, AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, traverseNodeParameters, WIKIPEDIA_TOOL_NODE_TYPE, displayParameter, AI_MCP_TOOL_NODE_TYPE, getNodeParameters;
+    //#region src/app/utils/nodes/nodeTransforms.ts
+    /**
+    * Returns the credentials that are displayable for the given node.
+    */
+    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);
+      });
+    }
+    /**
+    * Checks if the given node has credentials that can be filled.
+    */
+    function doesNodeHaveCredentialsToFill(nodeTypeProvider, node) {
+      return getNodeTypeDisplayableCredentials(nodeTypeProvider, node).length > 0;
+    }
+    /**
+    * Does node has the given credential filled
+    *
+    * @param credentialName E.g. "telegramApi"
+    */
+    function hasNodeCredentialFilled(node, credentialName) {
+      if (!node.credentials) return false;
+      return !!node.credentials[credentialName];
+    }
+    /**
+    * Checks if the given node has all credentials filled.
+    */
+    function doesNodeHaveAllCredentialsFilled(nodeTypeProvider, node) {
+      return getNodeTypeDisplayableCredentials(nodeTypeProvider, node).every(cred => hasNodeCredentialFilled(node, cred.name));
+    }
+    /**
+    * Checks if the given node needs agentInput
+    */
+    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";
+    }
+    /**
+    * Filters out options that should not be displayed
+    */
+    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");
+      });
+    }
+
+    //#endregion
+    _export({
+      a: needsAgentInput,
+      i: getParameterDisplayableOptions,
+      n: doesNodeHaveCredentialsToFill,
+      r: getNodeTypeDisplayableCredentials,
+      t: doesNodeHaveAllCredentialsFilled
+    });
+    return {
+      setters: [function (_useTelemetryLegacy00FJs) {
+        useNodeTypesStore = _useTelemetryLegacy00FJs.rt;
+      }, function (_constantsLegacy00NJs) {
+        AI_CODE_TOOL_LANGCHAIN_NODE_TYPE = _constantsLegacy00NJs.Ga;
+        traverseNodeParameters = _constantsLegacy00NJs.Ur;
+        WIKIPEDIA_TOOL_NODE_TYPE = _constantsLegacy00NJs.kn;
+        displayParameter = _constantsLegacy00NJs.mi;
+        AI_MCP_TOOL_NODE_TYPE = _constantsLegacy00NJs.q;
+        getNodeParameters = _constantsLegacy00NJs.yi;
+      }],
+      execute: function () {}
+    };
+  });
+})();

package/dist/assets/npsSurvey.store-legacy-oZP0npqy.js

@@ -0,0 +1,123 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./useTelemetry-legacy-Bu_8SoSm.js", "./constants-legacy-CLA25gM9.js"], function (_export, _context) {
+    "use strict";
+
+    var ref, useSettingsStore, useUIStore, useRootStore, assert, updateNpsSurveyState, getPromptsData, defineStore, NPS_SURVEY_MODAL_KEY, SIX_MONTHS_IN_MILLIS, THREE_DAYS_IN_MILLIS, CONTACT_PROMPT_MODAL_KEY, SEVEN_DAYS_IN_MILLIS, MAXIMUM_TIMES_TO_SHOW_SURVEY_IF_IGNORED, useNpsSurveyStore;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        ref = _vueRuntimeEsmBundlerLegacy003Js.It;
+      }, function (_useTelemetryLegacy00FJs) {
+        useSettingsStore = _useTelemetryLegacy00FJs.Bo;
+        useUIStore = _useTelemetryLegacy00FJs.Ni;
+        useRootStore = _useTelemetryLegacy00FJs.Qs;
+        assert = _useTelemetryLegacy00FJs._c;
+        updateNpsSurveyState = _useTelemetryLegacy00FJs._s;
+        getPromptsData = _useTelemetryLegacy00FJs.ps;
+        defineStore = _useTelemetryLegacy00FJs.xc;
+      }, function (_constantsLegacy00NJs) {
+        NPS_SURVEY_MODAL_KEY = _constantsLegacy00NJs.Io;
+        SIX_MONTHS_IN_MILLIS = _constantsLegacy00NJs.Js;
+        THREE_DAYS_IN_MILLIS = _constantsLegacy00NJs.Ys;
+        CONTACT_PROMPT_MODAL_KEY = _constantsLegacy00NJs.bo;
+        SEVEN_DAYS_IN_MILLIS = _constantsLegacy00NJs.qs;
+      }],
+      execute: function () {
+        //#region src/app/stores/npsSurvey.store.ts
+        MAXIMUM_TIMES_TO_SHOW_SURVEY_IF_IGNORED = 3;
+        _export("t", useNpsSurveyStore = defineStore("npsSurvey", () => {
+          const rootStore = useRootStore();
+          const uiStore = useUIStore();
+          const settingsStore = useSettingsStore();
+          const shouldShowNpsSurveyNext = ref(false);
+          const currentSurveyState = ref();
+          const currentUserId = ref();
+          const promptsData = ref();
+          function setupNpsSurveyOnLogin(userId, settings) {
+            currentUserId.value = userId;
+            if (settings) setShouldShowNpsSurvey(settings);
+          }
+          function setShouldShowNpsSurvey(settings) {
+            if (!settingsStore.isTelemetryEnabled) {
+              shouldShowNpsSurveyNext.value = false;
+              return;
+            }
+            currentSurveyState.value = settings.npsSurvey;
+            const userActivated = Boolean(settings.userActivated);
+            const userActivatedAt = settings.userActivatedAt;
+            const lastShownAt = currentSurveyState.value?.lastShownAt;
+            if (!userActivated || !userActivatedAt) return;
+            if (Date.now() - userActivatedAt < THREE_DAYS_IN_MILLIS) return;
+            if (!currentSurveyState.value || !lastShownAt) {
+              shouldShowNpsSurveyNext.value = true;
+              return;
+            }
+            const timeSinceLastShown = Date.now() - lastShownAt;
+            if ("responded" in currentSurveyState.value && timeSinceLastShown < SIX_MONTHS_IN_MILLIS) return;
+            if ("waitingForResponse" in currentSurveyState.value && timeSinceLastShown < SEVEN_DAYS_IN_MILLIS) return;
+            shouldShowNpsSurveyNext.value = true;
+          }
+          function resetNpsSurveyOnLogOut() {
+            shouldShowNpsSurveyNext.value = false;
+          }
+          async function showNpsSurveyIfPossible() {
+            if (!shouldShowNpsSurveyNext.value) return;
+            uiStore.openModal(NPS_SURVEY_MODAL_KEY);
+            shouldShowNpsSurveyNext.value = false;
+            const updatedState = {
+              waitingForResponse: true,
+              lastShownAt: Date.now(),
+              ignoredCount: currentSurveyState.value && "ignoredCount" in currentSurveyState.value ? currentSurveyState.value.ignoredCount : 0
+            };
+            await updateNpsSurveyState(rootStore.restApiContext, updatedState);
+            currentSurveyState.value = updatedState;
+          }
+          async function respondNpsSurvey() {
+            assert(currentSurveyState.value);
+            const updatedState = {
+              responded: true,
+              lastShownAt: currentSurveyState.value.lastShownAt
+            };
+            await updateNpsSurveyState(rootStore.restApiContext, updatedState);
+            currentSurveyState.value = updatedState;
+          }
+          async function ignoreNpsSurvey() {
+            assert(currentSurveyState.value);
+            const state = currentSurveyState.value;
+            const ignoredCount = "ignoredCount" in state ? state.ignoredCount : 0;
+            if (ignoredCount + 1 >= 3) {
+              await respondNpsSurvey();
+              return;
+            }
+            const updatedState = {
+              waitingForResponse: true,
+              lastShownAt: currentSurveyState.value.lastShownAt,
+              ignoredCount: ignoredCount + 1
+            };
+            await updateNpsSurveyState(rootStore.restApiContext, updatedState);
+            currentSurveyState.value = updatedState;
+          }
+          async function fetchPromptsData() {
+            assert(currentUserId.value);
+            if (!settingsStore.isTelemetryEnabled) return;
+            try {
+              promptsData.value = await getPromptsData(settingsStore.settings.instanceId, currentUserId.value);
+            } catch (e) {
+              console.error("Failed to fetch prompts data");
+            }
+            if (promptsData.value?.showContactPrompt) uiStore.openModal(CONTACT_PROMPT_MODAL_KEY);else await useNpsSurveyStore().showNpsSurveyIfPossible();
+          }
+          return {
+            promptsData,
+            resetNpsSurveyOnLogOut,
+            showNpsSurveyIfPossible,
+            ignoreNpsSurvey,
+            respondNpsSurvey,
+            setupNpsSurveyOnLogin,
+            fetchPromptsData
+          };
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{npsSurvey.store-BTpA4Bdf.js → npsSurvey.store-ylMA9JZD.js}

@@ -1,6 +1,6 @@
 import { It as ref } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { Ni as useUIStore, Ro as useSettingsStore, Ys as useRootStore, mc as assert, ms as updateNpsSurveyState, us as getPromptsData, vc as defineStore } from "./useTelemetry-EOV0Llso.js";
-import { Gs as SEVEN_DAYS_IN_MILLIS, Io as NPS_SURVEY_MODAL_KEY, Ks as SIX_MONTHS_IN_MILLIS, bo as CONTACT_PROMPT_MODAL_KEY, qs as THREE_DAYS_IN_MILLIS } from "./constants-DvlTm3U4.js";
+import { Bo as useSettingsStore, Ni as useUIStore, Qs as useRootStore, _c as assert, _s as updateNpsSurveyState, ps as getPromptsData, xc as defineStore } from "./useTelemetry-DedEakwK.js";
+import { Io as NPS_SURVEY_MODAL_KEY, Js as SIX_MONTHS_IN_MILLIS, Ys as THREE_DAYS_IN_MILLIS, bo as CONTACT_PROMPT_MODAL_KEY, qs as SEVEN_DAYS_IN_MILLIS } from "./constants-C5Tj3dXQ.js";
 const useNpsSurveyStore = defineStore("npsSurvey", () => {
 	const rootStore = useRootStore();
 	const uiStore = useUIStore();

package/dist/assets/{orderBy-CMVxNao4.js → orderBy-FDQLKrkD.js}

@@ -1,6 +1,6 @@
 import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
-import { m as require_isArray } from "./_MapCache-Byd-DTfo.js";
-import { It as require__baseOrderBy } from "./useTelemetry-EOV0Llso.js";
+import { m as require_isArray } from "./_MapCache-Dw6Llo22.js";
+import { It as require__baseOrderBy } from "./useTelemetry-DedEakwK.js";
 var require_orderBy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var baseOrderBy = require__baseOrderBy(), isArray = require_isArray();
 	function orderBy(collection, iteratees, orders, guard) {

package/dist/assets/orderBy-legacy-BZrAOdi3.js

@@ -0,0 +1,63 @@
+;
+(function () {
+  System.register(["./chunk-legacy-Re9CbdfL.js", "./_MapCache-legacy-DcX1vy0l.js", "./useTelemetry-legacy-Bu_8SoSm.js"], function (_export, _context) {
+    "use strict";
+
+    var __commonJS, require_isArray, require__baseOrderBy, require_orderBy;
+    return {
+      setters: [function (_chunkLegacy001Js) {
+        __commonJS = _chunkLegacy001Js.t;
+      }, function (_MapCacheLegacy005Js) {
+        require_isArray = _MapCacheLegacy005Js.m;
+      }, function (_useTelemetryLegacy00FJs) {
+        require__baseOrderBy = _useTelemetryLegacy00FJs.It;
+      }],
+      execute: function () {
+        //#region ../../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/orderBy.js
+        _export("t", require_orderBy = /* @__PURE__ */__commonJS({
+          "../../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/orderBy.js": (exports, module) => {
+            var baseOrderBy = require__baseOrderBy(),
+              isArray = require_isArray();
+            /**
+            * This method is like `_.sortBy` except that it allows specifying the sort
+            * orders of the iteratees to sort by. If `orders` is unspecified, all values
+            * are sorted in ascending order. Otherwise, specify an order of "desc" for
+            * descending or "asc" for ascending sort order of corresponding values.
+            *
+            * @static
+            * @memberOf _
+            * @since 4.0.0
+            * @category Collection
+            * @param {Array|Object} collection The collection to iterate over.
+            * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
+            *  The iteratees to sort by.
+            * @param {string[]} [orders] The sort orders of `iteratees`.
+            * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
+            * @returns {Array} Returns the new sorted array.
+            * @example
+            *
+            * var users = [
+            *   { 'user': 'fred',   'age': 48 },
+            *   { 'user': 'barney', 'age': 34 },
+            *   { 'user': 'fred',   'age': 40 },
+            *   { 'user': 'barney', 'age': 36 }
+            * ];
+            *
+            * // Sort by `user` in ascending order and by `age` in descending order.
+            * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
+            * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
+            */
+            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;
+          }
+        })); //#endregion
+      }
+    };
+  });
+})();

package/dist/assets/{overlay-B8MMvNgs.js → overlay-C02_kK8Y.js}

@@ -1,6 +1,6 @@
 import { J as onBeforeUnmount, Jt as NOOP, L as h, M as createVNode, Nt as onScopeDispose, Ot as init_reactivity_esm_bundler, P as defineComponent, Z as onMounted, _t as watch, at as renderSlot, jt as isRef, tn as init_shared_esm_bundler, vt as watchEffect, wt as computed } from "./vue.runtime.esm-bundler-DDuXT-9r.js";
-import { on as PatchFlags, pn as getScrollBarWidth } from "./src-D6S9Khji.js";
-import { B as removeClass, F as definePropType, H as throwError, I as addClass, L as addUnit, Mt as isClient, P as buildProps, R as getStyle, k as useNamespace, z as hasClass } from "./truncate-DGRsht-H.js";
+import { on as PatchFlags, pn as getScrollBarWidth } from "./src-DsaRShTK.js";
+import { B as removeClass, F as definePropType, H as throwError, I as addClass, L as addUnit, Mt as isClient, P as buildProps, R as getStyle, k as useNamespace, z as hasClass } from "./truncate-7XypoloM.js";
 var useDraggable = (targetRef, dragRef, draggable) => {
 	let transform = {
 		offsetX: 0,

package/dist/assets/overlay-legacy-CfieUdAZ.js

@@ -0,0 +1,218 @@
+;
+(function () {
+  System.register(["./vue.runtime.esm-bundler-legacy-Bq05oSFs.js", "./src-legacy-6Jvz4Sen.js", "./truncate-legacy-D2_XDpGK.js"], function (_export, _context) {
+    "use strict";
+
+    var onBeforeUnmount, NOOP, h, createVNode, onScopeDispose, init_reactivity_esm_bundler, defineComponent, onMounted, watch, renderSlot, isRef, init_shared_esm_bundler, watchEffect, computed, PatchFlags, getScrollBarWidth, removeClass, definePropType, throwError, addClass, addUnit, isClient, buildProps, getStyle, useNamespace, hasClass, useDraggable, useLockscreen, useSameTarget, overlayProps, overlayEmits, BLOCK, Overlay, ElOverlay;
+    return {
+      setters: [function (_vueRuntimeEsmBundlerLegacy003Js) {
+        onBeforeUnmount = _vueRuntimeEsmBundlerLegacy003Js.J;
+        NOOP = _vueRuntimeEsmBundlerLegacy003Js.Jt;
+        h = _vueRuntimeEsmBundlerLegacy003Js.L;
+        createVNode = _vueRuntimeEsmBundlerLegacy003Js.M;
+        onScopeDispose = _vueRuntimeEsmBundlerLegacy003Js.Nt;
+        init_reactivity_esm_bundler = _vueRuntimeEsmBundlerLegacy003Js.Ot;
+        defineComponent = _vueRuntimeEsmBundlerLegacy003Js.P;
+        onMounted = _vueRuntimeEsmBundlerLegacy003Js.Z;
+        watch = _vueRuntimeEsmBundlerLegacy003Js._t;
+        renderSlot = _vueRuntimeEsmBundlerLegacy003Js.at;
+        isRef = _vueRuntimeEsmBundlerLegacy003Js.jt;
+        init_shared_esm_bundler = _vueRuntimeEsmBundlerLegacy003Js.tn;
+        watchEffect = _vueRuntimeEsmBundlerLegacy003Js.vt;
+        computed = _vueRuntimeEsmBundlerLegacy003Js.wt;
+      }, function (_srcLegacy007Js) {
+        PatchFlags = _srcLegacy007Js.on;
+        getScrollBarWidth = _srcLegacy007Js.pn;
+      }, function (_truncateLegacy00hJs) {
+        removeClass = _truncateLegacy00hJs.B;
+        definePropType = _truncateLegacy00hJs.F;
+        throwError = _truncateLegacy00hJs.H;
+        addClass = _truncateLegacy00hJs.I;
+        addUnit = _truncateLegacy00hJs.L;
+        isClient = _truncateLegacy00hJs.Mt;
+        buildProps = _truncateLegacy00hJs.P;
+        getStyle = _truncateLegacy00hJs.R;
+        useNamespace = _truncateLegacy00hJs.k;
+        hasClass = _truncateLegacy00hJs.z;
+      }],
+      execute: function () {
+        //#region ../../../node_modules/.pnpm/element-plus@2.4.3_patch_hash=3bc4ea0a42ad52c6bbc3d06c12c2963d55b57d6b5b8d436e46e7fd8ff_87815230ec1d292541fa9e3e306612e7/node_modules/element-plus/es/hooks/use-draggable/index.mjs
+        _export("i", useDraggable = (targetRef, dragRef, draggable) => {
+          let transform = {
+            offsetX: 0,
+            offsetY: 0
+          };
+          const onMousedown = e => {
+            const downX = e.clientX;
+            const downY = e.clientY;
+            const {
+              offsetX,
+              offsetY
+            } = transform;
+            const targetRect = targetRef.value.getBoundingClientRect();
+            const targetLeft = targetRect.left;
+            const targetTop = targetRect.top;
+            const targetWidth = targetRect.width;
+            const targetHeight = targetRect.height;
+            const clientWidth = document.documentElement.clientWidth;
+            const clientHeight = document.documentElement.clientHeight;
+            const minLeft = -targetLeft + offsetX;
+            const minTop = -targetTop + offsetY;
+            const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
+            const maxTop = clientHeight - targetTop - targetHeight + offsetY;
+            const onMousemove = e2 => {
+              const moveX = Math.min(Math.max(offsetX + e2.clientX - downX, minLeft), maxLeft);
+              const moveY = Math.min(Math.max(offsetY + e2.clientY - downY, minTop), maxTop);
+              transform = {
+                offsetX: moveX,
+                offsetY: moveY
+              };
+              if (targetRef.value) targetRef.value.style.transform = `translate(${addUnit(moveX)}, ${addUnit(moveY)})`;
+            };
+            const onMouseup = () => {
+              document.removeEventListener("mousemove", onMousemove);
+              document.removeEventListener("mouseup", onMouseup);
+            };
+            document.addEventListener("mousemove", onMousemove);
+            document.addEventListener("mouseup", onMouseup);
+          };
+          const onDraggable = () => {
+            if (dragRef.value && targetRef.value) dragRef.value.addEventListener("mousedown", onMousedown);
+          };
+          const offDraggable = () => {
+            if (dragRef.value && targetRef.value) dragRef.value.removeEventListener("mousedown", onMousedown);
+          };
+          onMounted(() => {
+            watchEffect(() => {
+              if (draggable.value) onDraggable();else offDraggable();
+            });
+          });
+          onBeforeUnmount(() => {
+            offDraggable();
+          });
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/element-plus@2.4.3_patch_hash=3bc4ea0a42ad52c6bbc3d06c12c2963d55b57d6b5b8d436e46e7fd8ff_87815230ec1d292541fa9e3e306612e7/node_modules/element-plus/es/hooks/use-lockscreen/index.mjs
+        init_reactivity_esm_bundler();
+        _export("r", useLockscreen = (trigger, options = {}) => {
+          if (!isRef(trigger)) throwError("[useLockscreen]", "You need to pass a ref param to this function");
+          const ns = options.ns || useNamespace("popup");
+          const hiddenCls = computed(() => ns.bm("parent", "hidden"));
+          if (!isClient || hasClass(document.body, hiddenCls.value)) return;
+          let scrollBarWidth = 0;
+          let withoutHiddenClass = false;
+          let bodyWidth = "0";
+          const cleanup = () => {
+            setTimeout(() => {
+              if (typeof document === "undefined") return;
+              removeClass(document == null ? void 0 : document.body, hiddenCls.value);
+              if (withoutHiddenClass && document) document.body.style.width = bodyWidth;
+            }, 200);
+          };
+          watch(trigger, val => {
+            if (!val) {
+              cleanup();
+              return;
+            }
+            withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
+            if (withoutHiddenClass) bodyWidth = document.body.style.width;
+            scrollBarWidth = getScrollBarWidth(ns.namespace.value);
+            const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
+            const bodyOverflowY = getStyle(document.body, "overflowY");
+            if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
+            addClass(document.body, hiddenCls.value);
+          });
+          onScopeDispose(() => cleanup());
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/element-plus@2.4.3_patch_hash=3bc4ea0a42ad52c6bbc3d06c12c2963d55b57d6b5b8d436e46e7fd8ff_87815230ec1d292541fa9e3e306612e7/node_modules/element-plus/es/hooks/use-same-target/index.mjs
+        init_shared_esm_bundler();
+        _export("n", useSameTarget = handleClick => {
+          if (!handleClick) return {
+            onClick: NOOP,
+            onMousedown: NOOP,
+            onMouseup: NOOP
+          };
+          let mousedownTarget = false;
+          let mouseupTarget = false;
+          const onClick = e => {
+            if (mousedownTarget && mouseupTarget) handleClick(e);
+            mousedownTarget = mouseupTarget = false;
+          };
+          const onMousedown = e => {
+            mousedownTarget = e.target === e.currentTarget;
+          };
+          const onMouseup = e => {
+            mouseupTarget = e.target === e.currentTarget;
+          };
+          return {
+            onClick,
+            onMousedown,
+            onMouseup
+          };
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/element-plus@2.4.3_patch_hash=3bc4ea0a42ad52c6bbc3d06c12c2963d55b57d6b5b8d436e46e7fd8ff_87815230ec1d292541fa9e3e306612e7/node_modules/element-plus/es/components/overlay/src/overlay.mjs
+        overlayProps = buildProps({
+          mask: {
+            type: Boolean,
+            default: true
+          },
+          customMaskEvent: {
+            type: Boolean,
+            default: false
+          },
+          overlayClass: {
+            type: definePropType([String, Array, Object])
+          },
+          zIndex: {
+            type: definePropType([String, Number])
+          }
+        });
+        overlayEmits = {
+          click: evt => evt instanceof MouseEvent
+        };
+        BLOCK = "overlay";
+        Overlay = defineComponent({
+          name: "ElOverlay",
+          props: overlayProps,
+          emits: overlayEmits,
+          setup(props, {
+            slots,
+            emit
+          }) {
+            const ns = useNamespace(BLOCK);
+            const onMaskClick = e => {
+              emit("click", e);
+            };
+            const {
+              onClick,
+              onMousedown,
+              onMouseup
+            } = useSameTarget(props.customMaskEvent ? void 0 : onMaskClick);
+            return () => {
+              return props.mask ? createVNode("div", {
+                class: [ns.b(), props.overlayClass],
+                style: {
+                  zIndex: props.zIndex
+                },
+                onClick,
+                onMousedown,
+                onMouseup
+              }, [renderSlot(slots, "default")], PatchFlags.STYLE | PatchFlags.CLASS | PatchFlags.PROPS, ["onClick", "onMouseup", "onMousedown"]) : h("div", {
+                class: props.overlayClass,
+                style: {
+                  zIndex: props.zIndex,
+                  position: "fixed",
+                  top: "0px",
+                  right: "0px",
+                  bottom: "0px",
+                  left: "0px"
+                }
+              }, [renderSlot(slots, "default")]);
+            };
+          }
+        }); //#endregion
+        //#region ../../../node_modules/.pnpm/element-plus@2.4.3_patch_hash=3bc4ea0a42ad52c6bbc3d06c12c2963d55b57d6b5b8d436e46e7fd8ff_87815230ec1d292541fa9e3e306612e7/node_modules/element-plus/es/components/overlay/index.mjs
+        _export("t", ElOverlay = Overlay); //#endregion
+      }
+    };
+  });
+})();