@karibsen/eponyme 0.1.0 → 0.2.0

package/dist/runtime/components/ui/EPLinkDialog.vue.d.ts

@@ -0,0 +1,15 @@
+import type { UrlValue } from '../../types/index.js';
+type __VLS_Props = {
+    open: boolean;
+    modelValue?: unknown;
+    placeholder?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: UrlValue) => any;
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: UrlValue) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/EPLinkEditor.vue

@@ -1,10 +1,7 @@
 <script setup>
 import { computed, ref } from "vue";
 import EPButton from "./EPButton.vue";
-import EPDialog from "./EPDialog.vue";
-import EPInputText from "./EPInputText.vue";
-import EPRadioButton from "./EPRadioButton.vue";
-import EPSwitch from "./EPSwitch.vue";
+import EPLinkDialog from "./EPLinkDialog.vue";
 import EPTooltip from "./EPTooltip.vue";
 const props = defineProps({
   id: { type: String, required: true },
@@ -16,47 +13,24 @@ const props = defineProps({
 });
 const emit = defineEmits(["update:modelValue"]);
 const dialogOpen = ref(false);
-const draftHref = ref("");
-const draftType = ref("external");
-const draftOpenInNewTab = ref(false);
 const value = computed(() => {
   if (props.modelValue && typeof props.modelValue === "object" && !Array.isArray(props.modelValue)) {
     const link = props.modelValue;
     return {
       href: typeof link.href === "string" ? link.href : "",
       type: link.type === "internal" ? "internal" : "external",
-      openInNewTab: link.openInNewTab === true
+      openInNewTab: link.openInNewTab === true,
+      download: link.download === true
     };
   }
-  return { href: "", type: "external", openInNewTab: false };
+  return { href: "", type: "external", openInNewTab: false, download: false };
 });
-const typeOptions = [
-  { label: "Internal link", value: "internal" },
-  { label: "External link", value: "external" }
-];
 function openDialog() {
-  draftHref.value = value.value.href;
-  draftType.value = value.value.type;
-  draftOpenInNewTab.value = value.value.openInNewTab;
   dialogOpen.value = true;
 }
 function updateDialogOpen(open) {
   dialogOpen.value = open;
 }
-function updateType(type) {
-  draftType.value = type === "internal" ? "internal" : "external";
-}
-function updateHref(href) {
-  draftHref.value = String(href);
-}
-function save() {
-  emit("update:modelValue", {
-    href: draftHref.value.trim(),
-    type: draftType.value,
-    openInNewTab: draftOpenInNewTab.value
-  });
-  dialogOpen.value = false;
-}
 function openLink() {
   if (!value.value.href || typeof window === "undefined") return;
   const href = value.value.type === "internal" ? new URL(value.value.href, window.location.origin).href : value.value.href;
@@ -80,7 +54,7 @@ function openLink() {
         {{ value.href || "No link configured" }}
       </p>
       <p class="ep:mt-0.5 ep:mb-0 ep:text-[11px] ep:text-muted-ep">
-        {{ value.type === "internal" ? "Internal" : "External" }} · {{ value.openInNewTab ? "New tab" : "Same tab" }}
+        {{ value.type === "internal" ? "Internal" : "External" }} · {{ value.download ? "Download" : value.openInNewTab ? "New tab" : "Same tab" }}
       </p>
     </div>
     <EPTooltip content="Open link">
@@ -104,66 +78,11 @@ function openLink() {
     </EPTooltip>
   </div>
 
-  <EPDialog
+  <EPLinkDialog
     :open="dialogOpen"
-    title="Configure link"
-    description="Choose where the link points and how it should open."
+    :model-value="value"
+    :placeholder="placeholder"
     @update:open="updateDialogOpen"
-  >
-    <div class="ep:grid ep:gap-5">
-      <div>
-        <p class="ep:mt-0 ep:mb-2 ep:text-sm ep:font-medium ep:text-white">
-          Link type
-        </p>
-        <EPRadioButton
-          :model-value="draftType"
-          :options="typeOptions"
-          @update:model-value="updateType"
-        />
-      </div>
-
-      <label class="ep:block">
-        <span class="ep:mb-2 ep:block ep:text-sm ep:font-medium ep:text-white">Destination</span>
-        <EPInputText
-          :model-value="draftHref"
-          :type="draftType === 'external' ? 'url' : 'text'"
-          :placeholder="draftType === 'internal' ? '/contact' : placeholder || 'https://example.com'"
-          @update:model-value="updateHref"
-        />
-        <span class="ep:mt-1.5 ep:block ep:text-xs ep:text-muted-ep">
-          {{ draftType === "internal" ? "Use a path beginning with / or an anchor beginning with #." : "Use a complete HTTP(S) address." }}
-        </span>
-      </label>
-
-      <div class="ep:flex ep:items-center ep:justify-between ep:gap-4 ep:rounded-xl ep:bg-selected-ep/40 ep:px-4 ep:py-3">
-        <div>
-          <p class="ep:m-0 ep:text-sm ep:font-medium ep:text-white">
-            Open in new tab
-          </p>
-          <p class="ep:mt-1 ep:mb-0 ep:text-xs ep:text-muted-ep">
-            Keep the current page open when visitors follow this link.
-          </p>
-        </div>
-        <EPSwitch
-          :model-value="draftOpenInNewTab"
-          @update:model-value="draftOpenInNewTab = $event"
-        />
-      </div>
-
-      <div class="ep:flex ep:justify-end ep:gap-2">
-        <EPButton
-          variant="ghost"
-          @click="dialogOpen = false"
-        >
-          Cancel
-        </EPButton>
-        <EPButton
-          variant="primary"
-          @click="save"
-        >
-          Apply link
-        </EPButton>
-      </div>
-    </div>
-  </EPDialog>
+    @update:model-value="emit('update:modelValue', $event)"
+  />
 </template>

package/dist/runtime/composables/useEponyme.d.ts

@@ -6,6 +6,8 @@ import type { ValidationErrors } from '../utils/validate-eponyme-data.js';
 type ConfigEponymeName = EponymeName<typeof eponymeConfig>;
 export interface UseEponymeOptions {
     version?: EponymeVersionSelector;
+    /** Keep `{{ variables }}` unresolved. The dashboard editor needs the source text. */
+    raw?: boolean;
 }
 /** Read and save a configured eponyme through the public or draft API. */
 export declare function useEponyme<const Name extends ConfigEponymeName>(name: Name, options?: UseEponymeOptions): {

package/dist/runtime/composables/useEponyme.js

@@ -1,6 +1,7 @@
 import { clearNuxtData, useAsyncData, useRequestFetch, useRoute } from "#app";
 import { computed, ref } from "vue";
 import { readPreviewQuery, readPreviewVersion } from "../utils/preview.js";
+import { cacheDuringHydrationOnly } from "../utils/hydration-cache.js";
 export function useEponyme(name, options = {}) {
   const route = useRoute();
   const preview = readPreviewQuery(route.query);
@@ -8,10 +9,11 @@ export function useEponyme(name, options = {}) {
   const errors = ref({});
   const saving = ref(false);
   const requestFetch = useRequestFetch();
+  const cacheKey = `eponyme:${name}:${version}${options.raw ? ":raw" : ""}`;
   const { data: response, pending: loading, error, refresh: load } = useAsyncData(
-    `eponyme:${name}:${version}`,
-    () => requestFetch(`/api/eponyme/${name}`, { query: { version }, cache: "no-store" }),
-    { getCachedData: () => void 0 }
+    cacheKey,
+    () => requestFetch(`/api/eponyme/${name}`, { query: { version, raw: options.raw ? 1 : void 0 }, cache: "no-store" }),
+    { getCachedData: cacheDuringHydrationOnly }
   );
   const data = computed(() => response.value?.data);
   const status = computed(() => response.value?.status ?? "published");
@@ -31,12 +33,12 @@ export function useEponyme(name, options = {}) {
       });
       response.value = next;
       if (action === "publish") {
-        clearNuxtData((key) => key.startsWith(`eponyme:${name}:`) && key !== `eponyme:${name}:${version}`);
+        clearNuxtData((key) => key.startsWith(`eponyme:${name}:`) && key !== cacheKey);
         const parts = String(name).split("/");
         const slug = parts.pop();
         const collectionName = parts.join("/");
         if (collectionName && slug) {
-          clearNuxtData(`eponyme:collection:public:${collectionName}`);
+          clearNuxtData((key) => key.startsWith(`eponyme:collection:public:${collectionName}`));
           clearNuxtData((key) => key.startsWith(`eponyme:collection-entry:${collectionName}:${slug}:`));
         }
       }

package/dist/runtime/composables/useEponymeCollection.d.ts

@@ -1,10 +1,20 @@
 import type { ComputedRef, Ref } from 'vue';
 import type eponymeConfig from '#eponyme/config';
 import type { EponymeCollectionDataByName, EponymeCollectionName } from '../types/index.js';
-import type { EponymeCollectionEntry, EponymeStatus, EponymeVersionSelector } from '../server/services/eponyme-store.js';
+import type { EponymeCollectionEntry, EponymeSortDirection, EponymeStatus, EponymeVersionSelector } from '../server/services/eponyme-store.js';
 type ConfigCollectionName = EponymeCollectionName<typeof eponymeConfig>;
+/** Sortable keys: the entry metadata plus every field of the collection. */
+export type EponymeCollectionSortKey<Name extends ConfigCollectionName> = 'updatedAt' | 'publishedAt' | 'title' | 'slug' | (keyof EponymeCollectionDataByName<typeof eponymeConfig, Name> & string);
+export interface UseEponymeCollectionOptions<Name extends ConfigCollectionName> {
+    take?: number;
+    skip?: number;
+    orderBy?: EponymeCollectionSortKey<Name>;
+    order?: EponymeSortDirection;
+}
 export interface UseEponymeCollectionResult<Data extends Record<string, unknown>> {
     entries: ComputedRef<EponymeCollectionEntry<Data>[]>;
+    /** Matching entries before `take` and `skip`, for building a pager. */
+    total: ComputedRef<number>;
     pending: Ref<boolean>;
     error: Ref<Error | null | undefined>;
     refresh: () => Promise<void>;
@@ -22,6 +32,6 @@ export interface UseEponymeCollectionEntryResult<Data extends Record<string, unk
     error: Ref<Error | null | undefined>;
     refresh: () => Promise<void>;
 }
-export declare function useEponymeCollection<const Name extends ConfigCollectionName>(name: Name): UseEponymeCollectionResult<EponymeCollectionDataByName<typeof eponymeConfig, Name>>;
+export declare function useEponymeCollection<const Name extends ConfigCollectionName>(name: Name, options?: UseEponymeCollectionOptions<Name>): UseEponymeCollectionResult<EponymeCollectionDataByName<typeof eponymeConfig, Name>>;
 export declare function useEponymeCollectionEntry<const Name extends ConfigCollectionName>(name: Name, slug: string, options?: UseEponymeCollectionEntryOptions): UseEponymeCollectionEntryResult<EponymeCollectionDataByName<typeof eponymeConfig, Name>>;
 export {};

package/dist/runtime/composables/useEponymeCollection.js

@@ -2,17 +2,27 @@ import { useAsyncData, useRequestFetch, useRoute } from "#app";
 import { useEventListener } from "@vueuse/core";
 import { computed } from "vue";
 import { readPreviewQuery, readPreviewVersion } from "../utils/preview.js";
-export function useEponymeCollection(name) {
+import { cacheDuringHydrationOnly } from "../utils/hydration-cache.js";
+export function useEponymeCollection(name, options = {}) {
   const requestFetch = useRequestFetch();
+  const query = {
+    take: options.take,
+    skip: options.skip,
+    orderBy: options.orderBy,
+    order: options.order
+  };
   const result = useAsyncData(
-    `eponyme:collection:public:${name}`,
-    () => requestFetch(`/api/eponyme-collections/${name}`, { cache: "no-store" }),
-    { getCachedData: () => void 0 }
+    // The options belong in the key, otherwise two differently sorted calls to the
+    // same collection would share one cache entry.
+    `eponyme:collection:public:${name}:${options.take ?? ""}:${options.skip ?? ""}:${options.orderBy ?? ""}:${options.order ?? ""}`,
+    () => requestFetch(`/api/eponyme-collections/${name}`, { query, cache: "no-store" }),
+    { getCachedData: cacheDuringHydrationOnly }
   );
   const entries = computed(() => result.data.value?.entries ?? []);
   if (import.meta.client) useEventListener(window, "focus", () => void result.refresh());
   return {
     entries,
+    total: computed(() => result.data.value?.total ?? 0),
     pending: result.pending,
     error: result.error,
     refresh: async () => {
@@ -28,7 +38,7 @@ export function useEponymeCollectionEntry(name, slug, options = {}) {
   const result = useAsyncData(
     `eponyme:collection-entry:${name}:${slug}:${version}`,
     () => requestFetch(`/api/eponyme/${name}/${encodeURIComponent(slug)}`, { query: { version }, cache: "no-store" }),
-    { getCachedData: () => void 0 }
+    { getCachedData: cacheDuringHydrationOnly }
   );
   if (import.meta.client) useEventListener(window, "focus", () => void result.refresh());
   return {

package/dist/runtime/composables/useEponymeForm.js

@@ -47,7 +47,10 @@ export function useEponymeForm(name, options = {}) {
       } else {
         if (options.onSubmit && import.meta.dev)
           console.warn(`[Eponyme] Form "${name}" is managed, so its onSubmit handler is ignored.`);
-        await requestFetch(`/api/eponyme-forms/${name}`, { method: "POST", body: values.value });
+        await requestFetch(`/api/eponyme-forms/${name}`, {
+          method: "POST",
+          body: values.value
+        });
       }
       submitted.value = true;
       return true;

package/dist/runtime/composables/useEponymeHistory.d.ts

@@ -2,7 +2,7 @@ import type { EponymeHistoryEntry } from '../server/services/eponyme-store.js';
 export declare function useEponymeHistory(name: () => string): {
     history: import("vue").Ref<{
         id: number;
-        action: import("../server/services/eponyme-store.js").EponymeAction | "restore";
+        action: import("../server/services/eponyme-store.js").EponymeAction | "restore" | "import";
         status: import("../server/services/eponyme-store.js").EponymeStatus;
         createdAt: string;
         user: {
@@ -11,7 +11,7 @@ export declare function useEponymeHistory(name: () => string): {
         } | null;
     }[], EponymeHistoryEntry[] | {
         id: number;
-        action: import("../server/services/eponyme-store.js").EponymeAction | "restore";
+        action: import("../server/services/eponyme-store.js").EponymeAction | "restore" | "import";
         status: import("../server/services/eponyme-store.js").EponymeStatus;
         createdAt: string;
         user: {

package/dist/runtime/composables/useEponymeHistory.js

@@ -1,5 +1,6 @@
 import { useRequestFetch } from "#app";
 import { ref } from "vue";
+import { EPONYME_DATE_LOCALE } from "../utils/date-locale.js";
 export function useEponymeHistory(name) {
   const requestFetch = useRequestFetch();
   const history = ref([]);
@@ -20,5 +21,5 @@ export function useEponymeHistory(name) {
   return { history, pending, error, load };
 }
 export function formatVersionDate(value) {
-  return new Intl.DateTimeFormat(void 0, { dateStyle: "medium", timeStyle: "short" }).format(new Date(value));
+  return new Intl.DateTimeFormat(EPONYME_DATE_LOCALE, { dateStyle: "medium", timeStyle: "short" }).format(new Date(value));
 }

package/dist/runtime/composables/useEponymeVariables.d.ts

@@ -0,0 +1,3 @@
+import type { EponymeVariableSummary } from '../types/variables.js';
+/** Variables an editor can insert with `{{ name }}`, for listing them in the editor. */
+export declare function useEponymeVariables(): EponymeVariableSummary[];

package/dist/runtime/composables/useEponymeVariables.js

@@ -0,0 +1,5 @@
+import eponymeVariables from "#eponyme/variables";
+import { summariseEponymeVariables } from "../utils/variables.js";
+export function useEponymeVariables() {
+  return summariseEponymeVariables(eponymeVariables);
+}

package/dist/runtime/pages/EponymeDetailPage.vue

@@ -38,7 +38,7 @@ if (!schemas[eponymeName.value] && !collection.value && !form.value && !collecti
 <template>
   <main class="eponyme-root ep:flex ep:min-h-screen ep:flex-col ep:bg-theme-ep ep:font-sans ep:text-text-ep ep:md:flex-row">
     <EponymeSidebar :base-path="indexPath" />
-    <div class="ep:w-full">
+    <div class="ep:w-full ep:min-w-0 ep:md:flex-1">
       <EponymeFolderPage
         v-if="isFolder"
         :base-path="indexPath"

package/dist/runtime/pages/EponymeIndexPage.vue

@@ -1,34 +1,149 @@
 <script setup>
-import { useRoute, useSeoMeta } from "#app";
+import { nextTick, ref } from "vue";
+import { refreshNuxtData, useRequestFetch, useRoute, useSeoMeta } from "#app";
 import EponymeNavigationLink from "../components/editor/EponymeNavigationLink.vue";
 import EponymeSidebar from "../components/editor/EponymeSidebar.vue";
+import EPButton from "../components/ui/EPButton.vue";
+import EPDialog from "../components/ui/EPDialog.vue";
+import EPToast from "../components/ui/EPToast.vue";
+import { useEponymeAuth } from "../composables/useEponymeAuth";
 import { useEponymeConfig } from "../composables/useEponymeConfig";
 import { getEponymeCollections, getEponymeForms, getEponymeSchemas } from "../utils/get-eponyme-schemas";
 const config = useEponymeConfig();
 const route = useRoute();
+const auth = useEponymeAuth();
+const request = useRequestFetch();
 const eponymes = getEponymeSchemas(config);
 const collections = getEponymeCollections(config);
 const forms = getEponymeForms(config);
 const entries = { ...eponymes, ...collections, ...forms };
 useSeoMeta({ title: "Eponyme" });
+const fileInput = ref();
+const exporting = ref(false);
+const importing = ref(false);
+const preview = ref();
+const pendingFile = ref();
+const toast = ref({ open: false, title: "", description: "", variant: "success" });
 function label(name) {
   return name.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 }
+async function showToast(variant, title, description) {
+  toast.value.open = false;
+  await nextTick();
+  toast.value = { open: true, variant, title, description };
+}
+function describeError(caught, fallback) {
+  const error = caught;
+  const mismatch = error?.data?.data?.schemaMismatch;
+  const message = error?.statusMessage || error?.data?.statusMessage || fallback;
+  return mismatch?.length ? `${message} (${mismatch.join(", ")})` : message;
+}
+async function exportContent() {
+  exporting.value = true;
+  try {
+    const file = await request("/api/eponyme-export", { cache: "no-store" });
+    const url = URL.createObjectURL(new Blob([JSON.stringify(file, null, 2)], { type: "application/json" }));
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `eponyme-export-${file.eponyme.exportedAt.slice(0, 10)}.json`;
+    link.click();
+    URL.revokeObjectURL(url);
+  } catch (caught) {
+    await showToast("error", "Export failed", describeError(caught, "Unable to export the content."));
+  } finally {
+    exporting.value = false;
+  }
+}
+async function reviewFile(event) {
+  const input = event.target;
+  const file = input.files?.[0];
+  input.value = "";
+  if (!file) return;
+  importing.value = true;
+  try {
+    const parsed = JSON.parse(await file.text());
+    preview.value = await request("/api/eponyme-import?dryRun=1", { method: "POST", body: parsed });
+    pendingFile.value = parsed;
+  } catch (caught) {
+    pendingFile.value = void 0;
+    preview.value = void 0;
+    await showToast("error", "Import refused", caught instanceof SyntaxError ? "This file is not valid JSON." : describeError(caught, "Unable to read this export file."));
+  } finally {
+    importing.value = false;
+  }
+}
+async function confirmImport() {
+  if (!pendingFile.value) return;
+  importing.value = true;
+  try {
+    const result = await request("/api/eponyme-import", { method: "POST", body: pendingFile.value });
+    closePreview();
+    await refreshNuxtData();
+    await showToast(
+      "success",
+      "Content imported",
+      `${result.created} created, ${result.updated} updated${result.skipped.length ? `, ${result.skipped.length} skipped` : ""}.`
+    );
+  } catch (caught) {
+    await showToast("error", "Import failed", describeError(caught, "Unable to import this file."));
+  } finally {
+    importing.value = false;
+  }
+}
+function closePreview() {
+  preview.value = void 0;
+  pendingFile.value = void 0;
+}
 </script>
 
 <template>
   <main class="eponyme-root ep:flex ep:min-h-screen ep:flex-col ep:bg-theme-ep ep:font-sans ep:text-text-ep ep:md:flex-row">
     <EponymeSidebar :base-path="route.path" />
     <section class="ep:mx-auto ep:w-full ep:max-w-3xl ep:px-6 ep:py-8 ep:md:px-10 ep:md:py-12">
-      <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
-        Eponyme
-      </p>
-      <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
-        Content entries
-      </h1>
-      <p class="ep:mt-2 ep:text-sm ep:text-muted-ep">
-        Choose the content area you want to update.
-      </p>
+      <div class="ep:flex ep:flex-wrap ep:items-start ep:justify-between ep:gap-4">
+        <div>
+          <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
+            Eponyme
+          </p>
+          <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
+            Content entries
+          </h1>
+          <p class="ep:mt-2 ep:text-sm ep:text-muted-ep">
+            Choose the content area you want to update.
+          </p>
+        </div>
+        <div
+          v-if="auth.canEdit.value"
+          class="ep:flex ep:shrink-0 ep:items-center ep:gap-2"
+        >
+          <EPButton
+            label="Export"
+            icon="mingcute:download-2-line"
+            size="sm"
+            :loading="exporting"
+            :disabled="exporting"
+            title="Download every entry as a JSON file"
+            @click="exportContent"
+          />
+          <EPButton
+            v-if="auth.isOwner.value"
+            label="Import"
+            icon="mingcute:upload-2-line"
+            size="sm"
+            :loading="importing"
+            :disabled="importing"
+            title="Apply an export file from another environment"
+            @click="fileInput?.click()"
+          />
+          <input
+            ref="fileInput"
+            type="file"
+            accept="application/json,.json"
+            class="ep:hidden"
+            @change="reviewFile"
+          >
+        </div>
+      </div>
       <nav
         class="ep:mt-8 ep:grid ep:gap-3 ep:sm:grid-cols-2"
         aria-label="Content entries"
@@ -43,6 +158,54 @@ function label(name) {
         />
       </nav>
     </section>
+    <ClientOnly>
+      <EPDialog
+        :open="Boolean(preview)"
+        title="Import content"
+        description="Entries in the file overwrite their counterpart. Nothing is ever deleted."
+        @update:open="!$event && closePreview()"
+      >
+        <div v-if="preview">
+          <ul class="ep:m-0 ep:list-none ep:space-y-1 ep:p-0 ep:text-sm ep:text-muted-ep">
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.created }}</span> to create</li>
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.updated }}</span> to overwrite</li>
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.skipped.length }}</span> skipped</li>
+          </ul>
+          <ul
+            v-if="preview.skipped.length"
+            class="ep:mt-4 ep:max-h-40 ep:list-none ep:space-y-2 ep:overflow-y-auto ep:p-0 ep:text-xs ep:text-muted-ep"
+          >
+            <li
+              v-for="skipped in preview.skipped"
+              :key="skipped.name"
+            >
+              <span class="ep:font-medium ep:text-white">{{ skipped.name }}</span> — {{ skipped.reason }}
+            </li>
+          </ul>
+          <div class="ep:mt-6 ep:flex ep:justify-end ep:gap-2">
+            <EPButton
+              label="Cancel"
+              variant="ghost"
+              @click="closePreview"
+            />
+            <EPButton
+              label="Import"
+              variant="primary"
+              :loading="importing"
+              :disabled="importing || !preview.created && !preview.updated"
+              @click="confirmImport"
+            />
+          </div>
+        </div>
+      </EPDialog>
+      <EPToast
+        :open="toast.open"
+        :title="toast.title"
+        :description="toast.description"
+        :variant="toast.variant"
+        @update:open="toast.open = $event"
+      />
+    </ClientOnly>
   </main>
 </template>
 

package/dist/runtime/server/api/eponyme/[name].get.d.ts

@@ -1,4 +1,8 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeResult | {
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    data: Record<string, unknown>;
+    status: import("../../services/eponyme-store.js").EponymeStatus;
+    publishedAt: string | null;
+} | {
     data: Record<string, unknown>;
 }>>;
 export default _default;

package/dist/runtime/server/api/eponyme/[name].get.js

@@ -1,6 +1,7 @@
 import { createError, defineEventHandler, getQuery, getRequestURL, setResponseHeader } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { requireEponymeUser } from "../../utils/auth.js";
+import { interpolateEponymeContent } from "../../utils/eponyme-variables.js";
 function readVersion(raw) {
   if (raw === "draft") return "draft";
   const id = Number(raw);
@@ -16,5 +17,6 @@ export default defineEventHandler(async (event) => {
   }
   const result = name ? await useEponymeService().getResult(name, version) : void 0;
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
-  return requestedVersion ? result : { data: result.data };
+  const data = getQuery(event).raw ? result.data : interpolateEponymeContent(result.data);
+  return requestedVersion ? { ...result, data } : { data };
 });

package/dist/runtime/server/api/eponyme/[name].patch.js

@@ -1,6 +1,8 @@
 import { createError, defineEventHandler, getQuery, getRequestURL, readBody, setResponseStatus } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeBlockingHook, callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
   const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
@@ -8,7 +10,12 @@ export default defineEventHandler(async (event) => {
   if (!name) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
   const requestedAction = getQuery(event).action;
   const action = requestedAction === "draft" ? "draft" : "publish";
-  const result = await useEponymeService().patch(name, await readBody(event), action, user.id);
+  const service = useEponymeService();
+  const collection = splitEponymeCollectionEntry(service, name);
+  const body = await readBody(event);
+  const beforeSave = { name, collection, action, data: body, userId: user.id };
+  await callEponymeBlockingHook("eponyme:entry:beforeSave", beforeSave);
+  const result = await service.patch(name, beforeSave.data, action, user.id);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
   if ("conflict" in result && result.conflict)
     throw createError({ statusCode: 409, message: "This entry was changed by someone else. Reload the page to get the latest version." });
@@ -16,5 +23,14 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 422);
     return { errors: result.errors };
   }
+  await callEponymeHook(action === "publish" ? "eponyme:entry:published" : "eponyme:entry:saved", {
+    name,
+    collection,
+    action,
+    status: result.status,
+    publishedAt: result.publishedAt,
+    data: result.data,
+    userId: user.id
+  });
   return requestedAction ? result : { data: result.data };
 });

package/dist/runtime/server/api/eponyme-collections/[path].delete.js

@@ -1,11 +1,16 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
-  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
   const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-collections\//, ""));
-  if (!name || !await useEponymeService().deleteCollectionEntry(name))
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.deleteCollectionEntry(name))
     throw createError({ statusCode: 404, statusMessage: "Eponyme collection entry not found." });
+  await callEponymeHook("eponyme:entry:trashed", { name, collection, userId: user.id });
   return { deleted: true };
 });