@jxsuite/studio 2.4.3 → 4.0.0

package/dist/chunks/{studio-dgj7gq44.js → studio-v38hmvx1.js}

@@ -1,7 +1,7 @@
 import {
   getCfToken,
   setCfToken
-} from "./studio-a7pzveq1.js";
+} from "./studio-kyh9avvv.js";
 import {
   connectDeploy,
   currentDeploy,
@@ -10,20 +10,20 @@ import {
   noteDeployment,
   platformSupportsPublish,
   writeDeployConfig
-} from "./studio-aweyr4v1.js";
+} from "./studio-ahjfdy6e.js";
 import {
   activeRegistry,
   openModal
-} from "./studio-ra7ar50f.js";
+} from "./studio-t7qb9db8.js";
 import {
   html
-} from "./studio-5x5774ak.js";
+} from "./studio-kryvsw6j.js";
 import {
   projectState
-} from "./studio-cjm7fdjf.js";
+} from "./studio-p4ngc046.js";
 import {
   getPlatform
-} from "./studio-sas7mt3k.js";
+} from "./studio-9ab8gqsm.js";
 
 // src/publish/publish-panel.ts
 var PAGES_APP_INSTALL_URL = "https://github.com/apps/cloudflare-pages/installations/new";
@@ -387,4 +387,4 @@ function openPublishPanel() {
 export { seedPublishConnected, openPublishPanel };
 
 //# debugId=32DE20DAF46B08AA64756E2164756E21
-//# sourceMappingURL=studio-dgj7gq44.js.map
+//# sourceMappingURL=studio-v38hmvx1.js.map

package/dist/chunks/{studio-7ejemhej.js → studio-vadzgkrz.js}

@@ -8,16 +8,16 @@ import {
   SpectrumElement,
   property,
   query
-} from "./studio-xm3dbxvn.js";
+} from "./studio-zczps70q.js";
 import {
   css
-} from "./studio-0rqqhrdy.js";
+} from "./studio-7nte2hj4.js";
 import {
   ifDefined
-} from "./studio-twsafr1e.js";
+} from "./studio-m3hwn7y1.js";
 import {
   html
-} from "./studio-5x5774ak.js";
+} from "./studio-kryvsw6j.js";
 import {
   __require
 } from "./studio-a0tswy0w.js";
