@jxsuite/studio 4.1.0 → 5.0.0

package/dist/chunks/{studio-t5wqwzdh.js → studio-tjjk7jvk.js}

@@ -71,4 +71,4 @@ var documentPathsUnknownSourceMember = {
 };
 
 //# debugId=48AAE1140CF35C2C64756E2164756E21
-//# sourceMappingURL=studio-t5wqwzdh.js.map
+//# sourceMappingURL=studio-tjjk7jvk.js.map

package/dist/chunks/studio-vhv5tgxm.js

@@ -0,0 +1,51 @@
+// src/services/model-uri.ts
+var ENTRY_SCHEMA_FILES = new Set(["project.schema.json", "document.schema.json"]);
+function modelUriFor(path) {
+  return ENTRY_SCHEMA_FILES.has(path) ? `file:///.jx/generated/${path}` : `file:///${path}`;
+}
+function diffModelUrisFor(paneId, path) {
+  return {
+    head: `file:///.jx/diff/${paneId}/head/${path}`,
+    work: `file:///.jx/diff/${paneId}/work/${path}`
+  };
+}
+function monacoLangForPath(path) {
+  const ext = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+  switch (ext) {
+    case "cjs":
+    case "js":
+    case "mjs": {
+      return "javascript";
+    }
+    case "css": {
+      return "css";
+    }
+    case "htm":
+    case "html": {
+      return "html";
+    }
+    case "json": {
+      return "json";
+    }
+    case "md": {
+      return "markdown";
+    }
+    case "cts":
+    case "mts":
+    case "ts": {
+      return "typescript";
+    }
+    case "yaml":
+    case "yml": {
+      return "yaml";
+    }
+    default: {
+      return "plaintext";
+    }
+  }
+}
+
+export { modelUriFor, diffModelUrisFor, monacoLangForPath };
+
+//# debugId=9F8E4AF0009A2A9C64756E2164756E21
+//# sourceMappingURL=studio-vhv5tgxm.js.map

package/dist/chunks/{studio-qjy2z9bv.js → studio-vz68yn9e.js}

