@revenexx/studio-integrations 0.7.0 → 1.1.0

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

@@ -11,6 +11,40 @@
 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;
+/**
+ * The key a read answers from — which is the key a *deletion* has to remove, since
+ * what the user is clearing is the text in front of them.
+ *
+ * All four steps, in the order `resolveLocalized` reads them: the exact tag, the same
+ * language in another region, English, and the map's own first entry. `''` when the
+ * map holds no string at all.
+ */
+export declare function languageKeyRead(map: unknown, locale?: string): string;
+/**
+ * The key an edit is written to.
+ *
+ * The first two steps of {@link languageKeyRead} and deliberately not its last two:
+ * falling back to English or to the first entry answers "what can I show you", and
+ * writing there would put the author's text into a language they are not reading —
+ * the silent loss this exists to prevent (PO-259). A language the map does not hold
+ * yet is written under its base subtag, never the tag the host set, so that reading
+ * it back finds it: a `de-CH` studio reading a `de` text through the region step
+ * would otherwise write a new `de-CH` key and leave every plain-`de` reader on the
+ * old wording.
+ *
+ * **That guarantee is about the keys this function invents.** The first two steps
+ * return a key the map already holds, verbatim — so a map carrying `DE-ch` is written
+ * back into `DE-ch`, which the API's `^[a-z]{2,3}(-[A-Z]{2})?$` rejects. Not a case
+ * that can arise: such a map could not have been saved in the first place, and the
+ * only writer of these keys is this function. Returning an existing key as it stands
+ * is what makes the write land where the read came from, which is worth more here than
+ * normalising a shape nothing can produce — but it is why the sentence above says
+ * *invents* rather than *writes*.
+ *
+ * Deleting is the other question and has the other answer — see
+ * {@link languageKeyRead}.
+ */
+export declare function languageKeyToWrite(map: unknown, locale?: string): 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

package/dist/runtime/utils/localize.js

