@piwitests/server 0.22.1 → 0.24.0

package/.output/server/chunks/build/useDesktopLocalRuns-k7Gw3Fv3.mjs

@@ -0,0 +1,319 @@
+import { e as escapeGrep, t as toPosixPath } from './useOpenInIde-D74FmDNg.mjs';
+import { J as useState } from './server.mjs';
+import { computed } from 'vue';
+import { t as tauriCore, a as tauriEvent } from './useTauri-Kf3HE_42.mjs';
+import { e as errorMessage } from './index-ByWTzqF6.mjs';
+
+const RUN_MODE_FLAGS = {
+  normal: [],
+  headed: ["--headed"],
+  debug: ["--debug"],
+  ui: ["--ui"]
+};
+function groupByProject(cases) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of cases) {
+    const key = c.projectName || "";
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(c);
+  }
+  return groups;
+}
+function specArgs(cases, mode) {
+  if (mode === "grep") {
+    const escaped = cases.map((c) => escapeGrep(c.title));
+    return ["--grep", escaped.length === 1 ? escaped[0] : `(${escaped.join("|")})`];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const specs = [];
+  for (const c of cases) {
+    const spec = mode === "file-line" && c.line ? `${toPosixPath(c.filePath)}:${c.line}` : toPosixPath(c.filePath);
+    if (seen.has(spec)) continue;
+    seen.add(spec);
+    specs.push(spec);
+  }
+  return specs;
+}
+function displayArg(arg) {
+  return /[\s"'()|]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
+}
+function buildLocalRunPlan(cases, options = {}) {
+  if (cases.length === 0) return [];
+  const mode = options.mode ?? "file-line";
+  const runMode = options.runMode ?? "normal";
+  const repeatEach = Math.min(1e3, Math.max(1, Math.floor(options.repeatEach ?? 1)));
+  const steps = [];
+  for (const [project, projectCases] of groupByProject(cases)) {
+    const args = specArgs(projectCases, mode);
+    if (project) args.push(`--project=${project}`);
+    args.push(...RUN_MODE_FLAGS[runMode]);
+    if (options.trace) args.push("--trace=on");
+    if (repeatEach > 1) args.push(`--repeat-each=${repeatEach}`);
+    steps.push({ args, display: ["playwright", "test", ...args.map(displayArg)].join(" ") });
+  }
+  return steps;
+}
+function localRunProgressLabel(run) {
+  if (run.progressTotal) return `Running ${run.progressDone}/${run.progressTotal}…`;
+  return run.steps.length > 1 ? `Running ${run.stepIndex + 1}/${run.steps.length}…` : "Running…";
+}
+const DEFAULT_LOCAL_RUN_OPTIONS = {
+  mode: "file-line",
+  runMode: "normal",
+  trace: false,
+  repeatEach: 1
+};
+const LOCAL_RUN_MODE_ITEMS = [
+  { label: "Headless", value: "normal", icon: "i-lucide-square-terminal" },
+  { label: "Headed", value: "headed", icon: "i-lucide-app-window" },
+  { label: "Debug (inspector)", value: "debug", icon: "i-lucide-bug" },
+  { label: "UI mode", value: "ui", icon: "i-lucide-layout-grid" }
+];
+const RETRY_MODE_ITEMS = [
+  { label: "File:line", value: "file-line" },
+  { label: "Title (grep)", value: "grep" },
+  { label: "File only", value: "file" }
+];
+const MAX_LINES = 2e3;
+const MAX_FINISHED = 15;
+const OPTIONS_STORAGE_KEY = "piwi:desktop-local-run-options";
+let nextKey = 1;
+let unlisten = null;
+let startingSteps = 0;
+let pendingEvents = [];
+const runByShellId = /* @__PURE__ */ new Map();
+const exitResolvers = /* @__PURE__ */ new Map();
+const PROGRESS_TOTAL_RE = /^Running (\d+) tests? using \d+ workers?$/;
+const PROGRESS_RESULT_RE = /^\s{1,6}(?:✓|✘|✗|x|ok|-)\s+\d+\s/;
+function useDesktopLocalRuns() {
+  const runs = useState("desktop-local-runs", () => []);
+  const trayOpen = useState("desktop-local-runs-tray", () => false);
+  const optionsByProject = useState("desktop-local-run-options", () => ({}));
+  const activeCount = computed(() => runs.value.filter((r) => r.status === "running").length);
+  function getProjectOptions(projectId) {
+    return { ...DEFAULT_LOCAL_RUN_OPTIONS, ...optionsByProject.value[String(projectId)] };
+  }
+  function saveProjectOptions(projectId, patch) {
+    const next = { ...getProjectOptions(projectId), ...patch };
+    optionsByProject.value = { ...optionsByProject.value, [String(projectId)]: next };
+    try {
+      localStorage.setItem(OPTIONS_STORAGE_KEY, JSON.stringify(optionsByProject.value));
+    } catch {
+    }
+  }
+  function pushLine(run, text, error) {
+    run.lines.push({ text, error });
+    if (run.lines.length > MAX_LINES) run.lines.splice(0, run.lines.length - MAX_LINES);
+    if (error) return;
+    const total = PROGRESS_TOTAL_RE.exec(text);
+    if (total) {
+      run.progressTotal = (run.progressTotal ?? 0) + Number(total[1]);
+    } else if (PROGRESS_RESULT_RE.test(text)) {
+      run.progressDone = Math.min(run.progressDone + 1, run.progressTotal ?? run.progressDone + 1);
+    }
+  }
+  function dispatch(run, payload) {
+    if (payload.kind === "exit") {
+      exitResolvers.get(payload.id)?.(payload.code);
+      return;
+    }
+    pushLine(run, payload.line ?? "", payload.kind !== "stdout");
+  }
+  async function ensureListener() {
+    if (unlisten) return;
+    const events = tauriEvent();
+    if (!events) throw new Error("The desktop bridge is unavailable.");
+    unlisten = await events.listen("piwi:local-run", ({ payload }) => {
+      const run = runByShellId.get(payload.id);
+      if (run) dispatch(run, payload);
+      else if (startingSteps > 0) pendingEvents.push(payload);
+    });
+  }
+  async function runStep(run, step) {
+    const core = tauriCore();
+    if (!core) throw new Error("The desktop bridge is unavailable.");
+    startingSteps += 1;
+    let shellId;
+    try {
+      shellId = await core.invoke("desktop_run_local_tests", {
+        projectId: run.projectId,
+        args: step.args
+      });
+    } catch (error) {
+      startingSteps -= 1;
+      throw error;
+    }
+    const exit = new Promise((resolve) => exitResolvers.set(shellId, resolve));
+    runByShellId.set(shellId, run);
+    run.shellId = shellId;
+    const mine = pendingEvents.filter((p) => p.id === shellId);
+    pendingEvents = startingSteps > 1 ? pendingEvents.filter((p) => p.id !== shellId) : [];
+    startingSteps -= 1;
+    for (const payload of mine) dispatch(run, payload);
+    const code = await exit;
+    runByShellId.delete(shellId);
+    exitResolvers.delete(shellId);
+    run.shellId = null;
+    return code;
+  }
+  async function drive(run) {
+    try {
+      await ensureListener();
+      let worst = 0;
+      for (const [index, step] of run.steps.entries()) {
+        if (run.stopRequested) break;
+        run.stepIndex = index;
+        if (run.steps.length > 1) pushLine(run, `$ ${step.display}`, false);
+        const code = await runStep(run, step);
+        if (run.stopRequested) break;
+        if (code !== 0) worst = code ?? 1;
+      }
+      if (run.stopRequested) {
+        run.status = "stopped";
+      } else {
+        run.exitCode = typeof worst === "number" ? worst : 1;
+        run.status = worst === 0 ? "passed" : "failed";
+      }
+    } catch (error) {
+      pushLine(run, errorMessage(error), true);
+      run.status = "error";
+    } finally {
+      run.finishedAt = Date.now();
+      notifyFinished(run);
+      trimFinished();
+    }
+  }
+  function notifyFinished(run) {
+    if (run.status === "stopped") return;
+    const label = run.projectLabel || "Local run";
+    const tests = `${run.cases.length} test${run.cases.length === 1 ? "" : "s"}`;
+    const seconds = Math.max(1, Math.round(((run.finishedAt ?? Date.now()) - run.startedAt) / 1e3));
+    notifyUnfocused(run, label, tests, seconds);
+    run.piwiRunId == null ? [] : [
+      {
+        label: `Open run #${run.piwiRunId}`,
+        color: "neutral",
+        variant: "outline",
+        onClick: () => {
+        }
+      }
+    ];
+    if (run.status === "passed") ;
+    else if (run.status === "failed") ;
+    else ;
+  }
+  function notifyUnfocused(run, label, tests, seconds) {
+    if (typeof Notification === "undefined" || Notification.permission !== "granted") return;
+    if (!(void 0).hidden && (void 0).hasFocus()) return;
+    const title = run.status === "passed" ? "Local run passed" : run.status === "failed" ? "Local run failed" : "Local run could not start";
+    const body = run.status === "failed" ? `${label} — exit ${run.exitCode ?? 1} after ${seconds}s` : `${label} — ${tests} in ${seconds}s`;
+    try {
+      new Notification(title, { body });
+    } catch {
+    }
+  }
+  function trimFinished() {
+    const finished = runs.value.filter((r) => r.status !== "running");
+    if (finished.length <= MAX_FINISHED) return;
+    const drop = new Set(finished.slice(MAX_FINISHED).map((r) => r.key));
+    runs.value = runs.value.filter((r) => !drop.has(r.key));
+  }
+  function startRun(input) {
+    if (!tauriCore() || input.cases.length === 0) return null;
+    const options = { ...getProjectOptions(input.projectId), ...input.options };
+    const steps = buildLocalRunPlan(input.cases, options);
+    if (steps.length === 0) return null;
+    if (input.persistOptions !== false) saveProjectOptions(input.projectId, options);
+    const run = {
+      key: nextKey++,
+      projectId: String(input.projectId),
+      projectLabel: input.projectLabel ?? null,
+      cases: input.cases.map((c) => ({ ...c })),
+      options,
+      steps,
+      stepIndex: 0,
+      status: "running",
+      lines: [],
+      exitCode: null,
+      startedAt: Date.now(),
+      finishedAt: null,
+      shellId: null,
+      stopRequested: false,
+      progressTotal: null,
+      progressDone: 0,
+      piwiRunId: null,
+      piwiRunBaseline: null
+    };
+    runs.value = [run, ...runs.value];
+    const tracked = runs.value[0];
+    trayOpen.value = true;
+    void captureBaseline(tracked);
+    void drive(tracked);
+    return tracked;
+  }
+  async function captureBaseline(run) {
+    try {
+      const latest = await $fetch(`/api/projects/${run.projectId}/latest-run`);
+      run.piwiRunBaseline = latest?.id ?? 0;
+    } catch {
+    }
+  }
+  async function correlatePiwiRuns() {
+    const cutoff = Date.now() - 2 * 6e4;
+    for (const run of runs.value) {
+      if (run.piwiRunId != null || run.piwiRunBaseline == null) continue;
+      if (run.status !== "running" && (run.finishedAt ?? 0) < cutoff) continue;
+      try {
+        const latest = await $fetch(`/api/projects/${run.projectId}/latest-run`);
+        if (latest && latest.id > run.piwiRunBaseline) run.piwiRunId = latest.id;
+      } catch {
+      }
+    }
+  }
+  function rerun(run) {
+    return startRun({
+      projectId: run.projectId,
+      projectLabel: run.projectLabel,
+      cases: run.cases,
+      options: run.options,
+      persistOptions: false
+    });
+  }
+  async function stopRun(run) {
+    if (run.status !== "running") return;
+    run.stopRequested = true;
+    const core = tauriCore();
+    const shellId = run.shellId;
+    if (core && shellId != null) {
+      try {
+        await core.invoke("desktop_stop_local_tests", { runId: shellId });
+      } catch {
+      }
+      exitResolvers.get(shellId)?.(null);
+    }
+  }
+  function clearFinished() {
+    runs.value = runs.value.filter((r) => r.status === "running");
+  }
+  function latestForProject(projectId) {
+    if (projectId == null) return void 0;
+    const id = String(projectId);
+    return runs.value.find((r) => r.projectId === id);
+  }
+  return {
+    runs,
+    trayOpen,
+    activeCount,
+    startRun,
+    rerun,
+    stopRun,
+    clearFinished,
+    latestForProject,
+    getProjectOptions,
+    saveProjectOptions,
+    correlatePiwiRuns
+  };
+}
+
+export { LOCAL_RUN_MODE_ITEMS as L, RETRY_MODE_ITEMS as R, buildLocalRunPlan as b, localRunProgressLabel as l, useDesktopLocalRuns as u };
+//# sourceMappingURL=useDesktopLocalRuns-k7Gw3Fv3.mjs.map

package/.output/server/chunks/build/useDesktopLocalRuns-k7Gw3Fv3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDesktopLocalRuns-k7Gw3Fv3.mjs","sources":["../../../../node_modules/.cache/nuxt/.nuxt/dist/server/_nuxt/useDesktopLocalRuns-k7Gw3Fv3.js"],"names":[],"mappings":"","x_google_ignoreList":[0]}

package/.output/server/chunks/build/useDesktopProjectLink-WwLte59P.mjs

@@ -0,0 +1,67 @@
+import { t as tauriCore } from './useTauri-Kf3HE_42.mjs';
+import { j as useToast } from './server.mjs';
+import { ref, watch, toValue } from 'vue';
+import { e as errorMessage } from './index-ByWTzqF6.mjs';
+
+async function getDesktopProjectLink(projectId) {
+  const core = tauriCore();
+  if (!core || projectId == null || projectId === "") return null;
+  try {
+    return await core.invoke("desktop_get_project_link", {
+      projectId: String(projectId)
+    });
+  } catch {
+    return null;
+  }
+}
+function useDesktopProjectLink(projectId) {
+  const toast = useToast();
+  const available = ref(false);
+  const link = ref(null);
+  const busy = ref(false);
+  async function refresh() {
+    link.value = await getDesktopProjectLink(toValue(projectId));
+  }
+  watch(
+    () => toValue(projectId),
+    () => {
+      if (available.value) void refresh();
+    }
+  );
+  async function pickAndLink() {
+    const core = tauriCore();
+    const id = toValue(projectId);
+    if (!core || id == null || id === "") return false;
+    busy.value = true;
+    try {
+      const path = await core.invoke("desktop_pick_folder");
+      if (!path) return false;
+      await core.invoke("desktop_set_project_link", { projectId: String(id), path });
+      await refresh();
+      return true;
+    } catch (error) {
+      toast.add({ title: "Could not link the folder", description: errorMessage(error), color: "error" });
+      return false;
+    } finally {
+      busy.value = false;
+    }
+  }
+  async function unlink() {
+    const core = tauriCore();
+    const id = toValue(projectId);
+    if (!core || id == null || id === "") return;
+    busy.value = true;
+    try {
+      await core.invoke("desktop_set_project_link", { projectId: String(id), path: null });
+      link.value = null;
+    } catch (error) {
+      toast.add({ title: "Could not unlink the folder", description: errorMessage(error), color: "error" });
+    } finally {
+      busy.value = false;
+    }
+  }
+  return { available, link, busy, refresh, pickAndLink, unlink };
+}
+
+export { useDesktopProjectLink as u };
+//# sourceMappingURL=useDesktopProjectLink-WwLte59P.mjs.map

package/.output/server/chunks/build/useDesktopProjectLink-WwLte59P.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDesktopProjectLink-WwLte59P.mjs","sources":["../../../../node_modules/.cache/nuxt/.nuxt/dist/server/_nuxt/useDesktopProjectLink-WwLte59P.js"],"names":[],"mappings":"","x_google_ignoreList":[0]}

package/.output/server/chunks/build/{useFormControl-CZ9So7iX.mjs → useFormControl-8skMOTIf.mjs}

@@ -1,9 +1,9 @@
 import { computed, toValue } from 'vue';
-import { aI as unrefElement } from './server.mjs';
+import { aK as unrefElement } from './server.mjs';
 
 function useFormControl(el) {
   return computed(() => toValue(el) ? Boolean(unrefElement(el)?.closest("form")) : true);
 }
 
 export { useFormControl as u };
-//# sourceMappingURL=useFormControl-CZ9So7iX.mjs.map
+//# sourceMappingURL=useFormControl-8skMOTIf.mjs.map

package/.output/server/chunks/build/useFormControl-8skMOTIf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormControl-8skMOTIf.mjs","sources":["../../../../node_modules/.cache/nuxt/.nuxt/dist/server/_nuxt/useFormControl-8skMOTIf.js"],"names":[],"mappings":"","x_google_ignoreList":[0]}

package/.output/server/chunks/build/{useOpenInIde--6Me0WlL.mjs → useOpenInIde-D74FmDNg.mjs}

@@ -1,4 +1,4 @@
-import { L as useLocalStorage, j as useToast, J as useState } from './server.mjs';
+import { N as useLocalStorage, j as useToast, J as useState } from './server.mjs';
 import { computed } from 'vue';
 
 const MAX_CMD_LENGTH = 4096;
@@ -182,4 +182,4 @@ function useOpenInIde() {
 }
 
 export { IDE_METHOD_LABELS as I, JETBRAINS_PRODUCTS as J, VSCODE_SCHEME_LABELS as V, buildRetryCommand as b, escapeGrep as e, toPosixPath as t, useOpenInIde as u };
-//# sourceMappingURL=useOpenInIde--6Me0WlL.mjs.map
+//# sourceMappingURL=useOpenInIde-D74FmDNg.mjs.map

package/.output/server/chunks/build/useOpenInIde-D74FmDNg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOpenInIde-D74FmDNg.mjs","sources":["../../../../node_modules/.cache/nuxt/.nuxt/dist/server/_nuxt/useOpenInIde-D74FmDNg.js"],"names":[],"mappings":"","x_google_ignoreList":[0]}

package/.output/server/chunks/build/{users-IdmY9JZV.mjs → users-C9bjOBde.mjs}

@@ -1,15 +1,15 @@
-import { _ as _sfc_main$1 } from './Alert-DAb8nKVs.mjs';
-import { _ as __nuxt_component_11 } from './SectionCard-C753B3Yo.mjs';
+import { _ as _sfc_main$1 } from './Alert-He-UxEt6.mjs';
+import { _ as __nuxt_component_11 } from './SectionCard-DHAFvJxm.mjs';
 import { j as useToast, x as useAuth, m as _sfc_main$k, n as _sfc_main$7, o as _sfc_main$p, s as __nuxt_component_7, r as useRuntimeConfig } from './server.mjs';
 import { _ as __nuxt_component_3 } from './TableScroller-DMcdCVrH.mjs';
-import { _ as _sfc_main$2 } from './Table-CfDVAuUJ.mjs';
+import { _ as _sfc_main$2 } from './Table-qZdnm9t2.mjs';
 import { p as prettyDateFormat, w as createSortHeader } from './index-ByWTzqF6.mjs';
 import { defineComponent, withAsyncContext, computed, ref, reactive, unref, withCtx, createVNode, openBlock, createBlock, createCommentVNode, toDisplayString, createTextVNode, useSSRContext } from 'vue';
 import { ssrRenderComponent, ssrInterpolate } from 'vue/server-renderer';
 import { z } from 'zod';
-import { u as useFetch, a as useCopy } from './fetch-Be-j7hF1.mjs';
+import { u as useFetch, a as useCopy } from './fetch-tkz5_OA-.mjs';
 import './Card--Ike7sYc.mjs';
-import './HelpHint-C5Ru8BCc.mjs';
+import './HelpHint-plioHKA0.mjs';
 import './help-content-C876a9WD.mjs';
 import '../nitro/nitro.mjs';
 import 'node:crypto';
@@ -744,4 +744,4 @@ _sfc_main.setup = (props, ctx) => {
 };
 
 export { _sfc_main as default };
-//# sourceMappingURL=users-IdmY9JZV.mjs.map
+//# sourceMappingURL=users-C9bjOBde.mjs.map

package/.output/server/chunks/build/users-C9bjOBde.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"users-C9bjOBde.mjs","sources":["../../../../node_modules/.cache/nuxt/.nuxt/dist/server/_nuxt/users-C9bjOBde.js"],"names":["_sfc_main$3","_sfc_main$5","_sfc_main$4"],"mappings":"","x_google_ignoreList":[0]}