@jxsuite/studio 2.4.3 → 4.0.0

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

package/dist/chunks/studio-q7v10cg2.js

@@ -0,0 +1,106 @@
+// ../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("#");
+}
+
+export { isJsonObject, isRef, isFunctionDef, isExpressionDef, isNamedFormulaDef, hasStructuredBody, isPrototypeDef, isServerFnDef, isMappedArray, isTemplateString, bodyReturnsValue, getNestedStyle, ensureNestedStyle, isEventBinding, getEventBinding, paramNames, isTagExpression, tagNameCandidates, displayTagName, isPrivateStateKey };
+
+//# debugId=8B99E181A008FB9464756E2164756E21
+//# sourceMappingURL=studio-q7v10cg2.js.map

package/dist/chunks/{studio-2w11grav.js → studio-qq6jym04.js}

@@ -2,11 +2,11 @@ import {
   Directive,
   PartType,
   directive
-} from "./studio-kvfx9z2c.js";
+} from "./studio-4rzyrtjz.js";
 import {
   noChange,
   nothing
-} from "./studio-5x5774ak.js";
+} from "./studio-kryvsw6j.js";
 
 // ../../node_modules/lit-html/development/directives/unsafe-html.js
 var HTML_RESULT = 1;
@@ -50,4 +50,4 @@ var unsafeHTML = directive(UnsafeHTMLDirective);
 export { unsafeHTML };
 
 //# debugId=2A5B539DDAEE5D8464756E2164756E21
-//# sourceMappingURL=studio-2w11grav.js.map
+//# sourceMappingURL=studio-qq6jym04.js.map