@@ -240,7 +240,7 @@ class Tooltip extends SpectrumElement {
     `;
     if (this.selfManaged) {
       this.dependencyManager.add("sp-overlay");
-      import("./sp-overlay.dev-s18hymn9.js");
+      import("./sp-overlay.dev-yztmtrs1.js");
       return html`
         <sp-overlay
           ?open=${this.open && !this.disabled && this.dependencyManager.loaded}
@@ -315,4 +315,4 @@ defineElement("sp-tooltip", Tooltip);
 export { DependencyManagerController };
 
 //# debugId=B26C538C82CA430D64756E2164756E21
-//# sourceMappingURL=studio-7ejemhej.js.map
+//# sourceMappingURL=studio-vadzgkrz.js.map

package/dist/chunks/studio-wcy8trfx.js

@@ -0,0 +1,263 @@
+import {
+  notify,
+  toRaw
+} from "./studio-xrapxwwc.js";
+
+// src/view.ts
+var view = {
+  functionEditor: null,
+  blockActionBarEl: null,
+  selDragCleanup: null,
+  dndCleanups: [],
+  elementsCollapsed: new Set,
+  elementsFilter: "",
+  _currentDropTargetRow: null,
+  layerDragSourceHeight: 0,
+  _completionRegistered: false,
+  _layersCollapsed: null
+};
+
+// src/canvas/surface-registry.ts
+var STAGE_CLASS = "pane-stage";
+var _nextGen = 0;
+function nextRenderGeneration() {
+  _nextGen += 1;
+  return _nextGen;
+}
+var _surfaces = new Map;
+function surfaceForPane(paneId) {
+  let surface = _surfaces.get(paneId);
+  if (!surface) {
+    surface = freshSurface(paneId);
+    _surfaces.set(paneId, surface);
+  }
+  return surface;
+}
+function freshSurface(paneId) {
+  return {
+    centerObserver: null,
+    monacoEditor: null,
+    needsCenter: true,
+    panX: 0,
+    panY: 0,
+    panels: [],
+    paneId,
+    panzoomWrap: null,
+    prevCanvasMode: null,
+    prevStylebookCustomizedOnly: null,
+    prevStylebookFilter: null,
+    renderGeneration: 0,
+    sourceCollabCleanup: null,
+    wrap: null
+  };
+}
+function allCanvasSurfaces() {
+  return [..._surfaces.values()];
+}
+function stageContaining(node) {
+  if (!node) {
+    return null;
+  }
+  for (const surface of _surfaces.values()) {
+    if (surface.wrap?.contains(node)) {
+      return surface;
+    }
+  }
+  return null;
+}
+function releaseMountedPanels(surface) {
+  for (const panel of surface.panels) {
+    panel.renderScope?.stop();
+    panel.renderScope = null;
+  }
+  surface.panels.length = 0;
+  surface.prevCanvasMode = null;
+}
+function registerCanvasSurface(paneId, wrap) {
+  const surface = surfaceForPane(paneId);
+  surface.wrap = wrap;
+  releaseMountedPanels(surface);
+  return surface;
+}
+function createPaneSurface(paneId) {
+  const existing = _surfaces.get(paneId);
+  if (existing) {
+    disposePaneSurface(paneId);
+  }
+  const surface = freshSurface(paneId);
+  _surfaces.set(paneId, surface);
+  return surface;
+}
+var _teardown = null;
+function setSurfaceTeardown(fn) {
+  _teardown = fn;
+}
+function disposePaneSurface(paneId) {
+  const surface = _surfaces.get(paneId);
+  if (!surface) {
+    return;
+  }
+  _teardown?.(surface);
+  releaseMountedPanels(surface);
+  unregisterCanvasSurface(paneId);
+}
+function unregisterCanvasSurface(paneId) {
+  _surfaces.delete(paneId);
+}
+
+// src/services/monaco-buffer.ts
+var BUFFER_COMMIT = "commit";
+function bufferWrites(buffer) {
+  const timers = new Map;
+  const runs = new Map;
+  const inFlight = new Map;
+  let isAhead = false;
+  let isTyped = false;
+  let isShared = false;
+  function track(key, result) {
+    if (typeof result?.then !== "function") {
+      return result;
+    }
+    const promise = result.finally(() => {
+      if (inFlight.get(key) === promise) {
+        inFlight.delete(key);
+      }
+    });
+    inFlight.set(key, promise);
+    return promise;
+  }
+  const writes = {
+    arm(key, ms, run) {
+      clearTimeout(timers.get(key));
+      runs.set(key, run);
+      timers.set(key, setTimeout(() => {
+        timers.delete(key);
+        runs.delete(key);
+        track(key, run());
+      }, ms));
+    },
+    cancel() {
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+      runs.clear();
+    },
+    flush(key) {
+      const run = runs.get(key);
+      if (!run) {
+        return inFlight.get(key);
+      }
+      clearTimeout(timers.get(key));
+      timers.delete(key);
+      runs.delete(key);
+      return track(key, run());
+    },
+    ahead: () => isAhead,
+    markAhead() {
+      isAhead = true;
+    },
+    typed: () => isTyped,
+    markTyped() {
+      isAhead = true;
+      isTyped = true;
+    },
+    markSettled() {
+      isAhead = false;
+      isTyped = false;
+    },
+    shared: () => isShared,
+    markShared() {
+      isShared = true;
+    }
+  };
+  buffer._writes = writes;
+  return writes;
+}
+var SURFACE = {
+  logic: { holds: "The handler you were typing", reached: "written into", source: "Logic" },
+  source: { holds: "The source you were typing", reached: "parsed into", source: "Editor" }
+};
+function reportDiscarded(buffer, surface, failure) {
+  const writes = buffer._writes;
+  if (writes?.typed() !== true) {
+    return true;
+  }
+  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}".`, {
+    ...failure ? { detail: describeCommitFailure(failure.error) } : {},
+    key: `buffer-discarded:${surface}:${tab?.id ?? "none"}`,
+    source,
+    ...tab?.documentPath ? { path: tab.documentPath } : {}
+  });
+  return false;
+}
+function describeCommitFailure(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+function commitBufferWrites(buffer, surface) {
+  const writes = buffer?._writes;
+  if (!buffer || !writes) {
+    return true;
+  }
+  let pending;
+  try {
+    pending = writes.flush(BUFFER_COMMIT);
+  } catch (error) {
+    writes.cancel();
+    return reportDiscarded(buffer, surface, { error });
+  }
+  writes.cancel();
+  if (typeof pending?.then === "function") {
+    pending.then(() => reportDiscarded(buffer, surface, null), (error) => reportDiscarded(buffer, surface, { error }));
+    return true;
+  }
+  return reportDiscarded(buffer, surface, null);
+}
+function cancelBufferWrites(buffer) {
+  buffer?._writes?.cancel();
+}
+function bufferIsLive(buffer) {
+  return Boolean(buffer?.getModel());
+}
+function bufferMovedOn(buffer, expected) {
+  if (!bufferIsLive(buffer) || buffer.hasTextFocus() || buffer._writes?.ahead() || buffer._writes?.shared()) {
+    return true;
+  }
+  return expected !== undefined && buffer.getValue() !== expected;
+}
+function buffersForTab(tab) {
+  const raw = toRaw(tab);
+  const mounted = [
+    ...allCanvasSurfaces().map((surface) => surface.monacoEditor),
+    view.functionEditor
+  ];
+  return mounted.filter((buffer) => buffer != null && buffer._editingTab != null && toRaw(buffer._editingTab) === raw && bufferIsLive(buffer));
+}
+async function commitTabBuffers(tab) {
+  for (const buffer of buffersForTab(tab)) {
+    if (!bufferIsLive(buffer)) {
+      continue;
+    }
+    try {
+      await buffer._writes?.flush(BUFFER_COMMIT);
+    } catch (error) {
+      notify.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",
+        ...tab.documentPath ? { path: tab.documentPath } : {}
+      });
+    }
+  }
+}
+function tabBufferUnsaved(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 };
+
+//# debugId=19DB9325F890591F64756E2164756E21
+//# sourceMappingURL=studio-wcy8trfx.js.map

