@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/{studio-wcy8trfx.js → studio-q3x06vmj.js}

@@ -1,7 +1,7 @@
 import {
-  notify,
-  toRaw
-} from "./studio-xrapxwwc.js";
+  toRaw,
+  notify2
+} from "./studio-p1dw8wfw.js";
 
 // src/view.ts
 var view = {
@@ -18,7 +18,6 @@ var view = {
 };
 
 // src/canvas/surface-registry.ts
-var STAGE_CLASS = "pane-stage";
 var _nextGen = 0;
 function nextRenderGeneration() {
   _nextGen += 1;
@@ -36,6 +35,7 @@ function surfaceForPane(paneId) {
 function freshSurface(paneId) {
   return {
     centerObserver: null,
+    monacoDiffEditor: null,
     monacoEditor: null,
     needsCenter: true,
     panX: 0,
@@ -43,6 +43,7 @@ function freshSurface(paneId) {
     panels: [],
     paneId,
     panzoomWrap: null,
+    stage: null,
     prevCanvasMode: null,
     prevStylebookCustomizedOnly: null,
     prevStylebookFilter: null,
@@ -106,8 +107,8 @@ function unregisterCanvasSurface(paneId) {
 }
 
 // src/services/monaco-buffer.ts
-var BUFFER_COMMIT = "commit";
-function bufferWrites(buffer) {
+var BUFFER_COMMIT2 = "commit";
+function bufferWrites2(buffer) {
   const timers = new Map;
   const runs = new Map;
   const inFlight = new Map;
@@ -186,7 +187,7 @@ function reportDiscarded(buffer, surface, failure) {
   const tab = buffer._editingTab ?? null;
   const where = tab?.documentPath ?? "Untitled";
   const { holds, reached, source } = SURFACE[surface];
-  notify.warn(`${holds} was discarded — it was never ${reached} "${where}".`, {
+  notify2.warn(`${holds} was discarded — it was never ${reached} "${where}".`, {
     ...failure ? { detail: describeCommitFailure(failure.error) } : {},
     key: `buffer-discarded:${surface}:${tab?.id ?? "none"}`,
     source,
@@ -197,14 +198,14 @@ function reportDiscarded(buffer, surface, failure) {
 function describeCommitFailure(error) {
   return error instanceof Error ? error.stack ?? error.message : String(error);
 }
-function commitBufferWrites(buffer, surface) {
+function commitBufferWrites2(buffer, surface) {
   const writes = buffer?._writes;
   if (!buffer || !writes) {
     return true;
   }
   let pending;
   try {
-    pending = writes.flush(BUFFER_COMMIT);
+    pending = writes.flush(BUFFER_COMMIT2);
   } catch (error) {
     writes.cancel();
     return reportDiscarded(buffer, surface, { error });
@@ -216,14 +217,14 @@ function commitBufferWrites(buffer, surface) {
   }
   return reportDiscarded(buffer, surface, null);
 }
-function cancelBufferWrites(buffer) {
+function cancelBufferWrites2(buffer) {
   buffer?._writes?.cancel();
 }
-function bufferIsLive(buffer) {
+function bufferIsLive2(buffer) {
   return Boolean(buffer?.getModel());
 }
-function bufferMovedOn(buffer, expected) {
-  if (!bufferIsLive(buffer) || buffer.hasTextFocus() || buffer._writes?.ahead() || buffer._writes?.shared()) {
+function bufferMovedOn2(buffer, expected) {
+  if (!bufferIsLive2(buffer) || buffer.hasTextFocus() || buffer._writes?.ahead() || buffer._writes?.shared()) {
     return true;
   }
   return expected !== undefined && buffer.getValue() !== expected;
@@ -234,17 +235,17 @@ function buffersForTab(tab) {
     ...allCanvasSurfaces().map((surface) => surface.monacoEditor),
     view.functionEditor
   ];
-  return mounted.filter((buffer) => buffer != null && buffer._editingTab != null && toRaw(buffer._editingTab) === raw && bufferIsLive(buffer));
+  return mounted.filter((buffer) => buffer != null && buffer._editingTab != null && toRaw(buffer._editingTab) === raw && bufferIsLive2(buffer));
 }
-async function commitTabBuffers(tab) {
+async function commitTabBuffers2(tab) {
   for (const buffer of buffersForTab(tab)) {
-    if (!bufferIsLive(buffer)) {
+    if (!bufferIsLive2(buffer)) {
       continue;
     }
     try {
-      await buffer._writes?.flush(BUFFER_COMMIT);
+      await buffer._writes?.flush(BUFFER_COMMIT2);
     } catch (error) {
-      notify.error(`Could not save the editor's contents into "${tab.documentPath ?? "Untitled"}".`, {
+      notify2.error(`Could not save the editor's contents into "${tab.documentPath ?? "Untitled"}".`, {
         detail: error instanceof Error ? error.stack ?? error.message : String(error),
         key: `buffer-commit:${tab.id}`,
         source: "Editor",
@@ -253,11 +254,11 @@ async function commitTabBuffers(tab) {
     }
   }
 }
-function tabBufferUnsaved(tab) {
+function tabBufferUnsaved2(tab) {
   return buffersForTab(tab).some((buffer) => buffer._writes?.typed() === true);
 }
 
-export { view, STAGE_CLASS, nextRenderGeneration, surfaceForPane, allCanvasSurfaces, stageContaining, registerCanvasSurface, createPaneSurface, setSurfaceTeardown, disposePaneSurface, BUFFER_COMMIT, bufferWrites, commitBufferWrites, cancelBufferWrites, bufferIsLive, bufferMovedOn, commitTabBuffers, tabBufferUnsaved };
+export { view, nextRenderGeneration, surfaceForPane, allCanvasSurfaces, stageContaining, registerCanvasSurface, createPaneSurface, setSurfaceTeardown, disposePaneSurface, BUFFER_COMMIT2, bufferWrites2, commitBufferWrites2, cancelBufferWrites2, bufferIsLive2, bufferMovedOn2, commitTabBuffers2, tabBufferUnsaved2 };
 
-//# debugId=19DB9325F890591F64756E2164756E21
-//# sourceMappingURL=studio-wcy8trfx.js.map
+//# debugId=CEB2BECD922331C964756E2164756E21
+//# sourceMappingURL=studio-q3x06vmj.js.map

package/dist/chunks/{studio-6yw4y3my.js → studio-qhhm6hbt.js}

@@ -1,19 +1,19 @@
 import {
-  collectionInfo
-} from "./studio-b55y6ewx.js";
+  projectState
+} from "./studio-6ewqv390.js";
 import {
   findContentTypeSchema
-} from "./studio-trxrabqf.js";
+} from "./studio-k75n7vhp.js";
 import {
-  projectState
-} from "./studio-p4ngc046.js";
+  collectionInfo2
+} from "./studio-1knfqgy7.js";
 
 // src/content/entry-model.ts
 function collectionNames() {
   return Object.keys(projectState?.projectConfig?.content ?? {});
 }
 function entryCollection(name) {
-  const info = collectionInfo(name);
+  const info = collectionInfo2(name);
   if (!info) {
     return null;
   }
@@ -87,5 +87,5 @@ function missingRequired(schema, value) {
 
 export { entryCollection, entryCollections, collectionOfPath, seedEntry, missingRequired };
 
-//# debugId=4E0453F542F313E864756E2164756E21
-//# sourceMappingURL=studio-6yw4y3my.js.map
+//# debugId=DEACD1047368F5A364756E2164756E21
+//# sourceMappingURL=studio-qhhm6hbt.js.map

package/dist/chunks/studio-qk4bfsq2.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-vfq8qpjt.js";
+import {
+  showModal,
+  close2
+} from "./studio-kkqkcp3d.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-qk4bfsq2.js.map