@revenexx/studio-integrations 3.7.1 → 3.8.1

package/dist/runtime/utils/canvasFit.js

@@ -0,0 +1,78 @@
+const PADDING = 0.2;
+const MIN_SIDE = 160;
+function width(b) {
+  return b.right - b.left;
+}
+function height(b) {
+  return b.bottom - b.top;
+}
+function overlaps(a, b) {
+  return a.left < b.right && b.left < a.right && a.top < b.bottom && b.top < a.bottom;
+}
+function contains(outer, inner) {
+  return outer.left <= inner.left && outer.top <= inner.top && outer.right >= inner.right && outer.bottom >= inner.bottom;
+}
+function sidePadding(length) {
+  return Math.floor((length - length / (1 + PADDING)) * 0.5);
+}
+export function freeRectangles(canvas, panels) {
+  let free = [canvas];
+  for (const raw of panels) {
+    const panel = {
+      left: Math.max(raw.left, canvas.left),
+      top: Math.max(raw.top, canvas.top),
+      right: Math.min(raw.right, canvas.right),
+      bottom: Math.min(raw.bottom, canvas.bottom)
+    };
+    if (width(panel) <= 0 || height(panel) <= 0) continue;
+    const next = [];
+    for (const r of free) {
+      if (!overlaps(r, panel)) {
+        next.push(r);
+        continue;
+      }
+      if (panel.left > r.left) next.push({ ...r, right: panel.left });
+      if (panel.right < r.right) next.push({ ...r, left: panel.right });
+      if (panel.top > r.top) next.push({ ...r, bottom: panel.top });
+      if (panel.bottom < r.bottom) next.push({ ...r, top: panel.bottom });
+    }
+    free = next.filter((r, i) => !next.some((o, j) => j !== i && contains(o, r) && (!contains(r, o) || j < i)));
+  }
+  return free;
+}
+function zoomInto(area, drawing, minZoom, maxZoom) {
+  const w = width(area) - 2 * sidePadding(width(area));
+  const h = height(area) - 2 * sidePadding(height(area));
+  const zoom = Math.min(w / Math.max(drawing.width, 1), h / Math.max(drawing.height, 1));
+  return Math.min(maxZoom, Math.max(minZoom, zoom));
+}
+const CENTRAL_SHARE = 0.75;
+export function fitArea(canvas, panels, drawing, minZoom, maxZoom) {
+  const free = freeRectangles(canvas, panels).filter((r) => width(r) > 0 && height(r) > 0);
+  const roomy = free.filter((r) => width(r) >= MIN_SIDE && height(r) >= MIN_SIDE);
+  const usable = roomy.length ? roomy : free;
+  if (!usable.length) return canvas;
+  const zooms = usable.map((r) => zoomInto(r, drawing, minZoom, maxZoom));
+  const floor = Math.max(...zooms) * CENTRAL_SHARE - 1e-6;
+  const cx = (canvas.left + canvas.right) / 2;
+  const cy = (canvas.top + canvas.bottom) / 2;
+  const offCentre = (r) => Math.hypot((r.left + r.right) / 2 - cx, (r.top + r.bottom) / 2 - cy);
+  let best = null;
+  for (const [i, r] of usable.entries()) {
+    if (zooms[i] < floor) continue;
+    if (best === null || offCentre(r) < offCentre(best) - 1e-6 || Math.abs(offCentre(r) - offCentre(best)) <= 1e-6 && width(r) * height(r) > width(best) * height(best)) {
+      best = r;
+    }
+  }
+  return best ?? canvas;
+}
+export function paddingFor(canvas, area) {
+  const padX = sidePadding(width(area));
+  const padY = sidePadding(height(area));
+  return {
+    top: `${area.top - canvas.top + padY}px`,
+    right: `${canvas.right - area.right + padX}px`,
+    bottom: `${canvas.bottom - area.bottom + padY}px`,
+    left: `${area.left - canvas.left + padX}px`
+  };
+}