@@ -7,24 +7,39 @@ export function setStudioLocale(locale) {
 export function studioLocale() {
   return uiLocale.value;
 }
-function pickLanguage(map, locale) {
-  const keys = Object.keys(map);
+function baseLanguage(locale) {
+  const base = locale.toLowerCase().split(/[-_]/)[0] ?? "";
+  return /^[a-z]{2,3}$/.test(base) ? base : "en";
+}
+export function languageKeyRead(map, locale = studioLocale()) {
+  const obj = map && typeof map === "object" ? map : {};
+  const keys = Object.keys(obj);
   if (!keys.length) return "";
   const wanted = locale.toLowerCase();
-  const base = wanted.split("-")[0];
+  const base = baseLanguage(locale);
   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.find((k) => baseLanguage(k) === base),
+    keys.find((k) => baseLanguage(k) === "en"),
     keys[0]
   ];
   for (const key of candidates) {
     if (key === void 0) continue;
-    const picked = map[key];
-    if (typeof picked === "string") return picked;
+    if (typeof obj[key] === "string") return key;
   }
   return "";
 }
+export function languageKeyToWrite(map, locale = studioLocale()) {
+  const keys = map && typeof map === "object" ? Object.keys(map) : [];
+  const wanted = locale.toLowerCase();
+  const base = baseLanguage(locale);
+  return keys.find((k) => k.toLowerCase() === wanted) ?? keys.find((k) => baseLanguage(k) === base) ?? base;
+}
+function pickLanguage(map, locale) {
+  const key = languageKeyRead(map, locale);
+  const picked = key ? map[key] : void 0;
+  return typeof picked === "string" ? picked : "";
+}
 export function resolveLocalized(value, locale = uiLocale.value) {
   if (value === null || value === void 0) return "";
   if (typeof value === "object" && !Array.isArray(value)) {

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

@@ -17,7 +17,7 @@
  * 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
+ * `specs/runs.md` AC-8'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.
  *

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

@@ -0,0 +1,22 @@
+/**
+ * The `/integrations/…` paths a host actually serves, out of the route records its
+ * router hands back.
+ *
+ * The dashboard's four shortcuts into Import & Export, the SFTP server, the event
+ * stream and inbound webhooks point at pages this module does not have — they are
+ * the host's (PO-223, [`docs/host-surfaces.md`](../../../docs/host-surfaces.md)) —
+ * so each card is offered as a way in only where the host has the path.
+ *
+ * It lives here rather than in the page for the same reason `scanRoutes` lives in
+ * `src/pageRoutes.ts`: the trailing-slash strip and the decision to compare exactly
+ * are what the doc names as the *misinforming* failure mode, and prose does not
+ * fail. `servedPaths.test.ts` pins the three cases that matter.
+ *
+ * **Exact strings, deliberately.** A parametrised page registers
+ * `/integrations/:surface`, and a route-prefixing i18n strategy registers
+ * `/en/integrations/io`; neither is one of the four literals, so a host built that
+ * way is told its own surfaces live elsewhere. That is the documented limit of the
+ * question — narrower than resolving through the matcher, which a host with a
+ * catch-all page answers "yes" to everywhere.
+ */
+export declare function servedPaths(routePaths: string[]): Set<string>;

package/dist/runtime/utils/servedPaths.js

@@ -0,0 +1,3 @@
+export function servedPaths(routePaths) {
+  return new Set(routePaths.map((path) => path.replace(/\/$/, "")));
+}

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

@@ -42,4 +42,56 @@ export declare const RUN_STATUS_WORDS: readonly ["running", "succeeded", "failed
  * never disagree about which status they mean.
  */
 export declare function normalisedRunStatus(status: string | null | undefined): string;
+/**
+ * The classes a run's status badge is drawn with — the colour half of
+ * {@link runStatusLabel}, and it reads the same word.
+ *
+ * `statusClass` on its own is handed whatever the platform wrote, and the map it
+ * looks in knows the studio's vocabulary rather than Temporal's: `terminated` and
+ * `timed_out` are in no branch of it, so a run the operator terminated was drawn
+ * neutral — the colour a *cancelled* run wears — while its badge said "failed".
+ * Two runs reading the same, in two colours, because the word went through
+ * {@link normalisedRunStatus} and the colour did not.
+ *
+ * So this normalises first. Every surface drawing a run's state calls it rather
+ * than `statusClass`, which stays what it is: one map from a status *word* to a
+ * tone, for the many vocabularies across the cockpit that already speak it.
+ */
+export declare function runStatusClass(status: string | null | undefined): string;
 export declare function runStatusLabel(status: string | null | undefined): string;
+/**
+ * A missed run's state, as a word written for the operator.
+ *
+ * The counterpart to {@link runStatusLabel} for the entry a trigger firing leaves
+ * when its workflow could not run. A state the catalogue does not know is named as
+ * unknown and carries the platform's own value inside that frame, so an operator
+ * can still quote what arrived without the studio claiming the word as one of its
+ * own. Nothing in, nothing out — the same answer `runStatusLabel` gives, for a
+ * column that is never actually empty.
+ *
+ * **The match is exact, unlike `runStatusLabel`'s**, and that is the point rather
+ * than an omission. Everything else that reads this field compares it strictly —
+ * whether an entry offers replay and discard, and whether it counts towards the
+ * firings still waiting — so a value differing by case or a stray space is one the
+ * studio does not act on. Saying "waiting" for it would promise an action that is
+ * not offered; saying it is unknown is what the rest of the studio already
+ * believes.
+ *
+ * The frame carries the value with its surrounding whitespace off and nothing else
+ * touched. Not verbatim, twice over, and neither is worth chasing: the badge is
+ * HTML, which collapses whitespace, and it draws its text uppercased — so an
+ * operator reads the letters that arrived rather than the casing, exactly as they
+ * do for the three states the studio does have words for.
+ */
+export declare function deadLetterStatusLabel(status: string | null | undefined): string;
+/**
+ * The classes a missed run's state badge is drawn with, on every surface that lists
+ * one.
+ *
+ * The colour half of {@link deadLetterStatusLabel}, reading the same map by the same
+ * exact match, so the two cannot disagree about which states the studio knows: a
+ * state named as unknown is drawn as unknown. Tones come from the shared palette,
+ * so this is one more vocabulary mapped into the studio's colours rather than a
+ * second set of colours.
+ */
+export declare function deadLetterStatusClass(status: string | null | undefined): string;

package/dist/runtime/utils/statusStyle.js

@@ -89,13 +89,39 @@ export function normalisedRunStatus(status) {
     case "terminated":
     case "timed_out":
       return "failed";
+    // Temporal spells a cancellation the American way and the studio does not, so
+    // without this the *word* half of the promise fails on the surfaces that read
+    // the platform's answer directly: the row said `cancelled`, the record
+    // `canceled`, and in German the record said it in English.
+    case "canceled":
+      return "cancelled";
     default:
       return s;
   }
 }
+export function runStatusClass(status) {
+  return statusClass(normalisedRunStatus(status));
+}
 export function runStatusLabel(status) {
   const normalized = normalisedRunStatus(status);
   if (!normalized) return "";
   if (!RUN_STATUS_WORD_SET.has(normalized)) return normalized;
   return useIntegrationsT()(`integration.runs.status.${normalized}`);
 }
+const MISSED_RUN_STATUS_TONE = /* @__PURE__ */ new Map([
+  ["pending", "warning"],
+  ["replayed", "success"],
+  ["discarded", "neutral"]
+]);
+export function deadLetterStatusLabel(status) {
+  if (!status) return "";
+  const raw = String(status);
+  if (!MISSED_RUN_STATUS_TONE.has(raw)) {
+    return useIntegrationsT()("integration.deadLetters.status.unknown", { status: raw.trim() || raw });
+  }
+  return useIntegrationsT()(`integration.deadLetters.status.${raw}`);
+}
+export function deadLetterStatusClass(status) {
+  const tone = status ? MISSED_RUN_STATUS_TONE.get(String(status)) : void 0;
+  return toneClass(tone ?? "neutral");
+}

package/package.json

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