@karibsen/eponyme 0.1.0

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

@@ -0,0 +1,203 @@
+export type EponymeFieldType = 'string' | 'slug' | 'email' | 'url' | 'textarea' | 'richText' | 'number' | 'boolean' | 'image' | 'select' | 'radio' | 'checkboxGroup' | 'date' | 'color' | 'array' | 'section' | 'tabs';
+export type FieldVisibilityCondition = {
+    field: string;
+    equals: unknown;
+    notEquals?: never;
+} | {
+    field: string;
+    notEquals: unknown;
+    equals?: never;
+};
+export type FieldValidationResult = true | string | string[] | null | undefined;
+export type FieldValidator<T> = {
+    bivarianceHack(value: T, data: Readonly<Record<string, unknown>>): FieldValidationResult;
+}['bivarianceHack'];
+export interface DefaultFieldOptions<T> {
+    label?: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: T;
+    visibleWhen?: FieldVisibilityCondition | FieldVisibilityCondition[];
+    validate?: FieldValidator<T>;
+}
+export interface TextFieldOptions extends DefaultFieldOptions<string> {
+    minLength?: number;
+    maxLength?: number;
+    showCounter?: boolean;
+    placeholder?: string;
+    trim?: boolean;
+    regex?: RegExp;
+    email?: boolean;
+    url?: boolean;
+}
+export type StringFieldOptions = TextFieldOptions;
+export type TextareaFieldOptions = TextFieldOptions;
+export interface StringFieldDefinition {
+    type: 'string';
+    options: StringFieldOptions;
+}
+export interface SlugFieldOptions extends DefaultFieldOptions<string> {
+    minLength?: number;
+    maxLength?: number;
+    showCounter?: boolean;
+    placeholder?: string;
+}
+export interface SlugFieldDefinition {
+    type: 'slug';
+    options: SlugFieldOptions;
+}
+export interface TextareaFieldDefinition {
+    type: 'textarea';
+    options: TextareaFieldOptions;
+}
+export interface RichTextFieldOptions extends DefaultFieldOptions<string> {
+    minLength?: number;
+    maxLength?: number;
+    showCounter?: boolean;
+    placeholder?: string;
+}
+export interface RichTextFieldDefinition {
+    type: 'richText';
+    options: RichTextFieldOptions;
+}
+export type EmailFieldOptions = TextFieldOptions;
+export interface EmailFieldDefinition {
+    type: 'email';
+    options: EmailFieldOptions;
+}
+export type UrlType = 'internal' | 'external';
+export interface UrlValue {
+    href: string;
+    type: UrlType;
+    openInNewTab: boolean;
+}
+export interface UrlFieldOptions extends DefaultFieldOptions<UrlValue> {
+    placeholder?: string;
+}
+export interface UrlFieldDefinition {
+    type: 'url';
+    options: UrlFieldOptions;
+}
+export interface NumberFieldOptions extends DefaultFieldOptions<number> {
+    min?: number;
+    max?: number;
+    step?: number;
+    slider?: boolean;
+}
+export interface NumberFieldDefinition {
+    type: 'number';
+    options: NumberFieldOptions;
+}
+export type BooleanFieldOptions = DefaultFieldOptions<boolean>;
+export interface BooleanFieldDefinition {
+    type: 'boolean';
+    options: BooleanFieldOptions;
+}
+export interface ImageFieldOptions extends DefaultFieldOptions<string> {
+    label?: string;
+    description?: string;
+    placeholder?: string;
+}
+export interface ImageFieldDefinition {
+    type: 'image';
+    options: ImageFieldOptions;
+}
+export interface SelectOption<T extends string = string> {
+    label: string;
+    value: T;
+}
+export interface SelectFieldOptions<T extends string = string> extends DefaultFieldOptions<T> {
+    options: ReadonlyArray<SelectOption<T>>;
+    placeholder?: string;
+}
+export interface SelectFieldDefinition<T extends string = string> {
+    type: 'select';
+    options: SelectFieldOptions<T>;
+}
+export interface RadioFieldOptions<T extends string = string> extends DefaultFieldOptions<T> {
+    options: ReadonlyArray<SelectOption<T>>;
+}
+export interface RadioFieldDefinition<T extends string = string> {
+    type: 'radio';
+    options: RadioFieldOptions<T>;
+}
+export interface CheckboxGroupFieldOptions<T extends string = string> extends DefaultFieldOptions<T[]> {
+    options: ReadonlyArray<SelectOption<T>>;
+    minItems?: number;
+    maxItems?: number;
+}
+export interface CheckboxGroupFieldDefinition<T extends string = string> {
+    type: 'checkboxGroup';
+    options: CheckboxGroupFieldOptions<T>;
+}
+export interface TodayDateDefault {
+    readonly __eponymeDefault: 'today';
+}
+export interface DateFieldOptions extends Omit<DefaultFieldOptions<string>, 'defaultValue'> {
+    defaultValue?: string | TodayDateDefault;
+    min?: string;
+    max?: string;
+}
+export interface DateFieldDefinition {
+    type: 'date';
+    options: DateFieldOptions;
+}
+export interface ColorPreset {
+    label: string;
+    value: string;
+}
+export interface ColorFieldOptions extends DefaultFieldOptions<string> {
+    /** Clickable palette for this field; falls back to the module-wide `colorPresets`. */
+    presets?: ReadonlyArray<string | ColorPreset>;
+}
+export interface ColorFieldDefinition {
+    type: 'color';
+    options: ColorFieldOptions;
+}
+export type ArrayItemFieldDefinition = StringFieldDefinition | SlugFieldDefinition | EmailFieldDefinition | UrlFieldDefinition | TextareaFieldDefinition | RichTextFieldDefinition | NumberFieldDefinition | BooleanFieldDefinition | ImageFieldDefinition | SelectFieldDefinition | RadioFieldDefinition | CheckboxGroupFieldDefinition | DateFieldDefinition | ColorFieldDefinition;
+export type ArrayItemSchema = Record<string, ArrayItemFieldDefinition>;
+export type ArrayItemDefinition = ArrayItemFieldDefinition | ArrayItemSchema;
+export type ArrayItemValue<T extends ArrayItemDefinition> = T extends NumberFieldDefinition ? number : T extends BooleanFieldDefinition ? boolean : T extends UrlFieldDefinition ? UrlValue : T extends CheckboxGroupFieldDefinition<infer Value> ? Value[] : T extends ArrayItemFieldDefinition ? string : T extends ArrayItemSchema ? {
+    [K in keyof T]: ArrayItemValue<T[K]>;
+} : never;
+export interface ArrayFieldOptions<T extends ArrayItemDefinition> extends DefaultFieldOptions<Array<ArrayItemValue<T>>> {
+    of: T;
+    minItems?: number;
+    maxItems?: number;
+    addLabel?: string;
+    itemLabel?: string;
+    showCounter?: boolean;
+}
+export interface ArrayFieldDefinition<T extends ArrayItemDefinition = ArrayItemDefinition> {
+    type: 'array';
+    options: ArrayFieldOptions<T>;
+}
+export type SectionItemFieldDefinition = ArrayItemFieldDefinition | ArrayFieldDefinition;
+export type SectionSchema = Record<string, SectionItemFieldDefinition>;
+export type SectionItemValue<T extends SectionItemFieldDefinition> = T extends ArrayFieldDefinition<infer Item> ? Array<ArrayItemValue<Item>> : T extends ArrayItemFieldDefinition ? ArrayItemValue<T> : never;
+export type SectionValue<T extends SectionSchema> = {
+    [K in keyof T]: SectionItemValue<T[K]>;
+};
+export interface SectionFieldOptions<T extends SectionSchema> extends DefaultFieldOptions<SectionValue<T>> {
+    fields: T;
+}
+export interface SectionFieldDefinition<T extends SectionSchema = SectionSchema> {
+    type: 'section';
+    options: SectionFieldOptions<T>;
+}
+export interface TabDefinition<T extends SectionSchema = SectionSchema> {
+    label?: string;
+    fields: T;
+}
+export type TabsSchema = Record<string, TabDefinition>;
+export type TabsValue<T extends TabsSchema> = {
+    [K in keyof T]: SectionValue<T[K]['fields']>;
+};
+export interface TabFieldOptions<T extends TabsSchema> extends DefaultFieldOptions<TabsValue<T>> {
+    tabs: T;
+}
+export interface TabFieldDefinition<T extends TabsSchema = TabsSchema> {
+    type: 'tabs';
+    options: TabFieldOptions<T>;
+}
+export type FieldDefinition = SectionItemFieldDefinition | SectionFieldDefinition | TabFieldDefinition;

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

