Flowfile 0.3.3.1__py3-none-any.whl → 0.3.4__py3-none-any.whl

flowfile/web/static/assets/{vue-codemirror.esm-eb98fc8b.js → vue-codemirror.esm-25e75a08.js}

@@ -1,4 +1,583 @@
-import { d as defineComponent, X as shallowRef, B as inject, l as computed, n as onMounted, m as watch, U as onBeforeUnmount, Y as h$1, al as toRaw } from "./index-f25c9283.js";
+import { r as ref, j as defineStore, a as axios, d as defineComponent, ae as useCssVars, n as onMounted, c as openBlock, e as createElementBlock, p as createBaseVNode, L as renderSlot, h as createBlock, t as toDisplayString, i as createCommentVNode, T as normalizeStyle, s as normalizeClass, a7 as Teleport, R as nextTick, _ as _export_sfc, X as shallowRef, B as inject, l as computed, m as watch, U as onBeforeUnmount, Y as h$1, af as toRaw } from "./index-e235a8bc.js";
+const FLOW_ID_STORAGE_KEY = "last_flow_id";
+ref(null);
+const getDownstreamNodeIds = async (flow_id, node_id) => {
+  const response = await axios.get("/node/downstream_node_ids", {
+    params: { flow_id, node_id },
+    headers: { accept: "application/json" }
+  });
+  return response.data;
+};
+const loadDownstreamNodeIds = async (flowId, nodeId) => {
+  const downstreamNodeIds = await getDownstreamNodeIds(flowId, nodeId);
+  return downstreamNodeIds;
+};
+const useNodeStore = defineStore("node", {
+  state: () => {
+    const savedFlowId = sessionStorage.getItem(FLOW_ID_STORAGE_KEY);
+    const initialFlowId = savedFlowId ? parseInt(savedFlowId) : -1;
+    return {
+      inputCode: "",
+      flow_id: initialFlowId,
+      node_id: -1,
+      previous_node_id: -1,
+      nodeValidateFuncs: /* @__PURE__ */ new Map(),
+      nodeData: null,
+      node_exists: false,
+      is_loaded: false,
+      size_data_preview: 300,
+      dataTypes: ["String", "Datetime", "Int64", "Int32", "Int16", "Float64", "Float32", "Boolean"],
+      isDrawerOpen: false,
+      isAnalysisOpen: false,
+      drawCloseFunction: null,
+      initialEditorData: "",
+      runResults: {},
+      nodeDescriptions: {},
+      runNodeResults: {},
+      runNodeValidations: {},
+      currentRunResult: null,
+      isRunning: false,
+      showFlowResult: false,
+      tableVisible: false,
+      resultVersion: 0,
+      vueFlowInstance: null,
+      allExpressions: null,
+      isShowingLogViewer: false,
+      isStreamingLogs: false,
+      displayLogViewer: true,
+      showCodeGenerator: false
+    };
+  },
+  actions: {
+    toggleCodeGenerator() {
+      this.showCodeGenerator = !this.showCodeGenerator;
+    },
+    setCodeGeneratorVisibility(visible) {
+      this.showCodeGenerator = visible;
+    },
+    initializeResultCache(flowId) {
+      if (!this.runNodeResults[flowId]) {
+        this.runNodeResults[flowId] = {};
+      }
+    },
+    initializeValidationCache(flowId) {
+      if (!this.runNodeValidations[flowId]) {
+        this.runNodeValidations[flowId] = {};
+      }
+    },
+    setNodeResult(nodeId, result) {
+      this.initializeResultCache(this.flow_id);
+      this.runNodeResults[this.flow_id][nodeId] = result;
+    },
+    getNodeResult(nodeId) {
+      var _a2;
+      return (_a2 = this.runNodeResults[this.flow_id]) == null ? void 0 : _a2[nodeId];
+    },
+    resetNodeResult() {
+      console.log("Clearing node results");
+      this.runNodeResults = {};
+    },
+    clearFlowResults(flowId) {
+      if (this.runNodeResults[flowId]) {
+        delete this.runNodeResults[flowId];
+      }
+    },
+    setNodeValidation(nodeId, nodeValidationInput) {
+      if (typeof nodeId === "string") {
+        nodeId = parseInt(nodeId);
+      }
+      this.initializeValidationCache(this.flow_id);
+      const nodeValidation = {
+        ...nodeValidationInput,
+        validationTime: Date.now() / 1e3
+      };
+      this.runNodeValidations[this.flow_id][nodeId] = nodeValidation;
+    },
+    resetNodeValidation() {
+      this.runNodeValidations = {};
+    },
+    getNodeValidation(nodeId) {
+      var _a2;
+      return ((_a2 = this.runNodeValidations[this.flow_id]) == null ? void 0 : _a2[nodeId]) || {
+        isValid: true,
+        error: "",
+        validationTime: 0
+      };
+    },
+    insertRunResult(runResult, showResult = true) {
+      this.currentRunResult = runResult;
+      this.runResults[runResult.flow_id] = runResult;
+      this.showFlowResult = showResult;
+      this.isShowingLogViewer = this.displayLogViewer && showResult;
+      this.initializeResultCache(runResult.flow_id);
+      runResult.node_step_result.forEach((nodeResult) => {
+        this.runNodeResults[runResult.flow_id][nodeResult.node_id] = nodeResult;
+      });
+      this.resultVersion++;
+    },
+    resetRunResults() {
+      this.runNodeResults = {};
+      this.runResults = {};
+      this.currentRunResult = null;
+    },
+    initializeDescriptionCache(flowId) {
+      if (!this.nodeDescriptions[flowId]) {
+        this.nodeDescriptions[flowId] = {};
+      }
+    },
+    setNodeValidateFunc(nodeId, func) {
+      if (typeof nodeId === "string") {
+        nodeId = parseInt(nodeId);
+      }
+      this.nodeValidateFuncs.set(nodeId, func);
+    },
+    async validateNode(nodeId) {
+      if (typeof nodeId === "string") {
+        nodeId = parseInt(nodeId);
+      }
+      const func = this.nodeValidateFuncs.get(nodeId);
+      if (func) {
+        func();
+      } else {
+        console.warn("No validation function found for node", nodeId);
+      }
+    },
+    setFlowId(flowId) {
+      this.flow_id = flowId;
+      try {
+        sessionStorage.setItem(FLOW_ID_STORAGE_KEY, flowId.toString());
+      } catch (error) {
+        console.warn("Failed to store flow ID in session storage:", error);
+      }
+    },
+    setVueFlowInstance(vueFlowInstance) {
+      this.vueFlowInstance = vueFlowInstance;
+    },
+    setInitialEditorData(editorDataString) {
+      this.initialEditorData = editorDataString;
+    },
+    getInitialEditorData() {
+      return this.initialEditorData;
+    },
+    cacheNodeDescriptionDict(flowId, nodeId, description) {
+      this.initializeDescriptionCache(flowId);
+      this.nodeDescriptions[flowId][nodeId] = description;
+    },
+    clearNodeDescriptionCache(flowId, nodeId) {
+      if (this.nodeDescriptions[flowId] && this.nodeDescriptions[flowId][nodeId]) {
+        delete this.nodeDescriptions[flowId][nodeId];
+      }
+    },
+    clearFlowDescriptionCache(flowId) {
+      if (this.nodeDescriptions[flowId]) {
+        delete this.nodeDescriptions[flowId];
+      }
+    },
+    clearAllDescriptionCaches() {
+      this.nodeDescriptions = {};
+    },
+    async getNodeDescription(nodeId, forceRefresh = false) {
+      var _a2, _b;
+      this.initializeDescriptionCache(this.flow_id);
+      if (!forceRefresh && ((_a2 = this.nodeDescriptions[this.flow_id]) == null ? void 0 : _a2[nodeId])) {
+        return this.nodeDescriptions[this.flow_id][nodeId];
+      }
+      try {
+        const response = await axios.get("/node/description", {
+          params: {
+            node_id: nodeId,
+            flow_id: this.flow_id
+          }
+        });
+        this.cacheNodeDescriptionDict(this.flow_id, nodeId, response.data);
+        return response.data;
+      } catch (error) {
+        console.info("Error fetching node description:", error);
+        if ((_b = this.nodeDescriptions[this.flow_id]) == null ? void 0 : _b[nodeId]) {
+          console.warn("Using cached description due to API error");
+          return this.nodeDescriptions[this.flow_id][nodeId];
+        }
+        return "";
+      }
+    },
+    async setNodeDescription(nodeId, description) {
+      try {
+        this.cacheNodeDescriptionDict(this.flow_id, nodeId, description);
+        const response = await axios.post("/node/description/", JSON.stringify(description), {
+          params: {
+            flow_id: this.flow_id,
+            node_id: nodeId
+          },
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (response.data.status === "success") {
+          console.log(response.data.message);
+        } else {
+          console.warn("Unexpected success response structure:", response.data);
+        }
+      } catch (error) {
+        if (error.response) {
+          console.error("API error:", error.response.data.message);
+        } else if (error.request) {
+          console.error("The request was made but no response was received");
+        } else {
+          console.error("Error", error.message);
+        }
+        throw error;
+      }
+    },
+    setCloseFunction(f) {
+      this.drawCloseFunction = f;
+    },
+    getSizeDataPreview() {
+      return this.size_data_preview;
+    },
+    setSizeDataPreview(newHeight) {
+      this.size_data_preview = newHeight;
+    },
+    toggleDrawer() {
+      console.log("toggleDrawer in column-store.ts");
+      if (this.isDrawerOpen && this.drawCloseFunction) {
+        this.pushNodeData();
+      }
+      this.isDrawerOpen = !this.isDrawerOpen;
+    },
+    pushNodeData() {
+      if (this.drawCloseFunction && !this.isRunning) {
+        this.drawCloseFunction();
+        this.drawCloseFunction = null;
+      }
+    },
+    openDrawer(close_function) {
+      console.log("openDrawer in column-store.ts");
+      if (this.isDrawerOpen) {
+        console.log("pushing data");
+        this.pushNodeData();
+      }
+      if (close_function) {
+        this.drawCloseFunction = close_function;
+      }
+      this.isDrawerOpen = true;
+    },
+    closeDrawer() {
+      this.isDrawerOpen = false;
+      if (this.drawCloseFunction) {
+        this.pushNodeData();
+      }
+      this.node_id = -1;
+    },
+    openAnalysisDrawer(close_function) {
+      console.log("openAnalysisDrawer in column-store.ts");
+      if (this.isAnalysisOpen) {
+        this.pushNodeData();
+      }
+      if (close_function) {
+        this.drawCloseFunction = close_function;
+      }
+      this.isAnalysisOpen = true;
+    },
+    closeAnalysisDrawer() {
+      this.isAnalysisOpen = false;
+      if (this.drawCloseFunction) {
+        console.log("closeDrawer in column-store.ts");
+        this.pushNodeData();
+      }
+    },
+    getDataTypes() {
+      return this.dataTypes;
+    },
+    setInputCode(newCode) {
+      this.inputCode = newCode;
+    },
+    showLogViewer() {
+      console.log("triggered show log viewer");
+      this.isShowingLogViewer = this.displayLogViewer;
+    },
+    hideLogViewer() {
+      this.isShowingLogViewer = false;
+    },
+    toggleLogViewer() {
+      console.log("triggered toggle log viewer");
+      this.isShowingLogViewer = !this.isShowingLogViewer;
+    },
+    getRunResult(flow_id) {
+      return this.runResults[flow_id] || null;
+    },
+    async getTableExample(flow_id, node_id) {
+      try {
+        const response = await axios.get("/node/data", {
+          params: { flow_id, node_id },
+          headers: { accept: "application/json" }
+        });
+        return response.data;
+      } catch (error) {
+        console.error("Error fetching table example:", error);
+        return null;
+      }
+    },
+    async getNodeData(node_id, useCache = true) {
+      if (this.node_id === node_id && useCache) {
+        if (this.nodeData) {
+          this.is_loaded = true;
+          return this.nodeData;
+        }
+      }
+      try {
+        this.setFlowIdAndNodeId(this.flow_id, node_id);
+        const response = await axios.get("/node", {
+          params: { flow_id: this.flow_id, node_id: this.node_id },
+          headers: { accept: "application/json" }
+        });
+        this.nodeData = response.data;
+        this.is_loaded = true;
+        this.node_exists = true;
+        return this.nodeData;
+      } catch (error) {
+        console.error("Error fetching node data:", error);
+        this.nodeData = null;
+        this.is_loaded = false;
+        this.node_exists = false;
+        return null;
+      }
+    },
+    async reloadCurrentNodeData() {
+      return this.getNodeData(this.node_id, false);
+    },
+    setFlowIdAndNodeId(flow_id, node_id) {
+      if (this.node_id === node_id && this.flow_id === flow_id) {
+        return;
+      }
+      console.log("Automatically pushing the node data ");
+      this.pushNodeData();
+      this.previous_node_id = this.node_id;
+      if (this.flow_id !== flow_id) {
+        this.setFlowId(flow_id);
+      }
+      this.node_id = node_id;
+    },
+    getCurrentNodeData() {
+      return this.nodeData;
+    },
+    doReset() {
+      this.is_loaded = false;
+    },
+    getVueFlowInstance() {
+      return this.vueFlowInstance;
+    },
+    getEditorNodeData() {
+      var _a2;
+      if (this.node_id) {
+        return (_a2 = this.vueFlowInstance) == null ? void 0 : _a2.findNode(String(this.node_id));
+      }
+      return null;
+    },
+    async fetchExpressionsOverview() {
+      try {
+        const response = await axios.get("/editor/expression_doc");
+        this.allExpressions = response.data;
+        return this.allExpressions;
+      } catch (error) {
+        console.error("Error fetching expressions overview:", error);
+        return [];
+      }
+    },
+    async getExpressionsOverview() {
+      if (this.allExpressions) {
+        return this.allExpressions;
+      } else {
+        return await this.fetchExpressionsOverview();
+      }
+    },
+    async updateSettingsDirectly(inputData) {
+      var _a2, _b;
+      try {
+        const node = (_a2 = this.vueFlowInstance) == null ? void 0 : _a2.findNode(String(this.node_id));
+        inputData.pos_x = node.position.x;
+        inputData.pos_y = node.position.y;
+        console.log("updating settings");
+        console.log("node", node);
+        const response = await axios.post("/update_settings/", inputData, {
+          params: {
+            node_type: node.data.component.__name
+          }
+        });
+        const downstreamNodeIds = await loadDownstreamNodeIds(this.flow_id, inputData.node_id);
+        downstreamNodeIds.map((nodeId) => {
+          this.validateNode(nodeId);
+        });
+        return response.data;
+      } catch (error) {
+        console.error("Error updating settings:", (_b = error.response) == null ? void 0 : _b.data);
+        throw error;
+      }
+    },
+    async updateSettings(inputData) {
+      var _a2, _b;
+      try {
+        const node = (_a2 = this.vueFlowInstance) == null ? void 0 : _a2.findNode(String(this.node_id));
+        inputData.value.pos_x = node.position.x;
+        inputData.value.pos_y = node.position.y;
+        console.log("updating settings");
+        console.log("node", node);
+        const response = await axios.post("/update_settings/", inputData.value, {
+          params: {
+            node_type: node.data.component.__name
+          }
+        });
+        const downstreamNodeIds = await loadDownstreamNodeIds(
+          this.flow_id,
+          inputData.value.node_id
+        );
+        downstreamNodeIds.map((nodeId) => {
+          this.validateNode(nodeId);
+        });
+        return response.data;
+      } catch (error) {
+        console.error("Error updating settings:", (_b = error.response) == null ? void 0 : _b.data);
+        throw error;
+      }
+    },
+    updateNodeDescription(nodeId, description) {
+      this.cacheNodeDescriptionDict(this.flow_id, nodeId, description);
+    }
+  }
+});
+const _hoisted_1 = { class: "popover-container" };
+const _hoisted_2 = { key: 0 };
+const _hoisted_3 = ["innerHTML"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "PopOver",
+  props: {
+    content: {
+      type: String,
+      required: true
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    placement: {
+      type: String,
+      default: "top"
+    },
+    minWidth: {
+      type: Number,
+      default: 100
+    },
+    zIndex: {
+      type: Number,
+      default: 9999
+    }
+  },
+  setup(__props) {
+    useCssVars((_ctx) => ({
+      "64450ce2": props.minWidth + "px"
+    }));
+    const visible = ref(false);
+    const referenceEl = ref(null);
+    const popoverEl = ref(null);
+    const props = __props;
+    const popoverStyle = ref({
+      top: "0px",
+      left: "0px",
+      zIndex: props.zIndex.toString()
+    });
+    const showPopover = () => {
+      visible.value = true;
+      nextTick(() => {
+        updatePosition();
+      });
+    };
+    const hidePopover = () => {
+      visible.value = false;
+    };
+    const updatePosition = () => {
+      if (!referenceEl.value || !popoverEl.value)
+        return;
+      const referenceRect = referenceEl.value.getBoundingClientRect();
+      const popoverRect = popoverEl.value.getBoundingClientRect();
+      const offset = 20;
+      let top2 = 0;
+      let left = 0;
+      switch (props.placement) {
+        case "top":
+          top2 = referenceRect.top - popoverRect.height - offset;
+          left = referenceRect.left + referenceRect.width / 2 - popoverRect.width / 2;
+          break;
+        case "bottom":
+          top2 = referenceRect.bottom + offset;
+          left = referenceRect.left + referenceRect.width / 2 - popoverRect.width / 2;
+          break;
+        case "left":
+          top2 = referenceRect.top + referenceRect.height / 2 - popoverRect.height / 2;
+          left = referenceRect.left - popoverRect.width - offset;
+          break;
+        case "right":
+          top2 = referenceRect.top + referenceRect.height / 2 - popoverRect.height / 2;
+          left = referenceRect.right + offset;
+          break;
+      }
+      const viewportWidth = window.innerWidth;
+      const viewportHeight = window.innerHeight;
+      if (left < 10)
+        left = 10;
+      if (left + popoverRect.width > viewportWidth - 10) {
+        left = viewportWidth - popoverRect.width - 10;
+      }
+      if (top2 < 10)
+        top2 = 10;
+      if (top2 + popoverRect.height > viewportHeight - 10) {
+        top2 = viewportHeight - popoverRect.height - 10;
+      }
+      popoverStyle.value = {
+        top: `${top2}px`,
+        left: `${left}px`,
+        zIndex: props.zIndex.toString()
+      };
+    };
+    onMounted(() => {
+      window.addEventListener("resize", () => {
+        if (visible.value) {
+          updatePosition();
+        }
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createBaseVNode("div", {
+          ref_key: "referenceEl",
+          ref: referenceEl,
+          class: "popover-reference",
+          onMouseenter: showPopover,
+          onMouseleave: hidePopover
+        }, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 544),
+        visible.value ? (openBlock(), createBlock(Teleport, {
+          key: 0,
+          to: "body"
+        }, [
+          createBaseVNode("div", {
+            ref_key: "popoverEl",
+            ref: popoverEl,
+            style: normalizeStyle(popoverStyle.value),
+            class: normalizeClass(["popover", { "popover--left": props.placement === "left" }])
+          }, [
+            props.title !== "" ? (openBlock(), createElementBlock("h3", _hoisted_2, toDisplayString(props.title), 1)) : createCommentVNode("", true),
+            createBaseVNode("p", {
+              class: "content",
+              innerHTML: props.content
+            }, null, 8, _hoisted_3)
+          ], 6)
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const PopOver_vue_vue_type_style_index_0_scoped_e6f071d2_lang = "";
+const PopOver = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e6f071d2"]]);
 let rangeFrom = [], rangeTo = [];
 (() => {
   let numbers = "lc,34,7n,7,7b,19,,,,2,,2,,,20,b,1c,l,g,,2t,7,2,6,2,2,,4,z,,u,r,2j,b,1m,9,9,,o,4,,9,,3,,5,17,3,3b,f,,w,1j,,,,4,8,4,,3,7,a,2,t,,1m,,,,2,4,8,,9,,a,2,q,,2,2,1l,,4,2,4,2,2,3,3,,u,2,3,,b,2,1l,,4,5,,2,4,,k,2,m,6,,,1m,,,2,,4,8,,7,3,a,2,u,,1n,,,,c,,9,,14,,3,,1l,3,5,3,,4,7,2,b,2,t,,1m,,2,,2,,3,,5,2,7,2,b,2,s,2,1l,2,,,2,4,8,,9,,a,2,t,,20,,4,,2,3,,,8,,29,,2,7,c,8,2q,,2,9,b,6,22,2,r,,,,,,1j,e,,5,,2,5,b,,10,9,,2u,4,,6,,2,2,2,p,2,4,3,g,4,d,,2,2,6,,f,,jj,3,qa,3,t,3,t,2,u,2,1s,2,,7,8,,2,b,9,,19,3,3b,2,y,,3a,3,4,2,9,,6,3,63,2,2,,1m,,,7,,,,,2,8,6,a,2,,1c,h,1r,4,1c,7,,,5,,14,9,c,2,w,4,2,2,,3,1k,,,2,3,,,3,1m,8,2,2,48,3,,d,,7,4,,6,,3,2,5i,1m,,5,ek,,5f,x,2da,3,3x,,2o,w,fe,6,2x,2,n9w,4,,a,w,2,28,2,7k,,3,,4,,p,2,5,,47,2,q,i,d,,12,8,p,b,1a,3,1c,,2,4,2,2,13,,1v,6,2,2,2,2,c,,8,,1b,,1f,,,3,2,2,5,2,,,16,2,8,,6m,,2,,4,,fn4,,kh,g,g,g,a6,2,gt,,6a,,45,5,1ae,3,,2,5,4,14,3,4,,4l,2,fx,4,ar,2,49,b,4w,,1i,f,1k,3,1d,4,2,2,1x,3,10,5,,8,1q,,c,2,1g,9,a,4,2,,2n,3,2,,,2,6,,4g,,3,8,l,2,1l,2,,,,,m,,e,7,3,5,5f,8,2,3,,,n,,29,,2,6,,,2,,,2,,2,6j,,2,4,6,2,,2,r,2,2d,8,2,,,2,2y,,,,2,6,,,2t,3,2,4,,5,77,9,,2,6t,,a,2,,,4,,40,4,2,2,4,,w,a,14,6,2,4,8,,9,6,2,3,1a,d,,2,ba,7,,6,,,2a,m,2,7,,2,,2,3e,6,3,,,2,,7,,,20,2,3,,,,9n,2,f0b,5,1n,7,t4,,1r,4,29,,f5k,2,43q,,,3,4,5,8,8,2,7,u,4,44,3,1iz,1j,4,1e,8,,e,,m,5,,f,11s,7,,h,2,7,,2,,5,79,7,c5,4,15s,7,31,7,240,5,gx7k,2o,3k,6o".split(",").map((s) => s ? parseInt(s, 36) : 1);
@@ -6649,8 +7228,8 @@ class DocView extends ContentView {
   }
   scrollIntoView(target) {
     if (target.isSnapshot) {
-      let ref = this.view.viewState.lineBlockAt(target.range.head);
-      this.view.scrollDOM.scrollTop = ref.top - target.yMargin;
+      let ref2 = this.view.viewState.lineBlockAt(target.range.head);
+      this.view.scrollDOM.scrollTop = ref2.top - target.yMargin;
       this.view.scrollDOM.scrollLeft = target.xMargin;
       return;
     }
@@ -11258,8 +11837,8 @@ class EditorView {
   */
   scrollSnapshot() {
     let { scrollTop, scrollLeft } = this.scrollDOM;
-    let ref = this.viewState.scrollAnchorAt(scrollTop);
-    return scrollIntoView$1.of(new ScrollTarget(EditorSelection.cursor(ref.from), "start", "start", ref.top - scrollTop, scrollLeft, true));
+    let ref2 = this.viewState.scrollAnchorAt(scrollTop);
+    return scrollIntoView$1.of(new ScrollTarget(EditorSelection.cursor(ref2.from), "start", "start", ref2.top - scrollTop, scrollLeft, true));
   }
   /**
   Enable or disable tab-focus mode, which disables key bindings
@@ -12352,8 +12931,8 @@ function rectangleFor(state, a, b) {
   return ranges;
 }
 function absoluteColumn(view, x2) {
-  let ref = view.coordsAtPos(view.viewport.from);
-  return ref ? Math.round(Math.abs((ref.left - x2) / view.defaultCharacterWidth)) : -1;
+  let ref2 = view.coordsAtPos(view.viewport.from);
+  return ref2 ? Math.round(Math.abs((ref2.left - x2) / view.defaultCharacterWidth)) : -1;
 }
 function getPos(view, event) {
   let offset = view.posAtCoords({ x: event.clientX, y: event.clientY }, false);
@@ -22247,36 +22826,38 @@ var F = Object.assign(Object.assign({}, z), B), P = defineComponent({ name: "Vue
   };
 } }), T = P;
 export {
-  Decoration as D,
-  EditorState as E,
+  DefaultBufferLength as D,
+  EditorView as E,
   HighlightStyle as H,
   IterMode as I,
   LanguageSupport as L,
   NodeSet as N,
-  Parser as P,
+  PopOver as P,
   RangeSetBuilder as R,
-  T,
+  Tree as T,
   ViewPlugin as V,
-  autocompletion as a,
+  Parser as a,
   NodeType as b,
-  DefaultBufferLength as c,
-  NodeProp as d,
-  Tree as e,
-  syntaxTree as f,
-  LRLanguage as g,
-  indentNodeProp as h,
+  NodeProp as c,
+  syntaxTree as d,
+  LRLanguage as e,
+  indentNodeProp as f,
+  delimitedIndent as g,
+  foldNodeProp as h,
   ifNotIn as i,
-  delimitedIndent as j,
-  foldNodeProp as k,
-  foldInside as l,
-  completeFromList as m,
-  NodeWeakMap as n,
-  snippetCompletion as o,
-  syntaxHighlighting as p,
-  EditorView as q,
-  keymap as r,
+  foldInside as j,
+  completeFromList as k,
+  NodeWeakMap as l,
+  snippetCompletion as m,
+  syntaxHighlighting as n,
+  T as o,
+  Decoration as p,
+  EditorState as q,
+  autocompletion as r,
   styleTags as s,
   tags as t,
-  acceptCompletion as u,
-  indentMore as v
+  useNodeStore as u,
+  keymap as v,
+  acceptCompletion as w,
+  indentMore as x
 };

flowfile/web/static/assets/{vue-content-loader.es-860c0380.js → vue-content-loader.es-6c4b1c24.js}

@@ -1,4 +1,4 @@
-import { d as defineComponent, f as createVNode, l as computed } from "./index-f25c9283.js";
+import { d as defineComponent, f as createVNode, l as computed } from "./index-e235a8bc.js";
 var uid = function() {
   return Math.random().toString(36).substring(2);
 };

flowfile/web/static/index.html

@@ -12,7 +12,7 @@
 
     <!-- Material Icons -->
     <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
-    <script type="module" crossorigin src="/assets/index-f25c9283.js"></script>
+    <script type="module" crossorigin src="/assets/index-e235a8bc.js"></script>
     <link rel="stylesheet" href="/assets/index-681a3ed0.css">
   </head>
   <body>