package/dist/runtime/utils/executionMode.d.ts

@@ -0,0 +1,18 @@
+import type { WorkflowExecutionMode } from '../types/integrations.js';
+/**
+ * The message key that names an execution mode in a compact badge (PO-615).
+ *
+ * Two surfaces say it: the Mode column of the workflows list and the badge beside
+ * the name in a workflow's header. They used to read two sets of keys, and so the
+ * list wrote "ASYNC" where the header wrote "Asynchron" for the same workflow. One
+ * function keeps the word in one place — the lesson `triggerTypeLabel` was written
+ * on. Caller decides has no shorter form than its choice label, so both surfaces
+ * use that.
+ *
+ * A mode the studio does not know yet — or none at all — has no key: the caller
+ * decides what an unknown mode reads as, because the list shows a dash where the
+ * header falls back to the default mode.
+ */
+export declare function executionModeLabelKey(mode: WorkflowExecutionMode | string | null | undefined): string | null;
+/** The short word for an execution mode in the reader's language, or `fallback` for one without a key. */
+export declare function executionModeLabel(mode: WorkflowExecutionMode | string | null | undefined, fallback?: string): string;

package/dist/runtime/utils/executionMode.js

@@ -0,0 +1,17 @@
+import { useIntegrationsT } from "../composables/useIntegrationsT.js";
+export function executionModeLabelKey(mode) {
+  switch (mode) {
+    case "async_only":
+      return "integration.editor.executionMode.async.short";
+    case "sync_only":
+      return "integration.editor.executionMode.sync.short";
+    case "caller_decides":
+      return "integration.editor.executionMode.callerDecides.label";
+    default:
+      return null;
+  }
+}
+export function executionModeLabel(mode, fallback = "\u2014") {
+  const key = executionModeLabelKey(mode);
+  return key ? useIntegrationsT()(key) : fallback;
+}

package/dist/runtime/utils/optionSearch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Narrowing a list of options to what an operator typed, and ordering what is
+ * left by how well it matches (PO-650).
+ *
+ * An option has a label the operator reads and a value the platform stores —
+ * often a code (`EN-US`, `DE`). A term is first a guess at the start of one of
+ * them, and only after that something the label merely contains: "EN" is meant
+ * as English, not as the middle of "Armenisch". So the order is
+ *
+ *   1. the value starts with the term,
+ *   2. the label starts with it,
+ *   3. a word of the label starts with it,
+ *   4. the label or the value contains it,
+ *   5. every word of it is in the label, in any order ("Roth Carl"),
+ *
+ * and an option that matches none of them is not offered. Within a rank the
+ * options keep the order they came in, which is the order the platform chose.
+ */
+/**
+ * The options that match `term`, best match first. An empty term (or one of
+ * blanks) leaves the list as it is; a term nothing matches leaves it empty —
+ * never the whole list, which is what an operator would read as "matches".
+ */
+export declare function narrowOptions<T>(options: readonly T[], term: string, labelOf: (option: T) => string, valueOf: (option: T) => string): T[];

package/dist/runtime/utils/optionSearch.js

