nvent 0.4.4 → 0.5.0

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

@@ -1,240 +0,0 @@
-import {
-  computed,
-  inject,
-  provide,
-  shallowRef,
-  useRoute,
-  useRouter,
-  watch,
-  defineAsyncComponent
-} from "#imports";
-export function useComponentRouter(opts) {
-  const CTX_KEY = "component-router";
-  if (!opts || !("routes" in opts) || !opts.routes) {
-    const key = opts?.provideKey ?? CTX_KEY;
-    const ctx = inject(key, null);
-    if (!ctx) {
-      console.warn(
-        "[useComponentRouter] No parent router context found. Ensure a parent uses useComponentRouter with routes or wrap children in <component-router>."
-      );
-      const emptyRoute = shallowRef({ path: "", params: {}, query: {} });
-      const warnNav = async (_p) => console.warn(
-        "[useComponentRouter] push/replace called without a parent router context."
-      );
-      const noopMake = (p, _params) => p;
-      const noopHref = (p, _params) => p;
-      return {
-        route: emptyRoute,
-        push: warnNav,
-        replace: warnNav,
-        makePath: noopMake,
-        makeHref: noopHref,
-        pushTo: async (p, _params) => warnNav(p),
-        replaceTo: async (p, _params) => warnNav(p),
-        component: void 0
-      };
-    }
-    return ctx;
-  }
-  const props = {
-    routes: Array.isArray(opts.routes) ? opts.routes : Object.entries(opts.routes || {}).map(([path, component2]) => ({
-      path,
-      component: component2
-    })),
-    base: opts.base ?? "fp",
-    mode: opts.mode ?? "query",
-    initial: opts.initial,
-    provideKey: opts.provideKey ?? CTX_KEY,
-    debug: opts.debug === true
-  };
-  const nuxtRoute = useRoute();
-  const nuxtRouter = useRouter();
-  const component = shallowRef(null);
-  const route = shallowRef({
-    path: "",
-    params: {},
-    query: {}
-  });
-  const dbg = (...args) => {
-    if (props.debug) console.info("[component-router]", ...args);
-  };
-  function esc(text) {
-    return text.replace(/([.+*?=^!${}()[\]|\\])/g, "\\$1");
-  }
-  function compilePattern(path) {
-    const keys = [];
-    const dyn = /\/:([^/]+)/g;
-    let last = 0;
-    let pattern = "";
-    let m;
-    while (m = dyn.exec(path)) {
-      pattern += esc(path.slice(last, m.index));
-      keys.push(m[1]);
-      pattern += "/([^/]+)";
-      last = m.index + m[0].length;
-    }
-    pattern += esc(path.slice(last));
-    const regex = new RegExp("^" + pattern + "$");
-    dbg("compiled", { path, pattern, regex, keys });
-    return { regex, keys };
-  }
-  const records = computed(
-    () => props.routes.map((r) => {
-      const { regex, keys } = compilePattern(r.path);
-      return { ...r, regex, keys };
-    })
-  );
-  function matchPath(path) {
-    dbg("matchPath", path);
-    for (const r of records.value) {
-      const m = r.regex.exec(path);
-      dbg(" try", r.path, r.regex, !!m);
-      if (m) {
-        const params = {};
-        r.keys.forEach(
-          (k, i) => params[k] = decodeURIComponent(m[i + 1] || "")
-        );
-        return { record: r, params };
-      }
-    }
-    return null;
-  }
-  function setCurrent(path) {
-    dbg("setCurrent", path);
-    const m = matchPath(path) || matchPath(props.routes[0]?.path || "/");
-    if (!m) return;
-    component.value = m.record.component;
-    const [pathOnly, queryString] = path.split("?");
-    const queryParams = {};
-    if (queryString) {
-      const params = new URLSearchParams(queryString);
-      params.forEach((value, key) => {
-        queryParams[key] = value;
-      });
-    }
-    route.value = {
-      path: pathOnly || path,
-      params: m.params,
-      query: queryParams
-      // Only use query params from the current path, not from nuxtRoute
-    };
-    dbg("current", route.value);
-  }
-  function readFromHost() {
-    if (props.mode === "query") {
-      const p = nuxtRoute.query?.[props.base];
-      dbg("readFromHost(query)", p);
-      return typeof p === "string" ? p : null;
-    }
-    if (props.mode === "hash") {
-      const h = (typeof window !== "undefined" ? window.location.hash : "") || "";
-      const key = `#${props.base}=`;
-      const idx = h.indexOf(key);
-      dbg("readFromHost(hash)", h);
-      return idx >= 0 ? h.slice(idx + key.length) : null;
-    }
-    return null;
-  }
-  async function writeToHost(path, replace2 = false) {
-    dbg("writeToHost", path, { replace: replace2, mode: props.mode });
-    if (props.mode === "query") {
-      const [pathOnly, queryString] = path.split("?");
-      const pathQuery = {};
-      if (queryString) {
-        const params = new URLSearchParams(queryString);
-        params.forEach((value, key) => {
-          pathQuery[key] = value;
-        });
-      }
-      const nextQuery = { [props.base]: pathOnly, ...pathQuery };
-      if (nuxtRoute.query?.[props.base] === pathOnly && !queryString) {
-        setCurrent(path);
-        return;
-      }
-      await (replace2 ? nuxtRouter.replace({ query: nextQuery }) : nuxtRouter.push({ query: nextQuery }));
-      return;
-    }
-    if (props.mode === "hash" && typeof window !== "undefined") {
-      const key = `#${props.base}=`;
-      const nextHash = key + path;
-      if (window.location.hash !== nextHash) {
-        if (replace2) {
-          const url = window.location.href.replace(/#.*/, "") + nextHash;
-          window.history.replaceState(null, "", url);
-        } else {
-          window.location.hash = nextHash;
-        }
-      }
-      setCurrent(path);
-      return;
-    }
-    setCurrent(path);
-  }
-  async function push(path) {
-    await writeToHost(path, false);
-  }
-  async function replace(path) {
-    await writeToHost(path, true);
-  }
-  function makePath(patternOrPath, params) {
-    const hasDyn = /:[^/]+/.test(patternOrPath);
-    if (!hasDyn) return patternOrPath;
-    const replaced = patternOrPath.replace(/:([^/]+)/g, (_m, key) => {
-      const v = params?.[key];
-      return encodeURIComponent(v == null ? "" : String(v));
-    });
-    return replaced.replace(/\/{2,}/g, "/");
-  }
-  function makeHref(patternOrPath, params) {
-    const path = makePath(patternOrPath, params);
-    if (props.mode === "query") return `?${props.base}=${path}`;
-    if (props.mode === "hash") return `#${props.base}=${path}`;
-    return path;
-  }
-  async function pushTo(patternOrPath, params) {
-    const path = makePath(patternOrPath, params);
-    await push(path);
-  }
-  async function replaceTo(patternOrPath, params) {
-    const path = makePath(patternOrPath, params);
-    await replace(path);
-  }
-  const exposed = { push, replace, route, makePath, makeHref, pushTo, replaceTo };
-  provide(props.provideKey, exposed);
-  const initialPath = readFromHost() || props.initial || props.routes[0]?.path || "/";
-  dbg("init", { initialPath });
-  writeToHost(initialPath, true);
-  watch(
-    () => ({
-      q: nuxtRoute.query?.[props.base],
-      h: typeof window !== "undefined" ? window.location.hash : ""
-    }),
-    () => {
-      const path = readFromHost();
-      dbg("watch change detected ->", path);
-      if (path) setCurrent(path);
-    }
-  );
-  return { component, route, push, replace, makePath, makeHref, pushTo, replaceTo };
-}
-export default useComponentRouter;
-export function createComponentRoutes(glob, options) {
-  const base = options?.base || "";
-  const toPath = (key) => {
-    let p = key.replace(/^\.\//, "/").replace(/\.(vue|tsx?|jsx?)$/, "");
-    p = p.replace(/\/index$/, "");
-    p = p.replace(/\[(.+?)\]/g, ":$1");
-    if (!p.startsWith("/")) p = "/" + p;
-    if (base) {
-      const b = base.startsWith("/") ? base : "/" + base;
-      p = (b + (p === "/" ? "" : p)).replace(/\/+/, "/");
-    }
-    return p || "/";
-  };
-  return Object.entries(glob).map(([key, loader]) => ({
-    path: toPath(key),
-    component: defineAsyncComponent(
-      () => loader().then((m) => m.default || m)
-    )
-  }));
-}

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

@@ -1,80 +0,0 @@
-import { type Ref } from 'vue';
-/**
- * Composable for managing a single flow run's timeline and state
- *
- * Simple approach: No HMR persistence, rely on component lifecycle + URL state
- * - URL preserves flowId/runId across HMR
- * - Component remounts after HMR with correct state
- * - Fresh WebSocket connection on each mount = clean, predictable behavior
- */
-export declare function useFlowRunTimeline(flowId: Ref<string>, runId: Ref<string>): {
-    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,68 +0,0 @@
-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();
-  const startStream = () => {
-    if (import.meta.server) return;
-    if (!flowId.value || !runId.value) {
-      return;
-    }
-    flowWs.subscribe({
-      flowName: flowId.value,
-      runId: runId.value,
-      onEvent: (eventData) => {
-        if (eventData?.record) {
-          flowState.addEvent(eventData.record);
-        }
-      },
-      onHistory: (events) => {
-        for (const eventData of events) {
-          if (eventData?.record) {
-            flowState.addEvent(eventData.record);
-          }
-        }
-      }
-    }, {
-      autoReconnect: true,
-      maxRetries: 5,
-      baseDelayMs: 500,
-      maxDelayMs: 5e3,
-      onError: (err) => {
-        console.warn("[FlowRunTimeline] WebSocket error:", err);
-      }
-    });
-  };
-  const stopStream = () => {
-    if (import.meta.server) return;
-    flowWs.stop();
-  };
-  const loadRun = async () => {
-    if (!runId.value) return;
-    flowState.reset();
-    await nextTick();
-    startStream();
-  };
-  watch(runId, async (newRunId, oldRunId) => {
-    if (oldRunId && oldRunId !== newRunId) {
-      stopStream();
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    if (newRunId) {
-      await loadRun();
-    } else {
-      stopStream();
-    }
-  }, { immediate: true });
-  onBeforeUnmount(() => {
-    stopStream();
-  });
-  return {
-    flowState,
-    isConnected: computed(() => flowWs.connected.value),
-    isReconnecting: computed(() => flowWs.reconnecting.value),
-    loadRun,
-    stopStream
-  };
-}

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

@@ -1,18 +0,0 @@
-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: Ref<FlowRun[] | null | undefined>;
-    refresh: () => Promise<void>;
-    status: Ref<'idle' | 'pending' | 'success' | 'error'>;
-    error: Ref<FetchError | null | undefined>;
-};
-export {};

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

@@ -1,32 +0,0 @@
-import { ref, watch, useFetch } from "#imports";
-export function useFlowRuns(flowId) {
-  const refreshCounter = ref(0);
-  const { data: runs, refresh: _refresh, status, error } = useFetch(
-    () => `/api/_flows/${encodeURIComponent(flowId.value)}/runs?_t=${refreshCounter.value}`,
-    {
-      immediate: false,
-      watch: false,
-      // Disable automatic watch to prevent SSR execution
-      server: false
-      // Client-only to avoid hydration issues
-      // Don't use a key - this prevents Nuxt from caching across calls
-    }
-  );
-  const refresh = async () => {
-    refreshCounter.value++;
-    await _refresh();
-  };
-  watch(flowId, (newFlow, oldFlow) => {
-    if (import.meta.client && newFlow) {
-      if (newFlow !== oldFlow || !runs.value) {
-        refresh();
-      }
-    }
-  }, { immediate: true });
-  return {
-    runs,
-    refresh,
-    status,
-    error
-  };
-}

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

@@ -1,24 +0,0 @@
-import { type Ref } from '#imports';
-/**
- * Composable for infinite scroll flow runs with pagination
- */
-export declare function useFlowRunsInfinite(flowId: Ref<string>): {
-    items: import("vue").ComputedRef<{
-        id: string;
-        flowName: string;
-        status: "running" | "completed" | "failed" | "unknown";
-        createdAt: string;
-        startedAt?: string | undefined;
-        completedAt?: string | undefined;
-        stepCount: number;
-        completedSteps: number;
-    }[]>;
-    total: import("vue").ComputedRef<number>;
-    loading: import("vue").ComputedRef<boolean>;
-    hasMore: import("vue").ComputedRef<boolean>;
-    error: import("vue").ComputedRef<Error | null>;
-    loadMore: () => void;
-    refresh: () => Promise<void>;
-    checkForNewRuns: () => Promise<void>;
-    reset: () => void;
-};

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

@@ -1,123 +0,0 @@
-import { ref, computed, watch } from "#imports";
-export function useFlowRunsInfinite(flowId) {
-  const items = ref([]);
-  const total = ref(0);
-  const offset = ref(0);
-  const limit = 50;
-  const loading = ref(false);
-  const hasMore = ref(true);
-  const error = ref(null);
-  const newestRunId = ref(null);
-  const reset = () => {
-    items.value = [];
-    total.value = 0;
-    offset.value = 0;
-    hasMore.value = true;
-    error.value = null;
-    newestRunId.value = null;
-  };
-  const fetchPage = async (resetData = false) => {
-    if (!flowId.value || loading.value) return;
-    if (resetData) {
-      reset();
-    }
-    if (!hasMore.value && !resetData) return;
-    try {
-      loading.value = true;
-      error.value = null;
-      const response = await $fetch(
-        `/api/_flows/${encodeURIComponent(flowId.value)}/runs`,
-        {
-          query: {
-            limit,
-            offset: resetData ? 0 : offset.value,
-            _t: Date.now()
-            // Cache busting
-          }
-        }
-      );
-      if (resetData) {
-        items.value = response.items;
-        offset.value = response.items.length;
-        if (response.items.length > 0) {
-          newestRunId.value = response.items[0].id;
-        }
-      } else {
-        items.value.push(...response.items);
-        offset.value += response.items.length;
-      }
-      total.value = response.total;
-      hasMore.value = response.hasMore;
-    } catch (err) {
-      console.error("[useFlowRunsInfinite] fetch error:", err);
-      error.value = err instanceof Error ? err : new Error(String(err));
-    } finally {
-      loading.value = false;
-    }
-  };
-  const loadMore = () => {
-    if (!loading.value && hasMore.value) {
-      fetchPage(false);
-    }
-  };
-  const refresh = async () => {
-    await fetchPage(true);
-  };
-  const checkForNewRuns = async () => {
-    if (!flowId.value || loading.value) return;
-    try {
-      const response = await $fetch(
-        `/api/_flows/${encodeURIComponent(flowId.value)}/runs`,
-        {
-          query: {
-            limit: Math.max(items.value.length, 10),
-            // Fetch at least as many as we have loaded
-            offset: 0,
-            _t: Date.now()
-          }
-        }
-      );
-      if (response.items.length === 0) return;
-      const latestRunId = response.items[0].id;
-      const updatedItems = [...items.value];
-      const newRuns = [];
-      for (const freshRun of response.items) {
-        const existingIndex = updatedItems.findIndex((r) => r.id === freshRun.id);
-        if (existingIndex >= 0) {
-          updatedItems[existingIndex] = freshRun;
-        } else {
-          newRuns.push(freshRun);
-        }
-      }
-      if (newRuns.length > 0) {
-        items.value = [...newRuns, ...updatedItems];
-        newestRunId.value = latestRunId;
-      } else {
-        items.value = updatedItems;
-      }
-      total.value = response.total;
-      if (!newestRunId.value) {
-        newestRunId.value = latestRunId;
-      }
-    } catch (err) {
-      console.error("[useFlowRunsInfinite] checkForNewRuns error:", err);
-    }
-  };
-  watch(flowId, (newFlow, oldFlow) => {
-    if (import.meta.client && newFlow && newFlow !== oldFlow) {
-      refresh();
-    }
-  }, { immediate: true });
-  return {
-    items: computed(() => items.value),
-    total: computed(() => total.value),
-    loading: computed(() => loading.value),
-    hasMore: computed(() => hasMore.value),
-    error: computed(() => error.value),
-    loadMore,
-    refresh,
-    checkForNewRuns,
-    // For polling - prepends new runs without resetting
-    reset
-  };
-}

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

@@ -1,9 +0,0 @@
-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: () => void;
-    resume: () => void;
-};

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

@@ -1,33 +0,0 @@
-import { watch, onBeforeUnmount } from "#imports";
-export function useFlowRunsPolling(refresh, shouldPoll, intervalMs = 3e3) {
-  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();
-    } else {
-      pause();
-    }
-  }, { immediate: true });
-  onBeforeUnmount(() => {
-    pause();
-  });
-  return {
-    pause,
-    resume
-  };
-}