@@ -1,36 +1,30 @@
 import {
-  PUBLIC_DIR,
-  contentMountFor,
-  encodeProjectPath,
-  hostAssetDeclarations,
-  loopbackAssetSrc,
-  normalizeProjectPath,
-  projectLocales
-} from "./studio-2b946z26.js";
+  errorMessage2
+} from "./studio-yxa81f45.js";
 import {
-  activeTab
-} from "./studio-trxrabqf.js";
+  getPlatform2,
+  hasPlatform2
+} from "./studio-6nzaktvy.js";
 import {
-  getNodeAtPath,
-  projectState
-} from "./studio-p4ngc046.js";
+  notify2
+} from "./studio-p1dw8wfw.js";
 import {
-  errorMessage
-} from "./studio-9n4mrmnb.js";
-import {
-  notify
-} from "./studio-xrapxwwc.js";
+  projectState
+} from "./studio-6ewqv390.js";
 import {
-  isJsonObject,
-  paramNames
-} from "./studio-q7v10cg2.js";
+  activeTab2
+} from "./studio-az3zd49t.js";
 import {
-  loadedMonaco
-} from "./studio-ahn3pdgx.js";
+  PUBLIC_DIR,
+  normalizeProjectPath,
+  encodeProjectPath
+} from "./studio-5jy81t3s.js";
 import {
-  getPlatform,
-  hasPlatform
-} from "./studio-9ab8gqsm.js";
+  contentMountFor,
+  loopbackAssetSrc,
+  projectLocales2,
+  hostAssetDeclarations
+} from "./studio-4m0haseg.js";
 
 // src/files/media-upload.ts
 var IMAGE_EXTENSIONS = new Set([
@@ -78,7 +72,7 @@ var DEFAULT_ACCEPT = [
   ".otf"
 ].join(",");
 function uploadAccept() {
-  const declared = hasPlatform() ? getPlatform().assetCapabilities?.accept : undefined;
+  const declared = hasPlatform2() ? getPlatform2().assetCapabilities?.accept : undefined;
   return declared ?? DEFAULT_ACCEPT;
 }
 function extensionOf(name) {
@@ -158,8 +152,8 @@ async function uploadAssets(files, opts = {}) {
   if (list.length === 0) {
     return [];
   }
-  const platform = getPlatform();
-  const dir = opts.dir ?? uploadDirFor(activeTab.value?.documentPath ?? null);
+  const platform = getPlatform2();
+  const dir = opts.dir ?? uploadDirFor(activeTab2.value?.documentPath ?? null);
   let taken;
   try {
     const existing = await platform.listDirectory(dir);
@@ -167,11 +161,11 @@ async function uploadAssets(files, opts = {}) {
   } catch {
     taken = new Set;
   }
-  const maxBytes = hasPlatform() ? getPlatform().assetCapabilities?.maxUploadBytes : undefined;
+  const maxBytes = hasPlatform2() ? getPlatform2().assetCapabilities?.maxUploadBytes : undefined;
   const uploaded = [];
   for (const file of list) {
     if (maxBytes !== undefined && file.size > maxBytes) {
-      notify.error(`${file.name} is too large.`, {
+      notify2.error(`${file.name} is too large.`, {
         detail: `This backend accepts at most ${formatBytes(maxBytes)}; that file is ${formatBytes(file.size)}.`,
         source: "Media"
       });
@@ -184,119 +178,20 @@ async function uploadAssets(files, opts = {}) {
       const { path } = await platform.uploadFile(requested, file);
       uploaded.push({ kind: mediaKind(file), name, path, ref: assetRef(path) });
     } catch (error) {
-      notify.error(`Could not upload ${file.name}.`, {
-        detail: errorMessage(error),
+      notify2.error(`Could not upload ${file.name}.`, {
+        detail: errorMessage2(error),
         path: requested,
         source: "Media"
       });
     }
   }
   if (uploaded.length > 0) {
-    notify.success(uploaded.length === 1 ? `Uploaded ${uploaded[0].name} to ${dir}/` : `Uploaded ${uploaded.length} files to ${dir}/`);
+    notify2.success(uploaded.length === 1 ? `Uploaded ${uploaded[0].name} to ${dir}/` : `Uploaded ${uploaded.length} files to ${dir}/`);
     await mediaChangedHandler?.(dir);
   }
   return uploaded;
 }
 
-// src/services/code-services.ts
-async function codeService(action, payload) {
-  const platform = getPlatform();
-  if (!platform.codeService) {
-    return null;
-  }
-  return platform.codeService(action, payload);
-}
-async function locateDocument(name) {
-  const platform = getPlatform();
-  if (!platform.locateFile) {
-    return null;
-  }
-  return platform.locateFile(name);
-}
-var pluginSchemaCache = new Map;
-async function fetchPluginSchema(def, state) {
-  const importedPath = def.$prototype ? projectState?.projectConfig?.imports?.[def.$prototype] : null;
-  const src = def.$src || importedPath;
-  if (!src || !def.$prototype) {
-    return null;
-  }
-  const cacheKey = `${src}::${def.$prototype}`;
-  if (pluginSchemaCache.has(cacheKey)) {
-    return pluginSchemaCache.get(cacheKey);
-  }
-  try {
-    const platform = getPlatform();
-    if (!platform.fetchPluginSchema) {
-      pluginSchemaCache.set(cacheKey, null);
-      return null;
-    }
-    const base = !importedPath && state.documentPath ? `${location.origin}/${state.documentPath}` : undefined;
-    const schema = await platform.fetchPluginSchema(src, def.$prototype, base);
-    pluginSchemaCache.set(cacheKey, schema);
-    return schema;
-  } catch {
-    pluginSchemaCache.set(cacheKey, null);
-    return null;
-  }
-}
-function setLintMarkers(editor, diagnostics) {
-  const model = editor.getModel();
-  if (!model) {
-    return;
-  }
-  const monaco = loadedMonaco();
-  if (!monaco) {
-    return;
-  }
-  const markers = diagnostics.map((d) => {
-    const label = d.labels?.[0];
-    if (!label) {
-      return null;
-    }
-    const { line, column, length } = label.span;
-    return {
-      code: d.url ? { target: monaco.Uri.parse(d.url), value: d.code } : d.code,
-      endColumn: column + (length || 1),
-      endLineNumber: line,
-      message: d.message + (d.help ? `
-${d.help}` : ""),
-      severity: d.severity === "error" ? monaco.MarkerSeverity.Error : monaco.MarkerSeverity.Warning,
-      source: "oxlint",
-      startColumn: column,
-      startLineNumber: line
-    };
-  }).filter(Boolean);
-  monaco.editor.setModelMarkers(model, "oxlint", markers);
-}
-function getFunctionArgs(editing, document) {
-  const fromDef = (def) => {
-    if (!isJsonObject(def)) {
-      return null;
-    }
-    const params = def.parameters;
-    if (!Array.isArray(params) || params.length === 0) {
-      return null;
-    }
-    return paramNames(params);
-  };
-  if (editing.type === "def") {
-    const args = editing.defName ? fromDef(document?.state?.[editing.defName]) : null;
-    if (args) {
-      return args;
-    }
-  } else if (editing.type === "event") {
-    if (!document || !editing.path) {
-      return ["state", "event"];
-    }
-    const node = getNodeAtPath(document, editing.path);
-    const args = node && editing.eventKey ? fromDef(node[editing.eventKey]) : null;
-    if (args) {
-      return args;
-    }
-  }
-  return ["state", "event"];
-}
-
 // src/files/media-paths.ts
 function baseName(path) {
   const normalized = normalizeProjectPath(path);
@@ -313,7 +208,7 @@ function contentSections() {
   return content ?? null;
 }
 function mountOf(path) {
-  return contentMountFor(path, contentSections(), projectLocales());
+  return contentMountFor(path, contentSections(), projectLocales2());
 }
 function mountedPath(path, mount) {
   const prefix = normalizeProjectPath(mount.urlPrefix);
@@ -339,7 +234,7 @@ function previewFileSrc(path) {
   return loopbackAssetSrc(mediaSiteUrl(normalized));
 }
 
-export { IMAGE_EXTENSIONS, MEDIA_EXTENSIONS, uploadAccept, extensionOf, isImage, isMediaFile, mediaKind, setMediaChangedHandler, uploadAssets, baseName, dirName, mediaSiteUrl, previewFileSrc, codeService, locateDocument, pluginSchemaCache, fetchPluginSchema, setLintMarkers, getFunctionArgs };
+export { IMAGE_EXTENSIONS, MEDIA_EXTENSIONS, uploadAccept, extensionOf, isImage, isMediaFile, mediaKind, setMediaChangedHandler, uploadAssets, baseName, dirName, mediaSiteUrl, previewFileSrc };
 
-//# debugId=2FA1FC61EEB22B4F64756E2164756E21
-//# sourceMappingURL=studio-qjy2z9bv.js.map
+//# debugId=4C51950010FE40AA64756E2164756E21
+//# sourceMappingURL=studio-vz68yn9e.js.map

package/dist/chunks/studio-wqpngpsk.js

@@ -0,0 +1,174 @@
+// ../collab/src/diff-core.ts
+var DEFAULT_MAX_OPS = 500;
+
+class MaxOpsExceededError extends Error {
+  name = "MaxOpsExceededError";
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual2(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => deepEqual2(item, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    return keysA.length === keysB.length && keysA.every((key) => (key in b) && deepEqual2(a[key], b[key]));
+  }
+  return false;
+}
+function contentHash(text) {
+  let hash = 5381;
+  for (let i = 0;i < text.length; i++) {
+    hash = Math.imul(hash, 33) + (text.codePointAt(i) ?? 0);
+  }
+  return hash.toString(36);
+}
+function strongKey(item) {
+  return typeof item === "string" ? `s:${item}` : `n:${contentHash(JSON.stringify(item))}`;
+}
+function weakKey(item) {
+  if (typeof item === "string") {
+    return "s";
+  }
+  const node = item;
+  const attrs = node["attributes"];
+  const props = node["$props"];
+  const id = (isPlainObject(attrs) ? attrs["id"] : undefined) ?? (isPlainObject(props) ? props["key"] : undefined) ?? "";
+  return `w:${String(node["tagName"] ?? "")}:${String(id)}`;
+}
+function lcsPairs(aKeys, bKeys, maxCells = Number.POSITIVE_INFINITY) {
+  const n = aKeys.length;
+  const m = bKeys.length;
+  if (n === 0 || m === 0 || n * m > maxCells) {
+    return [];
+  }
+  const table = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }, () => 0));
+  for (let i = n - 1;i >= 0; i--) {
+    for (let j = m - 1;j >= 0; j--) {
+      table[i][j] = aKeys[i] === bKeys[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (aKeys[i] === bKeys[j]) {
+      pairs.push([i, j]);
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      i += 1;
+    } else {
+      j += 1;
+    }
+  }
+  return pairs;
+}
+function matchChildren(a, b, opts = {}) {
+  const maxCells = opts.maxCells ?? Number.POSITIVE_INFINITY;
+  const anchors = lcsPairs(a.map((item) => strongKey(item)), b.map((item) => strongKey(item)), maxCells);
+  const matches = [];
+  let prevA = -1;
+  let prevB = -1;
+  const gaps = [];
+  for (const [ai, bi] of anchors) {
+    gaps.push([prevA + 1, ai, prevB + 1, bi]);
+    matches.push({ aIndex: ai, bIndex: bi, identical: true });
+    prevA = ai;
+    prevB = bi;
+  }
+  gaps.push([prevA + 1, a.length, prevB + 1, b.length]);
+  for (const [aStart, aEnd, bStart, bEnd] of gaps) {
+    const aGap = a.slice(aStart, aEnd);
+    const bGap = b.slice(bStart, bEnd);
+    for (const [gi, gj] of lcsPairs(aGap.map((item) => weakKey(item)), bGap.map((item) => weakKey(item)), maxCells)) {
+      matches.push({ aIndex: aStart + gi, bIndex: bStart + gj, identical: false });
+    }
+  }
+  return matches.toSorted((x, y) => x.aIndex - y.aIndex);
+}
+
+class Differ {
+  ops = [];
+  maxOps;
+  constructor(maxOps) {
+    this.maxOps = maxOps;
+  }
+  result() {
+    return this.ops;
+  }
+  push(op) {
+    if (this.ops.length >= this.maxOps) {
+      throw new MaxOpsExceededError;
+    }
+    this.ops.push(op);
+  }
+  diffNode(path, a, b) {
+    for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+      if (key === "children") {
+        continue;
+      }
+      if (!(key in b)) {
+        this.push({ key, op: "set-key", path });
+      } else if (!deepEqual2(a[key], b[key])) {
+        this.push({ key, op: "set-key", path, value: b[key] });
+      }
+    }
+    const ca = a["children"];
+    const cb = b["children"];
+    if (Array.isArray(ca) && Array.isArray(cb)) {
+      this.diffChildren(path, ca, cb);
+    } else if (!deepEqual2(ca, cb)) {
+      this.push({ key: "children", op: "set-key", path, value: cb });
+    }
+  }
+  diffChildren(path, a, b) {
+    const matches = matchChildren(a, b);
+    const matchedA = new Set(matches.map((match) => match.aIndex));
+    const byB = new Map(matches.map((match) => [match.bIndex, match]));
+    for (let i = a.length - 1;i >= 0; i--) {
+      if (!matchedA.has(i)) {
+        this.push({ index: i, op: "remove-child", parentPath: path });
+      }
+    }
+    for (let i = 0;i < b.length; i++) {
+      const match = byB.get(i);
+      if (!match) {
+        this.push({ index: i, node: b[i], op: "insert-child", parentPath: path });
+        continue;
+      }
+      if (match.identical) {
+        continue;
+      }
+      const aItem = a[match.aIndex];
+      const bItem = b[i];
+      if (isPlainObject(aItem) && isPlainObject(bItem)) {
+        this.diffNode([...path, "children", i], aItem, bItem);
+      } else if (!deepEqual2(aItem, bItem)) {
+        this.push({ index: i, node: bItem, op: "set-child", parentPath: path });
+      }
+    }
+  }
+}
+function diffDocs2(a, b, opts = {}) {
+  const differ = new Differ(opts.maxOps ?? DEFAULT_MAX_OPS);
+  try {
+    differ.diffNode([], a, b);
+  } catch (error) {
+    if (error instanceof MaxOpsExceededError) {
+      return null;
+    }
+    throw error;
+  }
+  return differ.result();
+}
+
+export { deepEqual2, matchChildren, diffDocs2 };
+
+//# debugId=B46EF0DE7467ED2964756E2164756E21
+//# sourceMappingURL=studio-wqpngpsk.js.map