@@ -0,0 +1,3 @@
+export * from './auth.js';
+export * from './eponyme.js';
+export * from './field.js';

package/dist/runtime/types/index.js

@@ -0,0 +1,3 @@
+export * from "./auth.js";
+export * from "./eponyme.js";
+export * from "./field.js";

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

@@ -0,0 +1,11 @@
+import type { ModuleOptions } from '../../module'
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig {
+    eponyme?: ModuleOptions
+  }
+
+  interface NuxtOptions {
+    eponyme: ModuleOptions
+  }
+}

package/dist/runtime/utils/as-record.d.ts

@@ -0,0 +1 @@
+export declare function asRecord(value: unknown): Record<string, unknown>;

package/dist/runtime/utils/as-record.js

@@ -0,0 +1,3 @@
+export function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}

package/dist/runtime/utils/build-eponyme-schema.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { EponymeSchema } from '../types/index.js';
+import { type ValidationErrors, type ValidationMode } from './validate-eponyme-data.js';
+/**
+ * Exposes the Eponyme rules as a standard zod schema, so the same validation runs
+ * server-side on write and client-side on every keystroke.
+ *
+ * The rules themselves stay in `validate-eponyme-data.ts`: they carry mode-dependent
+ * semantics (`required` and lower bounds only apply when publishing) and cross-field
+ * context (`visibleWhen`, custom `validate`) that static zod checks cannot express.
+ * This wrapper turns the resulting path-keyed errors into zod issues, which is what
+ * gives consumers `issue.path` and a familiar `safeParse` API.
+ */
+export type EponymeZodSchema = z.ZodType<Record<string, unknown>>;
+/** Cached per (schema, mode) pair: the client rebuilds nothing while typing. */
+export declare function buildEponymeSchema(schema: EponymeSchema, mode?: ValidationMode): EponymeZodSchema;
+/** Same shape as a patch validation, for validating a partial payload. */
+export declare function buildEponymePatchSchema(schema: EponymeSchema, mode?: ValidationMode): EponymeZodSchema;
+/** Turns a zod error back into the `{ path: messages }` shape the API and the editor use. */
+export declare function zodErrorToValidationErrors(error: z.ZodError): ValidationErrors;
+/** Convenience wrapper: parse and get errors keyed by field path. */
+export declare function validateWithSchema(schema: EponymeSchema, data: unknown, mode?: ValidationMode): ValidationErrors;

