@jxsuite/studio 4.1.0 → 5.1.0

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-ahn3pdgx.js → studio-vw7mzp6z.js}

@@ -1,9 +1,9 @@
 import {
-  getPlatform
-} from "./studio-9ab8gqsm.js";
+  getPlatform2
+} from "./studio-6nzaktvy.js";
 import {
-  __require
-} from "./studio-a0tswy0w.js";
+  __preload
+} from "./studio-5te5tqng.js";
 
 // src/services/monaco-lazy.ts
 var _monaco = null;
@@ -21,7 +21,7 @@ async function applyPendingSchemas() {
   }
   _pendingSchemasDirty = false;
   try {
-    const { applyProjectSchemas } = await import("./monaco-setup-vx9bhp1d.js");
+    const { applyProjectSchemas } = await (__preload("8r62fj6y"), import("./monaco-setup-8r62fj6y.js"));
     applyProjectSchemas(_pendingSchemas);
   } catch {}
 }
@@ -31,8 +31,8 @@ function loadMonaco() {
   }
   _loading ??= (async () => {
     const [monaco] = await Promise.all([
-      import("./editor-cptq5jp1.js"),
-      import("./monaco-setup-vx9bhp1d.js")
+      (__preload("3qhbg51x"), import("./editor-3qhbg51x.js")),
+      (__preload("8r62fj6y"), import("./monaco-setup-8r62fj6y.js"))
     ]);
     _monaco = monaco;
     await applyPendingSchemas();
@@ -53,11 +53,11 @@ function mountStillWanted(container, existing, stillTargeted) {
 // src/format/format-host.ts
 var _formats = [];
 var _loaded = null;
-function loadFormats() {
+function loadFormats2() {
   if (!_loaded) {
     _loaded = (async () => {
       try {
-        const platform = getPlatform();
+        const platform = getPlatform2();
         _formats = await platform.listFormats?.() ?? [];
       } catch {
         _formats = [];
@@ -67,23 +67,21 @@ function loadFormats() {
   }
   return _loaded;
 }
-function refreshFormats() {
+function refreshFormats2() {
   _loaded = null;
   _formats = [];
   _extensionsLoaded = null;
   _extensions = [];
-}
-function setFormats(formats) {
-  _formats = formats;
-  _loaded = Promise.resolve(formats);
+  _catalogLoaded = null;
+  _catalog = [];
 }
 var _extensions = [];
 var _extensionsLoaded = null;
-function loadExtensions() {
+function loadExtensions2() {
   if (!_extensionsLoaded) {
     _extensionsLoaded = (async () => {
       try {
-        const platform = getPlatform();
+        const platform = getPlatform2();
         _extensions = await platform.listExtensions?.() ?? [];
       } catch {
         _extensions = [];
@@ -93,12 +91,27 @@ function loadExtensions() {
   }
   return _extensionsLoaded;
 }
-function getExtensions() {
+function getExtensions2() {
   return _extensions;
 }
-function setExtensions(extensions) {
-  _extensions = extensions;
-  _extensionsLoaded = Promise.resolve(extensions);
+var _catalog = [];
+var _catalogLoaded = null;
+function loadExtensionCatalog() {
+  if (!_catalogLoaded) {
+    _catalogLoaded = (async () => {
+      try {
+        const platform = getPlatform2();
+        _catalog = await platform.listExtensionCatalog?.() ?? [];
+      } catch {
+        _catalog = [];
+      }
+      return _catalog;
+    })();
+  }
+  return _catalogLoaded;
+}
+function getExtensionCatalog2() {
+  return _catalog;
 }
 async function shareProjectSchemas(platform) {
   let schemas = null;
@@ -106,29 +119,30 @@ async function shareProjectSchemas(platform) {
     schemas = await platform.fetchProjectSchemas?.() ?? null;
   } catch {}
   setProjectSchemasForMonaco(schemas);
-  await import("./jx-validate-8er6gbxy.js").then(({ applyProjectSchemas }) => applyProjectSchemas(schemas)).catch(() => false);
+  await (__preload("j0wxk72w"), import("./jx-validate-j0wxk72w.js")).then(({ applyProjectSchemas }) => applyProjectSchemas(schemas)).catch(() => false);
 }
-function refreshExtensionUi(platform) {
+function refreshExtensionUi2(platform) {
   shareProjectSchemas(platform);
-  import("./extension-sections-txv08xxg.js").then(({ syncExtensionSettingsSections }) => syncExtensionSettingsSections()).catch(() => {});
+  loadExtensionCatalog();
+  (__preload("3hpcambp"), import("./extension-sections-3hpcambp.js")).then(({ syncExtensionSettingsSections }) => syncExtensionSettingsSections()).catch(() => {});
 }
-function getFormats() {
+function getFormats2() {
   return _formats;
 }
-function formatByExtension(ext, capability) {
+function formatByExtension2(ext, capability) {
   const norm = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
   return _formats.find((f) => f.extensions.includes(norm) && (!capability || f.capabilities[capability]));
 }
-function formatByName(name) {
+function formatByName2(name) {
   if (!name) {
     return;
   }
   return _formats.find((f) => f.name === name);
 }
-function noFormatError(path) {
+function noFormatError2(path) {
   return new Error(`No format class imported for "${path}" — add one to project.json imports ` + `(e.g. "Markdown": "@jxsuite/parser/Markdown.class.json") and make sure the project's dependencies are installed`);
 }
-function formatForPath(path) {
+function formatForPath2(path) {
   if (!path) {
     return;
   }
@@ -136,9 +150,9 @@ function formatForPath(path) {
   if (dot === -1) {
     return;
   }
-  return formatByExtension(path.slice(dot));
+  return formatByExtension2(path.slice(dot));
 }
-function documentExtensions(kind) {
+function documentExtensions2(kind) {
   const exts = new Set;
   for (const f of _formats) {
     if (kind && !f.documentKinds.includes(kind)) {
@@ -151,17 +165,17 @@ function documentExtensions(kind) {
   exts.delete(".json");
   return [...exts];
 }
-function defaultContentFormat() {
+function defaultContentFormat2() {
   return _formats.find((f) => f.capabilities.serialize && f.documentKinds.includes("content"));
 }
 async function formatAction(payload) {
-  const platform = getPlatform();
+  const platform = getPlatform2();
   if (!platform.formatAction) {
     throw new Error("Platform does not support format actions");
   }
   return platform.formatAction(payload);
 }
-async function formatParse(name, source, options) {
+async function formatParse2(name, source, options) {
   return await formatAction({
     action: "parse",
     format: name,
@@ -169,7 +183,7 @@ async function formatParse(name, source, options) {
     source
   });
 }
-async function formatSerialize(name, doc, options) {
+async function formatSerialize2(name, doc, options) {
   return await formatAction({
     action: "serialize",
     doc,
@@ -177,7 +191,7 @@ async function formatSerialize(name, doc, options) {
     options
   });
 }
-function splitFormatDocument(format, doc) {
+function splitFormatDocument2(format, doc) {
   const hints = format?.studio?.documentMode;
   const componentWhen = hints?.componentWhen;
   if (componentWhen?.frontmatterKey) {
@@ -222,7 +236,7 @@ function splitFormatDocument(format, doc) {
   };
 }
 
-export { loadMonaco, loadedMonaco, mountStillWanted, loadFormats, refreshFormats, setFormats, loadExtensions, getExtensions, setExtensions, refreshExtensionUi, getFormats, formatByExtension, formatByName, noFormatError, formatForPath, documentExtensions, defaultContentFormat, formatParse, formatSerialize, splitFormatDocument };
+export { loadMonaco, loadedMonaco, mountStillWanted, loadFormats2, refreshFormats2, loadExtensions2, getExtensions2, getExtensionCatalog2, refreshExtensionUi2, getFormats2, formatByExtension2, formatByName2, noFormatError2, formatForPath2, documentExtensions2, defaultContentFormat2, formatParse2, formatSerialize2, splitFormatDocument2 };
 
-//# debugId=7A0A51B7AA10806664756E2164756E21
-//# sourceMappingURL=studio-ahn3pdgx.js.map
+//# debugId=DC4D74E6C120403064756E2164756E21
+//# sourceMappingURL=studio-vw7mzp6z.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