@revenexx/studio-integrations 1.3.0 → 1.4.0

package/dist/runtime/utils/errorPathAdvice.js

@@ -0,0 +1,19 @@
+import { findManifest } from "../data/integrationNodeCatalog.js";
+export function unwiredErrorPorts(blob) {
+  const advice = [];
+  for (const node of blob.nodes) {
+    const manifest = findManifest(node.nodeSlug, node.nodeVersion);
+    if (!manifest) continue;
+    const errorPorts = (manifest.outputs ?? []).filter((o) => o.kind === "error" && o.name).map((o) => o.name);
+    if (!errorPorts.length) continue;
+    if (!isReachable(node, blob, errorPorts)) continue;
+    for (const port of errorPorts) {
+      const wired = blob.edges.some((e) => e.from.nodeId === node.id && e.from.output === port);
+      if (!wired) advice.push({ nodeId: node.id, port });
+    }
+  }
+  return advice;
+}
+function isReachable(node, blob, errorPorts) {
+  return blob.edges.some((e) => e.to.nodeId === node.id) || blob.edges.some((e) => e.from.nodeId === node.id && !errorPorts.includes(e.from.output));
+}

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

@@ -13,10 +13,10 @@ export declare const toast: ((message: string | (() => string | import("vue").Co
     custom: (component: import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
     message: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
     promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
+        id?: number | string | undefined;
+        class?: string | undefined;
         action?: (import("vue-sonner").Action | import("vue").Component) | undefined;
         icon?: import("vue").Component | undefined;
-        class?: string | undefined;
-        id?: number | string | undefined;
         position?: ("top-left" | "top-right" | "bottom-left" | "bottom-right" | "top-center" | "bottom-center") | undefined;
         toasterId?: string | undefined;
         component?: import("vue").Component | undefined;

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

@@ -11,6 +11,13 @@ export type RunLike = Record<string, unknown>;
  * looks like a run (`status`, `temporal_run_id`) is the run, whatever else it has
  * on it.
  *
+ * The two guards are `RUN_OWN_FIELDS`, exported because `unwrapRecord` reads the
+ * same endpoint from `useIntegrationsRuns.ts` and has to apply the same rule —
+ * one list, two readers, rather than the two literals that used to sit here
+ * (PO-394). What stays different is deliberate: this one answers `null` where
+ * `unwrapRecord` throws, because a caller following a run has to count an
+ * unusable answer as a failed read rather than have it raised at it.
+ *
  * This is deliberately generous about the *rest* of the shape. It answers "where
  * is the run in this body", not "is this a usable run" — the caller decides that,
  * because a caller following a run has to be able to count an unusable answer as
@@ -28,4 +35,9 @@ export declare const RUN_TERMINAL: Set<string>;
 export declare function isTerminalRun(run: {
     status?: unknown;
 } | null | undefined): boolean;
+/**
+ * The fields that mark a body as the run itself rather than an envelope around
+ * one. A run carrying its own `data` field would otherwise be unwrapped into it.
+ */
+export declare const RUN_OWN_FIELDS: readonly ["status", "temporal_run_id"];
 export declare function unwrapRun(res: unknown): RunLike | null;

package/dist/runtime/utils/runEnvelope.js

@@ -2,10 +2,11 @@ export const RUN_TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "can
 export function isTerminalRun(run) {
   return RUN_TERMINAL.has(String(run?.status ?? "").toLowerCase());
 }
+export const RUN_OWN_FIELDS = ["status", "temporal_run_id"];
 export function unwrapRun(res) {
   if (!res || typeof res !== "object") return null;
   const o = res;
-  if ("data" in o && o.data && typeof o.data === "object" && !("status" in o) && !("temporal_run_id" in o)) {
+  if ("data" in o && o.data && typeof o.data === "object" && !RUN_OWN_FIELDS.some((f) => f in o)) {
     return o.data;
   }
   return o;

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

@@ -0,0 +1,48 @@
+/**
+ * Carrying a node's declared options through a select that reserves the empty
+ * string for "nothing chosen".
+ *
+ * "No choice" is a legitimate thing for a node to offer — "as the file came in",
+ * "unchanged", "all kinds" — and three node types in two packages arrived at the
+ * same way of writing it: an option with an empty value. The select underneath
+ * this UI refuses it: the empty string is how it says nothing is selected, so an
+ * item may not also carry it. Handed one anyway it throws while the list mounts,
+ * and takes the surrounding dialog's dismissal machinery down with it — nothing
+ * opened afterwards could be closed again.
+ *
+ * So every option value is carried under a substitute and swapped back on the way
+ * out. **Every** one, rather than only the empty value: a sentinel that stood
+ * beside untouched values would be a value a node could declare itself, and
+ * declaring it would silently store the empty string instead. Here a declared
+ * value always arrives prefixed and the empty one never is, so the two cannot
+ * collide whatever a node writes. What the node reads is unchanged.
+ */
+/** What the option meaning "no choice" is carried under. */
+export declare const EMPTY_OPTION_VALUE = "option-empty";
+/** Does this list of options ask for the substitute at all? */
+export declare function hasEmptyOption(options: Array<{
+    value: unknown;
+}> | undefined): boolean;
+/**
+ * An option's value as the select may receive it. That is the guard: the item
+ * component cannot be handed an empty value from here, whatever a node declares.
+ */
+export declare function toItemValue(value: unknown): string;
+/**
+ * The stored value as the select's model — encoded the way the items are, or it
+ * matches none of them and the trigger falls back to its placeholder.
+ *
+ * `null` is read as the empty option alongside the empty string, because that is
+ * what the platform hands back for one: Laravel converts an empty string to null
+ * anywhere in a request body, so the value chosen here returns as null on the next
+ * open and the choice would otherwise be gone. A setting with no value at all is
+ * not: nothing is stored for it, and a trigger claiming a choice the config does
+ * not hold would be the placeholder's lie in the other direction. A node that
+ * offers "no choice" declares it as the field's default, so a step placed on the
+ * canvas has the empty string from the start.
+ */
+export declare function toModelValue(value: unknown, options: Array<{
+    value: unknown;
+}> | undefined): string;
+/** What the select hands back, as the node wants it stored. */
+export declare function fromModelValue(value: string): string;

package/dist/runtime/utils/selectOptions.js

@@ -0,0 +1,19 @@
+const OPTION_VALUE_PREFIX = "option:";
+export const EMPTY_OPTION_VALUE = "option-empty";
+export function hasEmptyOption(options) {
+  return (options ?? []).some((o) => String(o.value) === "");
+}
+export function toItemValue(value) {
+  const s = String(value);
+  return s === "" ? EMPTY_OPTION_VALUE : OPTION_VALUE_PREFIX + s;
+}
+export function toModelValue(value, options) {
+  if (value === "" || value === null || value === void 0) {
+    return value !== void 0 && hasEmptyOption(options) ? EMPTY_OPTION_VALUE : "";
+  }
+  return OPTION_VALUE_PREFIX + String(value);
+}
+export function fromModelValue(value) {
+  if (value === EMPTY_OPTION_VALUE) return "";
+  return value.startsWith(OPTION_VALUE_PREFIX) ? value.slice(OPTION_VALUE_PREFIX.length) : value;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * How a keyboard shortcut is written for a reader, and which physical modifier
+ * `mod` stands for.
+ *
+ * ONE COPY, deliberately. This table existed twice — in the canvas context
+ * menu and in the control pane's tooltip — and the platform test existed a
+ * third time inside the shortcuts composable. The two tables had already
+ * drifted: the tooltip's knew nothing about `backspace`, `tab` or `space`, so a
+ * token it was never handed would have rendered as `BACKSPACE`. A shortcut is
+ * about to be shown in a third place (the overview the canvas opens), which is
+ * two copies too many.
+ *
+ * `IS_MAC` reads `navigator.platform`, which is deprecated and reports
+ * `MacIntel` for an iPad. It is kept because the replacement
+ * (`navigator.userAgentData.platform`) is not in every browser we serve, and
+ * because being wrong here costs a wrong glyph rather than a wrong key: the
+ * MATCHING side reads the same flag, so a machine we misread is a machine where
+ * ⌘ and Ctrl swap together and nothing goes silent.
+ */
+export declare const IS_MAC: boolean;
+/**
+ * A shortcut token string as a reader sees it: `'mod+enter'` → `⌘↵` on a mac,
+ * `Ctrl+↵` elsewhere.
+ *
+ * Alternatives are not rendered — `'f2|space'` is two ways to press one thing,
+ * and a caller that wants both writes both. Pass `isMac` to render for the other
+ * platform, which is what the unit suite does.
+ */
+/**
+ * A token string split into its tokens, where one of the tokens may be the
+ * separator itself.
+ *
+ * `'+'.split('+')` is two empty strings, and `'mod++'` is `['mod', '', '']` — so
+ * a pair of empties is a literal `+`. Without this the character disappeared:
+ * on a mac, where caps are joined with nothing, `+` rendered as an empty key cap,
+ * and elsewhere the join only put it back by accident. Exported so the matcher
+ * reads a binding the same way this writes it.
+ */
+export declare function shortcutTokens(tokens: string): string[];
+export declare function formatShortcut(tokens: string, isMac?: boolean): string;

package/dist/runtime/utils/shortcutLabel.js

@@ -0,0 +1,48 @@
+export const IS_MAC = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform ?? "");
+const MAC_TOKENS = {
+  mod: "\u2318",
+  shift: "\u21E7",
+  alt: "\u2325",
+  ctrl: "\u2303"
+};
+const OTHER_TOKENS = {
+  mod: "Ctrl",
+  shift: "Shift",
+  alt: "Alt",
+  ctrl: "Ctrl"
+};
+const KEY_TOKENS = {
+  enter: "\u21B5",
+  backspace: "\u232B",
+  delete: "Del",
+  escape: "Esc",
+  tab: "Tab",
+  space: "Space",
+  arrowup: "\u2191",
+  arrowdown: "\u2193",
+  arrowleft: "\u2190",
+  arrowright: "\u2192"
+};
+export function shortcutTokens(tokens) {
+  const parts = tokens.split("+");
+  const out = [];
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] === "" && parts[i + 1] === "") {
+      out.push("+");
+      i++;
+      continue;
+    }
+    if (parts[i] === "") continue;
+    out.push(parts[i]);
+  }
+  return out;
+}
+export function formatShortcut(tokens, isMac = IS_MAC) {
+  const mods = isMac ? MAC_TOKENS : OTHER_TOKENS;
+  const out = [];
+  for (const raw of shortcutTokens(tokens)) {
+    const t = raw.toLowerCase();
+    out.push(mods[t] ?? KEY_TOKENS[t] ?? (t.length === 1 ? t.toUpperCase() : t.charAt(0).toUpperCase() + t.slice(1)));
+  }
+  return isMac ? out.join("") : out.join("+");
+}

package/package.json

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