@jxsuite/studio 3.0.0 → 4.1.0

package/dist/chunks/{studio-g5gdqnyd.js → studio-mtfnaqs9.js}

@@ -3,39 +3,39 @@ import {
   getRecentProjects,
   openFileInTab,
   trackRecentFile
-} from "./studio-rh1cnamv.js";
+} from "./studio-5myknm0a.js";
 import {
-  live
-} from "./studio-c31yb4t6.js";
+  activeTab
+} from "./studio-trxrabqf.js";
+import {
+  classMap
+} from "./studio-m3hwn7y1.js";
+import {
+  flattenTree,
+  nodeLabel,
+  projectState
+} from "./studio-p4ngc046.js";
 import {
   activeRegistry,
-  activeTab,
   getLayerSlot
-} from "./studio-r5xbtctf.js";
-import {
-  classMap
-} from "./studio-twsafr1e.js";
+} from "./studio-t7qb9db8.js";
 import {
+  live,
   ref
-} from "./studio-kvfx9z2c.js";
+} from "./studio-4rzyrtjz.js";
 import {
   html,
   nothing,
   render
-} from "./studio-5x5774ak.js";
-import {
-  flattenTree,
-  nodeLabel,
-  projectState
-} from "./studio-cjm7fdjf.js";
+} from "./studio-kryvsw6j.js";
 import {
   documentExtensions,
   formatByExtension,
   loadFormats
-} from "./studio-hcxzyk3x.js";
+} from "./studio-ahn3pdgx.js";
 import {
   getPlatform
-} from "./studio-sas7mt3k.js";
+} from "./studio-9ab8gqsm.js";
 
 // src/panels/quick-search.ts
 var PALETTE_MODES = [
@@ -655,5 +655,5 @@ function renderOverlay() {
 
 export { PALETTE_MODES, modeSpec, resolvePaletteMode, fuzzyScore, rankBy, paletteArgs, getRecentCommands, initQuickSearch, openQuickSearch, closeQuickSearch, isQuickSearchOpen };
 
-//# debugId=D01DE0145FC9DB1664756E2164756E21
-//# sourceMappingURL=studio-g5gdqnyd.js.map
+//# debugId=444BCF8C29E5B5ED64756E2164756E21
+//# sourceMappingURL=studio-mtfnaqs9.js.map

package/dist/chunks/{studio-7ejemhej.js → studio-n6j9t10q.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-qgvhnxf4.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-n6j9t10q.js.map

package/dist/chunks/{studio-vhk5fmfv.js → studio-n8b9wqwy.js}

@@ -9,16 +9,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";
 
 // ../../node_modules/@spectrum-web-components/progress-circle/src/progress-circle.css.js
 var e = css`
@@ -288,4 +288,4 @@ defineElement("sp-progress-circle", ProgressCircle);
 export { languageResolverUpdatedSymbol, LanguageResolutionController, ProgressCircle };
 
 //# debugId=D9778D0A36E46FD364756E2164756E21
-//# sourceMappingURL=studio-vhk5fmfv.js.map
+//# sourceMappingURL=studio-n8b9wqwy.js.map

package/dist/chunks/{studio-cjm7fdjf.js → studio-p4ngc046.js}

@@ -1,104 +1,8 @@
-// ../schema/src/guards.ts
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isRef(value) {
-  return isJsonObject(value) && typeof value.$ref === "string";
-}
-function isFunctionDef(value) {
-  return isJsonObject(value) && value.$prototype === "Function";
-}
-function isExpressionDef(value) {
-  return isJsonObject(value) && isJsonObject(value.$expression);
-}
-function isNamedFormulaDef(value) {
-  return isExpressionDef(value) && Array.isArray(value.parameters) && value.parameters.length > 0;
-}
-function hasStructuredBody(value) {
-  return isFunctionDef(value) && Array.isArray(value.body);
-}
-function isPrototypeDef(value) {
-  return isJsonObject(value) && typeof value.$prototype === "string" && value.$prototype !== "Function";
-}
-function isServerFnDef(value) {
-  return isJsonObject(value) && value.timing === "server" && typeof value.$src === "string" && typeof value.$export === "string" && !value.$prototype;
-}
-var SCHEMA_KEYWORDS = new Set([
-  "type",
-  "enum",
-  "minimum",
-  "maximum",
-  "minLength",
-  "maxLength",
-  "pattern",
-  "format",
-  "items",
-  "properties",
-  "required",
-  "description",
-  "title",
-  "$comment"
-]);
-function isMappedArray(value) {
-  return isJsonObject(value) && value.$prototype === "Array";
-}
-function isTemplateString(value) {
-  return typeof value === "string" && value.includes("${");
-}
-function bodyReturnsValue(body) {
-  return /\breturn\b[^\S\n]*(?![;}\s]|$)/.test(body);
-}
-function isNestedStyle(value) {
-  return typeof value === "object" && value !== null;
-}
-function getNestedStyle(style, key) {
-  const value = style?.[key];
-  return isNestedStyle(value) ? value : undefined;
-}
-function ensureNestedStyle(style, key) {
-  const existing = style[key];
-  if (isNestedStyle(existing)) {
-    return existing;
-  }
-  const created = {};
-  style[key] = created;
-  return created;
-}
-function isEventBinding(value) {
-  return isRef(value) || isFunctionDef(value) || isExpressionDef(value);
-}
-function getEventBinding(node, key) {
-  const value = node[key];
-  return isEventBinding(value) ? value : undefined;
-}
-function paramNames(parameters) {
-  if (!parameters) {
-    return [];
-  }
-  return parameters.map((p) => typeof p === "string" ? p : p.name);
-}
-function isTagExpression(tagName) {
-  return isJsonObject(tagName) && isJsonObject(tagName.$expression);
-}
-function tagNameCandidates(tagName) {
-  if (typeof tagName === "string") {
-    return [tagName];
-  }
-  if (!isTagExpression(tagName)) {
-    return [];
-  }
-  const expression = tagName.$expression;
-  if (expression.operator === "?:") {
-    return [...new Set([expression.value, expression.initial])];
-  }
-  return [...new Set([...Object.values(expression.cases), expression.default])];
-}
-function displayTagName(tagName) {
-  return typeof tagName === "string" ? tagName : tagNameCandidates(tagName).join("|");
-}
-function isPrivateStateKey(key) {
-  return key.startsWith("#");
-}
+import {
+  displayTagName,
+  isEventBinding,
+  isRef
+} from "./studio-q7v10cg2.js";
 
 // src/ui/timing.ts
 var INPUT_DEBOUNCE = 400;
@@ -445,7 +349,7 @@ function updateCanvas(tab, patch) {
   }
 }
 
-export { isJsonObject, isRef, isFunctionDef, isExpressionDef, isNamedFormulaDef, hasStructuredBody, isPrototypeDef, isServerFnDef, isMappedArray, isTemplateString, bodyReturnsValue, getNestedStyle, ensureNestedStyle, isEventBinding, getEventBinding, paramNames, isTagExpression, tagNameCandidates, displayTagName, isPrivateStateKey, LIVE_PREVIEW, POLL_GIT, getNodeAtPath, childList, normalizeArrayChildren, parentElementPath, childIndex, pathKey, pathsEqual, isAncestor, flattenTree, nodeLabel, projectState, setProjectState, requireProjectState, stripEventHandlers, activityBar, leftPanel, rightPanel, toolbarEl, statusbarEl, initShellRefs, VOID_ELEMENTS, COMMON_SELECTORS, isNestedSelector, debouncedStyleCommit, cancelStyleDebounce, rendersInFlight, registerRenderer, render, renderOnly, updateSession, updateUi, updateCanvas };
+export { LIVE_PREVIEW, POLL_GIT, getNodeAtPath, childList, normalizeArrayChildren, parentElementPath, childIndex, pathKey, pathsEqual, isAncestor, flattenTree, nodeLabel, projectState, setProjectState, requireProjectState, stripEventHandlers, activityBar, leftPanel, rightPanel, toolbarEl, statusbarEl, initShellRefs, VOID_ELEMENTS, COMMON_SELECTORS, isNestedSelector, debouncedStyleCommit, cancelStyleDebounce, rendersInFlight, registerRenderer, render, renderOnly, updateSession, updateUi, updateCanvas };
 
-//# debugId=147E616828B71FA964756E2164756E21
-//# sourceMappingURL=studio-cjm7fdjf.js.map
+//# debugId=6E6FF14C9164545D64756E2164756E21
+//# sourceMappingURL=studio-p4ngc046.js.map

package/dist/chunks/studio-q43a5y9h.js

@@ -0,0 +1,394 @@
+import {
+  invalidateUsages
+} from "./studio-cft9r4r7.js";
+import {
+  projectState
+} from "./studio-p4ngc046.js";
+import {
+  getPlatform
+} from "./studio-9ab8gqsm.js";
+
+// src/files/gitignore.ts
+var RE_SPECIAL = /[.*+?^${}()|[\]\\]/;
+function literal(ch) {
+  return RE_SPECIAL.test(ch) ? `\\${ch}` : ch;
+}
+function stripTrailingSpaces(line) {
+  let end = line.length;
+  while (end > 0 && line[end - 1] === " ") {
+    let backslashes = 0;
+    let i = end - 2;
+    while (i >= 0 && line[i] === "\\") {
+      backslashes += 1;
+      i -= 1;
+    }
+    if (backslashes % 2 === 1) {
+      break;
+    }
+    end -= 1;
+  }
+  return line.slice(0, end);
+}
+function charClassEnd(pattern, start) {
+  let i = start + 1;
+  if (pattern[i] === "!") {
+    i += 1;
+  }
+  if (pattern[i] === "]") {
+    i += 1;
+  }
+  while (i < pattern.length) {
+    if (pattern[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (pattern[i] === "]") {
+      return i;
+    }
+    i += 1;
+  }
+  return -1;
+}
+function globToRegExpSource(pattern) {
+  let out = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      const next = pattern[i + 1];
+      if (next === undefined) {
+        out += String.raw`\\`;
+        i += 1;
+      } else {
+        out += literal(next);
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === "*") {
+      let stars = 0;
+      while (pattern[i] === "*") {
+        stars += 1;
+        i += 1;
+      }
+      const atSegmentStart = out === "" || out.endsWith("/");
+      if (stars >= 2 && atSegmentStart && pattern[i] === "/") {
+        out += "(?:[^/]+/)*";
+        i += 1;
+      } else if (stars >= 2 && atSegmentStart && i >= pattern.length) {
+        out += ".*";
+      } else {
+        out += "[^/]*";
+      }
+      continue;
+    }
+    if (ch === "?") {
+      out += "[^/]";
+      i += 1;
+      continue;
+    }
+    if (ch === "[") {
+      const end = charClassEnd(pattern, i);
+      if (end === -1) {
+        out += String.raw`\[`;
+        i += 1;
+        continue;
+      }
+      const raw = pattern.slice(i + 1, end);
+      const negatedClass = raw.startsWith("!");
+      const members = negatedClass ? raw.slice(1) : raw;
+      out += `[${negatedClass ? "^" : ""}${members.startsWith("]") ? String.raw`\]${members.slice(1)}` : members}]`;
+      i = end + 1;
+      continue;
+    }
+    out += literal(ch);
+    i += 1;
+  }
+  return out;
+}
+function parseLine(raw) {
+  let line = stripTrailingSpaces(raw);
+  if (line === "" || line.startsWith("#")) {
+    return null;
+  }
+  let negated = false;
+  if (line.startsWith("!")) {
+    negated = true;
+    line = line.slice(1);
+  }
+  let dirOnly = false;
+  if (line.endsWith("/")) {
+    dirOnly = true;
+    line = line.slice(0, -1);
+  }
+  let anchored = line.includes("/");
+  if (line.startsWith("/")) {
+    line = line.slice(1);
+    anchored = true;
+  }
+  if (line === "") {
+    return null;
+  }
+  const body = globToRegExpSource(line);
+  return {
+    dirOnly,
+    negated,
+    re: new RegExp(`^${anchored ? "" : "(?:.*/)?"}${body}$`),
+    source: raw
+  };
+}
+function parseGitignore(text) {
+  const rules = [];
+  for (const raw of text.split(/\r?\n/)) {
+    const rule = parseLine(raw);
+    if (rule) {
+      rules.push(rule);
+    }
+  }
+  return rules;
+}
+function normalizePath(path) {
+  const p = path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+  return p === "." ? "" : p;
+}
+function relativeTo(base, path) {
+  if (base === "") {
+    return path;
+  }
+  return path.startsWith(`${base}/`) ? path.slice(base.length + 1) : null;
+}
+function ancestorDirs(dir) {
+  const base = normalizePath(dir);
+  const chain = [""];
+  if (base === "") {
+    return chain;
+  }
+  let acc = "";
+  for (const segment of base.split("/")) {
+    acc = acc === "" ? segment : `${acc}/${segment}`;
+    chain.push(acc);
+  }
+  return chain;
+}
+function verdictFor(layers, path, isDir) {
+  let ignored = false;
+  for (const layer of layers) {
+    const rel = relativeTo(layer.base, path);
+    if (rel === null || rel === "") {
+      continue;
+    }
+    for (const rule of layer.rules) {
+      if (rule.dirOnly && !isDir) {
+        continue;
+      }
+      if (rule.re.test(rel)) {
+        ignored = !rule.negated;
+      }
+    }
+  }
+  return ignored;
+}
+function isIgnored(layers, path, isDir) {
+  const target = normalizePath(path);
+  if (target === "") {
+    return false;
+  }
+  const segments = target.split("/");
+  let prefix = "";
+  for (const [index, segment] of segments.entries()) {
+    prefix = prefix === "" ? segment : `${prefix}/${segment}`;
+    const last = index === segments.length - 1;
+    if (verdictFor(layers, prefix, last ? isDir : true)) {
+      return true;
+    }
+  }
+  return false;
+}
+var layerCache = new Map;
+var inFlight = new Map;
+function resetIgnoreCache() {
+  layerCache.clear();
+  inFlight.clear();
+}
+async function readGitignore(dir) {
+  try {
+    const text = await getPlatform().readFile(dir === "" ? ".gitignore" : `${dir}/.gitignore`);
+    return { base: dir, rules: parseGitignore(text) };
+  } catch {
+    return null;
+  }
+}
+function readLayer(dir) {
+  const cached = layerCache.get(dir);
+  if (cached !== undefined) {
+    return Promise.resolve(cached);
+  }
+  const pending = inFlight.get(dir);
+  if (pending) {
+    return pending;
+  }
+  const read = readGitignore(dir).then((layer) => {
+    layerCache.set(dir, layer);
+    inFlight.delete(dir);
+    return layer;
+  });
+  inFlight.set(dir, read);
+  return read;
+}
+async function reloadIgnoreCache() {
+  const dirs = [...layerCache.keys()];
+  inFlight.clear();
+  const fresh = await Promise.all(dirs.map((dir) => readGitignore(dir)));
+  layerCache.clear();
+  for (const [index, dir] of dirs.entries()) {
+    layerCache.set(dir, fresh[index] ?? null);
+  }
+}
+async function ensureIgnoreLayers(dir) {
+  await Promise.all(ancestorDirs(dir).map((ancestor) => readLayer(ancestor)));
+}
+function loadedLayersFor(dir) {
+  const layers = [];
+  for (const ancestor of ancestorDirs(dir)) {
+    const layer = layerCache.get(ancestor);
+    if (layer) {
+      layers.push(layer);
+    }
+  }
+  return layers;
+}
+function isIgnoredEntry(dir, path, isDir) {
+  return isIgnored(loadedLayersFor(dir), path, isDir);
+}
+function touchesGitignore(paths) {
+  return paths.some((path) => normalizePath(path).split("/").pop() === ".gitignore");
+}
+
+// src/files/fs-events.ts
+var RECENT_MS = 1500;
+var recentLocal = new Map;
+var norm = (p) => p.replaceAll("\\", "/");
+function markLocalMutation(...paths) {
+  const expiry = Date.now() + RECENT_MS;
+  for (const p of paths) {
+    if (p) {
+      recentLocal.set(norm(p), expiry);
+    }
+  }
+}
+function isRecentLocal(path) {
+  const key = norm(path);
+  const expiry = recentLocal.get(key);
+  if (expiry === undefined) {
+    return false;
+  }
+  if (Date.now() > expiry) {
+    recentLocal.delete(key);
+    return false;
+  }
+  return true;
+}
+function parentDir(path) {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? "." : path.slice(0, i);
+}
+function baseName(path) {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? path : path.slice(i + 1);
+}
+function applyFsEvents(dirs, expanded, events) {
+  const changedDirs = new Set;
+  for (const ev of events) {
+    const parent = parentDir(ev.path);
+    if (ev.type === "add" || ev.type === "addDir") {
+      const entries = dirs.get(parent);
+      if (entries && !entries.some((e) => e.path === ev.path)) {
+        entries.push({
+          name: baseName(ev.path),
+          path: ev.path,
+          type: ev.isDir ? "directory" : "file"
+        });
+        changedDirs.add(parent);
+      }
+      if (ev.type === "addDir" && !dirs.has(ev.path)) {
+        dirs.set(ev.path, []);
+      }
+    } else if (ev.type === "unlink" || ev.type === "unlinkDir") {
+      const entries = dirs.get(parent);
+      if (entries) {
+        const idx = entries.findIndex((e) => e.path === ev.path);
+        if (idx !== -1) {
+          entries.splice(idx, 1);
+          changedDirs.add(parent);
+        }
+      }
+      if (ev.type === "unlinkDir") {
+        dirs.delete(ev.path);
+        const nestedDirs = [];
+        for (const key of dirs.keys()) {
+          if (key.startsWith(`${ev.path}/`)) {
+            nestedDirs.push(key);
+          }
+        }
+        for (const key of nestedDirs) {
+          dirs.delete(key);
+        }
+        const staleExpanded = [];
+        for (const key of expanded) {
+          if (key === ev.path || key.startsWith(`${ev.path}/`)) {
+            staleExpanded.push(key);
+          }
+        }
+        for (const key of staleExpanded) {
+          expanded.delete(key);
+        }
+      }
+    }
+  }
+  return changedDirs;
+}
+function startFsSync(ctx) {
+  const platform = getPlatform();
+  if (!platform.subscribeFileEvents) {
+    return () => {};
+  }
+  let pending = [];
+  let timer = null;
+  const flush = () => {
+    timer = null;
+    const state = projectState;
+    const batch = pending.filter((e) => !isRecentLocal(e.path));
+    pending = [];
+    if (!state || batch.length === 0) {
+      return;
+    }
+    const changedDirs = applyFsEvents(state.dirs, state.expanded, batch);
+    if (ctx.onContentChange) {
+      for (const ev of batch) {
+        if (ev.type === "change") {
+          ctx.onContentChange(ev.path);
+        }
+      }
+    }
+    if (changedDirs.size > 0) {
+      ctx.renderLeftPanel();
+    }
+  };
+  return platform.subscribeFileEvents((events) => {
+    invalidateUsages();
+    ctx.invalidateDerivedCaches?.();
+    if (touchesGitignore(events.map((event) => event.path))) {
+      reloadIgnoreCache().then(() => ctx.renderLeftPanel());
+    }
+    pending.push(...events);
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(flush, 50);
+  });
+}
+
+export { resetIgnoreCache, ensureIgnoreLayers, isIgnoredEntry, markLocalMutation, isRecentLocal, applyFsEvents, startFsSync };
+
+//# debugId=3BC9649D86675B2D64756E2164756E21
+//# sourceMappingURL=studio-q43a5y9h.js.map