@@ -0,0 +1,31 @@
+var Rank = /* @__PURE__ */ ((Rank2) => {
+  Rank2[Rank2["ValuePrefix"] = 0] = "ValuePrefix";
+  Rank2[Rank2["LabelPrefix"] = 1] = "LabelPrefix";
+  Rank2[Rank2["WordPrefix"] = 2] = "WordPrefix";
+  Rank2[Rank2["Contains"] = 3] = "Contains";
+  Rank2[Rank2["AllWords"] = 4] = "AllWords";
+  return Rank2;
+})(Rank || {});
+function words(label) {
+  return label.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+function rankOf(label, value, term) {
+  if (value.startsWith(term)) return 0 /* ValuePrefix */;
+  if (label.startsWith(term)) return 1 /* LabelPrefix */;
+  if (words(label).some((word) => word.startsWith(term))) return 2 /* WordPrefix */;
+  if (label.includes(term) || value.includes(term)) return 3 /* Contains */;
+  const termWords = words(term);
+  if (termWords.length > 1 && termWords.every((word) => label.includes(word))) return 4 /* AllWords */;
+  return void 0;
+}
+export function narrowOptions(options, term, labelOf, valueOf) {
+  const needle = term.trim().toLocaleLowerCase();
+  if (!needle) return [...options];
+  const ranked = [];
+  options.forEach((option, index) => {
+    const rank = rankOf(labelOf(option).toLocaleLowerCase(), valueOf(option).toLocaleLowerCase(), needle);
+    if (rank !== void 0) ranked.push({ option, rank, index });
+  });
+  ranked.sort((a, b) => a.rank - b.rank || a.index - b.index);
+  return ranked.map((r) => r.option);
+}

package/dist/runtime/utils/runFailure.d.ts

@@ -0,0 +1,37 @@
+import type { RunStepRow } from '../types/integrations.js';
+/**
+ * Why a run failed, in the two parts an author reads it by (PO-690): the step
+ * it failed at, named the way the canvas names it, and the cause in the step's
+ * own words.
+ *
+ * Either may be missing. The step is unknown until the run's steps have been read,
+ * and stays unknown where they cannot be; the cause then falls back to what the run
+ * itself recorded, which is less precise but is still the platform's reason.
+ */
+export interface RunFailure {
+    step: string | null;
+    cause: string | null;
+}
+/** A node as the blob carries it, enough to look a step's node up by id and name it. */
+export interface FailureNode {
+    id: string;
+    name?: unknown;
+    nodeSlug: string;
+    nodeVersion?: string;
+}
+/** Whether a run, as the platform reports it, ended in failure. */
+export declare function isFailedRun(run: {
+    status?: unknown;
+} | null | undefined): boolean;
+/** A reason that is text with something in it, or nothing. */
+export declare function reasonText(value: unknown): string | null;
+/**
+ * The failure read off a run's steps, with `fallbackCause` where no step says why.
+ *
+ * The LAST failed row is the one taken: a step retried by the engine leaves a row
+ * per attempt, and the final one is the failure that ended the run. A failed step
+ * is named after its node on the canvas; a node no longer on the canvas — the run
+ * is of a saved version since edited — is named the way the catalogue names its
+ * kind, never by the generated id.
+ */
+export declare function runFailureFromSteps(steps: readonly RunStepRow[] | null | undefined, nodes: readonly FailureNode[], fallbackCause: string | null): RunFailure;

package/dist/runtime/utils/runFailure.js

@@ -0,0 +1,16 @@
+import { nodeDisplayName } from "./nodeDisplayName.js";
+import { stepError } from "./stepError.js";
+const FAILED_RUN = /* @__PURE__ */ new Set(["failed", "terminated", "timed_out"]);
+export function isFailedRun(run) {
+  return FAILED_RUN.has(String(run?.status ?? "").toLowerCase());
+}
+export function reasonText(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+export function runFailureFromSteps(steps, nodes, fallbackCause) {
+  const failed = [...steps ?? []].reverse().find((s) => String(s.status).toLowerCase() === "failed");
+  if (!failed) return { step: null, cause: fallbackCause };
+  const node = nodes.find((n) => n.id === failed.node_id);
+  const step = node ? nodeDisplayName(node) : nodeDisplayName({ nodeSlug: failed.node_slug });
+  return { step, cause: stepError(failed.error)?.message ?? fallbackCause };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-integrations",
-  "version": "3.7.1",
+  "version": "3.8.1",
   "type": "module",
   "description": "Integration Studio (core: workflows, node editor, runs, schedules, credentials, secrets, audit) as a standalone, publishable Nuxt module.",
   "repository": {