@karibsen/eponyme 0.1.1 → 0.3.0

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/index.d.ts

@@ -1,4 +1,5 @@
 export * from './auth.js';
 export * from './eponyme.js';
 export * from './field.js';
+export * from './captcha.js';
 export * from './variables.js';

package/dist/runtime/types/index.js

@@ -1,4 +1,5 @@
 export * from "./auth.js";
 export * from "./eponyme.js";
 export * from "./field.js";
+export * from "./captcha.js";
 export * from "./variables.js";

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/no-captcha.d.ts

@@ -0,0 +1,7 @@
+import type { EponymeCaptchaVerifier } from '../types/captcha.js';
+/**
+ * Stands in when no adapter is installed. It never claims success, so a form that
+ * requires a captcha refuses submissions rather than silently accepting them all.
+ */
+declare const verifier: EponymeCaptchaVerifier;
+export default verifier;

package/dist/runtime/utils/no-captcha.js

@@ -0,0 +1,5 @@
+const verifier = {
+  name: "none",
+  verify: async () => ({ success: false, reason: "No captcha adapter is installed." })
+};
+export default verifier;

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;
     }

package/dist/runtime/utils/variables.d.ts

@@ -14,5 +14,12 @@ export declare function summariseEponymeVariables(custom?: EponymeVariables): Ar
  * than blanked, so a typo shows up on the page instead of silently deleting text.
  */
 export declare function interpolateEponymeText(text: string, variables: Record<string, string>): string;
-/** Walks strings nested in objects and arrays, leaving every other value alone. */
+/**
+ * Walks strings nested in objects and arrays, leaving every other value alone.
+ *
+ * A branch containing no `{{ name }}` is returned as-is rather than rebuilt, so content
+ * without variables — which is most of it — costs no copy. The result therefore shares
+ * structure with its input and must be treated as read-only, which is already true of
+ * everything the read routes return.
+ */
 export declare function interpolateEponymeValue<T>(value: T, variables: Record<string, string>): T;

package/dist/runtime/utils/variables.js

@@ -42,11 +42,24 @@ export function interpolateEponymeText(text, variables) {
 }
 export function interpolateEponymeValue(value, variables) {
   if (typeof value === "string") return interpolateEponymeText(value, variables);
-  if (Array.isArray(value)) return value.map((item) => interpolateEponymeValue(item, variables));
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((item) => {
+      const interpolated = interpolateEponymeValue(item, variables);
+      if (interpolated !== item) changed = true;
+      return interpolated;
+    });
+    return changed ? next : value;
+  }
   if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [key, interpolateEponymeValue(nested, variables)])
-    );
+    let changed = false;
+    const next = {};
+    for (const [key, nested] of Object.entries(value)) {
+      const interpolated = interpolateEponymeValue(nested, variables);
+      if (interpolated !== nested) changed = true;
+      next[key] = interpolated;
+    }
+    return changed ? next : value;
   }
   return value;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karibsen/eponyme",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "A lightweight, type-safe content manager for Nuxt.",
   "license": "MIT",
   "type": "module",
@@ -62,6 +62,7 @@
     "@iconify-json/mingcute": "^1.2.7",
     "@nuxt/icon": "^2.3.1",
     "@nuxt/kit": "^4.4.8",
+    "@karibsen/ui": "latest",
     "@tailwindcss/vite": "^4.1.12",
     "@tanstack/vue-table": "^8.21.3",
     "@tiptap/extension-image": "^3.29.2",
@@ -70,6 +71,7 @@
     "@tiptap/vue-3": "^3.28.0",
     "@vueuse/core": "^14.3.0",
     "@vueuse/integrations": "^14.3.0",
+    "fuse.js": "^7.5.0",
     "picocolors": "^1.1.1",
     "reka-ui": "^2.10.1",
     "slugify": "^1.6.9",