package/dist/runtime/utils/build-eponyme-schema.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { validateEponymeData, validateEponymePatch } from "./validate-eponyme-data.js";
+const cache = /* @__PURE__ */ new WeakMap();
+function toIssuePath(path) {
+  return path === "_form" ? [] : path.split(".").map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+}
+function addErrorsToContext(errors, ctx) {
+  for (const [path, messages] of Object.entries(errors)) {
+    for (const message of messages)
+      ctx.addIssue({ code: "custom", message, path: toIssuePath(path) });
+  }
+}
+function createSchema(schema, mode) {
+  return z.custom((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value), {
+    message: "Body must be an object."
+  }).superRefine((value, ctx) => addErrorsToContext(validateEponymeData(schema, value, mode), ctx));
+}
+export function buildEponymeSchema(schema, mode = "publish") {
+  const modes = cache.get(schema) ?? {};
+  if (!modes[mode]) {
+    modes[mode] = createSchema(schema, mode);
+    cache.set(schema, modes);
+  }
+  return modes[mode];
+}
+export function buildEponymePatchSchema(schema, mode = "publish") {
+  return z.custom((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value), {
+    message: "Body must be an object."
+  }).superRefine((value, ctx) => addErrorsToContext(validateEponymePatch(schema, value, value, mode), ctx));
+}
+export function zodErrorToValidationErrors(error) {
+  const errors = /* @__PURE__ */ Object.create(null);
+  for (const issue of error.issues) {
+    const path = issue.path.length ? issue.path.join(".") : "_form";
+    (errors[path] ??= []).push(issue.message);
+  }
+  return errors;
+}
+export function validateWithSchema(schema, data, mode = "publish") {
+  const result = buildEponymeSchema(schema, mode).safeParse(data);
+  return result.success ? /* @__PURE__ */ Object.create(null) : zodErrorToValidationErrors(result.error);
+}

