@jxsuite/studio 3.0.0 → 4.1.0

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-3dkcd4c5.js → studio-x4qkdat5.js}

@@ -1,6 +1,3 @@
-import {
-  live
-} from "./studio-c31yb4t6.js";
 import {
   BLESSED_GLOBALS,
   BLESSED_OPERATORS,
@@ -8,35 +5,38 @@ import {
   intlHelpersClause,
   rectOf,
   renderEmptyState
-} from "./studio-j595e748.js";
+} from "./studio-2b946z26.js";
 import {
   LANGUAGE_TAG_PATTERN,
-  activeTab,
-  getLayerSlot
-} from "./studio-r5xbtctf.js";
+  activeTab
+} from "./studio-trxrabqf.js";
 import {
   classMap,
   ifDefined,
   styleMap
-} from "./studio-twsafr1e.js";
+} from "./studio-m3hwn7y1.js";
+import {
+  cloneValue
+} from "./studio-5ehhackm.js";
+import {
+  getLayerSlot
+} from "./studio-t7qb9db8.js";
 import {
+  live,
   ref
-} from "./studio-kvfx9z2c.js";
+} from "./studio-4rzyrtjz.js";
 import {
   html,
   nothing,
   render
-} from "./studio-5x5774ak.js";
+} from "./studio-kryvsw6j.js";
 import {
   isFunctionDef,
   isJsonObject,
   isNamedFormulaDef,
   isRef,
   isTemplateString
-} from "./studio-cjm7fdjf.js";
-import {
-  cloneValue
-} from "./studio-5ehhackm.js";
+} from "./studio-q7v10cg2.js";
 
 // src/panels/provenance.ts
 var PROVENANCE_TITLES = {
@@ -1700,6 +1700,10 @@ var functionDefSchema = {
       description: "Named export in $src module. Defaults to the state key name.",
       type: "string"
     },
+    $lazy: {
+      description: "Load $src on first call instead of importing it up front. The function then returns a " + "promise, so it may only be called from a handler or lifecycle hook — never bound as a " + "computed value. Use it for code most visitors never reach.",
+      type: "boolean"
+    },
     $prototype: { const: "Function", type: "string" },
     $src: {
       description: "External module specifier. Mutually exclusive with body.",
@@ -2083,6 +2087,7 @@ var CLASS_METHOD_ROLES = [
   "accessor",
   "parse",
   "serialize",
+  "rewrite",
   "discover",
   "load",
   "projectData",
@@ -2098,7 +2103,7 @@ var CLASS_METHOD_ROLES = [
   "testConnection"
 ];
 var classMethodDefSchema = {
-  description: "A class method or accessor definition. Capability roles (parse, serialize, discover, load) " + "mark static methods that hosts (compiler, server, studio) invoke for format dispatch.",
+  description: "A class method or accessor definition. Capability roles (parse, serialize, rewrite, discover, load) " + "mark static methods that hosts (compiler, server, studio) invoke for format dispatch.",
   properties: {
     $prototype: { const: "Function", type: "string" },
     access: { enum: ["public", "private", "protected"], type: "string" },
@@ -3003,6 +3008,45 @@ function configFieldSchema(field) {
   return { anyOf: [declared, { $ref: "#/$defs/RefObject" }] };
 }
 
+// src/services/context-resolver.ts
+var PARAM_SEGMENT = /^\{@(\w+)\}$/;
+function resolveContextPointer(pointer, opts) {
+  if (!pointer.startsWith("#/$context/")) {
+    return;
+  }
+  const segments = [];
+  for (const raw of pointer.slice("#/$context/".length).split("/")) {
+    const match = raw.match(PARAM_SEGMENT);
+    if (match) {
+      const value = opts.scope?.[match[1]];
+      if (typeof value !== "string" && typeof value !== "number") {
+        return;
+      }
+      const substituted = String(value);
+      if (!substituted) {
+        return;
+      }
+      segments.push(substituted);
+    } else {
+      segments.push(raw);
+    }
+  }
+  if (segments[0] === "$formats") {
+    if (segments.length !== 1) {
+      return;
+    }
+    return (opts.formats ?? []).map((format) => format.name);
+  }
+  let node = opts.projectConfig;
+  for (const segment of segments) {
+    if (node === null || typeof node !== "object") {
+      return;
+    }
+    node = node[segment];
+  }
+  return node;
+}
+
 // src/ui/expression-editor.ts
 var UNARY_OPS = new Set(["!", "-"]);
 var BINARY_OPS = new Set([
@@ -4187,46 +4231,7 @@ function renderForm(schema, value, opts) {
   return html`${propertyFields}`;
 }
 
-// src/services/context-resolver.ts
-var PARAM_SEGMENT = /^\{@(\w+)\}$/;
-function resolveContextPointer(pointer, opts) {
-  if (!pointer.startsWith("#/$context/")) {
-    return;
-  }
-  const segments = [];
-  for (const raw of pointer.slice("#/$context/".length).split("/")) {
-    const match = raw.match(PARAM_SEGMENT);
-    if (match) {
-      const value = opts.scope?.[match[1]];
-      if (typeof value !== "string" && typeof value !== "number") {
-        return;
-      }
-      const substituted = String(value);
-      if (!substituted) {
-        return;
-      }
-      segments.push(substituted);
-    } else {
-      segments.push(raw);
-    }
-  }
-  if (segments[0] === "$formats") {
-    if (segments.length !== 1) {
-      return;
-    }
-    return (opts.formats ?? []).map((format) => format.name);
-  }
-  let node = opts.projectConfig;
-  for (const segment of segments) {
-    if (node === null || typeof node !== "object") {
-      return;
-    }
-    node = node[segment];
-  }
-  return node;
-}
-
-export { renderProvenanceChip, countProvenance, renderProvenanceDots, renderFieldRow, renderKvRow, renderStaticKvRow, chipSummary, renderFormulaChips, applyCatalogPick, globalEntries, namedFormulaEntries, formulaCatalog, openFormulaPalette, REDIRECT_STATUSES, VALUE_SOURCE_LABELS, slotMode, capsForPosition, isActionExpression, expressionHint, renderOperandEditor, renderExpressionEditor, switchSlotMode, renderDynamicSlot, registerFormControl, getFormControl, referenceTarget, NULL_FORM_CONTEXT, renderForm, resolveContextPointer };
+export { renderProvenanceChip, countProvenance, renderProvenanceDots, renderFieldRow, renderKvRow, renderStaticKvRow, chipSummary, renderFormulaChips, applyCatalogPick, globalEntries, namedFormulaEntries, formulaCatalog, openFormulaPalette, REDIRECT_STATUSES, VALUE_SOURCE_LABELS, slotMode, capsForPosition, resolveContextPointer, isActionExpression, expressionHint, renderOperandEditor, renderExpressionEditor, switchSlotMode, renderDynamicSlot, registerFormControl, getFormControl, referenceTarget, NULL_FORM_CONTEXT, renderForm };
 
-//# debugId=D548DF8319DDE4D664756E2164756E21
-//# sourceMappingURL=studio-3dkcd4c5.js.map
+//# debugId=DDC68693A8D15CAC64756E2164756E21
+//# sourceMappingURL=studio-x4qkdat5.js.map

package/dist/chunks/studio-x813zp48.js

@@ -0,0 +1,195 @@
+import {
+  clearAiProvider,
+  getBaseUrl,
+  hasOpenAiKey,
+  preferredModel,
+  resetModelCache
+} from "./studio-dm19q43r.js";
+import {
+  clearCfConnection,
+  getCfAccountId,
+  getCfToken
+} from "./studio-kyh9avvv.js";
+import {
+  clearGithubToken,
+  githubTokenLocation,
+  githubTokenStored
+} from "./studio-1ngbejft.js";
+import {
+  getPlatform,
+  hasPlatform
+} from "./studio-9ab8gqsm.js";
+import {
+  __require
+} from "./studio-a0tswy0w.js";
+
+// src/settings/preferences-accounts.ts
+var _cfState = "checking";
+var _cfInFlight = null;
+function platformBrokersCf() {
+  return hasPlatform() && Boolean(getPlatform().cfConnect);
+}
+async function refreshCfConnection() {
+  if (!platformBrokersCf()) {
+    return;
+  }
+  _cfInFlight ??= (async () => {
+    try {
+      _cfState = await getPlatform().cfConnection?.() ?? null;
+    } catch {
+      _cfState = null;
+    }
+    _cfInFlight = null;
+    notifyCredentialsChanged();
+  })();
+  await _cfInFlight;
+}
+function ensureCfConnection() {
+  if (platformBrokersCf() && _cfState === "checking" && !_cfInFlight) {
+    refreshCfConnection();
+  }
+}
+function resetCfConnectionCache() {
+  _cfState = "checking";
+  _cfInFlight = null;
+}
+async function hostedConnect() {
+  const outcome = await getPlatform().cfConnect?.();
+  if (outcome?.status === "connected" && !outcome.connection.accountId) {
+    const { openCfAccountPicker } = await import("./cf-account-picker-en86v7x7.js");
+    await openCfAccountPicker();
+  }
+  resetModelCache();
+  await refreshCfConnection();
+}
+function brokeredCloudflareRecord() {
+  const disconnect = {
+    id: "disconnect",
+    label: "Disconnect",
+    run: async () => {
+      await getPlatform().cfDisconnect?.();
+      resetModelCache();
+      await refreshCfConnection();
+    },
+    variant: "negative"
+  };
+  const connect = (label) => ({
+    id: label === "Connect" ? "connect" : "reconnect",
+    label,
+    run: hostedConnect,
+    variant: "accent"
+  });
+  const base = { id: "cloudflare", label: "Cloudflare", revoke: () => {} };
+  if (_cfState === "checking") {
+    return { ...base, actions: [], connected: false, detail: "Checking your connection…" };
+  }
+  if (!_cfState?.connected) {
+    return {
+      ...base,
+      actions: [connect("Connect")],
+      connected: false,
+      detail: "Not connected. Connecting publishes this site and runs the assistant on Workers AI."
+    };
+  }
+  const revoke = () => {
+    disconnect.run();
+  };
+  if (_cfState.needsReconnect) {
+    return {
+      ...base,
+      actions: [connect("Reconnect"), disconnect],
+      connected: true,
+      detail: "Connection expired. Reconnect to keep publishing and the assistant working.",
+      revoke
+    };
+  }
+  if (_cfState.needsAccount || !_cfState.accountId) {
+    return {
+      ...base,
+      actions: [
+        {
+          id: "choose-account",
+          label: "Choose account",
+          run: async () => {
+            const { openCfAccountPicker } = await import("./cf-account-picker-en86v7x7.js");
+            if (await openCfAccountPicker()) {
+              resetModelCache();
+              await refreshCfConnection();
+            }
+          },
+          variant: "accent"
+        },
+        disconnect
+      ],
+      connected: true,
+      detail: "Connected, but no account is chosen yet — publishing and the assistant need one.",
+      revoke
+    };
+  }
+  return {
+    ...base,
+    actions: [disconnect],
+    connected: true,
+    detail: `Connected — ${_cfState.accountName ?? _cfState.accountId}.`,
+    revoke
+  };
+}
+function localCloudflareRecord() {
+  const cfToken = getCfToken();
+  const cfAccount = getCfAccountId();
+  return {
+    connected: Boolean(cfToken),
+    detail: cfToken ? `Connected${cfAccount ? ` — account ${cfAccount}` : ""}.` : "Not connected. Publishing will ask when it needs it.",
+    id: "cloudflare",
+    label: "Cloudflare",
+    revoke: clearCfConnection
+  };
+}
+function listAccounts() {
+  const githubToken = githubTokenStored();
+  const model = preferredModel();
+  const endpoint = getBaseUrl();
+  return [
+    {
+      id: "github",
+      label: "GitHub",
+      detail: githubToken ? githubTokenLocation() === "desktop" ? "Signed in — the token is in this app's config folder, readable only by you." : "Signed in — a device-flow token is stored in this browser." : "Not signed in. Cloning and pushing will ask when they need it.",
+      connected: Boolean(githubToken),
+      revoke: clearGithubToken
+    },
+    {
+      id: "ai",
+      label: "AI provider",
+      detail: hasOpenAiKey() ? `Key stored. Model ${model}${endpoint ? ` via ${endpoint}` : ""}.` : "No key stored. The Assistant section is where one is entered.",
+      connected: hasOpenAiKey(),
+      revoke: clearAiProvider
+    },
+    platformBrokersCf() ? brokeredCloudflareRecord() : localCloudflareRecord()
+  ];
+}
+function revokeAccount(id) {
+  const account = listAccounts().find((candidate) => candidate.id === id);
+  if (!account) {
+    return false;
+  }
+  account.revoke();
+  notifyCredentialsChanged();
+  return true;
+}
+var _listeners = new Set;
+function onCredentialsChanged(listener) {
+  _listeners.add(listener);
+  return () => {
+    _listeners.delete(listener);
+  };
+}
+function notifyCredentialsChanged() {
+  for (const listener of _listeners) {
+    listener();
+  }
+}
+
+export { platformBrokersCf, refreshCfConnection, ensureCfConnection, resetCfConnectionCache, listAccounts, revokeAccount, onCredentialsChanged, notifyCredentialsChanged };
+
+//# debugId=ECD354251070A96664756E2164756E21
+//# sourceMappingURL=studio-x813zp48.js.map