package/dist/chunks/{studio-hb7c46jy.js → studio-wx5609xd.js}

@@ -1,33 +1,39 @@
+import {
+  validateProjectConfig
+} from "./studio-68n67094.js";
 import {
   renderForm,
   resolveContextPointer
-} from "./studio-ef8t53vc.js";
-import {
-  validateProjectConfig
-} from "./studio-6kv3apa9.js";
+} from "./studio-5q69gfag.js";
 import {
   deriveSecretEnvName
-} from "./studio-0b6fs05q.js";
+} from "./studio-4pqqxbrt.js";
 import {
   paneOfContainer
-} from "./studio-pyrw8h0w.js";
+} from "./studio-kjjsjak4.js";
+import {
+  commitProjectConfig
+} from "./studio-hbtp0eh1.js";
 import {
-  commitProjectConfig,
-  errorMessage,
-  notify,
   paneRegion
-} from "./studio-ra7ar50f.js";
+} from "./studio-t7qb9db8.js";
+import {
+  errorMessage
+} from "./studio-9n4mrmnb.js";
+import {
+  notify
+} from "./studio-xrapxwwc.js";
 import {
   html,
   nothing,
   render
-} from "./studio-5x5774ak.js";
+} from "./studio-kryvsw6j.js";
 import {
   projectState
-} from "./studio-cjm7fdjf.js";
+} from "./studio-p4ngc046.js";
 import {
   getPlatform
-} from "./studio-sas7mt3k.js";
+} from "./studio-9ab8gqsm.js";
 
 // src/settings/contributed-section.ts
 var selectedEntries = new Map;
@@ -331,5 +337,5 @@ function renderMapLayout(contribution, opts, rerender, paneId) {
 
 export { selectContributedEntry, renderContributedSection };
 
-//# debugId=C8B3D1846143F4B964756E2164756E21
-//# sourceMappingURL=studio-hb7c46jy.js.map
+//# debugId=1F1C350DE28120E764756E2164756E21
+//# sourceMappingURL=studio-wx5609xd.js.map