package/dist/runtime/utils/changed-paths.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Dotted paths of every leaf that differs between two documents — `hero.title`,
+ * `items.0.title`. Used to tell which fields the user actually edited, so inline
+ * validation only flags those.
+ */
+export declare function changedPaths(next: unknown, previous: unknown, prefix?: string): string[];

package/dist/runtime/utils/changed-paths.js

@@ -0,0 +1,25 @@
+export function changedPaths(next, previous, prefix = "") {
+  if (next === previous) return [];
+  const nextRecord = isRecord(next) ? next : void 0;
+  const previousRecord = isRecord(previous) ? previous : void 0;
+  if (nextRecord && (previousRecord || previous === void 0) || previousRecord && next === void 0) {
+    const left = nextRecord ?? {};
+    const right = previousRecord ?? {};
+    return [.../* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])].flatMap((key) => changedPaths(left[key], right[key], join(prefix, key)));
+  }
+  const nextArray = Array.isArray(next) ? next : void 0;
+  const previousArray = Array.isArray(previous) ? previous : void 0;
+  if (nextArray && (previousArray || previous === void 0) || previousArray && next === void 0) {
+    const left = nextArray ?? [];
+    const right = previousArray ?? [];
+    const length = Math.max(left.length, right.length);
+    return Array.from({ length }, (_, index) => index).flatMap((index) => changedPaths(left[index], right[index], join(prefix, String(index))));
+  }
+  return JSON.stringify(next) === JSON.stringify(previous) ? [] : [prefix];
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function join(prefix, key) {
+  return prefix ? `${prefix}.${key}` : key;
+}

package/dist/runtime/utils/create-default-eponyme-data.d.ts

@@ -0,0 +1,5 @@
+import type { EponymeConfig, EponymeData, EponymeSchema } from '../types/index.js';
+export declare function createDefaultEponymeData<T extends EponymeSchema>(schema: T): EponymeData<T>;
+export declare function createDefaultEponymeDataByConfig<T extends EponymeConfig>(config: T): {
+    [k: string]: EponymeData<EponymeSchema>;
+};

package/dist/runtime/utils/create-default-eponyme-data.js

@@ -0,0 +1,12 @@
+import { getFieldDefaultValue } from "./get-field-default-value.js";
+import { getEponymeSchemas } from "./get-eponyme-schemas.js";
+export function createDefaultEponymeData(schema) {
+  return Object.fromEntries(
+    Object.entries(schema).map(([name, definition]) => [name, getFieldDefaultValue(definition)])
+  );
+}
+export function createDefaultEponymeDataByConfig(config) {
+  return Object.fromEntries(
+    Object.entries(getEponymeSchemas(config)).map(([name, schema]) => [name, createDefaultEponymeData(schema)])
+  );
+}

package/dist/runtime/utils/field-path.d.ts

@@ -0,0 +1,14 @@
+import type { ValidationErrors } from './validate-eponyme-data.js';
+/** `hero` + `title` -> `hero.title`; array items use their index as a segment. */
+export declare function joinFieldPath(prefix: string, segment: string | number): string;
+/** Stable DOM id for a field path, usable in `for`/`aria-*` attributes. */
+export declare function fieldPathId(path: string): string;
+/** Messages recorded for this exact path. */
+export declare function errorsAt(errors: ValidationErrors | undefined, path: string): string[];
+/**
+ * Errors of everything nested under `path`, re-keyed relative to it, so a container can
+ * hand its children exactly what concerns them without knowing its own depth.
+ */
+export declare function childErrors(errors: ValidationErrors | undefined, path: string): ValidationErrors;
+/** True when this path, or anything under it, has at least one message. */
+export declare function hasErrorsUnder(errors: ValidationErrors | undefined, path: string): boolean;

package/dist/runtime/utils/field-path.js

@@ -0,0 +1,23 @@
+export function joinFieldPath(prefix, segment) {
+  return prefix ? `${prefix}.${segment}` : String(segment);
+}
+export function fieldPathId(path) {
+  return `field-${path.replace(/\./g, "-")}`;
+}
+export function errorsAt(errors, path) {
+  return errors?.[path] ?? [];
+}
+export function childErrors(errors, path) {
+  if (!errors) return {};
+  const prefix = `${path}.`;
+  const nested = {};
+  for (const [key, messages] of Object.entries(errors)) {
+    if (key.startsWith(prefix)) nested[key.slice(prefix.length)] = messages;
+  }
+  return nested;
+}
+export function hasErrorsUnder(errors, path) {
+  if (!errors) return false;
+  const prefix = `${path}.`;
+  return Object.keys(errors).some((key) => key === path || key.startsWith(prefix));
+}

package/dist/runtime/utils/get-eponyme-schemas.d.ts

@@ -0,0 +1,7 @@
+import type { EponymeCollectionDefinitionBase, EponymeConfig, EponymeFormDefinitionBase, EponymeSchema } from '../types/index.js';
+export declare function isEponymeCollection(value: unknown): value is EponymeCollectionDefinitionBase;
+export declare function isEponymeForm(value: unknown): value is EponymeFormDefinitionBase;
+export declare function isEponymeSchema(value: EponymeSchema | EponymeCollectionDefinitionBase | EponymeFormDefinitionBase | EponymeConfig): value is EponymeSchema;
+export declare function getEponymeSchemas(config: EponymeConfig, prefix?: string): Record<string, EponymeSchema>;
+export declare function getEponymeCollections(config: EponymeConfig, prefix?: string): Record<string, EponymeCollectionDefinitionBase>;
+export declare function getEponymeForms(config: EponymeConfig, prefix?: string): Record<string, EponymeFormDefinitionBase>;

package/dist/runtime/utils/get-eponyme-schemas.js

@@ -0,0 +1,33 @@
+export function isEponymeCollection(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && value.__eponymeCollection === true);
+}
+export function isEponymeForm(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && value.__eponymeForm === true);
+}
+export function isEponymeSchema(value) {
+  if (isEponymeCollection(value) || isEponymeForm(value)) return false;
+  return Object.values(value).every((field) => typeof field === "object" && field !== null && "type" in field && typeof field.type === "string");
+}
+export function getEponymeSchemas(config, prefix = "") {
+  return Object.fromEntries(Object.entries(config).flatMap(([name, value]) => {
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (isEponymeCollection(value) || isEponymeForm(value)) return [];
+    return isEponymeSchema(value) ? [[path, value]] : Object.entries(getEponymeSchemas(value, path));
+  }));
+}
+export function getEponymeCollections(config, prefix = "") {
+  return Object.fromEntries(Object.entries(config).flatMap(([name, value]) => {
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (isEponymeCollection(value)) return [[path, value]];
+    if (isEponymeForm(value)) return [];
+    return isEponymeSchema(value) ? [] : Object.entries(getEponymeCollections(value, path));
+  }));
+}
+export function getEponymeForms(config, prefix = "") {
+  return Object.fromEntries(Object.entries(config).flatMap(([name, value]) => {
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (isEponymeForm(value)) return [[path, value]];
+    if (isEponymeCollection(value)) return [];
+    return isEponymeSchema(value) ? [] : Object.entries(getEponymeForms(value, path));
+  }));
+}

package/dist/runtime/utils/get-field-default-value.d.ts

@@ -0,0 +1,4 @@
+import type { ArrayItemDefinition, ArrayItemFieldDefinition, FieldDefinition } from '../types/field.js';
+export declare function isArrayItemFieldDefinition(definition: ArrayItemDefinition): definition is ArrayItemFieldDefinition;
+export declare function getArrayItemDefaultValue(definition: ArrayItemDefinition): unknown;
+export declare function getFieldDefaultValue(definition: FieldDefinition): unknown;

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

@@ -0,0 +1,56 @@
+export function isArrayItemFieldDefinition(definition) {
+  return "type" in definition;
+}
+export function getArrayItemDefaultValue(definition) {
+  if (isArrayItemFieldDefinition(definition)) return getFieldDefaultValue(definition);
+  return Object.fromEntries(
+    Object.entries(definition).map(([name, field]) => [name, getFieldDefaultValue(field)])
+  );
+}
+export function getFieldDefaultValue(definition) {
+  if (definition.type === "date" && isTodayDateDefault(definition.options.defaultValue))
+    return getLocalToday();
+  if (definition.options.defaultValue !== void 0)
+    return cloneDefaultValue(definition.options.defaultValue);
+  switch (definition.type) {
+    case "array":
+      return [];
+    case "checkboxGroup":
+      return [];
+    case "section":
+      return Object.fromEntries(
+        Object.entries(definition.options.fields).map(([name, field]) => [name, getFieldDefaultValue(field)])
+      );
+    case "tabs":
+      return Object.fromEntries(
+        Object.entries(definition.options.tabs).map(([tabName, tab]) => [
+          tabName,
+          Object.fromEntries(Object.entries(tab.fields).map(([name, field]) => [name, getFieldDefaultValue(field)]))
+        ])
+      );
+    case "number":
+      return 0;
+    case "url":
+      return { href: "", type: "external", openInNewTab: false };
+    case "boolean":
+      return false;
+    default:
+      return "";
+  }
+}
+function isTodayDateDefault(value) {
+  return Boolean(value && typeof value === "object" && "__eponymeDefault" in value && value.__eponymeDefault === "today");
+}
+function getLocalToday() {
+  const date = /* @__PURE__ */ new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function cloneDefaultValue(value) {
+  if (Array.isArray(value)) return value.map(cloneDefaultValue);
+  if (value && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneDefaultValue(item)]));
+  return value;
+}

