@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/studio-r1r7afxx.js

@@ -1,1066 +0,0 @@
-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