nvent 0.4.2 → 0.4.4

package/dist/runtime/app/composables/useAnalyzedFlows.js

@@ -1,4 +1,5 @@
 import { analyzedFlows } from "#build/analyzed-flows";
+import { readonly, ref } from "#imports";
 export function useAnalyzedFlows() {
   return readonly(ref(analyzedFlows));
 }

package/dist/runtime/app/composables/useComponentRouter.js

@@ -5,9 +5,9 @@ import {
   shallowRef,
   useRoute,
   useRouter,
-  watch
+  watch,
+  defineAsyncComponent
 } from "#imports";
-import { defineAsyncComponent } from "vue";
 export function useComponentRouter(opts) {
   const CTX_KEY = "component-router";
   if (!opts || !("routes" in opts) || !opts.routes) {

package/dist/runtime/app/composables/useFlowRunTimeline.d.ts

@@ -1,3 +1,4 @@
+import { type Ref } from 'vue';
 /**
  * Composable for managing a single flow run's timeline and state
  *
@@ -7,9 +8,73 @@
  * - Fresh WebSocket connection on each mount = clean, predictable behavior
  */
 export declare function useFlowRunTimeline(flowId: Ref<string>, runId: Ref<string>): {
-    flowState: any;
-    isConnected: any;
-    isReconnecting: any;
+    flowState: {
+        events: Ref<import("~~/.nuxt/imports").EventRecord[], import("~~/.nuxt/imports").EventRecord[]>;
+        state: import("vue").ComputedRef<import("~~/.nuxt/imports").FlowState>;
+        addEvent: (event: import("~~/.nuxt/imports").EventRecord) => void;
+        addEvents: (newEvents: import("~~/.nuxt/imports").EventRecord[]) => void;
+        reset: (newEvents?: import("~~/.nuxt/imports").EventRecord[]) => void;
+        isRunning: import("vue").ComputedRef<boolean>;
+        isCompleted: import("vue").ComputedRef<boolean>;
+        isFailed: import("vue").ComputedRef<boolean>;
+        stepList: import("vue").ComputedRef<{
+            status: "pending" | "running" | "completed" | "failed" | "retrying" | "waiting" | "timeout";
+            attempt: number;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            awaitType?: "time" | "event" | "trigger";
+            awaitData?: any;
+            result?: any;
+            key: string;
+        }[]>;
+        runningSteps: import("vue").ComputedRef<{
+            status: "pending" | "running" | "completed" | "failed" | "retrying" | "waiting" | "timeout";
+            attempt: number;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            awaitType?: "time" | "event" | "trigger";
+            awaitData?: any;
+            result?: any;
+            key: string;
+        }[]>;
+        waitingSteps: import("vue").ComputedRef<{
+            status: "pending" | "running" | "completed" | "failed" | "retrying" | "waiting" | "timeout";
+            attempt: number;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            awaitType?: "time" | "event" | "trigger";
+            awaitData?: any;
+            result?: any;
+            key: string;
+        }[]>;
+        failedSteps: import("vue").ComputedRef<{
+            status: "pending" | "running" | "completed" | "failed" | "retrying" | "waiting" | "timeout";
+            attempt: number;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            awaitType?: "time" | "event" | "trigger";
+            awaitData?: any;
+            result?: any;
+            key: string;
+        }[]>;
+        completedSteps: import("vue").ComputedRef<{
+            status: "pending" | "running" | "completed" | "failed" | "retrying" | "waiting" | "timeout";
+            attempt: number;
+            startedAt?: string;
+            completedAt?: string;
+            error?: string;
+            awaitType?: "time" | "event" | "trigger";
+            awaitData?: any;
+            result?: any;
+            key: string;
+        }[]>;
+    };
+    isConnected: import("vue").ComputedRef<boolean>;
+    isReconnecting: import("vue").ComputedRef<boolean>;
     loadRun: () => Promise<void>;
     stopStream: () => void;
 };

package/dist/runtime/app/composables/useFlowRunTimeline.js

@@ -1,4 +1,6 @@
 import { useFlowWebSocket } from "./useFlowWebSocket.js";
+import { useFlowState } from "./useFlowState.js";
+import { computed, nextTick, onBeforeUnmount, watch } from "vue";
 export function useFlowRunTimeline(flowId, runId) {
   const flowState = useFlowState();
   const flowWs = useFlowWebSocket();

package/dist/runtime/app/composables/useFlowRuns.d.ts

@@ -1,11 +1,18 @@
+import { type Ref } from '#imports';
+import type { FetchError } from 'ofetch';
+interface FlowRun {
+    id: string;
+    [key: string]: any;
+}
 /**
  * Composable for fetching and managing flow runs
  * Simple approach: Fresh fetch on every refresh, no stale cache
  * Client-only to avoid hydration mismatches
  */
 export declare function useFlowRuns(flowId: Ref<string>): {
-    runs: any;
+    runs: Ref<FlowRun[] | null | undefined>;
     refresh: () => Promise<void>;
-    status: any;
-    error: any;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
 };
+export {};

package/dist/runtime/app/composables/useFlowRuns.js

@@ -1,3 +1,4 @@
+import { ref, watch, useFetch } from "#imports";
 export function useFlowRuns(flowId) {
   const refreshCounter = ref(0);
   const { data: runs, refresh: _refresh, status, error } = useFetch(

package/dist/runtime/app/composables/useFlowRunsInfinite.d.ts

@@ -1,4 +1,4 @@
-import type { Ref } from 'vue';
+import { type Ref } from '#imports';
 /**
  * Composable for infinite scroll flow runs with pagination
  */

package/dist/runtime/app/composables/useFlowRunsPolling.d.ts

@@ -1,8 +1,9 @@
+import { type Ref } from '#imports';
 /**
  * Composable for auto-polling flow runs list
  * Polls continuously to keep the list fresh
  */
 export declare function useFlowRunsPolling(refresh: () => Promise<void>, shouldPoll: Ref<boolean>, intervalMs?: number): {
-    pause: import("@vueuse/shared").Fn;
-    resume: import("@vueuse/shared").Fn;
+    pause: () => void;
+    resume: () => void;
 };

package/dist/runtime/app/composables/useFlowRunsPolling.js

@@ -1,14 +1,21 @@
-import { useIntervalFn } from "@vueuse/core";
+import { watch, onBeforeUnmount } from "#imports";
 export function useFlowRunsPolling(refresh, shouldPoll, intervalMs = 3e3) {
-  const { pause, resume } = useIntervalFn(
-    async () => {
-      if (shouldPoll.value) {
-        await refresh();
-      }
-    },
-    intervalMs,
-    { immediate: false }
-  );
+  let intervalId = null;
+  const pause = () => {
+    if (intervalId) {
+      clearInterval(intervalId);
+      intervalId = null;
+    }
+  };
+  const resume = () => {
+    if (!intervalId) {
+      intervalId = setInterval(async () => {
+        if (shouldPoll.value) {
+          await refresh();
+        }
+      }, intervalMs);
+    }
+  };
   watch(shouldPoll, (should) => {
     if (should) {
       resume();

package/dist/runtime/app/composables/useFlowState.d.ts

@@ -1,4 +1,4 @@
-import { type Ref } from 'vue';
+import { type Ref } from '#imports';
 /**
  * Client-Side Flow State Reducer
  *

package/dist/runtime/app/composables/useFlowState.js

@@ -1,4 +1,4 @@
-import { ref, computed } from "vue";
+import { ref, computed } from "#imports";
 export function reduceFlowState(events) {
   const state = {
     status: "running",

package/dist/runtime/app/composables/useFlowsNavigation.d.ts

@@ -3,8 +3,8 @@
  * Uses URL query params for persistence across HMR
  */
 export declare function useFlowsNavigation(): {
-    selectedFlow: any;
-    selectedRunId: any;
-    timelineOpen: any;
-    selectedTab: any;
+    selectedFlow: import("vue").WritableComputedRef<string, string>;
+    selectedRunId: import("vue").WritableComputedRef<string, string>;
+    timelineOpen: import("vue").Ref<boolean, boolean>;
+    selectedTab: import("vue").WritableComputedRef<string, string>;
 };

package/dist/runtime/app/composables/useFlowsNavigation.js

@@ -1,3 +1,4 @@
+import { computed, ref, watch, useRoute, useRouter } from "#imports";
 export function useFlowsNavigation() {
   const route = useRoute();
   const router = useRouter();

package/dist/runtime/app/composables/useQueueJobs.d.ts

@@ -1,4 +1,5 @@
 import { type Ref } from '#imports';
+import type { FetchError } from 'ofetch';
 export interface Job {
     id: string;
     name: string;
@@ -17,4 +18,9 @@ export interface JobsResponse {
  * Composable for fetching jobs for a queue
  * Client-only to avoid hydration mismatches
  */
-export declare function useQueueJobs(queueName: Ref<string>, state?: Ref<string | null>): any;
+export declare function useQueueJobs(queueName: Ref<string>, state?: Ref<string | null>): {
+    data: Ref<JobsResponse | null | undefined>;
+    refresh: () => Promise<void>;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
+};

package/dist/runtime/app/composables/useQueueJobs.js

@@ -1,4 +1,4 @@
-import { ref } from "#imports";
+import { ref, useFetch } from "#imports";
 export function useQueueJobs(queueName, state = ref(null)) {
   return useFetch(
     () => {

package/dist/runtime/app/composables/useQueues.d.ts

@@ -1,3 +1,5 @@
+import { type Ref } from '#imports';
+import type { FetchError } from 'ofetch';
 export interface QueueCounts {
     active: number;
     completed: number;
@@ -36,8 +38,8 @@ export interface QueueInfo {
  * Client-only to avoid hydration mismatches
  */
 export declare function useQueues(): {
-    queues: any;
+    queues: Ref<QueueInfo[] | null | undefined>;
     refresh: () => Promise<void>;
-    status: any;
-    error: any;
+    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
+    error: Ref<FetchError | null | undefined>;
 };

package/dist/runtime/app/composables/useQueues.js

@@ -1,4 +1,4 @@
-import { ref } from "#imports";
+import { ref, useFetch } from "#imports";
 export function useQueues() {
   const refreshCounter = ref(0);
   const { data: queues, refresh: _refresh, status, error } = useFetch(

package/dist/runtime/app/pages/queues/index.vue

@@ -97,7 +97,7 @@
 </template>
 
 <script setup>
-import { ref } from "#imports";
+import { ref, useTemplateRef, h } from "#imports";
 import { getPaginationRowModel } from "@tanstack/table-core";
 import { UTable, UButton, UPagination } from "#components";
 import { useQueues } from "../../composables/useQueues";

package/dist/runtime/app/pages/queues/job.vue

@@ -204,7 +204,7 @@
 </template>
 
 <script setup>
-import { computed } from "#imports";
+import { computed, useFetch } from "#imports";
 import { UCard, UButton, UBadge } from "#components";
 import { useComponentRouter } from "../../composables/useComponentRouter";
 const router = useComponentRouter();

package/dist/runtime/app/pages/queues/jobs.vue

@@ -153,7 +153,7 @@
 </template>
 
 <script setup>
-import { ref, computed, watch } from "#imports";
+import { ref, computed, watch, resolveComponent, useTemplateRef, h } from "#imports";
 import { getPaginationRowModel } from "@tanstack/table-core";
 import { UTable, UButton, UBadge, UPagination, USelectMenu } from "#components";
 import { useQueueJobs } from "../../composables/useQueueJobs";

package/dist/runtime/app/plugins/vueflow.client.js

@@ -1,4 +1,4 @@
-import { defineNuxtPlugin } from "#app";
+import { defineNuxtPlugin } from "#imports";
 import { VueFlow } from "@vue-flow/core";
 import { Controls } from "@vue-flow/controls";
 import { MiniMap } from "@vue-flow/minimap";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Nuxt queue service based on Bullmq",
   "repository": "DevJoghurt/nuxt-queue",
   "license": "MIT",