@revenexx/studio-integrations 0.5.1 → 0.7.0

package/dist/runtime/utils/loadGate.js

@@ -0,0 +1,22 @@
+import { whenIdle } from "./whenIdle.js";
+export function createLoadGate(state) {
+  const { loading, loaded, started, finished } = state;
+  return {
+    async claim(force = false) {
+      const askedAt = started.value;
+      while (loading.value) {
+        await whenIdle(loading);
+        if (!force) return false;
+        if (finished.value > askedAt) return false;
+      }
+      if (loaded?.value && !force) return false;
+      started.value++;
+      loading.value = true;
+      return true;
+    },
+    release() {
+      loading.value = false;
+      finished.value++;
+    }
+  };
+}

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

@@ -1,11 +1,53 @@
+/**
+ * Tell the studio which language to render in. **This is the host's job**, and
+ * it is the whole contract: the module is published, so it must not go looking
+ * for the cockpit's storage keys or import the cockpit's i18n. A host with a
+ * language switcher calls this whenever the choice changes; a host with a fixed
+ * language sets `studioIntegrations.locale` in its Nuxt config instead and
+ * never calls this at all.
+ *
+ * A BCP-47 tag (`de`, `en`, `de-CH`). Empty or absent means English.
+ */
+export declare function setStudioLocale(locale: string | null | undefined): void;
+/** The language the studio is currently rendering in. Reactive when read in an effect. */
+export declare function studioLocale(): string;
 /**
  * Resolve a multilingual value from the Integrations API. The API returns
  * names and descriptions either as a plain string or as an already-parsed
  * object `{de:"…", en:"…"}` (the HTTP client does JSON decoding automatically).
  * JSON-encoded strings like `'{"de":"…","en":"…"}'` are also handled.
  *
- * Priority: 1) "en", 2) first key found. English is the cockpit default —
- * there is no working language switcher yet; browser-locale preference
- * returns together with the switcher.
+ * The language is the studio's ({@link setStudioLocale}) unless the caller
+ * names one. English is the fallback, and the map's own first entry the
+ * fallback after that.
+ *
+ * **This is the studio's only resolver, and that is the point.** The same three
+ * lines used to sit in seventeen components under six names (`labelText`, `loc`,
+ * `locText`, `localLabel`, `title`, `descriptionText`), all agreeing with this
+ * function by coincidence. A language switcher wired into this one place would
+ * have translated a fraction of the surface with nothing going red — so PO-229
+ * collapsed them here before building one. Anything that renders a name, a
+ * label, a description or a placeholder from the API calls this; nothing
+ * re-derives the rule.
+ *
+ * Two of the seventeen were named for their call site rather than for the rule
+ * (`WorkflowTriggerView`'s `title`, `WorkflowVariablesDialog`'s
+ * `descriptionText`), so no grep for the rule's shape found them. Both resolve
+ * text a person typed and went to `resolveDisplayName` below, not here.
+ */
+export declare function resolveLocalized(value: unknown, locale?: string): string;
+/**
+ * The same resolution, for a value that may be **text a person wrote** — a
+ * node's own name, a group frame's label.
+ *
+ * `resolveLocalized` normalises: it trims, and it reads a leading `{` as JSON.
+ * That is right for a manifest string and wrong for a user's own, and it has
+ * already cost once (PO-204): run through the trimming resolver, the node-name
+ * field ate the space the user had just typed, so "Fetch open orders" came back
+ * as "Fetchopenorders". A name like `{"a":"b"}` would render as `b`.
+ *
+ * So a string is passed through untouched and only the localised-object form is
+ * resolved. Use this wherever the value can be something a person typed; use
+ * `resolveLocalized` for anything that can only have come from a manifest.
  */
-export declare function resolveLocalized(value: unknown): string;
+export declare function resolveDisplayName(value: string | Record<string, string> | undefined | null, locale?: string): string;

package/dist/runtime/utils/localize.js

