@jxsuite/studio 2.4.3 → 4.0.0

package/dist/chunks/studio-r1r7afxx.js

@@ -0,0 +1,1066 @@
+import {
+  until
+} from "./studio-eqq1w638.js";
+import {
+  collectionOfPath,
+  entryCollection,
+  entryCollections,
+  missingRequired,
+  seedEntry
+} from "./studio-sf7zjgv1.js";
+import {
+  referenceTarget,
+  registerFormControl,
+  renderForm,
+  resolveContextPointer
+} from "./studio-5q69gfag.js";
+import {
+  DRAFT_FIELD,
+  DRAFT_MEANING,
+  hasDraftAxis,
+  isDraftEntry,
+  reloadDraftAwareGrids,
+  setIncludeDrafts
+} from "./studio-eesa1myv.js";
+import {
+  notePreviewOverlayEdit
+} from "./studio-cb12yz9w.js";
+import {
+  activeRegistry,
+  paneRegion
+} from "./studio-t7qb9db8.js";
+import {
+  errorMessage
+} from "./studio-9n4mrmnb.js";
+import {
+  LOCALE_PLACEHOLDER,
+  activateTab,
+  activeTab,
+  argsSchema,
+  booleanArg,
+  booleanProperty,
+  camelToLabel,
+  collectionForDirectory,
+  derivedEnumProperty,
+  enumArg,
+  mutateUpdateFrontmatter,
+  recordDocOp,
+  stringArg,
+  stringProperty,
+  toCamelCase,
+  transactDoc,
+  workspace
+} from "./studio-2zkz8evn.js";
+import {
+  effect,
+  effectScope,
+  notify
+} from "./studio-xrapxwwc.js";
+import {
+  live,
+  repeat
+} from "./studio-4rzyrtjz.js";
+import {
+  html,
+  nothing,
+  render
+} from "./studio-kryvsw6j.js";
+import {
+  cloneValue
+} from "./studio-5ehhackm.js";
+import {
+  projectState
+} from "./studio-p4ngc046.js";
+import {
+  defaultContentFormat,
+  formatByName,
+  formatForPath,
+  formatSerialize,
+  loadFormats
+} from "./studio-eenfkt4e.js";
+import {
+  __require
+} from "./studio-a0tswy0w.js";
+
+// src/settings/schema-field-ui.ts
+var FIELD_TYPES = ["string", "number", "boolean", "array", "object", "reference"];
+var FORMAT_OPTIONS = ["", "image", "date", "color"];
+function detectFieldType(schema) {
+  if (schema.$ref) {
+    return "reference";
+  }
+  return schema.type || "string";
+}
+function detectFieldFormat(schema) {
+  if (schema.type === "array" && schema.items?.format) {
+    return schema.items.format;
+  }
+  return schema.format || "";
+}
+function fieldCardTpl(fieldName, fieldSchema, isRequired, handlers, contentTypeNames = []) {
+  const type = detectFieldType(fieldSchema);
+  const format = detectFieldFormat(fieldSchema);
+  const isNested = type === "object";
+  const isRef = type === "reference";
+  const nestedProps = fieldSchema.properties || {};
+  const nestedRequired = fieldSchema.required || [];
+  const refTarget = fieldSchema.$ref ? fieldSchema.$ref.replace(/^#\/[^/]+\//, "") : "";
+  return html`
+    <div class="schema-field-card">
+      <div class="schema-field-row">
+        <sp-field-label size="s" class="schema-field-label"
+          >${camelToLabel(fieldName)}</sp-field-label
+        >
+        <sp-textfield
+          size="s"
+          quiet
+          value=${fieldName}
+          class="schema-field-name-input"
+          @change=${(e) => {
+    const target = e.target;
+    const newName = target.value.trim();
+    if (newName && newName !== fieldName) {
+      handlers.onRename(fieldName, newName);
+    } else {
+      target.value = fieldName;
+    }
+  }}
+          @keydown=${(e) => {
+    const target = e.target;
+    if (e.key === "Enter") {
+      target.blur();
+    }
+    if (e.key === "Escape") {
+      target.value = fieldName;
+      target.blur();
+    }
+  }}
+        ></sp-textfield>
+        ${typePickerTpl(type, (newType) => handlers.onChangeType(fieldName, newType))}
+        ${type === "string" || type === "array" ? formatPickerTpl(format, (f) => {
+    if (handlers.onChangeFormat) {
+      handlers.onChangeFormat(fieldName, f);
+    }
+  }) : nothing}
+        <sp-switch
+          size="s"
+          ?checked=${isRequired}
+          @change=${() => handlers.onToggleRequired(fieldName)}
+        >
+          Req
+        </sp-switch>
+        <sp-action-button
+          size="xs"
+          quiet
+          title="Delete field"
+          @click=${() => handlers.onDelete(fieldName)}
+        >
+          <sp-icon-delete slot="icon"></sp-icon-delete>
+        </sp-action-button>
+      </div>
+      ${isRef && contentTypeNames.length > 0 ? html`
+              <div class="schema-field-ref-target">
+                <sp-picker
+                  size="s"
+                  label="Target"
+                  value=${refTarget}
+                  @change=${(e) => {
+    if (handlers.onChangeRefTarget) {
+      handlers.onChangeRefTarget(fieldName, e.target.value);
+    }
+  }}
+                >
+                  ${contentTypeNames.map((n) => html`<sp-menu-item value=${n}>${n}</sp-menu-item>`)}
+                </sp-picker>
+              </div>
+            ` : nothing}
+      ${isNested ? html`
+              <div class="schema-field-nested">
+                ${Object.entries(nestedProps).map(([name, sub]) => nestedFieldCardTpl(fieldName, name, sub, nestedRequired.includes(name), handlers))}
+                ${nestedAddFieldTpl(fieldName, handlers)}
+              </div>
+            ` : nothing}
+    </div>
+  `;
+}
+function nestedFieldCardTpl(parentName, childName, childSchema, isRequired, handlers) {
+  const type = detectFieldType(childSchema);
+  const format = detectFieldFormat(childSchema);
+  return html`
+    <div class="schema-field-card schema-field-card--nested">
+      <div class="schema-field-row">
+        <sp-textfield
+          size="s"
+          quiet
+          value=${childName}
+          class="schema-field-name-input"
+          @change=${(e) => {
+    const target = e.target;
+    const newName = target.value.trim();
+    if (newName && newName !== childName && handlers.onRenameNested) {
+      handlers.onRenameNested(parentName, childName, newName);
+    } else {
+      target.value = childName;
+    }
+  }}
+          @keydown=${(e) => {
+    const target = e.target;
+    if (e.key === "Enter") {
+      target.blur();
+    }
+    if (e.key === "Escape") {
+      target.value = childName;
+      target.blur();
+    }
+  }}
+        ></sp-textfield>
+        ${typePickerTpl(type, (newType) => {
+    if (handlers.onChangeNestedType) {
+      handlers.onChangeNestedType(parentName, childName, newType);
+    }
+  })}
+        ${type === "string" || type === "array" ? formatPickerTpl(format, (f) => {
+    if (handlers.onChangeNestedFormat) {
+      handlers.onChangeNestedFormat(parentName, childName, f);
+    }
+  }) : nothing}
+        <sp-switch
+          size="s"
+          ?checked=${isRequired}
+          @change=${() => {
+    if (handlers.onToggleNestedRequired) {
+      handlers.onToggleNestedRequired(parentName, childName);
+    }
+  }}
+        >
+          Req
+        </sp-switch>
+        <sp-action-button
+          size="xs"
+          quiet
+          title="Delete field"
+          @click=${() => {
+    if (handlers.onDeleteNested) {
+      handlers.onDeleteNested(parentName, childName);
+    }
+  }}
+        >
+          <sp-icon-delete slot="icon"></sp-icon-delete>
+        </sp-action-button>
+      </div>
+    </div>
+  `;
+}
+function nestedAddFieldTpl(parentName, handlers) {
+  return html`
+    <div class="schema-nested-add">
+      <sp-textfield
+        size="s"
+        placeholder="field name"
+        class="schema-nested-add-name"
+        @keydown=${(e) => {
+    if (e.key === "Enter") {
+      const target = e.target;
+      const row = target.closest(".schema-nested-add");
+      const name = target.value.trim();
+      const typePicker = row?.querySelector("sp-picker");
+      const type = typePicker?.value || "string";
+      if (name && handlers.onAddNestedField) {
+        handlers.onAddNestedField(parentName, {
+          name,
+          required: false,
+          type
+        });
+        target.value = "";
+      }
+    }
+  }}
+      ></sp-textfield>
+      ${typePickerTpl("string", () => {})}
+      <sp-action-button
+        size="xs"
+        quiet
+        title="Add nested field"
+        @click=${(e) => {
+    const target = e.target;
+    const row = target.closest(".schema-nested-add");
+    const nameInput = row?.querySelector(".schema-nested-add-name");
+    const typePicker = row?.querySelector("sp-picker");
+    const name = nameInput?.value?.trim();
+    const type = typePicker?.value || "string";
+    if (name && handlers.onAddNestedField) {
+      handlers.onAddNestedField(parentName, {
+        name,
+        required: false,
+        type
+      });
+      if (nameInput) {
+        nameInput.value = "";
+      }
+    }
+  }}
+      >
+        <sp-icon-add slot="icon"></sp-icon-add>
+      </sp-action-button>
+    </div>
+  `;
+}
+function typePickerTpl(value, onChange) {
+  return html`
+    <sp-picker
+      size="s"
+      label="Type"
+      value=${value}
+      @change=${(e) => onChange(e.target.value)}
+    >
+      ${FIELD_TYPES.map((t) => html`<sp-menu-item value=${t}>${t}</sp-menu-item>`)}
+    </sp-picker>
+  `;
+}
+function formatPickerTpl(value, onChange) {
+  return html`
+    <sp-picker
+      size="s"
+      label="Format"
+      value=${value}
+      @change=${(e) => onChange(e.target.value)}
+    >
+      ${FORMAT_OPTIONS.map((f) => html`<sp-menu-item value=${f}>${f || "(none)"}</sp-menu-item>`)}
+    </sp-picker>
+  `;
+}
+function addFieldFormTpl(state, handlers) {
+  return html`
+    <div class="schema-add-field">
+      <sp-textfield
+        size="s"
+        placeholder="Field name"
+        .value=${state.name}
+        @input=${(e) => handlers.onInput("name", e.target.value)}
+        @keydown=${(e) => {
+    if (e.key === "Enter") {
+      handlers.onConfirm();
+    }
+    if (e.key === "Escape") {
+      handlers.onCancel();
+    }
+  }}
+      ></sp-textfield>
+      ${typePickerTpl(state.type, (t) => handlers.onInput("type", t))}
+      ${state.type === "string" || state.type === "array" ? formatPickerTpl(state.format || "", (f) => handlers.onInput("format", f)) : nothing}
+      <sp-switch
+        size="s"
+        ?checked=${state.required}
+        @change=${(e) => handlers.onInput("required", e.target.checked)}
+      >
+        Required
+      </sp-switch>
+      <sp-action-button size="s" @click=${handlers.onConfirm}>Add</sp-action-button>
+      <sp-action-button size="s" quiet @click=${handlers.onCancel}>Cancel</sp-action-button>
+    </div>
+  `;
+}
+function schemaForType(type, format) {
+  switch (type) {
+    case "number": {
+      return { type: "number" };
+    }
+    case "boolean": {
+      return { type: "boolean" };
+    }
+    case "array": {
+      return format ? { items: { format, type: "string" }, type: "array" } : { items: { type: "string" }, type: "array" };
+    }
+    case "object": {
+      return { properties: {}, required: [], type: "object" };
+    }
+    case "reference": {
+      return { $ref: "#/content/" };
+    }
+    default: {
+      return format ? { format, type: "string" } : { type: "string" };
+    }
+  }
+}
+
+// src/ui/form-controls.ts
+var blankAddFieldState = () => ({
+  format: "",
+  name: "",
+  required: false,
+  type: "string"
+});
+var addFieldOpen = new Set;
+var addFieldStates = new Map;
+function cloneSchema(value) {
+  const base = value && typeof value === "object" && !Array.isArray(value) ? value : { properties: {}, required: [], type: "object" };
+  return JSON.parse(JSON.stringify(base));
+}
+function schemaBuilderControl({ key, value, onChange, ctx, rerender }) {
+  const schema = value && typeof value === "object" && !Array.isArray(value) ? value : { properties: {}, required: [], type: "object" };
+  const properties = schema.properties ?? {};
+  const required = schema.required ?? [];
+  const stateKey = `${ctx.fieldKeyPrefix ?? ""}.${key}`;
+  const update = (mutate) => {
+    const draft = cloneSchema(value);
+    draft.type ??= "object";
+    draft.properties ??= {};
+    draft.required ??= [];
+    mutate(draft);
+    onChange(draft);
+    rerender?.();
+  };
+  const contentTypesValue = ctx.resolvePointer("#/$context/content");
+  const contentTypeNames = contentTypesValue && typeof contentTypesValue === "object" ? Object.keys(contentTypesValue) : [];
+  const handlers = {
+    onAddNestedField: (parentName, fieldState) => update((draft) => {
+      const parent = draft.properties?.[parentName];
+      const name = toCamelCase(fieldState.name);
+      if (!parent || !name) {
+        return;
+      }
+      parent.properties ??= {};
+      parent.properties[name] = schemaForType(fieldState.type);
+      if (fieldState.required) {
+        parent.required ??= [];
+        if (!parent.required.includes(name)) {
+          parent.required.push(name);
+        }
+      }
+    }),
+    onChangeFormat: (name, format) => update((draft) => {
+      const prop = draft.properties?.[name];
+      if (!prop) {
+        return;
+      }
+      draft.properties[name] = schemaForType(prop.type || "string", format || undefined);
+    }),
+    onChangeNestedFormat: (parentName, childName, format) => update((draft) => {
+      const parent = draft.properties?.[parentName];
+      const prop = parent?.properties?.[childName];
+      if (!prop) {
+        return;
+      }
+      parent.properties[childName] = schemaForType(prop.type || "string", format || undefined);
+    }),
+    onChangeNestedType: (parentName, childName, newType) => update((draft) => {
+      const parent = draft.properties?.[parentName];
+      const prop = parent?.properties?.[childName];
+      if (!prop) {
+        return;
+      }
+      const oldFormat = newType === "string" || newType === "array" ? detectFieldFormat(prop) : undefined;
+      parent.properties[childName] = schemaForType(newType, oldFormat || undefined);
+    }),
+    onChangeRefTarget: (name, target) => update((draft) => {
+      if (!draft.properties?.[name]) {
+        return;
+      }
+      draft.properties[name] = { $ref: `#/content/${target}` };
+    }),
+    onChangeType: (name, newType) => update((draft) => {
+      const prop = draft.properties?.[name];
+      if (!prop) {
+        return;
+      }
+      const oldFormat = newType === "string" || newType === "array" ? detectFieldFormat(prop) : undefined;
+      draft.properties[name] = schemaForType(newType, oldFormat || undefined);
+    }),
+    onDelete: (name) => update((draft) => {
+      delete draft.properties?.[name];
+      draft.required = (draft.required ?? []).filter((r) => r !== name);
+    }),
+    onDeleteNested: (parentName, childName) => update((draft) => {
+      const parent = draft.properties?.[parentName];
+      if (!parent?.properties) {
+        return;
+      }
+      delete parent.properties[childName];
+      if (parent.required) {
+        parent.required = parent.required.filter((r) => r !== childName);
+      }
+    }),
+    onRename: (oldName, newName) => update((draft) => {
+      const normalized = toCamelCase(newName);
+      if (!draft.properties || !normalized || draft.properties[normalized]) {
+        return;
+      }
+      const next = {};
+      for (const [k, v] of Object.entries(draft.properties)) {
+        next[k === oldName ? normalized : k] = v;
+      }
+      draft.properties = next;
+      draft.required = (draft.required ?? []).map((r) => r === oldName ? normalized : r);
+    }),
+    onRenameNested: (parentName, oldChild, newChild) => update((draft) => {
+      const parent = draft.properties?.[parentName];
+      const normalized = toCamelCase(newChild);
+      if (!parent?.properties || !normalized || parent.properties[normalized]) {
+        return;
+      }
+      const next = {};
+      for (const [k, v] of Object.entries(parent.properties)) {
+        next[k === oldChild ? normalized : k] = v;
+      }
+      parent.properties = next;
+      if (parent.required) {
+        parent.required = parent.required.map((r) => r === oldChild ? normalized : r);
+      }
+    }),
+    onToggleNestedRequired: (parentName, childName) => update((draft) => {
+      const parent = draft.properties?.[parentName];
+      if (!parent) {
+        return;
+      }
+      parent.required ??= [];
+      const idx = parent.required.indexOf(childName);
+      if (idx === -1) {
+        parent.required.push(childName);
+      } else {
+        parent.required.splice(idx, 1);
+      }
+    }),
+    onToggleRequired: (name) => update((draft) => {
+      draft.required ??= [];
+      const idx = draft.required.indexOf(name);
+      if (idx === -1) {
+        draft.required.push(name);
+      } else {
+        draft.required.splice(idx, 1);
+      }
+    })
+  };
+  const fieldCards = repeat(Object.entries(properties), ([name]) => name, ([name, def]) => fieldCardTpl(name, def, required.includes(name), handlers, contentTypeNames));
+  const addFieldState = addFieldStates.get(stateKey) ?? blankAddFieldState();
+  return html`
+    <div class="schema-builder">
+      <div class="schema-field-list">${fieldCards}</div>
+      ${addFieldOpen.has(stateKey) ? addFieldFormTpl(addFieldState, {
+    onCancel: () => {
+      addFieldOpen.delete(stateKey);
+      addFieldStates.delete(stateKey);
+      rerender?.();
+    },
+    onConfirm: () => {
+      const raw = addFieldState.name.trim();
+      const name = toCamelCase(raw);
+      if (!name) {
+        return;
+      }
+      addFieldOpen.delete(stateKey);
+      addFieldStates.delete(stateKey);
+      update((draft) => {
+        draft.properties[name] = schemaForType(addFieldState.type, addFieldState.format || undefined);
+        if (addFieldState.required && !draft.required.includes(name)) {
+          draft.required.push(name);
+        }
+      });
+    },
+    onInput: (field, val) => {
+      addFieldStates.set(stateKey, { ...addFieldState, [field]: val });
+      rerender?.();
+    }
+  }) : html`
+              <sp-action-button
+                size="s"
+                quiet
+                @click=${() => {
+    addFieldOpen.add(stateKey);
+    addFieldStates.set(stateKey, blankAddFieldState());
+    rerender?.();
+  }}
+              >
+                <sp-icon-add slot="icon"></sp-icon-add> Add Field
+              </sp-action-button>
+            `}
+    </div>
+  `;
+}
+registerFormControl("schema-builder", schemaBuilderControl);
+registerFormControl("secret", ({ key, value, onChange, ctx, rerender }) => {
+  const { commitSecret } = ctx;
+  const envName = typeof value === "string" && value ? value : null;
+  return html`<sp-textfield
+    size="s"
+    type="password"
+    class="secret-field"
+    placeholder=${envName ? `Stored as ${envName}` : "Not set"}
+    ?disabled=${!commitSecret}
+    @change=${async (e) => {
+    const target = e.target;
+    const secretValue = target.value;
+    if (!commitSecret || !secretValue) {
+      return;
+    }
+    const name = await commitSecret(key, secretValue);
+    target.value = "";
+    if (typeof name === "string" && name && name !== envName) {
+      onChange(name);
+    } else {
+      rerender?.();
+    }
+  }}
+  ></sp-textfield>`;
+});
+var entryIdCache = new Map;
+var entryIdResult = new Map;
+function invalidateReferenceEntries(collection) {
+  if (collection === undefined) {
+    entryIdCache.clear();
+    entryIdResult.clear();
+  } else {
+    entryIdCache.delete(collection);
+    entryIdResult.delete(collection);
+  }
+}
+function entryIdsFor(collection) {
+  const known = entryIdCache.get(collection);
+  if (known) {
+    return known;
+  }
+  const pending = import("./content-source-t88vb2dr.js").then((m) => m.listCollectionEntryIds(collection));
+  entryIdCache.set(collection, pending);
+  return pending;
+}
+function referenceTextField(current, onChange) {
+  return html`<sp-textfield
+    size="s"
+    class="reference-field"
+    .value=${current}
+    @change=${(e) => onChange(e.target.value.trim() || undefined)}
+  ></sp-textfield>`;
+}
+function referencePicker(collection, ids, current, onChange) {
+  const dangling = current !== "" && !ids.includes(current);
+  return html`
+    <sp-picker
+      size="s"
+      class="reference-field"
+      value=${current || "__none__"}
+      @change=${(e) => {
+    const chosen = e.target.value;
+    onChange(chosen === "__none__" ? undefined : chosen);
+  }}
+    >
+      <sp-menu-item value="__none__">—</sp-menu-item>
+      ${dangling ? html`<sp-menu-item class="reference-missing" value=${current}
+              >${current} — not found</sp-menu-item
+            >` : nothing}
+      ${ids.map((id) => html`<sp-menu-item value=${id}>${id}</sp-menu-item>`)}
+    </sp-picker>
+    ${ids.length === 0 ? html`<span class="reference-note">No ${collection} entries yet.</span>` : nothing}
+  `;
+}
+registerFormControl("reference", ({ schema, value, onChange, rerender }) => {
+  const collection = referenceTarget(schema);
+  const current = typeof value === "string" ? value : "";
+  if (collection === null) {
+    return html`<div class="reference-control">
+      ${referenceTextField(current, onChange)}
+      <span class="reference-note"
+        >No collection referenced — add <code>"$ref": "#/content/&lt;type&gt;"</code> to this
+        field.</span
+      >
+    </div>`;
+  }
+  const failedTpl = (error) => html`
+    ${referenceTextField(current, onChange)}
+    <span class="reference-note reference-note--failed"
+      >Could not list ${collection} entries — ${error}</span
+    >
+    ${rerender ? html`<sp-action-button
+            size="s"
+            quiet
+            @click=${() => {
+    invalidateReferenceEntries(collection);
+    rerender();
+  }}
+            >Retry</sp-action-button
+          >` : nothing}
+  `;
+  const done = entryIdResult.get(collection);
+  if (done) {
+    return html`<div class="reference-control">
+      ${"ids" in done ? referencePicker(collection, done.ids, current, onChange) : failedTpl(done.error)}
+    </div>`;
+  }
+  const resolved = entryIdsFor(collection).then((ids) => {
+    entryIdResult.set(collection, { ids });
+    return referencePicker(collection, ids, current, onChange);
+  }, (error) => {
+    const message = errorMessage(error);
+    entryIdResult.set(collection, { error: message });
+    return failedTpl(message);
+  });
+  return html`<div class="reference-control">
+    ${until(resolved, html`<sp-picker size="s" class="reference-field" disabled label="Loading…"></sp-picker>`)}
+  </div>`;
+});
+
+// src/content/entry-fields.ts
+function fieldsAreDocument(tab) {
+  return tab.doc.sourceFormat == null && tab.doc.mode !== "content";
+}
+function entryFields(tab) {
+  return fieldsAreDocument(tab) ? tab.doc.document : tab.doc.content?.frontmatter ?? {};
+}
+function mutateDocumentField(tab, field, value) {
+  const doc = tab.doc.document;
+  const before = Object.hasOwn(doc, field) ? cloneValue(doc[field]) : undefined;
+  const deletes = value === undefined || value === null || value === "";
+  if (deletes) {
+    delete doc[field];
+  } else {
+    doc[field] = value;
+  }
+  const after = deletes ? undefined : cloneValue(value);
+  recordDocOp({
+    forward: { key: field, op: "set-key", path: [], value: after },
+    inverse: { key: field, op: "set-key", path: [], value: before }
+  });
+  tab.doc.dirty = true;
+  notePreviewOverlayEdit();
+}
+function mutateEntryField(tab, field, value) {
+  if (fieldsAreDocument(tab)) {
+    mutateDocumentField(tab, field, value);
+  } else {
+    mutateUpdateFrontmatter(tab, field, value);
+  }
+}
+function commitEntryFields(tab, patch) {
+  transactDoc(tab, (t) => {
+    for (const [field, value] of Object.entries(patch)) {
+      mutateEntryField(t, field, value);
+    }
+  });
+}
+
+// src/content/entry-editor.ts
+var ENTRY_MODE = "entry";
+var ENTRY_TAB_MODES = [ENTRY_MODE];
+var _active = new Map;
+function activeIn(paneId) {
+  return _active.get(paneId) ?? null;
+}
+function entryPaneMounted(paneId, tab) {
+  const panel = activeIn(paneId);
+  return panel !== null && panel.tabId === tab.id && panel.wrap.isConnected;
+}
+function detachEntryPane(paneId) {
+  const panel = _active.get(paneId);
+  if (!panel) {
+    return;
+  }
+  panel.scope.stop();
+  _active.delete(paneId);
+}
+function setEntryDraft(tab, draft) {
+  transactDoc(tab, (t) => mutateEntryField(t, DRAFT_FIELD, draft));
+}
+function entryDraftPill(tab) {
+  const collection = collectionOfPath(tab.documentPath);
+  const fields = entryFields(tab);
+  if (!collection || !hasDraftAxis(collection.schema, fields)) {
+    return nothing;
+  }
+  const draft = isDraftEntry(fields);
+  return html`<span
+    class=${draft ? "entry-pill entry-pill--draft" : "entry-pill"}
+    title=${draft ? DRAFT_MEANING : "Not marked a draft."}
+    >${draft ? "Draft" : "Published"}</span
+  >`;
+}
+function formContext(tab) {
+  return {
+    fieldKeyPrefix: `entry:${tab.id}`,
+    resolvePointer: (pointer, scope) => resolveContextPointer(pointer, {
+      projectConfig: projectState?.projectConfig ?? {},
+      scope
+    })
+  };
+}
+function absentRequiredErrors(collection, fields) {
+  const errors = {};
+  for (const field of missingRequired(collection.schema, fields)) {
+    errors[field] = "Required — this entry does not have one.";
+  }
+  return errors;
+}
+function headerTpl(tab, collection) {
+  const fields = entryFields(tab);
+  const draftAxis = hasDraftAxis(collection.schema, fields);
+  const draft = isDraftEntry(fields);
+  return html`
+    <div class="entry-editor-header">
+      <h3>${tab.documentPath?.split("/").pop() ?? "Untitled"}</h3>
+      <span class="entry-editor-collection">${collection.name}</span>
+      ${draftAxis ? html`
+              <sp-switch
+                size="s"
+                class="entry-draft-switch"
+                .checked=${live(draft)}
+                title=${DRAFT_MEANING}
+                @change=${(e) => setEntryDraft(tab, e.target.checked)}
+                >Draft</sp-switch
+              >
+            ` : nothing}
+    </div>
+    ${draft ? html`<p class="entry-editor-note">${DRAFT_MEANING}</p>` : nothing}
+  `;
+}
+function notAnEntryTpl(tab) {
+  return html`
+    <div class="entry-editor-empty">
+      <p>
+        ${tab.documentPath ?? "This document"} is not an entry of any content collection, so there
+        is no schema to draw a form from.
+      </p>
+      <p class="entry-editor-note">
+        A collection is a <code>content</code> entry in <code>project.json</code> whose
+        <code>source</code> directory contains this file and which declares a <code>schema</code>.
+      </p>
+      <sp-action-button
+        size="s"
+        @click=${() => {
+    activeRegistry()?.run("settings.open", { section: "content" });
+  }}
+        >Content types…</sp-action-button
+      >
+    </div>
+  `;
+}
+function renderEntryMode(surface, tab) {
+  const { paneId, wrap: canvasWrap } = surface;
+  if (entryPaneMounted(paneId, tab)) {
+    return;
+  }
+  detachEntryPane(paneId);
+  const scope = effectScope();
+  const panel = { paneId, scope, tabId: tab.id, wrap: canvasWrap };
+  _active.set(paneId, panel);
+  const rerender = () => {
+    if (activeIn(paneId) === panel) {
+      draw();
+    }
+  };
+  const draw = () => {
+    const collection = collectionOfPath(tab.documentPath);
+    if (!collection) {
+      render(html`<div class="entry-editor" data-jx-region=${paneRegion(paneId, "entry")}>
+          ${notAnEntryTpl(tab)}
+        </div>`, canvasWrap);
+      return;
+    }
+    const fields = entryFields(tab);
+    render(html`
+        <div class="entry-editor" data-jx-region=${paneRegion(paneId, "entry")}>
+          ${headerTpl(tab, collection)}
+          <div class="entry-editor-fields" data-jx-region=${paneRegion(paneId, "entry/fields")}>
+            ${renderForm(collection.schema, fields, {
+      context: formContext(tab),
+      errors: absentRequiredErrors(collection, fields),
+      onChange: (patch) => commitEntryFields(tab, patch),
+      rerender
+    })}
+          </div>
+        </div>
+      `, canvasWrap);
+  };
+  scope.run(() => {
+    effect(() => {
+      if (activeIn(paneId) !== panel) {
+        return;
+      }
+      tab.doc.document;
+      tab.doc.content?.frontmatter;
+      projectState?.projectConfig?.content;
+      draw();
+    });
+  });
+}
+async function openEntryEditor(path) {
+  const { openFileInTab } = await import("./files-0cratsr0.js");
+  await openFileInTab(path);
+  for (const [id, tab] of workspace.tabs.entries()) {
+    if (tab.documentPath !== path) {
+      continue;
+    }
+    for (const mode of ENTRY_TAB_MODES) {
+      if (!tab.capabilities.modes.includes(mode)) {
+        tab.capabilities.modes.unshift(mode);
+      }
+    }
+    tab.session.ui.canvasMode = ENTRY_MODE;
+    tab.session.ui.preview = false;
+    activateTab(id);
+    return tab;
+  }
+  return null;
+}
+
+// src/content/entry-commands.ts
+function creatableCollections() {
+  return entryCollections().map((collection) => collection.name);
+}
+async function seedText(collection) {
+  const seed = seedEntry(collection.schema);
+  const formatName = (collection.def.format ? formatByName(collection.def.format)?.name : undefined) ?? formatForPath(`untitled${collection.ext}`)?.name ?? defaultContentFormat()?.name;
+  if (collection.ext === ".json" || formatName === undefined) {
+    return JSON.stringify(seed, null, 2);
+  }
+  return formatSerialize(formatName, { ...seed, children: [] }, { frontmatter: Object.keys(seed).length > 0, mode: "roundtrip" });
+}
+async function createEntry(collectionName, opts = {}) {
+  const collection = entryCollection(collectionName);
+  if (!collection) {
+    notify.error(`No content collection named "${collectionName}" to create an entry in.`, {
+      detail: "A collection needs a `content` entry in project.json whose `source` is a directory. A " + "collection whose source names a single file (a CSV catalogue) has rows, not entry files.",
+      source: "Content"
+    });
+    return null;
+  }
+  await loadFormats().catch(() => {});
+  let content;
+  try {
+    content = await seedText(collection);
+  } catch (error) {
+    notify.error(`Could not prepare a new ${collection.name} entry.`, {
+      detail: errorMessage(error),
+      path: collection.dir,
+      source: "Content"
+    });
+    return null;
+  }
+  const requested = opts.dir;
+  const destination = requested !== undefined && collectionForDirectory(requested)?.name === collection.name ? requested : collection.dir;
+  if (destination.includes(LOCALE_PLACEHOLDER)) {
+    notify.error(`"${collection.name}" is a localized collection.`, {
+      detail: `Its entries live in one directory per language (${collection.dir}). Open the folder for ` + "the language you are writing in and create the entry there.",
+      path: collection.dir,
+      source: "Content"
+    });
+    return null;
+  }
+  const { createFileIn } = await import("./files-0cratsr0.js");
+  const created = await createFileIn({
+    content,
+    dir: destination,
+    format: { ext: collection.ext, kind: "fixed" },
+    source: "Content",
+    suggestedName: "untitled",
+    title: `New ${collection.name} entry`
+  });
+  if (created === null) {
+    return null;
+  }
+  invalidateReferenceEntries(collection.name);
+  await openEntryEditor(created);
+  return created;
+}
+function activeEntryTab() {
+  const tab = activeTab.value;
+  return tab && collectionOfPath(tab.documentPath) ? tab : null;
+}
+function contentCommands() {
+  return [
+    {
+      args: argsSchema({
+        collection: derivedEnumProperty(creatableCollections, "The content collection the entry is created in.")
+      }),
+      category: "File",
+      id: "content.newEntry",
+      level: "project",
+      menus: ["palette"],
+      group: "1_file",
+      requires: "a project with a directory-backed content collection",
+      when: (ctx) => ctx.project.open,
+      enablement: () => creatableCollections().length > 0,
+      undo: "project",
+      aiTool: {
+        description: "Create a content entry in one of the project's collections, seeded from that collection's schema defaults, and open it in the entry form.",
+        name: "new_content_entry"
+      },
+      run: async (_ctx, args) => {
+        const names = creatableCollections();
+        await createEntry(enumArg("content.newEntry", args, "collection", names));
+      },
+      title: "New Entry"
+    },
+    {
+      args: argsSchema({
+        path: stringProperty("Project-relative path of the entry file to open.")
+      }),
+      category: "File",
+      id: "content.openEntry",
+      level: "project",
+      menus: ["context/file", "palette"],
+      group: "1_file",
+      requires: "an open project",
+      when: (ctx) => ctx.project.open,
+      aiTool: {
+        description: "Open a content entry as a schema-driven form — its collection's fields, with a picker " + "for every reference to another collection.",
+        name: "open_entry_form"
+      },
+      run: async (_ctx, args) => {
+        await openEntryEditor(stringArg("content.openEntry", args, "path"));
+      },
+      title: "Open Entry Form"
+    },
+    {
+      args: argsSchema({
+        draft: booleanProperty("True marks the open entry a draft; false marks it published. Written as a `draft` field on the entry.")
+      }),
+      category: "Document",
+      id: "content.setDraft",
+      level: "document",
+      menus: ["context/tab", "palette"],
+      group: "3_document",
+      requires: "a content entry open",
+      when: (ctx) => ctx.document.open,
+      enablement: () => activeEntryTab() !== null,
+      undo: "document",
+      aiTool: {
+        description: "Mark the open content entry a draft, or published. Studio filters drafts out of its own lists; the build does not exclude them yet.",
+        name: "set_entry_draft"
+      },
+      run: (_ctx, args) => {
+        const tab = activeEntryTab();
+        if (!tab) {
+          throw new Error("content.setDraft: the active document is not a content entry");
+        }
+        setEntryDraft(tab, booleanArg("content.setDraft", args, "draft"));
+      },
+      title: "Set Draft"
+    },
+    {
+      args: argsSchema({
+        include: booleanProperty("True lists entries marked `draft: true` alongside the rest.")
+      }),
+      category: "View",
+      id: "content.setIncludeDrafts",
+      level: "project",
+      menus: ["palette"],
+      group: "2_view",
+      requires: "an open project",
+      when: (ctx) => ctx.project.open,
+      aiTool: {
+        description: "Choose whether draft entries appear in Studio's content listings.",
+        name: "set_including_drafts"
+      },
+      run: async (_ctx, args) => {
+        setIncludeDrafts(booleanArg("content.setIncludeDrafts", args, "include"));
+        await reloadDraftAwareGrids();
+      },
+      title: "Include Drafts"
+    }
+  ];
+}
+function registerContentCommands(registry) {
+  registry.registerAll(contentCommands());
+}
+
+export { detectFieldFormat, fieldCardTpl, addFieldFormTpl, schemaForType, entryFields, entryPaneMounted, detachEntryPane, entryDraftPill, renderEntryMode, createEntry, contentCommands, registerContentCommands };
+
+//# debugId=1103B912C500FD3E64756E2164756E21
+//# sourceMappingURL=studio-r1r7afxx.js.map