@jxsuite/studio 2.0.1 → 2.1.0

package/dist/chunks/studio-9je6w5sq.js

@@ -0,0 +1,1000 @@
+import {
+  cellToText,
+  coerceCellInput,
+  collectionDirs,
+  columnsFromSchema,
+  createCollectionSource,
+  createGridController,
+  createPagesSource,
+  inferColumnsFromRows,
+  isRecentLocal,
+  makeGridTabId,
+  markLocalMutation
+} from "./studio-k2sxjph5.js";
+import {
+  MEDIA_EXTENSIONS,
+  extensionOf
+} from "./studio-f12h6177.js";
+import {
+  activateTab,
+  argsSchema,
+  errorMessage,
+  findContentTypeSchema,
+  openModal,
+  openTab,
+  optionalStringArg,
+  resolveI18n,
+  servedLocaleOfPath,
+  stringArg,
+  stringProperty,
+  workspace
+} from "./studio-41exgzhq.js";
+import {
+  html
+} from "./studio-5x5774ak.js";
+import {
+  projectState
+} from "./studio-cjm7fdjf.js";
+import {
+  formatForPath,
+  loadFormats
+} from "./studio-adn0z1k3.js";
+import {
+  getPlatform
+} from "./studio-sas7mt3k.js";
+
+// src/services/data-service.ts
+function platformOrNull() {
+  try {
+    return getPlatform();
+  } catch {
+    return null;
+  }
+}
+function dataSurfaceAvailable() {
+  return typeof platformOrNull()?.dataRows === "function";
+}
+async function fetchConnections() {
+  const platform = platformOrNull();
+  if (typeof platform?.dataConnections !== "function") {
+    return null;
+  }
+  return platform.dataConnections();
+}
+async function testConnection(connection) {
+  const platform = platformOrNull();
+  if (typeof platform?.dataConnectionTest !== "function") {
+    return { error: "Connection tests are not supported by this backend", ok: false };
+  }
+  try {
+    return await platform.dataConnectionTest(connection);
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error), ok: false };
+  }
+}
+async function pushSchema(opts) {
+  const platform = platformOrNull();
+  if (typeof platform?.dataPush !== "function") {
+    return { applied: false, errors: ["Schema push is not supported by this backend"], plan: [] };
+  }
+  try {
+    return await platform.dataPush(opts);
+  } catch (error) {
+    return {
+      applied: false,
+      errors: [error instanceof Error ? error.message : String(error)],
+      plan: []
+    };
+  }
+}
+function requireMember(name) {
+  const platform = platformOrNull();
+  const member = platform?.[name];
+  if (member === undefined || member === null) {
+    throw new Error(`The ${String(name)} surface is not supported by this backend`);
+  }
+  return member;
+}
+function fetchRows(query) {
+  return requireMember("dataRows")(query);
+}
+function insertRow(req) {
+  return requireMember("dataInsertRow")(req);
+}
+function updateRow(req) {
+  return requireMember("dataUpdateRow")(req);
+}
+function deleteRow(req) {
+  return requireMember("dataDeleteRow")(req);
+}
+function deriveSecretEnvName(sectionKey, entryKey, fieldKey) {
+  const constant = (raw) => raw.replaceAll(/([a-z0-9])([A-Z])/g, "$1_$2").replaceAll(/[^A-Za-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "").toUpperCase();
+  const parts = [entryKey ?? sectionKey, fieldKey.replace(/Env$/, "")].map((part) => constant(part)).filter(Boolean);
+  const name = parts.join("_") || "SECRET";
+  return /^\d/.test(name) ? `JX_${name}` : name;
+}
+
+// src/grid/csv-codec.ts
+function splitRecords(text) {
+  const records = [];
+  let fields = [];
+  let field = "";
+  let inQuotes = false;
+  let fieldStarted = false;
+  const endField = () => {
+    fields.push(field);
+    field = "";
+    fieldStarted = false;
+  };
+  const endRecord = () => {
+    endField();
+    if (fields.length === 1 && fields[0] === "") {
+      fields = [];
+      return;
+    }
+    records.push(fields);
+    fields = [];
+  };
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i += 1;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+    if (ch === '"' && !fieldStarted) {
+      inQuotes = true;
+      fieldStarted = true;
+    } else if (ch === '"') {
+      field += ch;
+    } else if (ch === ",") {
+      endField();
+    } else if (ch === `
+`) {
+      endRecord();
+    } else if (ch === "\r") {
+      if (text[i + 1] === `
+`) {
+        i += 1;
+      }
+      endRecord();
+    } else {
+      field += ch;
+      fieldStarted = true;
+    }
+  }
+  if (field !== "" || fields.length > 0) {
+    endRecord();
+  }
+  return records;
+}
+function parseCsv(text) {
+  const crlf = (text.match(/\r\n/g) ?? []).length;
+  const bareLf = (text.match(/(?<!\r)\n/g) ?? []).length;
+  const eol = crlf > bareLf ? `\r
+` : `
+`;
+  const trailingNewline = text.endsWith(`
+`);
+  const records = splitRecords(text);
+  const headers = records[0] ?? [];
+  const rows = records.slice(1);
+  const width = Math.max(headers.length, ...rows.map((r) => r.length), 0);
+  while (headers.length < width) {
+    headers.push("");
+  }
+  for (const row of rows) {
+    while (row.length < width) {
+      row.push("");
+    }
+  }
+  return { eol, headers, rows, trailingNewline };
+}
+function encodeField(value) {
+  if (/[",\n\r]/.test(value)) {
+    return `"${value.replaceAll('"', '""')}"`;
+  }
+  return value;
+}
+function serializeCsv(doc) {
+  const lines = [doc.headers, ...doc.rows].map((fields) => fields.map((field) => encodeField(field)).join(","));
+  return lines.join(doc.eol) + (doc.trailingNewline ? doc.eol : "");
+}
+
+// src/grid/sources/csv-file-source.ts
+var ID_FIELDS = ["id", "sku", "slug", "Slug"];
+function fieldNamesForHeaders(headers) {
+  const used = new Set;
+  return headers.map((header, i) => {
+    let name = header.trim() === "" ? `column${i + 1}` : header;
+    if (used.has(name)) {
+      name = `${name}__${i + 1}`;
+    }
+    used.add(name);
+    return name;
+  });
+}
+function pickIdField(fields, doc) {
+  for (const candidate of ID_FIELDS) {
+    const idx = fields.indexOf(candidate);
+    if (idx === -1) {
+      continue;
+    }
+    const values = doc.rows.map((row) => row[idx] ?? "");
+    if (values.every((v) => v !== "") && new Set(values).size === values.length) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function buildModel(text, path) {
+  const doc = parseCsv(text);
+  const fields = fieldNamesForHeaders(doc.headers);
+  const idField = pickIdField(fields, doc);
+  const idIndex = idField ? fields.indexOf(idField) : -1;
+  const keys = doc.rows.map((row, i) => idIndex === -1 ? String(i) : row[idIndex]);
+  const keyToIndex = new Map(keys.map((key, i) => [key, i]));
+  const contentType = findContentTypeSchema(path, projectState?.projectConfig);
+  const schemaProps = contentType?.schema?.properties ?? {};
+  const sampleRows = doc.rows.slice(0, 50).map((row) => {
+    const cells = {};
+    for (const [i, field] of fields.entries()) {
+      cells[field] = row[i] ?? "";
+    }
+    return cells;
+  });
+  const inferred = new Map(inferColumnsFromRows(sampleRows).map((c) => [c.field, c]));
+  const typed = new Map(columnsFromSchema(contentType?.schema, { idField: idField ?? undefined }).map((c) => [
+    c.field,
+    c
+  ]));
+  const columns = fields.map((field, i) => {
+    const fromSchema = field in schemaProps ? typed.get(field) : undefined;
+    const column = fromSchema ?? inferred.get(field) ?? {
+      editable: true,
+      field,
+      kind: "string",
+      title: doc.headers[i] || field
+    };
+    return { ...column, pk: field === idField, title: doc.headers[i]?.trim() || column.title };
+  });
+  return { columns, doc, fields, keys, keyToIndex, loadText: text };
+}
+function rowCells(model, rowIndex) {
+  const cells = {};
+  const row = model.doc.rows[rowIndex] ?? [];
+  for (const [i, field] of model.fields.entries()) {
+    const column = model.columns[i];
+    const raw = row[i] ?? "";
+    cells[field] = column.kind === "string" || column.kind === "text" || column.kind === "readonly" ? raw : coerceCellInput(raw, column);
+  }
+  return cells;
+}
+function applyBatch(model, batch) {
+  const rows = model.doc.rows.map((row) => [...row]);
+  const colFor = (field) => model.fields.indexOf(field);
+  for (const cell of batch.cells) {
+    const rowIndex = model.keyToIndex.get(cell.rowKey);
+    const colIndex = colFor(cell.field);
+    if (rowIndex === undefined || colIndex === -1) {
+      continue;
+    }
+    rows[rowIndex][colIndex] = cellToText(cell.value);
+  }
+  for (const insert of batch.inserts) {
+    const row = model.fields.map((field) => cellToText(insert.cells[field] ?? null));
+    rows.push(row);
+  }
+  const dropIndexes = batch.deletes.map((del) => model.keyToIndex.get(del.rowKey)).filter((i) => i !== undefined).toSorted((a, b) => b - a);
+  for (const index of dropIndexes) {
+    rows.splice(index, 1);
+  }
+  return { ...model.doc, rows };
+}
+function uniformResult(batch, outcome) {
+  return {
+    cells: batch.cells.map((c) => ({ field: c.field, rowKey: c.rowKey, ...outcome })),
+    deletes: batch.deletes.map((d) => ({ rowKey: d.rowKey, ...outcome })),
+    inserts: batch.inserts.map((i) => ({
+      error: outcome.error,
+      ok: outcome.ok,
+      tempKey: i.tempKey
+    }))
+  };
+}
+function createCsvFileSource(path) {
+  let loadPromise = null;
+  const load = (force = false) => {
+    if (!force && loadPromise) {
+      return loadPromise;
+    }
+    loadPromise = getPlatform().readFile(path).then((text) => buildModel(text, path));
+    return loadPromise;
+  };
+  return {
+    backingPaths: () => new Map([[path, "*"]]),
+    capabilities: { delete: true, insert: true, remotePaging: false, remoteSort: false },
+    async columns() {
+      const current = await load();
+      return current.columns;
+    },
+    async commit(batch) {
+      const current = await load();
+      const platform = getPlatform();
+      let onDisk = null;
+      try {
+        onDisk = await platform.readFile(path);
+      } catch {
+        onDisk = null;
+      }
+      if (onDisk !== current.loadText && !isRecentLocal(path)) {
+        return uniformResult(batch, {
+          error: "File changed on disk — refresh to reload",
+          ok: false,
+          stale: true
+        });
+      }
+      const nextDoc = applyBatch(current, batch);
+      const text = serializeCsv(nextDoc);
+      markLocalMutation(path);
+      await platform.writeFile(path, text);
+      loadPromise = Promise.resolve(buildModel(text, path));
+      return uniformResult(batch, { ok: true });
+    },
+    id: path,
+    label: path.split("/").pop() ?? path,
+    async refresh() {
+      await load(true);
+    },
+    async rows() {
+      const current = await load();
+      const rows = current.doc.rows.map((_, i) => ({
+        cells: rowCells(current, i),
+        key: current.keys[i]
+      }));
+      return { rows, total: rows.length };
+    },
+    async serializeForSource(batch) {
+      const current = await load();
+      return serializeCsv(applyBatch(current, batch));
+    }
+  };
+}
+
+// src/grid/sources/connector-source.ts
+var DATA_PAGE_SIZE = 50;
+function kindForSqlType(type) {
+  const t = type.toLowerCase();
+  if (/(int|real|floa|doub|num|dec)/.test(t)) {
+    return "number";
+  }
+  if (t.includes("bool")) {
+    return "boolean";
+  }
+  if (/(timestamp|datetime|date)/.test(t)) {
+    return "date";
+  }
+  return "string";
+}
+function editableColumn(column) {
+  return !column.pk && column.name !== "created_at" && column.name !== "updated_at";
+}
+function toCellValue(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function createConnectorSource(connection, table) {
+  let columnsMeta = [];
+  let pkName = "id";
+  const pkValues = new Map;
+  const applyMeta = (columns) => {
+    if (columns.length > 0) {
+      columnsMeta = columns;
+      pkName = columns.find((c) => c.pk)?.name ?? "id";
+    }
+  };
+  const toQuery = (query) => ({
+    table,
+    ...connection ? { connection } : {},
+    limit: query?.limit ?? DATA_PAGE_SIZE,
+    offset: query?.offset ?? 0,
+    ...query?.orderBy ? { dir: query.dir ?? "asc", orderBy: query.orderBy } : {}
+  });
+  const rowKeyOf = (row, index) => {
+    const pk = row[pkName];
+    if (typeof pk === "string" || typeof pk === "number") {
+      pkValues.set(String(pk), pk);
+      return String(pk);
+    }
+    return `row-${index}`;
+  };
+  return {
+    capabilities: { delete: true, insert: true, remotePaging: true, remoteSort: true },
+    async columns() {
+      if (columnsMeta.length === 0) {
+        const result = await fetchRows(toQuery({ limit: 1, offset: 0 }));
+        applyMeta(result.columns);
+      }
+      return columnsMeta.map((meta) => {
+        const kind = editableColumn(meta) ? kindForSqlType(meta.type) : "readonly";
+        return {
+          editable: kind !== "readonly",
+          field: meta.name,
+          kind,
+          pk: meta.pk === true,
+          title: meta.name,
+          widthHint: meta.pk ? 80 : undefined
+        };
+      });
+    },
+    async commit(batch) {
+      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 [rowKey, patches] of byRow) {
+        const pk = pkValues.get(rowKey);
+        const outcome = (ok, error) => {
+          for (const patch of patches) {
+            result.cells.push({ error, field: patch.field, ok, rowKey });
+          }
+        };
+        if (pk === undefined) {
+          outcome(false, "Row has no primary key — refresh the grid");
+          continue;
+        }
+        try {
+          const set = {};
+          for (const patch of patches) {
+            set[patch.field] = patch.value;
+          }
+          await updateRow({ pk, set, table, ...connection ? { connection } : {} });
+          outcome(true);
+        } catch (error) {
+          outcome(false, error instanceof Error ? error.message : String(error));
+        }
+      }
+      for (const insert of batch.inserts) {
+        try {
+          const values = {};
+          for (const [field, value] of Object.entries(insert.cells)) {
+            if (value !== null) {
+              values[field] = value;
+            }
+          }
+          const { row } = await insertRow({ table, values, ...connection ? { connection } : {} });
+          const pk = row[pkName];
+          const newKey = typeof pk === "string" || typeof pk === "number" ? String(pk) : undefined;
+          if (newKey !== undefined && (typeof pk === "string" || typeof pk === "number")) {
+            pkValues.set(newKey, pk);
+          }
+          result.inserts.push({ newKey, 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) {
+        const pk = pkValues.get(del.rowKey);
+        if (pk === undefined) {
+          result.deletes.push({
+            error: "Row has no primary key — refresh the grid",
+            ok: false,
+            rowKey: del.rowKey
+          });
+          continue;
+        }
+        try {
+          await deleteRow({ pk, table, ...connection ? { connection } : {} });
+          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: makeGridTabId({ connection: connection ?? "default", kind: "data", table }),
+    label: table,
+    async refresh() {
+      columnsMeta = [];
+      pkValues.clear();
+    },
+    async rows(query) {
+      const result = await fetchRows(toQuery(query));
+      applyMeta(result.columns);
+      const rows = result.rows.map((row, index) => {
+        const key = rowKeyOf(row, index);
+        const cells = {};
+        for (const meta of columnsMeta) {
+          cells[meta.name] = toCellValue(row[meta.name]);
+        }
+        return { cells, key };
+      });
+      return { rows, total: result.total };
+    }
+  };
+}
+
+// src/browse/library-model.ts
+var LIBRARY_CATEGORIES = [
+  { key: "all", label: "All" },
+  { dir: "pages", key: "pages", label: "Pages" },
+  { dir: "layouts", key: "layouts", label: "Layouts" },
+  { dir: "components", key: "components", label: "Components" },
+  { dir: "content", key: "content", label: "Content" },
+  { dir: "public", key: "media", label: "Media" }
+];
+var LIBRARY_CATEGORY_KEYS = LIBRARY_CATEGORIES.map((c) => c.key);
+function libraryCategory(key) {
+  return LIBRARY_CATEGORIES.find((c) => c.key === key);
+}
+function uploadDirForCategory(key) {
+  return libraryCategory(key)?.dir;
+}
+function categoryFor(dir, ext) {
+  if (ext && MEDIA_EXTENSIONS.has(ext)) {
+    return "Media";
+  }
+  if (dir.startsWith("pages")) {
+    return "Pages";
+  }
+  if (dir.startsWith("layouts")) {
+    return "Layouts";
+  }
+  if (dir.startsWith("components")) {
+    return "Components";
+  }
+  if (dir.startsWith("content")) {
+    return "Content";
+  }
+  if (dir.startsWith("public")) {
+    return "Media";
+  }
+  if (dir.startsWith("data")) {
+    return "Content";
+  }
+  if (dir.startsWith("styles")) {
+    return "Components";
+  }
+  return "Other";
+}
+function contentTypeFor(filePath) {
+  const content = projectState?.projectConfig?.content ?? {};
+  for (const [name, entry] of Object.entries(content)) {
+    if (!entry.source) {
+      continue;
+    }
+    const prefix = entry.source.replace(/^\.\//, "").replace(/\/$/, "");
+    if (filePath.startsWith(`${prefix}/`) || filePath === prefix) {
+      return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+  }
+  return null;
+}
+var SKIP_DIRS = new Set(["node_modules", ".git", ".jx", "dist", "build", ".cache"]);
+async function walk(dir, platform, out, failures, i18n) {
+  let entries;
+  try {
+    entries = await platform.listDirectory(dir);
+  } catch (error) {
+    failures.push({ dir, error: errorMessage(error) });
+    return;
+  }
+  const subdirectories = [];
+  for (const entry of entries) {
+    if (entry.type === "directory") {
+      if (!SKIP_DIRS.has(entry.name)) {
+        subdirectories.push(entry.path);
+      }
+      continue;
+    }
+    const ext = extensionOf(entry.name);
+    const category = categoryFor(entry.path, ext);
+    out.push({
+      category,
+      ext,
+      locale: servedLocaleOfPath(entry.path, i18n) ?? undefined,
+      modified: entry.modified,
+      name: entry.name,
+      path: entry.path,
+      size: entry.size,
+      type: category === "Content" ? contentTypeFor(entry.path) ?? ext ?? "file" : ext || "file"
+    });
+  }
+  await Promise.all(subdirectories.map((sub) => walk(sub, platform, out, failures, i18n)));
+}
+async function scanLibrary(dirs, platform) {
+  const files = [];
+  const failures = [];
+  const { i18n } = resolveI18n(projectState?.projectConfig ?? {});
+  await Promise.all(dirs.map((dir) => walk(dir, platform, files, failures, i18n)));
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return { failures, files };
+}
+function filterLibrary(files, filter) {
+  let result = files;
+  const category = libraryCategory(filter.category);
+  if (category && category.key !== "all") {
+    result = result.filter((f) => f.category === category.label);
+  }
+  const query = filter.query.trim().toLowerCase();
+  if (query) {
+    result = result.filter((f) => f.name.toLowerCase().includes(query) || f.path.toLowerCase().includes(query));
+  }
+  const locale = filter.locale?.trim();
+  if (locale) {
+    result = result.filter((f) => f.locale === locale);
+  }
+  return result;
+}
+var LIBRARY_LAYOUTS = ["table", "cards", "media", "calendar", "board"];
+var LIBRARY_LAYOUT_LABELS = {
+  board: "Board",
+  calendar: "Calendar",
+  cards: "Cards",
+  media: "Media",
+  table: "Table"
+};
+var PREVIEW_LAYOUTS = new Set([
+  "cards",
+  "media"
+]);
+var DATE_PREFIX = /^(\d{4}-\d{2}-\d{2})/;
+function libraryDate(file) {
+  const prefix = DATE_PREFIX.exec(file.name);
+  if (prefix) {
+    return prefix[1];
+  }
+  if (file.modified) {
+    const parsed = new Date(file.modified);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString().slice(0, 10);
+    }
+  }
+  return null;
+}
+function projectLocales() {
+  return resolveI18n(projectState?.projectConfig ?? {}).i18n?.locales ?? [];
+}
+function libraryLocales(files) {
+  const present = new Set;
+  for (const file of files) {
+    if (file.locale) {
+      present.add(file.locale);
+    }
+  }
+  return projectLocales().filter((tag) => present.has(tag));
+}
+function groupByDate(files) {
+  const byDay = new Map;
+  const undated = [];
+  for (const file of files) {
+    const date = libraryDate(file);
+    if (date === null) {
+      undated.push(file);
+      continue;
+    }
+    const bucket = byDay.get(date);
+    if (bucket) {
+      bucket.push(file);
+    } else {
+      byDay.set(date, [file]);
+    }
+  }
+  const days = [...byDay.entries()].map(([date, dayFiles]) => ({ date, files: dayFiles })).toSorted((a, b) => b.date.localeCompare(a.date));
+  return { days, undated };
+}
+function groupByCategory(files) {
+  const byGroup = new Map;
+  for (const file of files) {
+    const bucket = byGroup.get(file.category);
+    if (bucket) {
+      bucket.push(file);
+    } else {
+      byGroup.set(file.category, [file]);
+    }
+  }
+  const order = LIBRARY_CATEGORIES.map((c) => c.label);
+  return [...byGroup.entries()].map(([group, groupFiles]) => ({ files: groupFiles, group })).toSorted((a, b) => {
+    const ai = order.indexOf(a.group);
+    const bi = order.indexOf(b.group);
+    if (ai === bi) {
+      return a.group.localeCompare(b.group);
+    }
+    return (ai === -1 ? order.length : ai) - (bi === -1 ? order.length : bi);
+  });
+}
+
+// src/browse/library-source.ts
+var LIBRARY_READ_ONLY = "The Library lists files; it does not edit them. Rename, duplicate or delete from the file's " + "context menu, or open the file to edit it.";
+function libraryColumns() {
+  return [
+    { editable: false, field: "name", kind: "string", pk: true, title: "Name", widthHint: 260 },
+    { editable: false, field: "category", kind: "string", title: "Category", widthHint: 120 },
+    { editable: false, field: "locale", kind: "string", title: "Locale", widthHint: 90 },
+    { editable: false, field: "type", kind: "string", title: "Type", widthHint: 120 },
+    { editable: false, field: "size", kind: "number", title: "Size", widthHint: 90 },
+    { editable: false, field: "modified", kind: "date", title: "Modified", widthHint: 160 },
+    { editable: false, field: "path", kind: "readonly", title: "Path", widthHint: 320 }
+  ];
+}
+function libraryRow(file) {
+  return {
+    cells: {
+      category: file.category,
+      locale: file.locale ?? null,
+      modified: file.modified ?? null,
+      name: file.name,
+      path: file.path,
+      size: file.size ?? null,
+      type: file.type
+    },
+    key: file.path
+  };
+}
+function libraryTabId() {
+  return makeGridTabId({ kind: "library" });
+}
+function createLibrarySource(dirs) {
+  let scan = null;
+  let inFlight = null;
+  const projectDirs = dirs ?? (() => projectState?.projectDirs ?? []);
+  async function ensureScan() {
+    if (scan) {
+      return scan;
+    }
+    inFlight ??= scanLibrary(projectDirs(), getPlatform()).then((result) => {
+      scan = result;
+      inFlight = null;
+      return result;
+    });
+    return inFlight;
+  }
+  return {
+    capabilities: { delete: false, insert: false, remotePaging: false, remoteSort: false },
+    columns: () => Promise.resolve(libraryColumns()),
+    commit(batch) {
+      return Promise.resolve({
+        cells: batch.cells.map((cell) => ({
+          error: LIBRARY_READ_ONLY,
+          field: cell.field,
+          ok: false,
+          rowKey: cell.rowKey
+        })),
+        deletes: batch.deletes.map((row) => ({
+          error: LIBRARY_READ_ONLY,
+          ok: false,
+          rowKey: row.rowKey
+        })),
+        inserts: batch.inserts.map((row) => ({
+          error: LIBRARY_READ_ONLY,
+          ok: false,
+          tempKey: row.tempKey
+        }))
+      });
+    },
+    failures: () => scan?.failures ?? [],
+    files: () => scan?.files ?? [],
+    id: libraryTabId(),
+    label: "Library",
+    async refresh() {
+      scan = null;
+      inFlight = null;
+      await ensureScan();
+    },
+    async rows() {
+      const result = await ensureScan();
+      return { rows: result.files.map((file) => libraryRow(file)), total: result.files.length };
+    },
+    scanned: () => scan !== null
+  };
+}
+
+// src/grid/grid-open.ts
+var GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
+async function openCsvGridTab(path) {
+  const existing = workspace.tabs.get(path);
+  if (existing) {
+    activateTab(path);
+    return existing;
+  }
+  try {
+    await loadFormats();
+  } catch {}
+  const source = createCsvFileSource(path);
+  const tab = openTab({
+    capabilities: { modes: ["grid", "source"] },
+    document: structuredClone(GRID_STUB_DOCUMENT),
+    documentPath: path,
+    id: path,
+    sourceFormat: formatForPath(path)?.name ?? null
+  });
+  const controller = createGridController(tab, source);
+  controller.load();
+  return tab;
+}
+function openVirtualGridTab(source) {
+  const tab = openTab({
+    capabilities: { modes: ["grid"] },
+    document: structuredClone(GRID_STUB_DOCUMENT),
+    documentPath: null,
+    id: source.id
+  });
+  const controller = createGridController(tab, source);
+  controller.load();
+  return tab;
+}
+function openCollectionGrid(typeName) {
+  const id = makeGridTabId({ kind: "collection", name: typeName });
+  const existing = workspace.tabs.get(id);
+  if (existing) {
+    activateTab(id);
+    return existing;
+  }
+  return openVirtualGridTab(createCollectionSource(typeName));
+}
+function openLibraryTab() {
+  const id = libraryTabId();
+  const existing = workspace.tabs.get(id);
+  if (existing) {
+    activateTab(id);
+    return existing;
+  }
+  return openTab({
+    capabilities: { modes: ["manage"] },
+    document: structuredClone(GRID_STUB_DOCUMENT),
+    documentPath: null,
+    id
+  });
+}
+function openPagesGrid() {
+  const id = makeGridTabId({ kind: "pages" });
+  const existing = workspace.tabs.get(id);
+  if (existing) {
+    activateTab(id);
+    return existing;
+  }
+  return openVirtualGridTab(createPagesSource());
+}
+function openConnectorGrid(connection, table) {
+  const id = makeGridTabId({ connection: connection ?? "default", kind: "data", table });
+  const existing = workspace.tabs.get(id);
+  if (existing) {
+    activateTab(id);
+    return existing;
+  }
+  return openVirtualGridTab(createConnectorSource(connection, table));
+}
+async function openGridSourcePicker() {
+  const collections = collectionDirs();
+  let connections = [];
+  if (dataSurfaceAvailable()) {
+    const response = await fetchConnections().catch(() => null);
+    connections = response?.connections ?? [];
+  }
+  const handle = openModal(html`<sp-dialog-wrapper
+      open
+      dismissable
+      underlay
+      headline="Open Grid"
+      @close=${() => handle.close()}
+    >
+      <sp-menu class="jx-grid-picker">
+        <sp-menu-group>
+          <span slot="header">Project</span>
+          <sp-menu-item
+            @click=${() => {
+    handle.close();
+    openPagesGrid();
+  }}
+            >Pages</sp-menu-item
+          >
+          ${collections.map(({ name }) => html`<sp-menu-item
+                @click=${() => {
+    handle.close();
+    openCollectionGrid(name);
+  }}
+                >Collection: ${name}</sp-menu-item
+              >`)}
+        </sp-menu-group>
+        ${connections.map((conn) => html`<sp-menu-group>
+              <span slot="header">Data · ${conn.name}</span>
+              ${conn.tables.length === 0 ? html`<sp-menu-item disabled>No tables — push a schema first</sp-menu-item>` : conn.tables.map((table) => html`<sp-menu-item
+                          @click=${() => {
+    handle.close();
+    openConnectorGrid(conn.name, table);
+  }}
+                          >${table}</sp-menu-item
+                        >`)}
+            </sp-menu-group>`)}
+      </sp-menu>
+    </sp-dialog-wrapper>`, { label: "Open Grid" });
+}
+function gridCommands() {
+  return [
+    {
+      args: argsSchema({
+        name: stringProperty("The content collection's name, as project.json declares it.")
+      }),
+      category: "Project",
+      id: "collection.editInGrid",
+      level: "project",
+      menus: ["context/file", "palette"],
+      group: "5_data",
+      requires: "a project that declares content collections",
+      when: (ctx) => ctx.project.open,
+      aiTool: {
+        description: "Open a content collection's entries as an editable grid in a new tab.",
+        name: "open_collection_grid"
+      },
+      run: (_commandCtx, args) => {
+        const name = stringArg("collection.editInGrid", args, "name");
+        const declared = collectionDirs().map((c) => c.name);
+        if (!declared.includes(name)) {
+          throw new RangeError(`command "collection.editInGrid" argument "name": "${name}" is not a content ` + `collection this project declares — it declares: ` + `${declared.length > 0 ? declared.join(", ") : "none"}`);
+        }
+        openCollectionGrid(name);
+      },
+      title: "Edit Collection in Grid"
+    },
+    {
+      args: {
+        additionalProperties: false,
+        properties: {
+          connection: stringProperty('The connection name from project.json. Defaults to "default".'),
+          table: stringProperty("The table to open.")
+        },
+        required: ["table"],
+        type: "object"
+      },
+      category: "Project",
+      id: "data.openGrid",
+      level: "project",
+      menus: ["palette"],
+      group: "5_data",
+      requires: "a platform that serves the data routes",
+      when: (ctx) => ctx.project.open,
+      enablement: (ctx) => ctx.capability.dataRows,
+      aiTool: {
+        description: "Open a connector table as an editable grid in a new tab.",
+        name: "open_data_grid"
+      },
+      run: (_commandCtx, args) => {
+        const table = stringArg("data.openGrid", args, "table");
+        openConnectorGrid(optionalStringArg("data.openGrid", args, "connection"), table);
+      },
+      title: "Open Data Grid"
+    }
+  ];
+}
+function registerGridCommands(registry) {
+  registry.registerAll(gridCommands());
+}
+
+export { dataSurfaceAvailable, testConnection, pushSchema, deriveSecretEnvName, parseCsv, createCsvFileSource, LIBRARY_CATEGORIES, LIBRARY_CATEGORY_KEYS, libraryCategory, uploadDirForCategory, scanLibrary, filterLibrary, LIBRARY_LAYOUTS, LIBRARY_LAYOUT_LABELS, PREVIEW_LAYOUTS, projectLocales, libraryLocales, groupByDate, groupByCategory, libraryColumns, createLibrarySource, openCsvGridTab, openLibraryTab, openPagesGrid, openGridSourcePicker, registerGridCommands };
+
+//# debugId=B5A73986FCDCB07464756E2164756E21
+//# sourceMappingURL=studio-9je6w5sq.js.map