package/dist/runtime/utils/humanize-label.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns a field name into a human label: `launch_date` -> `Launch Date`.
+ * Shared by every layer so what the editor shows and what error messages refer to
+ * can never drift apart.
+ */
+export declare function humanizeLabel(name: string, configured?: string): string;

package/dist/runtime/utils/humanize-label.js

@@ -0,0 +1,3 @@
+export function humanizeLabel(name, configured) {
+  return configured || name.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}

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

@@ -0,0 +1 @@
+export declare function initials(value: string): string;

package/dist/runtime/utils/initials.js

@@ -0,0 +1,3 @@
+export function initials(value) {
+  return value.slice(0, 2).toUpperCase();
+}

package/dist/runtime/utils/is-field-visible.d.ts

@@ -0,0 +1,2 @@
+import type { DefaultFieldOptions } from '../types/index.js';
+export declare function isFieldVisible(options: Pick<DefaultFieldOptions<unknown>, 'visibleWhen'>, data: Record<string, unknown>): boolean;

package/dist/runtime/utils/is-field-visible.js

@@ -0,0 +1,14 @@
+function getValue(data, path) {
+  return path.split(".").reduce((value, segment) => {
+    return value && typeof value === "object" && !Array.isArray(value) ? value[segment] : void 0;
+  }, data);
+}
+function matches(condition, data) {
+  const value = getValue(data, condition.field);
+  return "equals" in condition ? value === condition.equals : value !== condition.notEquals;
+}
+export function isFieldVisible(options, data) {
+  if (!options.visibleWhen) return true;
+  const conditions = Array.isArray(options.visibleWhen) ? options.visibleWhen : [options.visibleWhen];
+  return conditions.every((condition) => matches(condition, data));
+}

