@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/{studio-3bqpr0zh.js → studio-pxbgypmg.js}

@@ -1,60 +1,236 @@
 import {
-  collectionDirs,
-  createCollectionSource,
-  createPagesSource
-} from "./studio-b55y6ewx.js";
+  reactive
+} from "./studio-p1dw8wfw.js";
 import {
-  cellToText,
-  coerceCellInput,
-  columnsFromSchema,
-  createGridController,
-  inferColumnsFromRows,
-  makeGridTabId
-} from "./studio-cmb03bg5.js";
+  getPlatform2
+} from "./studio-6nzaktvy.js";
 import {
-  isRecentLocal,
-  markLocalMutation
-} from "./studio-q43a5y9h.js";
+  loadFormats2,
+  formatForPath2
+} from "./studio-vw7mzp6z.js";
 import {
-  MEDIA_EXTENSIONS,
-  extensionOf
-} from "./studio-qjy2z9bv.js";
+  projectState
+} from "./studio-6ewqv390.js";
 import {
-  activateTab,
-  argsSchema,
-  findContentTypeSchema,
-  openTab,
-  optionalStringArg,
   resolveI18n,
   servedLocaleOfPath,
   stringArg,
+  optionalStringArg,
+  argsSchema,
   stringProperty,
-  workspace
-} from "./studio-trxrabqf.js";
+  findContentTypeSchema,
+  workspace2,
+  openTab2,
+  activateTab2
+} from "./studio-k75n7vhp.js";
 import {
-  projectState
-} from "./studio-p4ngc046.js";
+  registerSurface,
+  mountSurface,
+  openDialogSurface,
+  layerHost2
+} from "./studio-vfq8qpjt.js";
 import {
-  openModal
-} from "./studio-t7qb9db8.js";
+  errorMessage2
+} from "./studio-yxa81f45.js";
 import {
-  errorMessage
-} from "./studio-9n4mrmnb.js";
+  markLocalMutation2,
+  isRecentLocal2
+} from "./studio-g3jevyjt.js";
 import {
-  html
-} from "./studio-kryvsw6j.js";
+  makeGridTabId,
+  parseGridTabId,
+  columnsFromSchema,
+  inferColumnsFromRows,
+  coerceCellInput,
+  cellToText,
+  createGridController
+} from "./studio-gb13095a.js";
 import {
-  formatForPath,
-  loadFormats
-} from "./studio-ahn3pdgx.js";
+  collectionDirs2,
+  createCollectionSource2,
+  createPagesSource2
+} from "./studio-1knfqgy7.js";
 import {
-  getPlatform
-} from "./studio-9ab8gqsm.js";
+  MEDIA_EXTENSIONS,
+  extensionOf
+} from "./studio-jxp12rnj.js";
+// src/surfaces/grid-open.json
+var grid_open_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioGridOpen",
+  $description: "Every grid-able source a project has, grouped by where it comes from: the project's own pages and content collections first, then each connection's tables. It is the ISLAND of a confirm dialog rather than a dialog of its own — `ui/layers.ts`'s dialog owns the headline, the cancel button, modality and focus, and this document is only the list — because a second answer to \"what is a dialog\" is a defect (§12.5). Group headings are why it is not the kit menu: a menu row can carry a divider above it and cannot carry a name for the run it opens.",
+  tagName: "div",
+  attributes: {
+    part: "sources"
+  },
+  style: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "var(--jx-space-3)",
+    minWidth: "280px",
+    fontFamily: "var(--jx-font-sans)",
+    fontSize: "var(--jx-text-md)",
+    color: "var(--fg)",
+    '& [part="group-title"]': {
+      margin: "0",
+      fontSize: "var(--jx-text-xs)",
+      fontWeight: "600",
+      textTransform: "uppercase",
+      letterSpacing: "0.04em",
+      color: "var(--fg-dim)"
+    },
+    '& [part="rows"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "1px",
+      marginTop: "var(--jx-space-1)"
+    },
+    '& [part="source"]': {
+      textAlign: "left",
+      background: "none",
+      border: "none",
+      color: "var(--fg)",
+      font: "inherit",
+      padding: "var(--jx-space-2) var(--jx-space-2)",
+      borderRadius: "var(--jx-radius-sm)",
+      cursor: "pointer"
+    },
+    '& [part="source"]:hover': {
+      background: "var(--bg-hover)"
+    },
+    '& [part="source"]:focus-visible': {
+      outline: "var(--jx-focus-ring)",
+      outlineOffset: "-2px"
+    },
+    '& [part="group-empty"]': {
+      margin: "0",
+      padding: "var(--jx-space-2)",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-sm)"
+    }
+  },
+  children: [
+    {
+      $prototype: "Array",
+      items: {
+        $ref: "#/state/groups"
+      },
+      key: {
+        $ref: "$map/item/key"
+      },
+      map: {
+        $description: "One origin of grid-able sources. A connection with no tables says why it has none instead of drawing an empty box — an author who has not pushed a schema yet is exactly the reader who needs the sentence.",
+        tagName: "section",
+        attributes: {
+          part: "group",
+          "data-group": "${$map.item.key}"
+        },
+        children: [
+          {
+            tagName: "h3",
+            attributes: {
+              part: "group-title"
+            },
+            textContent: "${$map.item.title}"
+          },
+          {
+            tagName: "div",
+            attributes: {
+              part: "rows"
+            },
+            $switch: {
+              $ref: "$map/item/state"
+            },
+            cases: {
+              listed: {
+                tagName: "div",
+                attributes: {
+                  part: "rows-list",
+                  role: "none"
+                },
+                style: {
+                  display: "contents"
+                },
+                children: [
+                  {
+                    $prototype: "Array",
+                    items: {
+                      $ref: "$map/item/rows"
+                    },
+                    key: {
+                      $ref: "$map/item/id"
+                    },
+                    map: {
+                      tagName: "button",
+                      attributes: {
+                        part: "source",
+                        type: "button",
+                        "data-source": "${$map.item.id}"
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/open"
+                            },
+                            value: [
+                              {
+                                $ref: "$map/item/id"
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      textContent: "${$map.item.label}"
+                    }
+                  }
+                ]
+              },
+              empty: {
+                tagName: "p",
+                attributes: {
+                  part: "group-empty"
+                },
+                textContent: "${$map.item.emptyMessage}"
+              }
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/surfaces/grid-open.ts
+registerSurface("grid-open", grid_open_default);
+function mountGridOpenSurface(host, groups, open) {
+  const scope = reactive({ groups, open });
+  let mounted = null;
+  let disposed = false;
+  const ready = mountSurface("grid-open", scope, host).then((surface) => {
+    if (disposed) {
+      surface.dispose();
+      return surface.root;
+    }
+    mounted = surface;
+    return surface.root;
+  });
+  return {
+    dispose() {
+      disposed = true;
+      mounted?.dispose();
+      mounted = null;
+    },
+    ready
+  };
+}
 
 // src/services/data-service.ts
 function platformOrNull() {
   try {
-    return getPlatform();
+    return getPlatform2();
   } catch {
     return null;
   }
@@ -324,7 +500,7 @@ function createCsvFileSource(path) {
     if (!force && loadPromise) {
       return loadPromise;
     }
-    loadPromise = getPlatform().readFile(path).then((text) => buildModel(text, path));
+    loadPromise = getPlatform2().readFile(path).then((text) => buildModel(text, path));
     return loadPromise;
   };
   return {
@@ -336,14 +512,14 @@ function createCsvFileSource(path) {
     },
     async commit(batch) {
       const current = await load();
-      const platform = getPlatform();
+      const platform = getPlatform2();
       let onDisk = null;
       try {
         onDisk = await platform.readFile(path);
       } catch {
         onDisk = null;
       }
-      if (onDisk !== current.loadText && !isRecentLocal(path)) {
+      if (onDisk !== current.loadText && !isRecentLocal2(path)) {
         return uniformResult(batch, {
           error: "File changed on disk — refresh to reload",
           ok: false,
@@ -352,7 +528,7 @@ function createCsvFileSource(path) {
       }
       const nextDoc = applyBatch(current, batch);
       const text = serializeCsv(nextDoc);
-      markLocalMutation(path);
+      markLocalMutation2(path);
       await platform.writeFile(path, text);
       loadPromise = Promise.resolve(buildModel(text, path));
       return uniformResult(batch, { ok: true });
@@ -608,7 +784,7 @@ async function walk(dir, platform, out, failures, i18n) {
   try {
     entries = await platform.listDirectory(dir);
   } catch (error) {
-    failures.push({ dir, error: errorMessage(error) });
+    failures.push({ dir, error: errorMessage2(error) });
     return;
   }
   const subdirectories = [];
@@ -774,7 +950,7 @@ function createLibrarySource(dirs) {
     if (scan) {
       return scan;
     }
-    inFlight ??= scanLibrary(projectDirs(), getPlatform()).then((result) => {
+    inFlight ??= scanLibrary(projectDirs(), getPlatform2()).then((result) => {
       scan = result;
       inFlight = null;
       return result;
@@ -824,28 +1000,28 @@ function createLibrarySource(dirs) {
 // src/grid/grid-open.ts
 var GRID_STUB_DOCUMENT = { children: [], tagName: "div" };
 async function openCsvGridTab(path) {
-  const existing = workspace.tabs.get(path);
+  const existing = workspace2.tabs.get(path);
   if (existing) {
-    activateTab(path);
+    activateTab2(path);
     return existing;
   }
   try {
-    await loadFormats();
+    await loadFormats2();
   } catch {}
   const source = createCsvFileSource(path);
-  const tab = openTab({
+  const tab = openTab2({
     capabilities: { modes: ["grid", "source"] },
     document: structuredClone(GRID_STUB_DOCUMENT),
     documentPath: path,
     id: path,
-    sourceFormat: formatForPath(path)?.name ?? null
+    sourceFormat: formatForPath2(path)?.name ?? null
   });
   const controller = createGridController(tab, source);
   controller.load();
   return tab;
 }
 function openVirtualGridTab(source) {
-  const tab = openTab({
+  const tab = openTab2({
     capabilities: { modes: ["grid"] },
     document: structuredClone(GRID_STUB_DOCUMENT),
     documentPath: null,
@@ -857,21 +1033,21 @@ function openVirtualGridTab(source) {
 }
 function openCollectionGrid(typeName) {
   const id = makeGridTabId({ kind: "collection", name: typeName });
-  const existing = workspace.tabs.get(id);
+  const existing = workspace2.tabs.get(id);
   if (existing) {
-    activateTab(id);
+    activateTab2(id);
     return existing;
   }
-  return openVirtualGridTab(createCollectionSource(typeName));
+  return openVirtualGridTab(createCollectionSource2(typeName));
 }
 function openLibraryTab() {
   const id = libraryTabId();
-  const existing = workspace.tabs.get(id);
+  const existing = workspace2.tabs.get(id);
   if (existing) {
-    activateTab(id);
+    activateTab2(id);
     return existing;
   }
-  return openTab({
+  return openTab2({
     capabilities: { modes: ["manage"] },
     document: structuredClone(GRID_STUB_DOCUMENT),
     documentPath: null,
@@ -880,66 +1056,87 @@ function openLibraryTab() {
 }
 function openPagesGrid() {
   const id = makeGridTabId({ kind: "pages" });
-  const existing = workspace.tabs.get(id);
+  const existing = workspace2.tabs.get(id);
   if (existing) {
-    activateTab(id);
+    activateTab2(id);
     return existing;
   }
-  return openVirtualGridTab(createPagesSource());
+  return openVirtualGridTab(createPagesSource2());
 }
 function openConnectorGrid(connection, table) {
   const id = makeGridTabId({ connection: connection ?? "default", kind: "data", table });
-  const existing = workspace.tabs.get(id);
+  const existing = workspace2.tabs.get(id);
   if (existing) {
-    activateTab(id);
+    activateTab2(id);
     return existing;
   }
   return openVirtualGridTab(createConnectorSource(connection, table));
 }
+function openGridSource(id) {
+  const ref = parseGridTabId(id);
+  if (ref?.kind === "pages") {
+    openPagesGrid();
+  } else if (ref?.kind === "collection") {
+    openCollectionGrid(ref.name);
+  } else if (ref?.kind === "data") {
+    openConnectorGrid(ref.connection, ref.table);
+  }
+}
+function sourceGroups(collections, connections) {
+  return [
+    {
+      emptyMessage: "",
+      key: "project",
+      rows: [
+        { id: makeGridTabId({ kind: "pages" }), label: "Pages" },
+        ...collections.map(({ name }) => ({
+          id: makeGridTabId({ kind: "collection", name }),
+          label: `Collection: ${name}`
+        }))
+      ],
+      state: "listed",
+      title: "Project"
+    },
+    ...connections.map((conn) => ({
+      emptyMessage: "No tables — push a schema first.",
+      key: `data:${conn.name}`,
+      rows: conn.tables.map((table) => ({
+        id: makeGridTabId({ connection: conn.name, kind: "data", table }),
+        label: table
+      })),
+      state: conn.tables.length === 0 ? "empty" : "listed",
+      title: `Data · ${conn.name}`
+    }))
+  ];
+}
 async function openGridSourcePicker() {
-  const collections = collectionDirs();
+  const collections = collectionDirs2();
   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" });
+  let list = null;
+  const handle = openDialogSurface({
+    cancelLabel: "Cancel",
+    confirmLabel: "",
+    headline: "Open Grid",
+    island: (host) => {
+      list = mountGridOpenSurface(host, sourceGroups(collections, connections), (id) => {
+        handle.close();
+        openGridSource(id);
+      });
+    },
+    layer: layerHost2("dialog"),
+    onCancel: () => handle.close(),
+    onClosed: () => {
+      list?.dispose();
+      list = null;
+    },
+    onConfirm: () => {},
+    region: "grid/open"
+  });
+  handle.ready;
 }
 function gridCommands() {
   return [
@@ -954,13 +1151,9 @@ function gridCommands() {
       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);
+        const declared = collectionDirs2().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"}`);
         }
@@ -986,10 +1179,6 @@ function gridCommands() {
       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);
@@ -1004,5 +1193,5 @@ function registerGridCommands(registry) {
 
 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=157CEC83DCC4607364756E2164756E21
-//# sourceMappingURL=studio-3bqpr0zh.js.map
+//# debugId=0C172BA58EF4714F64756E2164756E21
+//# sourceMappingURL=studio-pxbgypmg.js.map

package/dist/chunks/studio-q0a3yk4n.js

@@ -0,0 +1,33 @@
+// src/services/cem-export.ts
+function collectSlots(node, slots = []) {
+  if (node?.tagName === "slot") {
+    const name = node.attributes?.name;
+    slots.push(typeof name === "string" ? name.trim() : "");
+  }
+  if (Array.isArray(node?.children)) {
+    for (const c of node.children) {
+      collectSlots(typeof c === "string" ? undefined : c, slots);
+    }
+  }
+  return slots;
+}
+function validateComponentSlots(doc) {
+  const names = collectSlots(doc);
+  const unnamed = names.filter((n) => n === "").length;
+  if (unnamed > 1) {
+    return `Component has ${unnamed} unnamed <slot> elements — only one default slot is allowed. Give extra slots a name attribute.`;
+  }
+  const seen = new Set;
+  for (const n of names) {
+    if (n && seen.has(n)) {
+      return `Duplicate slot name "${n}" — slot names must be unique within a component.`;
+    }
+    seen.add(n);
+  }
+  return null;
+}
+
+export { validateComponentSlots };
+
+//# debugId=0D8AED6D7269E13264756E2164756E21
+//# sourceMappingURL=studio-q0a3yk4n.js.map