@karibsen/eponyme 0.1.1 → 0.2.0

package/dist/runtime/server/services/eponyme-store.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { createDefaultEponymeData } from "../../utils/create-default-eponyme-data.js";
 import { getEponymeCollections, getEponymeSchemas } from "../../utils/get-eponyme-schemas.js";
@@ -71,7 +72,7 @@ export class EponymeService {
     if (!schema) return void 0;
     const defaults = this.createState(schema);
     const row = this.getCollectionEntry(name) ? await this.client.eponyme.findUnique({ where: { name } }) : await this.client.eponyme.upsert({ where: { name }, create: { name, data: defaults }, update: {} });
-    if (!row) return void 0;
+    if (!row || row.deletedAt) return void 0;
     const state = this.normalizeState(schema, row.data);
     if (sameData(state, row.data)) return { state, updatedAt: row.updatedAt };
     const healed = await this.client.eponyme.update({ where: { name }, data: { data: state } });
@@ -138,7 +139,7 @@ export class EponymeService {
     const definition = this.collections[name];
     if (!definition) return void 0;
     const rows = await this.client.eponyme.findMany({
-      where: { name: { startsWith: `${name}/` } },
+      where: { name: { startsWith: `${name}/` }, deletedAt: null },
       orderBy: [
         { updatedAt: "desc" },
         { name: "asc" }
@@ -181,7 +182,7 @@ export class EponymeService {
       if (!path.includes(":slug"))
         throw new Error(`[Eponyme] previewPaths.${name} must include ":slug" to generate collection sitemap URLs.`);
       const rows = await this.client.eponyme.findMany({
-        where: { name: { startsWith: `${name}/` } },
+        where: { name: { startsWith: `${name}/` }, deletedAt: null },
         orderBy: [
           { updatedAt: "desc" },
           { name: "asc" }
@@ -200,6 +201,108 @@ export class EponymeService {
       entries.set(entry.loc, entry);
     return [...entries.values()];
   }
+  /**
+   * Every singleton and every live collection entry, as a portable file.
+   * Collections are read with one query each rather than one per entry.
+   */
+  async exportContent() {
+    const schemas = {};
+    const entries = [];
+    for (const [name, schema] of Object.entries(this.schemas)) {
+      schemas[name] = schemaFingerprint(schema);
+      const row = await this.loadRow(name);
+      if (row) entries.push({ name, ...toExportEntry(row.state) });
+    }
+    for (const [name, definition] of Object.entries(this.collections)) {
+      schemas[name] = schemaFingerprint(definition.fields);
+      const rows = await this.client.eponyme.findMany({
+        where: { name: { startsWith: `${name}/` }, deletedAt: null },
+        orderBy: [
+          { updatedAt: "desc" },
+          { name: "asc" }
+        ]
+      });
+      for (const row of rows) {
+        const slug = row.name.slice(name.length + 1);
+        if (!slug || slug.includes("/")) continue;
+        entries.push({ name: row.name, collection: name, ...toExportEntry(this.normalizeState(definition.fields, row.data)) });
+      }
+    }
+    return {
+      eponyme: { format: 1, exportedAt: (/* @__PURE__ */ new Date()).toISOString(), schemas },
+      entries
+    };
+  }
+  /**
+   * Applies an export file on top of the current content: every entry it carries is
+   * upserted, everything else is left alone. Nothing is ever deleted.
+   *
+   * The schema check runs first and refuses the whole file, so an import can never
+   * land half of its entries into a configuration that no longer matches.
+   */
+  async importContent(file, options = {}) {
+    const parsed = parseExportFile(file);
+    if (!parsed) return { errors: ["This file is not an Eponyme export."] };
+    const declared = parsed.eponyme.schemas;
+    const mismatch = Object.keys(declared).filter((name) => {
+      const local = this.schemas[name] ?? this.collections[name]?.fields;
+      return !local || schemaFingerprint(local) !== declared[name];
+    });
+    for (const entry of parsed.entries) {
+      const owner = entry.collection ?? this.getCollectionEntry(entry.name)?.name ?? entry.name;
+      if (!(owner in declared) && !mismatch.includes(owner)) mismatch.push(owner);
+    }
+    if (mismatch.length) {
+      return {
+        errors: ["The exported schema does not match this application's configuration."],
+        schemaMismatch: mismatch
+      };
+    }
+    const result = { dryRun: Boolean(options.dryRun), created: 0, updated: 0, skipped: [] };
+    for (const entry of parsed.entries) {
+      const collectionEntry = this.getCollectionEntry(entry.name);
+      const schema = this.schemas[entry.name] ?? collectionEntry?.definition.fields;
+      if (!schema) {
+        result.skipped.push({ name: entry.name, reason: "No schema is configured for this entry." });
+        continue;
+      }
+      const row = await this.client.eponyme.findUnique({ where: { name: entry.name } });
+      if (row?.deletedAt) {
+        result.skipped.push({ name: entry.name, reason: "An entry with this name is in the trash. Restore it or delete it permanently first." });
+        continue;
+      }
+      const state = this.normalizeState(schema, {
+        __eponyme: {
+          version: 1,
+          draft: entry.draft,
+          published: entry.published,
+          status: entry.status,
+          publishedAt: entry.publishedAt
+        }
+      });
+      if (collectionEntry) {
+        const { slugField } = collectionEntry.definition;
+        if (slugField in state.__eponyme.draft) state.__eponyme.draft[slugField] = collectionEntry.slug;
+        if (slugField in state.__eponyme.published) state.__eponyme.published[slugField] = collectionEntry.slug;
+      }
+      if (!options.dryRun) {
+        const data = state;
+        await this.client.eponyme.upsert({ where: { name: entry.name }, create: { name: entry.name, data }, update: { data } });
+        await this.client.eponymeVersion.create({
+          data: {
+            entryName: entry.name,
+            data,
+            action: "import",
+            status: state.__eponyme.status,
+            userId: options.actorId ?? null
+          }
+        });
+      }
+      if (row) result.updated++;
+      else result.created++;
+    }
+    return result;
+  }
   async createCollectionEntry(name, payload, actorId) {
     const definition = this.collections[name];
     if (!definition) return void 0;
@@ -210,8 +313,8 @@ export class EponymeService {
     const slug = normalizeSlug(String(input[definition.slugField] || input[definition.titleField] || ""));
     if (!slug) return { errors: { [definition.slugField]: ["A slug or title is required."] } };
     const entryName = `${name}/${slug}`;
-    if (await this.client.eponyme.findUnique({ where: { name: entryName } }))
-      return { errors: { [definition.slugField]: ["This slug is already in use."] } };
+    const taken = await this.slugTakenError(definition, entryName);
+    if (taken) return taken;
     const defaults = createDefaultEponymeData(definition.fields);
     const data = { ...defaults, ...input, [definition.slugField]: slug };
     const errors = validateEponymePatch(definition.fields, data, data, "draft");
@@ -228,14 +331,47 @@ export class EponymeService {
     try {
       await this.client.eponyme.create({ data: { name: entryName, data: state } });
     } catch (error) {
-      if (isPrismaError(error, "P2002")) return { errors: { [definition.slugField]: ["This slug is already in use."] } };
+      if (isPrismaError(error, "P2002")) return await this.slugTakenError(definition, entryName) ?? { errors: { [definition.slugField]: ["This slug is already in use."] } };
       throw error;
     }
     await this.client.eponymeVersion.create({ data: { entryName, data: state, action: "draft", status: "draft", userId: actorId ?? null } });
     return { slug, data, status: "draft", publishedAt: null };
   }
+  /**
+   * A trashed entry keeps its row, so it keeps its slug: reusing one has to be
+   * refused with an error the editor can act on rather than the generic message.
+   */
+  async slugTakenError(definition, entryName) {
+    const row = await this.client.eponyme.findUnique({ where: { name: entryName } });
+    if (!row) return void 0;
+    return {
+      errors: {
+        [definition.slugField]: [row.deletedAt ? "An entry with this slug is in the trash. Restore it or delete it permanently first." : "This slug is already in use."]
+      }
+    };
+  }
+  /** Moves an entry to the trash. Its history is kept, so it stays restorable. */
   async deleteCollectionEntry(name) {
     if (!this.getCollectionEntry(name)) return false;
+    const { count } = await this.client.eponyme.updateMany({
+      where: { name, deletedAt: null },
+      data: { deletedAt: /* @__PURE__ */ new Date() }
+    });
+    return count > 0;
+  }
+  async restoreCollectionEntry(name) {
+    if (!this.getCollectionEntry(name)) return false;
+    const { count } = await this.client.eponyme.updateMany({
+      where: { name, deletedAt: { not: null } },
+      data: { deletedAt: null }
+    });
+    return count > 0;
+  }
+  /** Definitive: `onDelete: Cascade` takes the entry's whole history with it. */
+  async purgeCollectionEntry(name) {
+    if (!this.getCollectionEntry(name)) return false;
+    const row = await this.client.eponyme.findUnique({ where: { name } });
+    if (!row?.deletedAt) return false;
     try {
       await this.client.eponyme.delete({ where: { name } });
     } catch (error) {
@@ -244,6 +380,33 @@ export class EponymeService {
     }
     return true;
   }
+  /** Trashed entries of a collection, most recently updated first. */
+  async listCollectionTrash(name) {
+    const definition = this.collections[name];
+    if (!definition) return void 0;
+    const rows = await this.client.eponyme.findMany({
+      where: { name: { startsWith: `${name}/` }, deletedAt: { not: null } },
+      orderBy: [
+        { updatedAt: "desc" },
+        { name: "asc" }
+      ]
+    });
+    const entries = rows.flatMap((row) => {
+      const slug = row.name.slice(name.length + 1);
+      if (!slug || slug.includes("/")) return [];
+      const state = this.normalizeState(definition.fields, row.data);
+      return [{
+        slug,
+        title: String(state.__eponyme.draft[definition.titleField] || slug),
+        data: state.__eponyme.draft,
+        status: state.__eponyme.status,
+        publishedAt: state.__eponyme.publishedAt,
+        updatedAt: row.updatedAt ? new Date(row.updatedAt).toISOString() : null,
+        deletedAt: row.deletedAt ? new Date(row.deletedAt).toISOString() : null
+      }];
+    });
+    return { entries, total: entries.length };
+  }
   async patch(name, payload, action = "publish", actorId) {
     const schema = this.getSchema(name);
     if (!schema) return void 0;
@@ -293,7 +456,7 @@ export class EponymeService {
     });
     return versions.map((version) => ({
       id: version.id,
-      action: version.action === "draft" || version.action === "publish" ? version.action : "restore",
+      action: isHistoryAction(version.action) ? version.action : "restore",
       status: version.status === "draft" ? "draft" : "published",
       createdAt: new Date(version.createdAt).toISOString(),
       user: version.user ? { id: version.user.id, username: version.user.username } : null
@@ -333,6 +496,68 @@ function getStoredState(value) {
   );
   return valid ? state : void 0;
 }
+function isHistoryAction(action) {
+  return action === "draft" || action === "publish" || action === "import";
+}
+function toExportEntry(state) {
+  return {
+    draft: state.__eponyme.draft,
+    published: state.__eponyme.published,
+    status: state.__eponyme.status,
+    publishedAt: state.__eponyme.publishedAt
+  };
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function describeSchema(schema) {
+  const fields = schema;
+  return Object.keys(fields).sort().map((key) => `${key}:${describeField(fields[key])}`).join(",");
+}
+function describeField(field) {
+  if (!isPlainObject(field) || typeof field.type !== "string") return "unknown";
+  const options = isPlainObject(field.options) ? field.options : {};
+  if (field.type === "array") {
+    const item = isPlainObject(options.of) ? options.of : {};
+    return `array(${typeof item.type === "string" ? describeField(item) : describeSchema(item)})`;
+  }
+  if (field.type === "section")
+    return `section(${describeSchema(isPlainObject(options.fields) ? options.fields : {})})`;
+  if (field.type === "tabs") {
+    const tabs = isPlainObject(options.tabs) ? options.tabs : {};
+    return `tabs(${Object.keys(tabs).sort().map((key) => {
+      const tab = tabs[key];
+      return `${key}:${describeSchema(isPlainObject(tab) && isPlainObject(tab.fields) ? tab.fields : {})}`;
+    }).join(",")})`;
+  }
+  return field.type;
+}
+export function schemaFingerprint(schema) {
+  return createHash("sha256").update(describeSchema(schema)).digest("hex").slice(0, 32);
+}
+function parseExportFile(value) {
+  if (!isPlainObject(value)) return void 0;
+  const envelope = value.eponyme;
+  if (!isPlainObject(envelope) || envelope.format !== 1 || !isPlainObject(envelope.schemas)) return void 0;
+  if (!Object.values(envelope.schemas).every((fingerprint) => typeof fingerprint === "string")) return void 0;
+  if (!Array.isArray(value.entries)) return void 0;
+  const entries = [];
+  for (const entry of value.entries) {
+    if (!isPlainObject(entry)) return void 0;
+    const { name, collection, draft, published, status, publishedAt } = entry;
+    const valid = typeof name === "string" && name.length > 0 && isPlainObject(draft) && isPlainObject(published) && (status === "draft" || status === "published") && (publishedAt === null || typeof publishedAt === "string") && (collection === void 0 || typeof collection === "string");
+    if (!valid) return void 0;
+    entries.push({ name, collection, draft, published, status, publishedAt });
+  }
+  return {
+    eponyme: {
+      format: 1,
+      exportedAt: typeof envelope.exportedAt === "string" ? envelope.exportedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      schemas: envelope.schemas
+    },
+    entries
+  };
+}
 function mergeErrors(...groups) {
   const errors = {};
   for (const group of groups) {

package/dist/runtime/server/utils/eponyme-entry.d.ts

@@ -0,0 +1,9 @@
+import type { EponymeService } from '../services/eponyme-store.js';
+/**
+ * Splits `<collection>/<slug>` when the name belongs to a configured collection, so
+ * hook listeners can branch on the collection without re-parsing the name themselves.
+ */
+export declare function splitEponymeCollectionEntry(service: EponymeService, name: string): {
+    name: string;
+    slug: string;
+} | undefined;

package/dist/runtime/server/utils/eponyme-entry.js

@@ -0,0 +1,7 @@
+export function splitEponymeCollectionEntry(service, name) {
+  const separator = name.lastIndexOf("/");
+  if (separator <= 0) return void 0;
+  const collection = name.slice(0, separator);
+  const slug = name.slice(separator + 1);
+  return slug && service.getCollection(collection) ? { name: collection, slug } : void 0;
+}

package/dist/runtime/server/utils/eponyme-hooks.d.ts

@@ -0,0 +1,16 @@
+import type { EponymeHooks } from '../../types/hooks.js';
+type HookName = keyof EponymeHooks;
+type HookContext<Name extends HookName> = Parameters<EponymeHooks[Name]>[0];
+/**
+ * Notification hooks. The write already happened, so a listener that throws is
+ * logged and swallowed: a failing webhook must not report a successful save as an
+ * error the editor cannot act on.
+ */
+export declare function callEponymeHook<Name extends Exclude<HookName, `${string}before${string}`>>(name: Name, context: HookContext<Name>): Promise<void>;
+/**
+ * Blocking hooks, run before the write. A listener may mutate `context.data` to amend
+ * the payload, or throw to reject the operation — the error surfaces as a 422 so the
+ * message reaches the editor.
+ */
+export declare function callEponymeBlockingHook<Name extends Extract<HookName, `${string}before${string}`>>(name: Name, context: HookContext<Name>): Promise<void>;
+export {};

package/dist/runtime/server/utils/eponyme-hooks.js

@@ -0,0 +1,24 @@
+import { createError } from "h3";
+import { useNitroApp } from "nitropack/runtime";
+function hooks() {
+  return useNitroApp().hooks;
+}
+export async function callEponymeHook(name, context) {
+  try {
+    await hooks().callHook(name, context);
+  } catch (error) {
+    console.error(`[Eponyme] The "${name}" hook threw. The operation itself succeeded.`, error);
+  }
+}
+export async function callEponymeBlockingHook(name, context) {
+  try {
+    await hooks().callHook(name, context);
+  } catch (error) {
+    if (error && typeof error === "object" && "statusCode" in error) throw error;
+    throw createError({
+      statusCode: 422,
+      statusMessage: error instanceof Error ? error.message : `Rejected by the "${name}" hook.`,
+      data: { errors: { _form: [error instanceof Error ? error.message : "Rejected by a server hook."] } }
+    });
+  }
+}

package/dist/runtime/types/field.d.ts

@@ -70,6 +70,7 @@ export interface UrlValue {
     href: string;
     type: UrlType;
     openInNewTab: boolean;
+    download?: boolean;
 }
 export interface UrlFieldOptions extends DefaultFieldOptions<UrlValue> {
     placeholder?: string;

package/dist/runtime/types/hooks.d.ts

@@ -0,0 +1,67 @@
+import type { EponymeAction, EponymeStatus } from '../server/services/eponyme-store.js';
+export interface EponymeEntryContext {
+    /** Full entry name, `homepage` or `articles/my-article`. */
+    name: string;
+    /** Collection name and slug when the entry belongs to one. */
+    collection?: {
+        name: string;
+        slug: string;
+    };
+    action: EponymeAction | 'restore';
+    status: EponymeStatus;
+    publishedAt: string | null;
+    data: Record<string, unknown>;
+    /** Author of the write, absent for an unattended one. */
+    userId?: string;
+}
+/** Mutating `data` here changes what gets written. */
+export interface EponymeEntryBeforeSaveContext {
+    name: string;
+    collection?: {
+        name: string;
+        slug: string;
+    };
+    action: EponymeAction;
+    data: Record<string, unknown>;
+    userId?: string;
+}
+/** Trash moves carry no content: the entry is untouched, only its availability changed. */
+export interface EponymeEntryTrashContext {
+    /** Full entry name, `articles/my-article`. Only collection entries can be trashed. */
+    name: string;
+    collection: {
+        name: string;
+        slug: string;
+    };
+    /** Author of the move, absent for an unattended one. */
+    userId?: string;
+}
+export interface EponymeFormSubmissionContext {
+    form: string;
+    data: Record<string, unknown>;
+    /** Absent until the submission is stored, so `undefined` in `before`. */
+    id?: string;
+}
+export interface EponymeHooks {
+    /**
+     * Runs before the write. Throwing rejects it with a 422, so an application can
+     * enforce a rule the schema cannot express. Mutating `data` amends the payload.
+     */
+    'eponyme:entry:beforeSave': (context: EponymeEntryBeforeSaveContext) => void | Promise<void>;
+    /** After a draft save. The entry is already stored. */
+    'eponyme:entry:saved': (context: EponymeEntryContext) => void | Promise<void>;
+    /** After a publication: the usual place to purge a cache or ping a webhook. */
+    'eponyme:entry:published': (context: EponymeEntryContext) => void | Promise<void>;
+    /** After a history version was restored as the current draft. */
+    'eponyme:entry:restored': (context: EponymeEntryContext) => void | Promise<void>;
+    /** After a collection entry was moved to the trash. It is recoverable, nothing was destroyed. */
+    'eponyme:entry:trashed': (context: EponymeEntryTrashContext) => void | Promise<void>;
+    /** After a collection entry was taken back out of the trash. */
+    'eponyme:entry:untrashed': (context: EponymeEntryTrashContext) => void | Promise<void>;
+    /** After a collection entry and its whole history were deleted for good. */
+    'eponyme:entry:purged': (context: EponymeEntryTrashContext) => void | Promise<void>;
+    /** Runs before a managed submission is stored. Throwing rejects it with a 422. */
+    'eponyme:form:beforeSubmit': (context: EponymeFormSubmissionContext) => void | Promise<void>;
+    /** After a managed submission was stored, with its id. */
+    'eponyme:form:submitted': (context: Required<EponymeFormSubmissionContext>) => void | Promise<void>;
+}

package/dist/runtime/types/nuxt.d.ts

@@ -9,3 +9,13 @@ declare module '@nuxt/schema' {
     eponyme: ModuleOptions
   }
 }
+
+declare module 'nitropack/types' {
+  import type { EponymeHooks } from './hooks'
+
+  // Interface augmentation: the body is empty by design, the point is the supertype.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface NitroRuntimeHooks extends EponymeHooks {}
+}
+
+export {}

package/dist/runtime/utils/build-navigation-tree.d.ts

@@ -0,0 +1,22 @@
+import type { EponymeNavigationNode } from '../types/eponyme-navigation.js';
+export interface EponymeNavigationTreeInput {
+    /** Singleton entry names, `pages/homepage`. Only the keys are read. */
+    schemas: Record<string, unknown>;
+    collections: Record<string, {
+        label?: string;
+    }>;
+    forms: Record<string, {
+        label?: string;
+    }>;
+    /** Entries already loaded per collection, added as leaves under their collection. */
+    collectionEntries?: Record<string, Array<{
+        slug: string;
+        title: string;
+    }>>;
+}
+/**
+ * Turns the flat, slash-separated names of the configuration into the nested tree the
+ * sidebar renders. Intermediate segments become folders, so `pages/homepage` yields a
+ * `pages` folder even though nothing declares one.
+ */
+export declare function buildEponymeNavigationTree(input: EponymeNavigationTreeInput): EponymeNavigationNode[];

package/dist/runtime/utils/build-navigation-tree.js

@@ -0,0 +1,30 @@
+import { humanizeLabel } from "./humanize-label.js";
+export function buildEponymeNavigationTree(input) {
+  const root = [];
+  function addPath(pathValue, finalKind, configuredLabel) {
+    const parts = pathValue.split("/");
+    let children = root;
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
+      const path = parts.slice(0, index + 1).join("/");
+      const last = index === parts.length - 1;
+      const kind = last ? finalKind : "folder";
+      let node = children.find((item) => item.path === path);
+      if (!node) {
+        node = { kind, path, label: humanizeLabel(part, last ? configuredLabel : void 0), children: [] };
+        children.push(node);
+      } else if (last) {
+        node.kind = finalKind;
+        if (configuredLabel) node.label = configuredLabel;
+      }
+      children = node.children;
+    }
+  }
+  for (const entry of Object.keys(input.schemas)) addPath(entry, "entry");
+  for (const [name, definition] of Object.entries(input.collections)) {
+    addPath(name, "collection", definition.label);
+    for (const entry of input.collectionEntries?.[name] ?? []) addPath(`${name}/${entry.slug}`, "entry", entry.title);
+  }
+  for (const [name, definition] of Object.entries(input.forms)) addPath(name, "form", definition.label);
+  return root;
+}

package/dist/runtime/utils/date-locale.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dates in the dashboard are formatted with a fixed locale rather than the ambient one.
+ *
+ * `Intl.DateTimeFormat(undefined, …)` resolves to the server's locale during SSR and to
+ * the visitor's in the browser, so the two renders disagree and Vue reports a hydration
+ * mismatch on every timestamp. The dashboard interface is English throughout, so pinning
+ * the locale keeps the formatting consistent with the rest of it. `en-GB` is day-first
+ * and 24-hour, which reads closer to what most of the world expects than `en-US`.
+ */
+export declare const EPONYME_DATE_LOCALE = "en-GB";

package/dist/runtime/utils/date-locale.js

@@ -0,0 +1 @@
+export const EPONYME_DATE_LOCALE = "en-GB";

package/dist/runtime/utils/downloadable-link.d.ts

@@ -0,0 +1,2 @@
+export declare function getDownloadableExtension(href: string): string | undefined;
+export declare function isDownloadableLink(href: string): boolean;

package/dist/runtime/utils/downloadable-link.js

@@ -0,0 +1,35 @@
+const DOWNLOADABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "7z",
+  "apk",
+  "bz2",
+  "csv",
+  "dmg",
+  "doc",
+  "docx",
+  "epub",
+  "gz",
+  "json",
+  "odg",
+  "odp",
+  "ods",
+  "odt",
+  "pdf",
+  "ppt",
+  "pptx",
+  "rar",
+  "rtf",
+  "tar",
+  "txt",
+  "xls",
+  "xlsx",
+  "xml",
+  "zip"
+]);
+export function getDownloadableExtension(href) {
+  const path = href.trim().split(/[?#]/, 1)[0] ?? "";
+  const extension = path.match(/\.([a-z0-9]+)$/i)?.[1]?.toLowerCase();
+  return extension && DOWNLOADABLE_EXTENSIONS.has(extension) ? extension : void 0;
+}
+export function isDownloadableLink(href) {
+  return getDownloadableExtension(href) !== void 0;
+}

package/dist/runtime/utils/filter-navigation-tree.d.ts

@@ -0,0 +1,7 @@
+import type { EponymeNavigationNode } from '../types/eponyme-navigation.js';
+/**
+ * Keeps the nodes matching `query`, along with every ancestor needed to reach them.
+ * A node matched on its own label keeps all of its children, so selecting a folder
+ * shows what it holds. An empty query returns the tree untouched.
+ */
+export declare function filterEponymeNavigationTree(nodes: EponymeNavigationNode[], query: string): EponymeNavigationNode[];

package/dist/runtime/utils/filter-navigation-tree.js

@@ -0,0 +1,39 @@
+import Fuse from "fuse.js";
+function normalize(value) {
+  return value.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLowerCase();
+}
+function collect(nodes, items) {
+  for (const node of nodes) {
+    items.push({ path: node.path, label: normalize(node.label), searchPath: normalize(node.path) });
+    collect(node.children, items);
+  }
+}
+const indexes = /* @__PURE__ */ new WeakMap();
+function indexOf(nodes) {
+  const cached = indexes.get(nodes);
+  if (cached) return cached;
+  const items = [];
+  collect(nodes, items);
+  const fuse = new Fuse(items, {
+    keys: ["label", "searchPath"],
+    // Tolerant enough for a typo, strict enough that a short query does not match everything.
+    threshold: 0.35,
+    // Without this a match near the end of a long label is penalised into irrelevance.
+    ignoreLocation: true
+  });
+  indexes.set(nodes, fuse);
+  return fuse;
+}
+export function filterEponymeNavigationTree(nodes, query) {
+  const term = normalize(query.trim());
+  if (!term) return nodes;
+  const matched = new Set(indexOf(nodes).search(term).map((result) => result.item.path));
+  function keep(list) {
+    return list.flatMap((node) => {
+      if (matched.has(node.path)) return [node];
+      const children = keep(node.children);
+      return children.length ? [{ ...node, children }] : [];
+    });
+  }
+  return keep(nodes);
+}

package/dist/runtime/utils/get-field-default-value.js

@@ -31,7 +31,7 @@ export function getFieldDefaultValue(definition) {
     case "number":
       return 0;
     case "url":
-      return { href: "", type: "external", openInNewTab: false };
+      return { href: "", type: "external", openInNewTab: false, download: false };
     case "boolean":
       return false;
     default:

package/dist/runtime/utils/hydration-cache.d.ts

@@ -0,0 +1,11 @@
+import type { NuxtApp } from '#app';
+/**
+ * `getCachedData` for reads that must never serve a stale value.
+ *
+ * Returning `undefined` unconditionally looks like the obvious way to always refetch,
+ * but it also discards the payload the server rendered from: the first client render
+ * then has no data and disagrees with the HTML, which Vue reports as a hydration
+ * mismatch. Reusing the payload while hydrating, and nothing afterwards, keeps the
+ * first paint faithful and still refetches on every later navigation.
+ */
+export declare function cacheDuringHydrationOnly<T>(key: string, nuxtApp: NuxtApp): T | undefined;

package/dist/runtime/utils/hydration-cache.js

@@ -0,0 +1,3 @@
+export function cacheDuringHydrationOnly(key, nuxtApp) {
+  return nuxtApp.isHydrating ? nuxtApp.payload.data[key] : void 0;
+}

package/dist/runtime/utils/validate-eponyme-data.js

@@ -127,7 +127,7 @@ function validateFieldRules(name, definition, value, errors, mode, _context) {
       return;
     }
     const link = value;
-    if (typeof link.href !== "string" || !["internal", "external"].includes(String(link.type)) || typeof link.openInNewTab !== "boolean") {
+    if (typeof link.href !== "string" || !["internal", "external"].includes(String(link.type)) || typeof link.openInNewTab !== "boolean" || link.download !== void 0 && typeof link.download !== "boolean") {
       addError(errors, name, "Must be a valid link.");
       return;
     }