@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/{studio-bgxt93ga.js → studio-d055c37e.js}

@@ -1,23 +1,23 @@
 import {
-  projectState
-} from "./studio-p4ngc046.js";
+  getPlatform2
+} from "./studio-6nzaktvy.js";
 import {
-  getPlatform
-} from "./studio-9ab8gqsm.js";
+  projectState
+} from "./studio-6ewqv390.js";
 
 // src/files/components.ts
-var componentRegistry = [];
+var componentRegistry2 = [];
 var _componentRegistryLoaded = false;
-async function loadComponentRegistry() {
+async function loadComponentRegistry2() {
   try {
-    const platform = getPlatform();
-    componentRegistry = await platform.discoverComponents(projectState?.projectRoot || undefined);
+    const platform = getPlatform2();
+    componentRegistry2 = await platform.discoverComponents(projectState?.projectRoot || undefined);
     _componentRegistryLoaded = true;
   } catch {
     _componentRegistryLoaded = true;
   }
 }
-function buildComponentInstance(comp) {
+function buildComponentInstance2(comp) {
   const $props = Object.fromEntries((comp.props ?? []).map((p) => [p.name, p.default !== undefined ? p.default : ""]));
   const children = [];
   for (const slot of comp.slots ?? []) {
@@ -38,7 +38,7 @@ function buildComponentInstance(comp) {
     ...children.length > 0 ? { children } : {}
   };
 }
-function computeRelativePath(fromDocPath, toCompPath) {
+function computeRelativePath2(fromDocPath, toCompPath) {
   if (!fromDocPath) {
     return `./${toCompPath}`;
   }
@@ -56,7 +56,7 @@ function computeRelativePath(fromDocPath, toCompPath) {
   return (ups > 0 ? "../".repeat(ups) : "./") + remaining.join("/");
 }
 
-export { componentRegistry, _componentRegistryLoaded, loadComponentRegistry, buildComponentInstance, computeRelativePath };
+export { componentRegistry2, loadComponentRegistry2, buildComponentInstance2, computeRelativePath2 };
 
-//# debugId=37666BFABEF9083664756E2164756E21
-//# sourceMappingURL=studio-bgxt93ga.js.map
+//# debugId=771ED3632A98E38064756E2164756E21
+//# sourceMappingURL=studio-d055c37e.js.map

package/dist/chunks/studio-d1ja2x9r.js

@@ -0,0 +1,362 @@
+import {
+  errorMessage2
+} from "./studio-yxa81f45.js";
+import {
+  reactive,
+  notify2
+} from "./studio-p1dw8wfw.js";
+import {
+  REGION_ATTR,
+  overlayRegion,
+  registerSurface,
+  mountSurface,
+  whenReady,
+  layerHost2
+} from "./studio-erdatzvp.js";
+import {
+  showModal,
+  close2
+} from "./studio-5jy81t3s.js";
+// src/surfaces/github-auth.json
+var github_auth_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioGithubAuth",
+  $description: "The RFC 8628 device flow's waiting room: the code GitHub minted, the page to type it into, and a Cancel. A `jx-dialog`, so the platform owns modality, Escape, focus restoration and the backdrop — and it is the reason the dialog has no confirm button at all: the answer arrives from GitHub over a poll rather than from anything the reader can press here, so a primary button would be a control with nothing to do. Nothing in this document talks to GitHub: `github/github-auth.ts` keeps the client id, the poll loop, its failure budget and every report the three outcomes raise.",
+  tagName: "jx-dialog",
+  $props: {
+    headline: "Sign in to GitHub",
+    confirmLabel: "",
+    cancelLabel: "Cancel",
+    size: "sm"
+  },
+  attributes: {
+    part: "github-auth"
+  },
+  oncancel: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/cancel"
+        },
+        value: []
+      }
+    ]
+  },
+  onclose: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/closed"
+        },
+        value: []
+      }
+    ]
+  },
+  style: {
+    $description: "Four `.github-auth-*` rules in `styles/overlays.css` become the parts below, and two things in them do not travel. `.github-auth-dialog`'s `padding: 16px 0` was the card's own body padding drawn by hand, and `jx-dialog` already pads its body; `.github-auth-dialog p { font-size: 13px }` was a body size this surface picked for itself, and what the paragraphs now inherit is the dialog's own `--jx-text-md`. The `8px 0` margins go with them — the column is a flex column with a gap, so a margin between two rows would be a second opinion about the same space. The code keeps its 24px, which is above the token scale on purpose: it is a string the reader has to copy onto another screen, and reading it out loud is the whole job of this dialog.",
+    '& [part="device"]': {
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      gap: "var(--jx-space-3)",
+      textAlign: "center"
+    },
+    '& [part="lede"], & [part="waiting"]': {
+      margin: "0"
+    },
+    '& [part="code"]': {
+      $description: "`<code>`, not a styled `<div>`: this is a literal string to be transcribed, and the element that says so is also the one a reader's own stylesheet and a screen reader's character-by-character mode already know about.",
+      fontFamily: "var(--font-mono)",
+      fontSize: "24px",
+      fontWeight: "700",
+      letterSpacing: "2px",
+      padding: "var(--jx-space-3) var(--jx-space-4)",
+      background: "var(--hover-bg)",
+      borderRadius: "var(--radius)"
+    },
+    '& [part="link"]': {
+      $description: "The blue this carried as a `var(--accent, …)` fallback is gone: `--accent` is declared on `:root` in `styles/tokens.css`, so the fallback could only ever have painted when the token was missing — which is a theme fault to fix rather than a colour to hard-code.",
+      color: "var(--accent)",
+      textDecoration: "underline"
+    },
+    '& [part="waiting"]': {
+      color: "var(--fg-dim)",
+      fontStyle: "italic"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "device"
+      },
+      children: [
+        {
+          tagName: "p",
+          attributes: {
+            part: "lede"
+          },
+          textContent: "Enter this code on GitHub to authorize Jx Studio:"
+        },
+        {
+          tagName: "code",
+          attributes: {
+            part: "code"
+          },
+          textContent: "${state.userCode}"
+        },
+        {
+          tagName: "a",
+          attributes: {
+            part: "link",
+            href: "${state.verificationUri}",
+            target: "_blank",
+            rel: "noreferrer"
+          },
+          textContent: "Open ${state.verificationUri}"
+        },
+        {
+          tagName: "p",
+          attributes: {
+            part: "waiting"
+          },
+          textContent: "Waiting for authorization…"
+        }
+      ]
+    }
+  ]
+};
+
+// src/surfaces/github-auth.ts
+registerSurface("github-auth", github_auth_default);
+function openGithubAuthSurface(options) {
+  const slot = document.createElement("div");
+  slot.style.pointerEvents = "auto";
+  slot.setAttribute(REGION_ATTR, overlayRegion("dialog", "github-auth"));
+  options.layer.append(slot);
+  let closed = false;
+  const finish = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    options.onClosed();
+  };
+  const scope = reactive({
+    cancel: () => {
+      options.onCancel();
+    },
+    closed: finish,
+    userCode: options.userCode,
+    verificationUri: options.verificationUri
+  });
+  let mounted = null;
+  const ready = mountSurface("github-auth", scope, slot).then(async (surface) => {
+    mounted = surface;
+    const element = surface.root;
+    if (closed) {
+      surface.dispose();
+      return element;
+    }
+    await whenReady(element);
+    if (closed) {
+      return element;
+    }
+    showModal(element);
+    return element;
+  });
+  return {
+    close() {
+      const element = mounted?.root;
+      if (element instanceof HTMLElement) {
+        close2(element);
+      }
+      mounted?.dispose();
+      mounted = null;
+      slot.remove();
+      finish();
+    },
+    host: slot,
+    ready
+  };
+}
+
+// src/github/github-auth.ts
+var CLIENT_ID = "Ov23liYVlMFpgjOEPXJH";
+var STORAGE_KEY = "jx_github_token";
+function nativeAuth() {
+  return globalThis.__jxPlatform?.githubAuth ?? null;
+}
+var nativeToken = null;
+var nativeStored = false;
+function githubTokenStored() {
+  return nativeToken !== null || nativeStored || localStorage.getItem(STORAGE_KEY) !== null;
+}
+function githubTokenLocation() {
+  return nativeAuth() ? "desktop" : "browser";
+}
+var NOTIFY_KEY = "github.auth";
+var SOURCE = "Source Control";
+var RETRY = "git.signInToGithub";
+var MAX_POLL_FAILURES = 3;
+var UNREACHABLE_DETAIL = "The request never reached GitHub. GitHub's device-flow endpoints send no CORS headers, so a " + "browser cannot call them directly — the desktop app can. A machine that is offline fails " + "identically, and the browser does not say which happened.";
+function getGithubToken() {
+  return nativeToken ?? localStorage.getItem(STORAGE_KEY);
+}
+function clearGithubToken() {
+  nativeToken = null;
+  nativeStored = false;
+  localStorage.removeItem(STORAGE_KEY);
+  nativeAuth()?.signOut().catch(() => {});
+}
+function reportUnreachable(error) {
+  notify2.error("Could not reach GitHub to sign in.", {
+    action: RETRY,
+    detail: `${UNREACHABLE_DETAIL}
+
+${errorMessage2(error)}`,
+    key: NOTIFY_KEY,
+    source: SOURCE
+  });
+}
+function reportRefused(message, detail) {
+  notify2.warn(message, { action: RETRY, detail, key: NOTIFY_KEY, source: SOURCE });
+}
+async function requestDeviceCode() {
+  let codeRes;
+  try {
+    codeRes = await fetch("https://github.com/login/device/code", {
+      body: JSON.stringify({ client_id: CLIENT_ID, scope: "repo" }),
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+  } catch (error) {
+    reportUnreachable(error);
+    return null;
+  }
+  if (!codeRes.ok) {
+    reportRefused("GitHub refused to start the sign-in.", `GitHub answered ${codeRes.status}${codeRes.statusText ? ` ${codeRes.statusText}` : ""}.`);
+    return null;
+  }
+  return await codeRes.json();
+}
+async function authenticateGithub() {
+  const existing = getGithubToken();
+  if (existing) {
+    return existing;
+  }
+  const native = nativeAuth();
+  if (native) {
+    try {
+      const { token } = await native.signIn();
+      nativeToken = token;
+      return token;
+    } catch (error) {
+      reportRefused("GitHub sign-in was not completed.", errorMessage2(error));
+      return null;
+    }
+  }
+  const codeData = await requestDeviceCode();
+  if (!codeData) {
+    return null;
+  }
+  const { device_code, user_code, verification_uri, interval = 5 } = codeData;
+  return new Promise((resolve) => {
+    let cancelled = false;
+    let pollTimer = null;
+    let failures = 0;
+    let answered = false;
+    const settle = (token) => {
+      if (answered) {
+        return;
+      }
+      answered = true;
+      cancelled = true;
+      if (pollTimer) {
+        clearTimeout(pollTimer);
+        pollTimer = null;
+      }
+      resolve(token);
+    };
+    let closing = false;
+    const takeDown = () => {
+      if (closing) {
+        return;
+      }
+      closing = true;
+      handle.close();
+    };
+    const done = (token) => {
+      settle(token);
+      takeDown();
+    };
+    const poll = async () => {
+      if (cancelled) {
+        return;
+      }
+      try {
+        const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+          body: JSON.stringify({
+            client_id: CLIENT_ID,
+            device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          }),
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json"
+          },
+          method: "POST"
+        });
+        const tokenData = await tokenRes.json();
+        failures = 0;
+        if (tokenData.access_token) {
+          localStorage.setItem(STORAGE_KEY, tokenData.access_token);
+          done(tokenData.access_token);
+          return;
+        }
+        if (tokenData.error === "authorization_pending") {
+          pollTimer = setTimeout(poll, interval * 1000);
+          return;
+        }
+        if (tokenData.error === "slow_down") {
+          pollTimer = setTimeout(poll, (interval + 5) * 1000);
+          return;
+        }
+        reportRefused("GitHub sign-in was not completed.", tokenData.error === "access_denied" ? "The authorization was declined on GitHub." : tokenData.error === "expired_token" ? "The device code expired before it was entered." : `GitHub answered "${tokenData.error ?? "an unrecognised response"}".`);
+        done(null);
+      } catch (error) {
+        failures += 1;
+        if (failures >= MAX_POLL_FAILURES) {
+          reportUnreachable(error);
+          done(null);
+          return;
+        }
+        pollTimer = setTimeout(poll, interval * 1000);
+      }
+    };
+    const handle = openGithubAuthSurface({
+      layer: layerHost2("dialog"),
+      onCancel: () => {
+        takeDown();
+      },
+      onClosed: () => {
+        done(null);
+      },
+      userCode: user_code,
+      verificationUri: verification_uri
+    });
+    pollTimer = setTimeout(poll, interval * 1000);
+  });
+}
+
+export { githubTokenStored, githubTokenLocation, clearGithubToken, authenticateGithub };
+
+//# debugId=6031989CF8E575E564756E2164756E21
+//# sourceMappingURL=studio-d1ja2x9r.js.map