package/dist/runtime/utils/normalize-hex-color.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Canonical lowercase 6-digit form of a hex colour, or `undefined` when the value is not one.
+ * Comparing swatches needs it: a stored `#FFF` and a preset `#ffffff` are the same colour.
+ * Alpha (`#rrggbbaa`) is preserved, since the validator accepts it.
+ */
+export declare function normalizeHexColor(value: unknown): string | undefined;
+/** True when both values denote the same colour, whatever their notation. */
+export declare function sameHexColor(left: unknown, right: unknown): boolean;

package/dist/runtime/utils/normalize-hex-color.js

@@ -0,0 +1,11 @@
+export function normalizeHexColor(value) {
+  if (typeof value !== "string") return void 0;
+  const hex = value.trim().toLowerCase();
+  if (/^#[\da-f]{3}$/.test(hex)) return `#${[...hex.slice(1)].map((char) => char + char).join("")}`;
+  if (/^#(?:[\da-f]{6}|[\da-f]{8})$/.test(hex)) return hex;
+  return void 0;
+}
+export function sameHexColor(left, right) {
+  const normalizedLeft = normalizeHexColor(left);
+  return normalizedLeft !== void 0 && normalizedLeft === normalizeHexColor(right);
+}

package/dist/runtime/utils/normalize-slug.d.ts

@@ -0,0 +1 @@
+export declare function normalizeSlug(value: string): string;

package/dist/runtime/utils/normalize-slug.js

@@ -0,0 +1,4 @@
+import slugify from "slugify";
+export function normalizeSlug(value) {
+  return slugify(value, { lower: true, strict: true, trim: true });
+}

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

@@ -0,0 +1,30 @@
+/** Mirrors `EponymeVersionSelector`, redeclared so this stays free of server imports. */
+type PreviewVersion = 'draft' | 'published' | number;
+/**
+ * Single source of truth for `previewPaths` semantics, shared by the dashboard
+ * preview panel and the server-side sitemap builder so both resolve an entry to
+ * the exact same public URL.
+ */
+/** The slug is URL-encoded. */
+export declare function applyPreviewSlug(path: string, slug: string): string;
+/**
+ * Splits `<collection>/<slug>` against the configured collection names.
+ * Collection entries are one level deep, so a slug containing `/` never matches.
+ */
+export declare function splitCollectionEntry(collectionNames: string[], name: string): {
+    collection: string;
+    slug: string;
+} | undefined;
+/**
+ * An exact key (a singleton) returns its path unchanged; `<collection>/<slug>`
+ * returns `previewPaths[collection]` with `:slug` filled in.
+ */
+export declare function resolvePreviewPath(previewPaths: Record<string, string>, collectionNames: string[], name: string): string | undefined;
+/** Reads `?__eponyme_preview_version=` — `draft` by default, or a numeric history id. */
+export declare function readPreviewVersion(raw: unknown): PreviewVersion;
+/** Reads the preview query params, unwrapping the repeated-param array form. */
+export declare function readPreviewQuery(query: Record<string, unknown>): {
+    entry: string | undefined;
+    version: unknown;
+};
+export {};

package/dist/runtime/utils/preview.js

@@ -0,0 +1,30 @@
+export function applyPreviewSlug(path, slug) {
+  return path.replace(/:slug\b/g, encodeURIComponent(slug));
+}
+export function splitCollectionEntry(collectionNames, name) {
+  for (const collection of collectionNames) {
+    const prefix = `${collection}/`;
+    if (!name.startsWith(prefix)) continue;
+    const slug = name.slice(prefix.length);
+    if (slug && !slug.includes("/")) return { collection, slug };
+  }
+}
+export function resolvePreviewPath(previewPaths, collectionNames, name) {
+  const exact = previewPaths[name];
+  if (exact) return exact;
+  const entry = splitCollectionEntry(collectionNames, name);
+  if (!entry) return void 0;
+  const pattern = previewPaths[entry.collection];
+  if (!pattern || !pattern.includes(":slug")) return void 0;
+  return applyPreviewSlug(pattern, entry.slug);
+}
+export function readPreviewVersion(raw) {
+  if (raw === "published") return "published";
+  const id = Number(raw);
+  return Number.isSafeInteger(id) && id > 0 ? id : "draft";
+}
+export function readPreviewQuery(query) {
+  const entry = Array.isArray(query.__eponyme_preview) ? query.__eponyme_preview[0] : query.__eponyme_preview;
+  const version = Array.isArray(query.__eponyme_preview_version) ? query.__eponyme_preview_version[0] : query.__eponyme_preview_version;
+  return { entry: entry === void 0 || entry === null ? void 0 : String(entry), version };
+}

package/dist/runtime/utils/validate-eponyme-data.d.ts

@@ -0,0 +1,10 @@
+import type { EponymeSchema } from '../types/index.js';
+/**
+ * Errors are keyed by the path of the field they belong to — `title`, `hero.title`,
+ * `items.0.title` — so the editor can show each message on the field that produced it.
+ * `_form` carries errors about the payload as a whole.
+ */
+export type ValidationErrors = Record<string, string[]>;
+export type ValidationMode = 'draft' | 'publish';
+export declare function validateEponymePatch(schema: EponymeSchema, payload: unknown, data?: Record<string, unknown>, mode?: ValidationMode): ValidationErrors;
+export declare function validateEponymeData(schema: EponymeSchema, data: Record<string, unknown>, mode?: ValidationMode): ValidationErrors;