@@ -1,11 +1,34 @@
-export function resolveLocalized(value) {
+import { shallowRef } from "vue";
+const uiLocale = shallowRef("en");
+export function setStudioLocale(locale) {
+  const next = typeof locale === "string" ? locale.trim() : "";
+  uiLocale.value = next || "en";
+}
+export function studioLocale() {
+  return uiLocale.value;
+}
+function pickLanguage(map, locale) {
+  const keys = Object.keys(map);
+  if (!keys.length) return "";
+  const wanted = locale.toLowerCase();
+  const base = wanted.split("-")[0];
+  const candidates = [
+    keys.find((k) => k.toLowerCase() === wanted),
+    keys.find((k) => k.toLowerCase().split("-")[0] === base),
+    keys.find((k) => k.toLowerCase().split("-")[0] === "en"),
+    keys[0]
+  ];
+  for (const key of candidates) {
+    if (key === void 0) continue;
+    const picked = map[key];
+    if (typeof picked === "string") return picked;
+  }
+  return "";
+}
+export function resolveLocalized(value, locale = uiLocale.value) {
   if (value === null || value === void 0) return "";
   if (typeof value === "object" && !Array.isArray(value)) {
-    const map = value;
-    const keys = Object.keys(map);
-    if (!keys.length) return "";
-    const picked = map["en"] ?? map[keys[0]];
-    return typeof picked === "string" ? picked : "";
+    return pickLanguage(value, locale);
   }
   if (typeof value !== "string") return String(value);
   const trimmed = value.trim();
@@ -13,8 +36,12 @@ export function resolveLocalized(value) {
   try {
     const parsed = JSON.parse(trimmed);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return trimmed;
-    return resolveLocalized(parsed);
+    return resolveLocalized(parsed, locale);
   } catch {
     return trimmed;
   }
 }
+export function resolveDisplayName(value, locale = uiLocale.value) {
+  if (typeof value === "string") return value;
+  return resolveLocalized(value, locale);
+}

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

@@ -0,0 +1,59 @@
+/**
+ * A proxy rather than a hand-written object, so the whole library stays reachable:
+ * `toast.dismiss`, `toast.promise`, `toast.custom` and whatever it gains next are
+ * forwarded and guarded on access. Listing the methods by hand would have turned the
+ * first call to an unlisted one into "undefined is not a function" — a second defect
+ * of the same shape as the one this file exists for.
+ */
+export declare const toast: ((message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number) & {
+    success: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    info: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    warning: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    error: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+    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?: ({
+        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;
+        cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
+        toasterId?: string | undefined;
+        component?: import("vue").Component | undefined;
+        componentProps?: any;
+        richColors?: boolean | undefined;
+        invert?: boolean | undefined;
+        closeButton?: boolean | undefined;
+        dismissible?: boolean | undefined;
+        duration?: number | undefined;
+        important?: boolean | undefined;
+        onDismiss?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
+        onAutoClose?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
+        cancelButtonStyle?: import("vue").CSSProperties | undefined;
+        actionButtonStyle?: import("vue").CSSProperties | undefined;
+        style?: import("vue").CSSProperties | undefined;
+        unstyled?: boolean | undefined;
+        classes?: import("vue-sonner").ToastClasses | undefined;
+        descriptionClass?: string | undefined;
+        closeButtonPosition?: ("top-left" | "top-right" | "bottom-left" | "bottom-right") | undefined;
+        testId?: string | undefined;
+    } & {
+        loading?: string | import("vue").Component;
+        success?: (string | import("vue").Component | ((data: ToastData) => import("vue").Component | string | Promise<import("vue").Component | string>)) | (import("vue-sonner").PromiseIExtendedResult | ((data: ToastData) => import("vue-sonner").PromiseIExtendedResult | Promise<import("vue-sonner").PromiseIExtendedResult>)) | undefined;
+        error?: (string | import("vue").Component | ((data: any) => import("vue").Component | string | Promise<import("vue").Component | string>)) | (import("vue-sonner").PromiseIExtendedResult | ((data: any) => import("vue-sonner").PromiseIExtendedResult | Promise<import("vue-sonner").PromiseIExtendedResult>));
+        description?: string | import("vue").Component | ((data: any) => import("vue").Component | string | Promise<import("vue").Component | string>);
+        finally?: () => void | Promise<void>;
+    }) | undefined) => (string & {
+        unwrap: () => Promise<ToastData>;
+    }) | (number & {
+        unwrap: () => Promise<ToastData>;
+    }) | {
+        unwrap: () => Promise<ToastData>;
+    } | undefined;
+    dismiss: (id?: number | string) => string | number | undefined;
+    loading: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
+} & {
+    getHistory: () => (import("vue-sonner").ToastT<import("vue").Component> | import("vue-sonner").ToastToDismiss)[];
+    getToasts: () => (import("vue-sonner").ToastT<import("vue").Component> | import("vue-sonner").ToastToDismiss)[];
+};

package/dist/runtime/utils/notify.js

@@ -0,0 +1,21 @@
+import { toast as sonner } from "vue-sonner";
+function guarded(kind, fn) {
+  return (...args) => {
+    try {
+      return fn(...args);
+    } catch (e) {
+      console.warn(`[studio-integrations] notification dropped (${kind}): ${String(args[0])}`, e);
+      return void 0;
+    }
+  };
+}
+export const toast = new Proxy(sonner, {
+  apply(target, thisArg, args) {
+    return guarded("message", (...a) => Reflect.apply(target, thisArg, a))(...args);
+  },
+  get(target, prop) {
+    const value = Reflect.get(target, prop);
+    if (typeof value !== "function") return value;
+    return guarded(String(prop), (...args) => value.apply(target, args));
+  }
+});

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

@@ -0,0 +1,72 @@
+/**
+ * How often a poll is still allowed to fetch once realtime is carrying the same
+ * updates.
+ *
+ * Every run surface polls: the runs list every three seconds, the detail panel
+ * every three and its timeline every ten, the replay canvas every four. That is the
+ * only thing that made a `running → completed` transition appear at all, and it is
+ * expensive — `runs.vue`'s pass fans out one request per workflow and then
+ * reconciles up to five active runs, so the list can cost dozens of requests every
+ * three seconds while anything is in flight.
+ *
+ * Talkback replaces the *latency* argument for polling, not the safety argument. So
+ * the intervals stay exactly where they are and this decides, per tick, whether the
+ * tick may spend a request: at the ordinary cadence while nothing is being reported,
+ * and at a slow safety cadence once something is.
+ *
+ * COUNTING TICKS, NOT READING A CLOCK, and that is deliberate twice over. The tick
+ * is the only thing that has actually happened — a wall-clock reading would make
+ * this disagree with a `setInterval` the browser throttled in a background tab. And
+ * `specs/runs.md` AC-12's test installs Playwright's fake clock and fast-forwards
+ * it; a `Date.now()` in here would read the fake time, which is the kind of
+ * coupling that makes a test pass for the wrong reason.
+ *
+ * WHAT `delivering` HAS TO MEAN, and this is the argument the parameter's name is
+ * carrying. Being subscribed is no evidence: a channel resolves from the local
+ * subscription, so a tenant whose event catalogue never publishes these topics holds
+ * open channels that stay silent for the life of the tab — and thinning on that state
+ * would make such a tenant ten times slower than before any of this existed, with
+ * nothing anywhere saying so. `useIntegrationsRealtime` therefore counts deliveries,
+ * and this is only ever thinned once something has really arrived.
+ *
+ * WHY A SLOW POLL RATHER THAN NONE. What is still unavailable is whether delivery is
+ * CONTINUING: a socket that dies quietly after one event keeps reading as delivering,
+ * because the per-channel confirmation that would settle it is not passed through the
+ * packages between Centrifugo and here. A budget that stopped fetching entirely would
+ * then show a stale list for as long as the tab stayed open, with nothing anywhere
+ * saying so. Backing off from three seconds to thirty gives up latency we now get
+ * from events and keeps the property that mattered: the view converges without the
+ * operator doing anything.
+ *
+ * The caller keeps its own tick-shedding (`!loading.value`) in front of this, so a
+ * tick that finds a load still out neither fetches nor spends budget — see
+ * `loadGate.ts` for why that flag is trustworthy.
+ */
+export interface PollBudgetOptions {
+    /** The caller's own interval, i.e. how much time one `due()` call stands for. */
+    intervalMs: number;
+    /** The gap between fetches while reports are arriving. */
+    liveIntervalMs: number;
+}
+export interface PollBudget {
+    /**
+     * Whether this tick may fetch. Advances the budget, so call it once per tick and
+     * last in the condition — `hasActive && !loading && budget.due(delivering)`.
+     */
+    due: (delivering: boolean) => boolean;
+    /**
+     * Counts a fetch this budget did not authorise: a report's refetch, a manual
+     * refresh, a row action, an opening surface's first read. Without it the next due
+     * tick would send a second request for a state that was just read.
+     *
+     * CALL IT IN THE LOADER, not at each call site, wherever the surface has a loader
+     * of its own to put it in — `[id].vue`'s `loadRuns`, `RunDetailPanel`'s
+     * `loadSummary` and `loadTimelineEvents`, `runs.vue`'s `reload`. A contract that
+     * asks every future caller to remember is one that ends up wider than the wiring,
+     * which is how this note came to be written.
+     */
+    spend: () => void;
+}
+/** The safety cadence every run surface backs off to while reports are arriving. */
+export declare const SAFETY_POLL_MS = 30000;
+export declare function createPollBudget(options: PollBudgetOptions): PollBudget;

package/dist/runtime/utils/pollBudget.js

@@ -0,0 +1,17 @@
+export const SAFETY_POLL_MS = 3e4;
+export function createPollBudget(options) {
+  let elapsed = 0;
+  return {
+    due(delivering) {
+      elapsed += options.intervalMs;
+      if (!delivering || elapsed >= options.liveIntervalMs) {
+        elapsed = 0;
+        return true;
+      }
+      return false;
+    },
+    spend() {
+      elapsed = 0;
+    }
+  };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Which credential types offer the "Use revenexx …" source alternative, and
+ * under which kind.
+ *
+ * This lives apart from the component that renders it because its *parents* need
+ * it too: the detail dialog mounts that component only for the types it actually
+ * serves, since for every other type it renders nothing anyway.
+ *
+ * It was once load-bearing for a different reason — the component resolved
+ * cockpit-only composables at setup time, so mounting it outside the cockpit
+ * threw and took the surrounding form down. That is fixed (PO-222): the component
+ * asks whether those sources exist. So this guard is now tidiness rather than
+ * protection, which is also why the create dialog never having one stopped
+ * mattering.
+ */
+export type RevenexxSourceKind = 'sftp' | 'smtp' | 'api';
+export declare const REVENEXX_SOURCE_KIND_BY_SLUG: Record<string, RevenexxSourceKind>;
+/**
+ * Whether this credential type has a managed revenexx counterpart to copy from.
+ *
+ * Own properties only: `in` would answer yes for everything on the prototype
+ * chain, so a type slugged `toString` or `constructor` would pass the guard and
+ * then resolve to a function instead of a kind — and this guard is what decides
+ * whether the cockpit-coupled component mounts at all.
+ */
+export declare function hasRevenexxSource(slug: string | null | undefined): boolean;

package/dist/runtime/utils/revenexxCredentialSource.js

@@ -0,0 +1,8 @@
+export const REVENEXX_SOURCE_KIND_BY_SLUG = {
+  "revenexx:sftp": "sftp",
+  "revenexx:smtp": "smtp",
+  "revenexx:api": "api"
+};
+export function hasRevenexxSource(slug) {
+  return !!slug && Object.hasOwn(REVENEXX_SOURCE_KIND_BY_SLUG, slug);
+}

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

@@ -0,0 +1,116 @@
+/** A rhythm the picker can build, and `describeRecurrence` can always say. */
+export type Recurrence = 
+/** `interval` minutes apart, all day, every day. `1` means every minute. */
+{
+    kind: 'minutes';
+    interval: number;
+}
+/** Once an hour, at `minute` past. */
+ | {
+    kind: 'hourly';
+    minute: number;
+}
+/** Every `interval` hours (2 or more), at `minute` past. */
+ | {
+    kind: 'hours';
+    interval: number;
+    minute: number;
+}
+/** Once a day, at a fixed time. */
+ | {
+    kind: 'daily';
+    hour: number;
+    minute: number;
+}
+/**
+ * Several times a day, at the same minute past each of `hours` — two or more —
+ * and on `days`, or every day when that is `null`.
+ *
+ * A list of hours and a run of them are the same rhythm written two ways
+ * (`9,10,11` fires exactly when `9-11` does), so both read back into this one
+ * form and `toCron` picks the canonical spelling. Times with *different*
+ * minutes are not one rhythm and cron cannot express them in one expression:
+ * 07:30 and 09:15 is two schedules.
+ */
+ | {
+    kind: 'times';
+    minute: number;
+    hours: number[];
+    days: number[] | null;
+}
+/** On the given weekdays (0 = Sunday), at a fixed time. Never empty. */
+ | {
+    kind: 'weekly';
+    days: number[];
+    hour: number;
+    minute: number;
+}
+/** On one day of the month, at a fixed time. */
+ | {
+    kind: 'monthly';
+    day: number;
+    hour: number;
+    minute: number;
+};
+/**
+ * The zone a schedule without one of its own runs in: the platform's default,
+ * which is UTC (`config('app.timezone')`, which nothing overrides).
+ *
+ * Not the zone the studio *writes*. A schedule set up here carries
+ * `Europe/Berlin` from the trigger's own default config, and this is only what a
+ * schedule that arrived without a zone actually runs in.
+ */
+export declare const PLATFORM_TIMEZONE = "UTC";
+/**
+ * The zone a schedule's numbers are read in — its own where it has one, the
+ * platform's default where it does not.
+ *
+ * One function because two surfaces show it: the trigger settings under the
+ * controls, and the Schedules page in its own column. A surface that answered this
+ * for itself is how one schedule ends up with two zones, and a zone is half of
+ * what a time means.
+ */
+export declare function scheduleTimezone(timezone: unknown): string;
+/**
+ * The rhythm an expression describes, or `null` when it is not one of them.
+ *
+ * @param cron A five-field expression: minute hour day-of-month month day-of-week.
+ */
+export declare function parseCron(cron: string | null | undefined): Recurrence | null;
+/**
+ * The five-field expression for a rhythm. Always valid, always five fields, and
+ * **never both a day of the month and a weekday** — cron reads that pair as
+ * "either", so a picker that produced it would mean something other than what it
+ * showed.
+ *
+ * Three rhythms are written in their canonical form rather than literally, so one
+ * rhythm has one expression: an hourly interval of 1 is `hourly`, a weekly
+ * schedule on all seven days is `daily`, and every day of the week under `times`
+ * is written as an open field. Reading any of them back therefore gives the
+ * canonical form, not the one passed in.
+ */
+export declare function toCron(r: Recurrence): string;
+/**
+ * A sentence for a rhythm. Total: every `Recurrence` has one, which is what lets
+ * a surface show the sentence in place of the expression.
+ */
+export declare function describeRecurrence(r: Recurrence): string;
+/**
+ * A sentence for the expression, or `null` when it cannot be said plainly.
+ *
+ * Nothing at all is the point where it happens. A wrong aid is worse than none,
+ * because a schedule that reads "Daily at 03:00" and fires hourly is a fault
+ * nobody goes looking for — so the shapes this cannot read produce no sentence,
+ * and the surface shows the expression instead.
+ *
+ * Times are read as written: the expression's own numbers, in the schedule's own
+ * timezone. Nothing here converts anything, which is why the timezone is the
+ * caller's to show.
+ */
+export declare function describeCron(cron: string | null | undefined): string | null;
+/**
+ * How long a rhythm waits between firings, in minutes — the order a "when does
+ * this run" column sorts in. An expression that cannot be read sorts last, since
+ * the alternative is ordering rows by a string the reader cannot see.
+ */
+export declare function cadenceRank(cron: string | null | undefined): number;