@revenexx/studio-integrations 0.7.0 → 1.0.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/package.json

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