nvent 0.4.3 → 0.4.5

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

@@ -1,122 +0,0 @@
-import { ref, computed, onUnmounted } from "#imports";
-export function useQueueUpdates(queueName) {
-  const ws = ref(null);
-  const isConnected = ref(false);
-  const isReconnecting = ref(false);
-  const state = ref({
-    counts: null,
-    lastEvent: null,
-    countsUpdatedAt: null,
-    shouldRefreshJobs: false
-  });
-  let reconnectTimeout = null;
-  let reconnectAttempts = 0;
-  const maxReconnectAttempts = 5;
-  const connect = () => {
-    if (!import.meta.client || !queueName.value) return;
-    if (ws.value) {
-      try {
-        ws.value.close();
-      } catch {
-      }
-      ws.value = null;
-    }
-    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-    const wsUrl = `${protocol}//${window.location.host}/api/_queues/ws`;
-    try {
-      const socket = new WebSocket(wsUrl);
-      ws.value = socket;
-      socket.onopen = () => {
-        console.log("[useQueueUpdates] connected");
-        isConnected.value = true;
-        isReconnecting.value = false;
-        reconnectAttempts = 0;
-        socket.send(JSON.stringify({
-          type: "subscribe",
-          queueName: queueName.value
-        }));
-      };
-      socket.onmessage = (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          if (message.type === "event") {
-            state.value.lastEvent = message.event;
-            const eventType = message.event?.eventType;
-            if (["waiting", "active", "completed", "failed"].includes(eventType)) {
-              state.value.shouldRefreshJobs = true;
-            }
-          } else if (message.type === "counts") {
-            state.value.counts = message.counts;
-            state.value.countsUpdatedAt = Date.now();
-          } else if (message.type === "error") {
-            console.error("[useQueueUpdates] error:", message.message);
-          }
-        } catch (err) {
-          console.error("[useQueueUpdates] parse error:", err);
-        }
-      };
-      socket.onerror = (error) => {
-        console.error("[useQueueUpdates] error:", error);
-      };
-      socket.onclose = () => {
-        console.log("[useQueueUpdates] disconnected");
-        isConnected.value = false;
-        if (reconnectAttempts < maxReconnectAttempts && queueName.value) {
-          isReconnecting.value = true;
-          reconnectAttempts++;
-          const delay = Math.min(1e3 * Math.pow(2, reconnectAttempts), 1e4);
-          reconnectTimeout = setTimeout(() => {
-            console.log(`[useQueueUpdates] reconnecting (attempt ${reconnectAttempts})...`);
-            connect();
-          }, delay);
-        } else {
-          isReconnecting.value = false;
-        }
-      };
-    } catch (err) {
-      console.error("[useQueueUpdates] connection error:", err);
-      isConnected.value = false;
-    }
-  };
-  const disconnect = () => {
-    if (reconnectTimeout) {
-      clearTimeout(reconnectTimeout);
-      reconnectTimeout = null;
-    }
-    if (ws.value) {
-      try {
-        if (ws.value.readyState === WebSocket.OPEN) {
-          ws.value.send(JSON.stringify({
-            type: "unsubscribe",
-            queueName: queueName.value
-          }));
-        }
-        ws.value.close();
-      } catch {
-      }
-      ws.value = null;
-    }
-    isConnected.value = false;
-    isReconnecting.value = false;
-  };
-  if (import.meta.client && queueName.value) {
-    connect();
-  }
-  onUnmounted(() => {
-    disconnect();
-  });
-  const resetRefreshFlag = () => {
-    state.value.shouldRefreshJobs = false;
-  };
-  return {
-    isConnected: computed(() => isConnected.value),
-    isReconnecting: computed(() => isReconnecting.value),
-    counts: computed(() => state.value.counts),
-    lastEvent: computed(() => state.value.lastEvent),
-    countsUpdatedAt: computed(() => state.value.countsUpdatedAt),
-    shouldRefreshJobs: computed(() => state.value.shouldRefreshJobs),
-    resetRefreshFlag,
-    connect,
-    disconnect
-  };
-}

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

@@ -1,44 +0,0 @@
-import type { FetchError } from 'ofetch';
-export interface QueueCounts {
-    active: number;
-    completed: number;
-    failed: number;
-    delayed: number;
-    waiting: number;
-    paused: number;
-}
-export interface QueueConfig {
-    queue: {
-        prefix?: string;
-        defaultJobOptions?: Record<string, any>;
-        limiter?: {
-            max?: number;
-            duration?: number;
-            groupKey?: string;
-        };
-    };
-    worker: {
-        concurrency?: number;
-        lockDurationMs?: number;
-        maxStalledCount?: number;
-        drainDelayMs?: number;
-        autorun?: boolean;
-        pollingIntervalMs?: number;
-    };
-}
-export interface QueueInfo {
-    name: string;
-    counts: QueueCounts;
-    isPaused: boolean;
-    config?: QueueConfig;
-}
-/**
- * Composable for fetching queue list with job counts
- * Client-only to avoid hydration mismatches
- */
-export declare function useQueues(): {
-    queues: globalThis.Ref<QueueInfo[] | null | undefined>;
-    refresh: () => Promise<void>;
-    status: globalThis.Ref<'idle' | 'pending' | 'success' | 'error'>;
-    error: globalThis.Ref<FetchError | null | undefined>;
-};

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

@@ -1,26 +0,0 @@
-import { ref, useFetch } from "#imports";
-export function useQueues() {
-  const refreshCounter = ref(0);
-  const { data: queues, refresh: _refresh, status, error } = useFetch(
-    () => `/api/_queues?_t=${refreshCounter.value}`,
-    {
-      immediate: false,
-      watch: false,
-      server: false
-      // Client-only
-    }
-  );
-  const refresh = async () => {
-    refreshCounter.value++;
-    await _refresh();
-  };
-  if (import.meta.client) {
-    refresh();
-  }
-  return {
-    queues,
-    refresh,
-    status,
-    error
-  };
-}

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

