@jxsuite/studio 3.0.0 → 4.1.0

package/dist/chunks/studio-b55y6ewx.js

@@ -0,0 +1,498 @@
+import {
+  columnsFromSchema,
+  getGridController,
+  inferColumnsFromRows,
+  makeGridTabId,
+  parseSourceForPath
+} from "./studio-cmb03bg5.js";
+import {
+  isRecentLocal,
+  markLocalMutation
+} from "./studio-q43a5y9h.js";
+import {
+  workspace
+} from "./studio-trxrabqf.js";
+import {
+  projectState
+} from "./studio-p4ngc046.js";
+import {
+  reactive
+} from "./studio-xrapxwwc.js";
+import {
+  defaultContentFormat,
+  documentExtensions,
+  formatByName,
+  formatForPath,
+  formatSerialize,
+  loadFormats
+} from "./studio-ahn3pdgx.js";
+import {
+  getPlatform
+} from "./studio-9ab8gqsm.js";
+import {
+  __require
+} from "./studio-a0tswy0w.js";
+
+// src/content/draft-state.ts
+var DRAFT_FIELD = "draft";
+var DRAFT_MEANING = "Marked a draft. Studio filters drafts out of its own lists; the build does not exclude them yet.";
+function isDraftEntry(fields) {
+  return fields?.[DRAFT_FIELD] === true;
+}
+function schemaDeclaresDraft(schema) {
+  return schema?.properties?.[DRAFT_FIELD]?.type === "boolean";
+}
+function hasDraftAxis(schema, fields) {
+  return schemaDeclaresDraft(schema) || isDraftEntry(fields);
+}
+var draftView = reactive({ includeDrafts: false });
+function includingDrafts() {
+  return draftView.includeDrafts;
+}
+function setIncludeDrafts(include) {
+  draftView.includeDrafts = include;
+}
+function applyDraftFilter(items, fieldsOf, includeDrafts) {
+  return includeDrafts ? items : items.filter((item) => !isDraftEntry(fieldsOf(item)));
+}
+
+// src/grid/sources/content-source.ts
+var PATH_FIELD = "__path";
+function collectionInfo(typeName) {
+  const content = projectState?.projectConfig?.content ?? {};
+  const def = content[typeName];
+  if (!def?.source) {
+    return null;
+  }
+  const dir = def.source.replace(/^\.\//, "").replace(/\/$/, "");
+  const ext = def.format === "json" ? ".json" : formatByName(def.format)?.extensions[0] ?? defaultContentFormat()?.extensions[0] ?? ".json";
+  return { def, dir, ext, name: typeName };
+}
+function collectionDirs() {
+  const content = projectState?.projectConfig?.content ?? {};
+  return Object.entries(content).filter(([, def]) => {
+    const source = def.source?.replace(/^\.\//, "") ?? "";
+    return source !== "" && !/\.[a-z0-9]+$/i.test(source);
+  }).map(([name, def]) => ({ dir: def.source.replace(/^\.\//, "").replace(/\/$/, ""), name }));
+}
+async function listEntryFiles(dir, exts) {
+  const platform = getPlatform();
+  const results = [];
+  const walk = async (current) => {
+    let children;
+    try {
+      children = await platform.listDirectory(current);
+    } catch {
+      return;
+    }
+    for (const entry of children) {
+      if (entry.type === "directory") {
+        await walk(entry.path);
+      } else if (exts.some((ext) => entry.path.endsWith(ext))) {
+        results.push(entry.path);
+      }
+    }
+  };
+  await walk(dir);
+  return results.toSorted();
+}
+async function listCollectionEntryIds(typeName) {
+  await loadFormats().catch(() => {});
+  const info = collectionInfo(typeName);
+  if (!info) {
+    return [];
+  }
+  const files = await listEntryFiles(info.dir, [info.ext]);
+  return files.map((path) => {
+    const base = path.split("/").pop() ?? path;
+    return base.slice(0, base.length - info.ext.length);
+  });
+}
+async function mapLimit(items, limit, fn) {
+  const results = Array.from({ length: items.length });
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await fn(items[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function toCellValue(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value) && value.every((v) => typeof v !== "object" || v === null)) {
+    return value.map(String);
+  }
+  return JSON.stringify(value);
+}
+function openTabFor(path) {
+  for (const tab of workspace.tabs.values()) {
+    if (tab.documentPath === path) {
+      return tab;
+    }
+  }
+  return null;
+}
+function extraRowsAreStrings(rows, field) {
+  return rows.every((row) => {
+    const value = row[field];
+    return value === null || value === undefined || typeof value !== "string" ? true : !value.startsWith("{") && !value.startsWith("[");
+  });
+}
+var draftAwareSources = new WeakSet;
+async function reloadDraftAwareGrids() {
+  const reloads = [];
+  for (const tab of workspace.tabs.values()) {
+    const controller = getGridController(tab);
+    if (controller && draftAwareSources.has(controller.source)) {
+      reloads.push(controller.load());
+    }
+  }
+  await Promise.all(reloads);
+}
+function createEntryFileSource(opts) {
+  const source = buildEntryFileSource(opts);
+  if (opts.drafts) {
+    draftAwareSources.add(source);
+  }
+  return source;
+}
+function buildEntryFileSource(opts) {
+  const entries = new Map;
+  let loadPromise = null;
+  let columnsCache = null;
+  const load = (force = false) => {
+    if (!force && loadPromise) {
+      return loadPromise;
+    }
+    loadPromise = (async () => {
+      await loadFormats().catch(() => {});
+      const platform = getPlatform();
+      const files = await opts.list();
+      entries.clear();
+      columnsCache = null;
+      const loaded = await mapLimit(files, 8, async (path) => {
+        try {
+          const text = await platform.readFile(path);
+          const parsed = await parseSourceForPath(path, text);
+          return {
+            document: parsed.document,
+            formatName: parsed.format.name,
+            frontmatter: parsed.frontmatter ?? {},
+            rawText: text
+          };
+        } catch {
+          return null;
+        }
+      });
+      for (const [index, path] of files.entries()) {
+        const record = loaded[index];
+        if (record) {
+          entries.set(path, record);
+        }
+      }
+    })();
+    return loadPromise;
+  };
+  const buildColumns = () => {
+    if (columnsCache) {
+      return columnsCache;
+    }
+    const pathColumn = {
+      editable: false,
+      field: PATH_FIELD,
+      insertOnly: true,
+      kind: "string",
+      pk: true,
+      required: true,
+      title: "Path",
+      widthHint: 220
+    };
+    const schemaColumns = columnsFromSchema(opts.schema());
+    const known = new Set([PATH_FIELD, ...schemaColumns.map((c) => c.field)]);
+    const extraRows = [...entries.values()].map((entry) => {
+      const cells = {};
+      for (const [key, value] of Object.entries(entry.frontmatter)) {
+        if (!known.has(key) && !key.startsWith("$")) {
+          cells[key] = toCellValue(value);
+        }
+      }
+      return cells;
+    });
+    const extraColumns = inferColumnsFromRows(extraRows);
+    for (const column of extraColumns) {
+      column.editable = column.kind !== "text" || extraRowsAreStrings(extraRows, column.field);
+    }
+    if (opts.priorityFields?.length) {
+      const rank = (c) => {
+        const index = opts.priorityFields.indexOf(c.field);
+        return index === -1 ? opts.priorityFields.length : index;
+      };
+      extraColumns.sort((a, b) => rank(a) - rank(b));
+    }
+    columnsCache = withDraftColumn([pathColumn, ...schemaColumns, ...extraColumns]);
+    return columnsCache;
+  };
+  const draftAxis = () => {
+    if (!opts.drafts) {
+      return false;
+    }
+    const schema = opts.schema();
+    return hasDraftAxis(schema) || [...entries.values()].some((entry) => hasDraftAxis(schema, entry.frontmatter));
+  };
+  const withDraftColumn = (columns) => {
+    const index = columns.findIndex((column) => column.field === DRAFT_FIELD);
+    if (index < 1 || !draftAxis()) {
+      return columns;
+    }
+    const rest = columns.filter((column) => column.field !== DRAFT_FIELD);
+    return [rest[0], columns[index], ...rest.slice(1)];
+  };
+  const rowFor = (path, entry) => {
+    const cells = { [PATH_FIELD]: path };
+    for (const column of buildColumns()) {
+      if (column.field === PATH_FIELD) {
+        continue;
+      }
+      cells[column.field] = toCellValue(entry.frontmatter[column.field]);
+    }
+    return { cells, fingerprint: entry.rawText, key: path };
+  };
+  const writeEntry = async (path, entry, patches) => {
+    const platform = getPlatform();
+    const frontmatter = { ...entry.frontmatter };
+    for (const patch of patches) {
+      if (patch.value === null) {
+        delete frontmatter[patch.field];
+      } else {
+        frontmatter[patch.field] = patch.value;
+      }
+    }
+    const doc = entry.document;
+    const fullDoc = { ...frontmatter, ...doc, children: doc.children ?? [] };
+    const text = await formatSerialize(entry.formatName, fullDoc, { mode: "roundtrip" });
+    markLocalMutation(path);
+    await platform.writeFile(path, text);
+    entries.set(path, { ...entry, frontmatter, rawText: text });
+  };
+  return {
+    backingPaths: () => new Map([...entries.keys()].map((path) => [path, path])),
+    capabilities: { delete: true, insert: true, remotePaging: false, remoteSort: false },
+    async columns() {
+      await load();
+      return buildColumns();
+    },
+    async commit(batch) {
+      await load();
+      const platform = getPlatform();
+      const result = { cells: [], deletes: [], inserts: [] };
+      const byRow = new Map;
+      for (const cell of batch.cells) {
+        const list = byRow.get(cell.rowKey) ?? [];
+        list.push({ field: cell.field, value: cell.value });
+        byRow.set(cell.rowKey, list);
+      }
+      for (const [path, patches] of byRow) {
+        const outcome = (ok, error, stale) => {
+          for (const patch of patches) {
+            result.cells.push({ error, field: patch.field, ok, rowKey: path, stale });
+          }
+        };
+        const entry = entries.get(path);
+        if (!entry) {
+          outcome(false, "Entry no longer loaded — refresh the grid");
+          continue;
+        }
+        const openTab = openTabFor(path);
+        if (openTab?.doc.dirty) {
+          outcome(false, "Open in a tab with unsaved changes — save or close it first");
+          continue;
+        }
+        let onDisk = null;
+        try {
+          onDisk = await platform.readFile(path);
+        } catch {
+          onDisk = null;
+        }
+        if (onDisk !== entry.rawText && !isRecentLocal(path)) {
+          outcome(false, "File changed on disk — refresh to reload", true);
+          continue;
+        }
+        try {
+          await writeEntry(path, entry, patches);
+          outcome(true);
+          if (openTab) {
+            const { reloadFileInTab } = await import("./files-3kfkwhk4.js");
+            reloadFileInTab(path);
+          }
+        } catch (error) {
+          outcome(false, error instanceof Error ? error.message : String(error));
+        }
+      }
+      for (const insert of batch.inserts) {
+        const rawPath = insert.cells[PATH_FIELD];
+        if (typeof rawPath !== "string" || rawPath.trim() === "") {
+          result.inserts.push({ error: "Path is required", ok: false, tempKey: insert.tempKey });
+          continue;
+        }
+        const path = opts.resolveInsertPath(rawPath);
+        let exists = entries.has(path);
+        if (!exists) {
+          try {
+            await platform.readFile(path);
+            exists = true;
+          } catch {
+            exists = false;
+          }
+        }
+        if (exists) {
+          result.inserts.push({
+            error: `${path} already exists`,
+            ok: false,
+            tempKey: insert.tempKey
+          });
+          continue;
+        }
+        const formatName = opts.insertFormatName(path);
+        if (!formatName) {
+          result.inserts.push({
+            error: `No format can serialize ${path}`,
+            ok: false,
+            tempKey: insert.tempKey
+          });
+          continue;
+        }
+        try {
+          const frontmatter = {};
+          for (const [field, value] of Object.entries(insert.cells)) {
+            if (field !== PATH_FIELD && value !== null) {
+              frontmatter[field] = value;
+            }
+          }
+          const text = await formatSerialize(formatName, { ...frontmatter, children: [] }, { frontmatter: Object.keys(frontmatter).length > 0, mode: "roundtrip" });
+          markLocalMutation(path);
+          await platform.writeFile(path, text);
+          const parsed = await parseSourceForPath(path, text);
+          entries.set(path, {
+            document: parsed.document,
+            formatName: parsed.format.name,
+            frontmatter: parsed.frontmatter ?? {},
+            rawText: text
+          });
+          result.inserts.push({ newKey: path, ok: true, tempKey: insert.tempKey });
+        } catch (error) {
+          result.inserts.push({
+            error: error instanceof Error ? error.message : String(error),
+            ok: false,
+            tempKey: insert.tempKey
+          });
+        }
+      }
+      for (const del of batch.deletes) {
+        if (openTabFor(del.rowKey)) {
+          result.deletes.push({
+            error: "Open in a tab — close it first",
+            ok: false,
+            rowKey: del.rowKey
+          });
+          continue;
+        }
+        try {
+          markLocalMutation(del.rowKey);
+          await platform.deleteFile(del.rowKey);
+          entries.delete(del.rowKey);
+          result.deletes.push({ ok: true, rowKey: del.rowKey });
+        } catch (error) {
+          result.deletes.push({
+            error: error instanceof Error ? error.message : String(error),
+            ok: false,
+            rowKey: del.rowKey
+          });
+        }
+      }
+      return result;
+    },
+    id: opts.id,
+    label: opts.label,
+    async refresh() {
+      await load(true);
+    },
+    async rows() {
+      await load();
+      const listed = opts.drafts ? applyDraftFilter([...entries.entries()], ([, entry]) => entry.frontmatter, includingDrafts()) : [...entries.entries()];
+      const rows = listed.map(([path, entry]) => rowFor(path, entry));
+      return { rows, total: rows.length };
+    }
+  };
+}
+function createCollectionSource(typeName) {
+  const requireInfo = () => {
+    const info = collectionInfo(typeName);
+    if (!info) {
+      throw new Error(`No content collection named "${typeName}" in project.json`);
+    }
+    return info;
+  };
+  return createEntryFileSource({
+    drafts: true,
+    id: makeGridTabId({ kind: "collection", name: typeName }),
+    insertFormatName: (path) => {
+      const info = requireInfo();
+      return (info.def.format ? formatByName(info.def.format)?.name : undefined) ?? formatForPath(path)?.name ?? defaultContentFormat()?.name ?? null;
+    },
+    label: typeName,
+    list: () => {
+      const info = requireInfo();
+      return listEntryFiles(info.dir, [info.ext]);
+    },
+    resolveInsertPath: (raw) => {
+      const info = requireInfo();
+      let path = raw.trim().replace(/^\.\//, "").replace(/^\//, "");
+      if (!path.includes("/")) {
+        path = `${info.dir}/${path}`;
+      }
+      if (!path.endsWith(info.ext)) {
+        path = `${path}${info.ext}`;
+      }
+      return path;
+    },
+    schema: () => requireInfo().def.schema
+  });
+}
+function createPagesSource() {
+  const pageExts = () => {
+    const exts = documentExtensions("page").filter((ext) => ext !== ".json");
+    return exts.length > 0 ? exts : [".md"];
+  };
+  return createEntryFileSource({
+    id: makeGridTabId({ kind: "pages" }),
+    insertFormatName: (path) => formatForPath(path)?.name ?? null,
+    label: "Pages",
+    list: () => listEntryFiles("pages", pageExts()),
+    priorityFields: ["title", "description"],
+    resolveInsertPath: (raw) => {
+      let path = raw.trim().replace(/^\.\//, "").replace(/^\//, "");
+      if (!path.startsWith("pages/")) {
+        path = `pages/${path}`;
+      }
+      if (!pageExts().some((ext) => path.endsWith(ext))) {
+        path = `${path}${pageExts()[0]}`;
+      }
+      return path;
+    },
+    schema: () => null
+  });
+}
+
+export { DRAFT_FIELD, DRAFT_MEANING, isDraftEntry, hasDraftAxis, setIncludeDrafts, PATH_FIELD, collectionInfo, collectionDirs, listCollectionEntryIds, reloadDraftAwareGrids, createCollectionSource, createPagesSource };
+
+//# debugId=EEA6C59DFC58D56B64756E2164756E21
+//# sourceMappingURL=studio-b55y6ewx.js.map

package/dist/chunks/{studio-s519zc99.js → studio-bgxt93ga.js}

@@ -1,9 +1,9 @@
 import {
   projectState
-} from "./studio-cjm7fdjf.js";
+} from "./studio-p4ngc046.js";
 import {
   getPlatform
-} from "./studio-sas7mt3k.js";
+} from "./studio-9ab8gqsm.js";
 
 // src/files/components.ts
 var componentRegistry = [];
@@ -59,4 +59,4 @@ function computeRelativePath(fromDocPath, toCompPath) {
 export { componentRegistry, _componentRegistryLoaded, loadComponentRegistry, buildComponentInstance, computeRelativePath };
 
 //# debugId=37666BFABEF9083664756E2164756E21
-//# sourceMappingURL=studio-s519zc99.js.map
+//# sourceMappingURL=studio-bgxt93ga.js.map

package/dist/chunks/studio-cft9r4r7.js

@@ -0,0 +1,119 @@
+import {
+  errorMessage
+} from "./studio-9n4mrmnb.js";
+import {
+  getPlatform,
+  hasPlatform
+} from "./studio-9ab8gqsm.js";
+
+// src/services/references.ts
+function usagesSupported() {
+  return hasPlatform() && typeof getPlatform().findReferences === "function";
+}
+function keyOf(query) {
+  return `${query.path ?? ""}\x00${query.tagName ?? ""}`;
+}
+var settled = new Map;
+var inFlight = new Map;
+function peekUsages(query) {
+  if (!usagesSupported()) {
+    return { status: "unsupported" };
+  }
+  return settled.get(keyOf(query)) ?? (inFlight.has(keyOf(query)) ? { status: "pending" } : null);
+}
+async function loadUsages(query) {
+  if (!usagesSupported()) {
+    return { status: "unsupported" };
+  }
+  if (!query.path && !query.tagName) {
+    return { status: "failed", message: "no target to look for" };
+  }
+  const key = keyOf(query);
+  const done = settled.get(key);
+  if (done) {
+    return done;
+  }
+  const running = inFlight.get(key);
+  if (running) {
+    return running;
+  }
+  const pending = (async () => {
+    try {
+      const result = await getPlatform().findReferences({
+        ...query.path === undefined ? {} : { path: query.path },
+        ...query.tagName === undefined ? {} : { tagName: query.tagName }
+      });
+      return { result, status: "ready" };
+    } catch (error) {
+      return { message: errorMessage(error), status: "failed" };
+    } finally {
+      inFlight.delete(key);
+    }
+  })();
+  inFlight.set(key, pending);
+  const state = await pending;
+  settled.set(key, state);
+  return state;
+}
+function retryUsages(query) {
+  settled.delete(keyOf(query));
+  return loadUsages(query);
+}
+function invalidateUsages() {
+  settled.clear();
+}
+function splitUsages(result) {
+  let pages = 0;
+  for (const file of result.files) {
+    if (file.path.startsWith("pages/")) {
+      pages += 1;
+    }
+  }
+  return { others: result.files.length - pages, pages };
+}
+function usageHeadline(result) {
+  const { others, pages } = splitUsages(result);
+  if (pages === 0 && others === 0) {
+    return "Not used yet";
+  }
+  const parts = [];
+  if (pages > 0) {
+    parts.push(`${pages} page${pages === 1 ? "" : "s"}`);
+  }
+  if (others > 0) {
+    parts.push(`${others} other file${others === 1 ? "" : "s"}`);
+  }
+  return `Used on ${parts.join(" and ")}`;
+}
+function usageWarning(state, verb) {
+  if (state.status === "unsupported") {
+    return null;
+  }
+  if (state.status === "pending") {
+    return "Counting references…";
+  }
+  if (state.status === "failed") {
+    return `References could not be counted (${state.message}) — this may break more than it appears to.`;
+  }
+  const { files, refsTotal } = state.result;
+  if (files.length === 0) {
+    return verb === "delete" ? "Nothing else in this project refers to it." : "Nothing else in this project refers to it, so nothing needs updating.";
+  }
+  const where = `${refsTotal} reference${refsTotal === 1 ? "" : "s"} in ${files.length} file${files.length === 1 ? "" : "s"}`;
+  const floor = state.result.errors.length > 0 ? " (at least — some documents could not be read)" : "";
+  if (verb === "delete") {
+    return `${where}${floor} will break. Those files stay on disk; the references in them stop resolving.`;
+  }
+  if (verb === "convert") {
+    return `${where}${floor} will be updated automatically to point at the new file.`;
+  }
+  return `${where}${floor} will be updated automatically. Nothing else changes.`;
+}
+function usageFiles(result) {
+  return result.files.toSorted((a, b) => b.count - a.count || a.path.localeCompare(b.path));
+}
+
+export { usagesSupported, peekUsages, loadUsages, retryUsages, invalidateUsages, splitUsages, usageHeadline, usageWarning, usageFiles };
+
+//# debugId=F66D72E5CAE74C4664756E2164756E21
+//# sourceMappingURL=studio-cft9r4r7.js.map