@@ -1,19 +0,0 @@
-import { type Ref } from '#imports';
-import type { QueueInfo, QueueCounts } from './useQueues.js';
-/**
- * Composable for live queue updates across all queues
- * Subscribes to WebSocket updates for multiple queues
- */
-export declare function useQueuesLive(queues: Ref<QueueInfo[] | null | undefined>): {
-    queues: import("vue").ComputedRef<{
-        counts: QueueCounts;
-        name: string;
-        isPaused: boolean;
-        config?: import("#imports").QueueConfig;
-    }[] | null>;
-    isConnected: import("vue").ComputedRef<boolean>;
-    isReconnecting: import("vue").ComputedRef<boolean>;
-    liveCounts: import("vue").ComputedRef<Record<string, QueueCounts>>;
-    connect: () => void;
-    disconnect: () => void;
-};

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

@@ -1,143 +0,0 @@
-import { ref, computed, watch, onUnmounted } from "#imports";
-export function useQueuesLive(queues) {
-  const ws = ref(null);
-  const isConnected = ref(false);
-  const isReconnecting = ref(false);
-  const liveCounts = ref({});
-  let reconnectTimeout = null;
-  let reconnectAttempts = 0;
-  const maxReconnectAttempts = 5;
-  const safeSend = (data) => {
-    if (!ws.value || ws.value.readyState !== WebSocket.OPEN) return false;
-    try {
-      ws.value.send(JSON.stringify(data));
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  const subscribeToQueues = (queueNames) => {
-    if (!ws.value || ws.value.readyState !== WebSocket.OPEN) return;
-    for (const queueName of queueNames) {
-      safeSend({
-        type: "subscribe",
-        queueName
-      });
-    }
-  };
-  const connect = () => {
-    if (!import.meta.client) return;
-    if (ws.value) {
-      try {
-        ws.value.close();
-      } catch {
-      }
-      ws.value = null;
-    }
-    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-    const wsUrl = `${protocol}//${window.location.host}/api/_queues/ws`;
-    try {
-      const socket = new WebSocket(wsUrl);
-      ws.value = socket;
-      socket.onopen = () => {
-        console.log("[useQueuesLive] connected");
-        isConnected.value = true;
-        isReconnecting.value = false;
-        reconnectAttempts = 0;
-        if (queues.value) {
-          const queueNames = queues.value.map((q) => q.name);
-          subscribeToQueues(queueNames);
-        }
-      };
-      socket.onmessage = (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          if (message.type === "counts" && message.queueName) {
-            liveCounts.value[message.queueName] = message.counts;
-          } else if (message.type === "error") {
-            console.error("[useQueuesLive] error:", message.message);
-          }
-        } catch (err) {
-          console.error("[useQueuesLive] parse error:", err);
-        }
-      };
-      socket.onerror = (error) => {
-        console.error("[useQueuesLive] error:", error);
-      };
-      socket.onclose = () => {
-        console.log("[useQueuesLive] disconnected");
-        isConnected.value = false;
-        if (reconnectAttempts < maxReconnectAttempts) {
-          isReconnecting.value = true;
-          reconnectAttempts++;
-          const delay = Math.min(1e3 * Math.pow(2, reconnectAttempts), 1e4);
-          reconnectTimeout = setTimeout(() => {
-            console.log(`[useQueuesLive] reconnecting (attempt ${reconnectAttempts})...`);
-            connect();
-          }, delay);
-        } else {
-          isReconnecting.value = false;
-        }
-      };
-    } catch (err) {
-      console.error("[useQueuesLive] connection error:", err);
-      isConnected.value = false;
-    }
-  };
-  const disconnect = () => {
-    if (reconnectTimeout) {
-      clearTimeout(reconnectTimeout);
-      reconnectTimeout = null;
-    }
-    if (ws.value) {
-      try {
-        if (queues.value) {
-          for (const queue of queues.value) {
-            safeSend({
-              type: "unsubscribe",
-              queueName: queue.name
-            });
-          }
-        }
-        ws.value.close();
-      } catch {
-      }
-      ws.value = null;
-    }
-    isConnected.value = false;
-    isReconnecting.value = false;
-  };
-  if (import.meta.client) {
-    connect();
-  }
-  watch(
-    () => queues.value,
-    (newQueues, oldQueues) => {
-      if (!newQueues || !ws.value || ws.value.readyState !== WebSocket.OPEN) return;
-      const oldNames = new Set(oldQueues?.map((q) => q.name) || []);
-      const newNames = newQueues.map((q) => q.name);
-      const toSubscribe = newNames.filter((name) => !oldNames.has(name));
-      if (toSubscribe.length > 0) {
-        subscribeToQueues(toSubscribe);
-      }
-    }
-  );
-  onUnmounted(() => {
-    disconnect();
-  });
-  const queuesWithLiveCounts = computed(() => {
-    if (!queues.value) return null;
-    return queues.value.map((queue) => ({
-      ...queue,
-      counts: liveCounts.value[queue.name] || queue.counts
-    }));
-  });
-  return {
-    queues: queuesWithLiveCounts,
-    isConnected: computed(() => isConnected.value),
-    isReconnecting: computed(() => isReconnecting.value),
-    liveCounts: computed(() => liveCounts.value),
-    connect,
-    disconnect
-  };
-}

package/dist/runtime/app/pages/flows/index.d.vue.ts

@@ -1,3 +0,0 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;