@karibsen/eponyme 0.1.0

package/dist/runtime/composables/useEponymeConfig.js

@@ -0,0 +1,4 @@
+import eponymeConfig from "#eponyme/config";
+export function useEponymeConfig() {
+  return eponymeConfig;
+}

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

@@ -0,0 +1,35 @@
+import type { ComputedRef, Ref } from 'vue';
+import type eponymeConfig from '#eponyme/config';
+import type { EponymeFormDataByName, EponymeFormFieldDefinition, EponymeFormName } from '../types/index.js';
+import type { ValidationErrors } from '../utils/validate-eponyme-data.js';
+type ConfigFormName = EponymeFormName<typeof eponymeConfig>;
+export interface UseEponymeFormField {
+    name: string;
+    definition: EponymeFormFieldDefinition;
+    label: string;
+    required: boolean;
+    value: unknown;
+    errors: string[];
+    update: (value: unknown) => void;
+}
+export interface UseEponymeFormOptions<Data extends Record<string, unknown>> {
+    /** Required for a `custom` form: receives the validated data. */
+    onSubmit?: (data: Data) => unknown | Promise<unknown>;
+}
+export interface UseEponymeFormResult<Data extends Record<string, unknown>> {
+    fields: ComputedRef<UseEponymeFormField[]>;
+    values: Ref<Data>;
+    errors: ComputedRef<ValidationErrors>;
+    pending: Ref<boolean>;
+    submitted: Ref<boolean>;
+    /** Name of the trap field to render hidden, or `false` when disabled. */
+    honeypot: string | false;
+    submit: () => Promise<boolean>;
+    reset: () => void;
+}
+/**
+ * Renders nothing: the host application owns the markup, so a public page never
+ * inherits the dashboard's styling or its editor dependencies.
+ */
+export declare function useEponymeForm<const Name extends ConfigFormName>(name: Name, options?: UseEponymeFormOptions<EponymeFormDataByName<typeof eponymeConfig, Name>>): UseEponymeFormResult<EponymeFormDataByName<typeof eponymeConfig, Name>>;
+export {};

package/dist/runtime/composables/useEponymeForm.js

@@ -0,0 +1,75 @@
+import { useRequestFetch } from "#app";
+import { computed, ref } from "vue";
+import { createDefaultEponymeData } from "../utils/create-default-eponyme-data.js";
+import { getEponymeForms } from "../utils/get-eponyme-schemas.js";
+import { humanizeLabel } from "../utils/humanize-label.js";
+import { useEponymeConfig } from "./useEponymeConfig.js";
+import { useEponymeValidation } from "./useEponymeValidation.js";
+function resolveForm(name) {
+  const definition = getEponymeForms(useEponymeConfig())[name];
+  if (!definition) throw new Error(`[Eponyme] Unknown form "${name}". Declare it with form() in eponyme.config.ts.`);
+  return definition;
+}
+export function useEponymeForm(name, options = {}) {
+  const definition = resolveForm(name);
+  const requestFetch = useRequestFetch();
+  const serverErrors = ref({});
+  const pending = ref(false);
+  const submitted = ref(false);
+  const values = ref(createDefaultEponymeData(definition.fields));
+  const validation = useEponymeValidation(definition.fields, values, ref({}), { serverErrors });
+  const fields = computed(() => Object.entries(definition.fields).map(([fieldName, fieldDefinition]) => ({
+    name: fieldName,
+    definition: fieldDefinition,
+    label: humanizeLabel(fieldName, fieldDefinition.options.label),
+    required: Boolean(fieldDefinition.options.required),
+    value: values.value[fieldName],
+    errors: validation.errors.value[fieldName] ?? [],
+    update: (value) => {
+      values.value = { ...values.value, [fieldName]: value };
+    }
+  })));
+  function reset() {
+    values.value = createDefaultEponymeData(definition.fields);
+    serverErrors.value = {};
+    submitted.value = false;
+    validation.reset();
+  }
+  async function submit() {
+    serverErrors.value = {};
+    if (!validation.validateForPublish()) return false;
+    pending.value = true;
+    try {
+      if (definition.submission.mode === "custom") {
+        if (!options.onSubmit)
+          throw new Error(`[Eponyme] Form "${name}" uses the custom submission mode and needs an onSubmit handler. Switch it to submission: { mode: 'managed' } to let Eponyme store it instead.`);
+        await options.onSubmit(values.value);
+      } 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 });
+      }
+      submitted.value = true;
+      return true;
+    } catch (error) {
+      const fetchError = error;
+      if (fetchError.statusCode === 422) {
+        serverErrors.value = fetchError.data?.errors ?? {};
+        return false;
+      }
+      throw error;
+    } finally {
+      pending.value = false;
+    }
+  }
+  return {
+    fields,
+    values,
+    errors: validation.errors,
+    pending,
+    submitted,
+    honeypot: definition.honeypot,
+    submit,
+    reset
+  };
+}

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

@@ -0,0 +1,26 @@
+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";
+        status: import("../server/services/eponyme-store.js").EponymeStatus;
+        createdAt: string;
+        user: {
+            id: string;
+            username: string;
+        } | null;
+    }[], EponymeHistoryEntry[] | {
+        id: number;
+        action: import("../server/services/eponyme-store.js").EponymeAction | "restore";
+        status: import("../server/services/eponyme-store.js").EponymeStatus;
+        createdAt: string;
+        user: {
+            id: string;
+            username: string;
+        } | null;
+    }[]>;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<string, string>;
+    load: () => Promise<void>;
+};
+export declare function formatVersionDate(value: string): string;

package/dist/runtime/composables/useEponymeHistory.js

@@ -0,0 +1,24 @@
+import { useRequestFetch } from "#app";
+import { ref } from "vue";
+export function useEponymeHistory(name) {
+  const requestFetch = useRequestFetch();
+  const history = ref([]);
+  const pending = ref(false);
+  const error = ref("");
+  async function load() {
+    pending.value = true;
+    error.value = "";
+    try {
+      const response = await requestFetch(`/api/eponyme-history/${name()}`);
+      history.value = response.history;
+    } catch {
+      error.value = "Unable to load version history.";
+    } finally {
+      pending.value = false;
+    }
+  }
+  return { history, pending, error, load };
+}
+export function formatVersionDate(value) {
+  return new Intl.DateTimeFormat(void 0, { dateStyle: "medium", timeStyle: "short" }).format(new Date(value));
+}

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

@@ -0,0 +1,21 @@
+import type { Ref } from 'vue';
+import type { EponymeSchema } from '../types/index.js';
+import type { ValidationErrors, ValidationMode } from '../utils/validate-eponyme-data.js';
+export interface UseEponymeValidationOptions {
+    /** Errors reported by the server, always shown regardless of what the user touched. */
+    serverErrors?: Ref<ValidationErrors>;
+}
+/**
+ * Validates the edited document while the user types, using the same schema the server
+ * enforces on write. Only the fields the user actually changed are flagged, so opening an
+ * entry with incomplete content does not paint it red — until a publish attempt fails, at
+ * which point everything is revealed.
+ */
+export declare function useEponymeValidation(schema: EponymeSchema, data: Ref<Record<string, unknown>>, savedData: Ref<Record<string, unknown>>, options?: UseEponymeValidationOptions): {
+    errors: import("vue").ComputedRef<ValidationErrors>;
+    touched: import("vue").ComputedRef<Set<string>>;
+    showAll: Ref<boolean, boolean>;
+    validateNow: (mode?: ValidationMode) => ValidationErrors;
+    validateForPublish: () => boolean;
+    reset: () => void;
+};

package/dist/runtime/composables/useEponymeValidation.js

@@ -0,0 +1,34 @@
+import { computed, ref, watch } from "vue";
+import { useDebounceFn } from "@vueuse/core";
+import { buildEponymeSchema, zodErrorToValidationErrors } from "../utils/build-eponyme-schema.js";
+import { changedPaths } from "../utils/changed-paths.js";
+const DEBOUNCE_MS = 300;
+export function useEponymeValidation(schema, data, savedData, options = {}) {
+  const liveErrors = ref({});
+  const showAll = ref(false);
+  function validateNow(mode = "draft") {
+    const result = buildEponymeSchema(schema, mode).safeParse(data.value);
+    liveErrors.value = result.success ? {} : zodErrorToValidationErrors(result.error);
+    return liveErrors.value;
+  }
+  const validateDebounced = useDebounceFn(() => validateNow("draft"), DEBOUNCE_MS);
+  watch(data, () => void validateDebounced(), { deep: true });
+  const touched = computed(() => new Set(changedPaths(data.value, savedData.value)));
+  const errors = computed(() => {
+    const merged = { ...options.serverErrors?.value };
+    for (const [path, messages] of Object.entries(liveErrors.value)) {
+      if (!showAll.value && !touched.value.has(path)) continue;
+      merged[path] = [.../* @__PURE__ */ new Set([...merged[path] ?? [], ...messages])];
+    }
+    return merged;
+  });
+  function validateForPublish() {
+    showAll.value = true;
+    return Object.keys(validateNow("publish")).length === 0;
+  }
+  function reset() {
+    showAll.value = false;
+    liveErrors.value = {};
+  }
+  return { errors, touched, showAll, validateNow, validateForPublish, reset };
+}

package/dist/runtime/fields/array.d.ts

@@ -0,0 +1,2 @@
+import type { ArrayFieldDefinition, ArrayFieldOptions, ArrayItemDefinition } from '../types/field.js';
+export declare function array<const T extends ArrayItemDefinition>(options: ArrayFieldOptions<T>): ArrayFieldDefinition<T>;

package/dist/runtime/fields/array.js

@@ -0,0 +1,3 @@
+export function array(options) {
+  return { type: "array", options };
+}

package/dist/runtime/fields/boolean.d.ts

@@ -0,0 +1,2 @@
+import type { BooleanFieldDefinition, BooleanFieldOptions } from '../types/field.js';
+export declare function boolean(options?: BooleanFieldOptions): BooleanFieldDefinition;

package/dist/runtime/fields/boolean.js

@@ -0,0 +1,3 @@
+export function boolean(options = {}) {
+  return { type: "boolean", options };
+}

package/dist/runtime/fields/checkbox-group.d.ts

@@ -0,0 +1,2 @@
+import type { CheckboxGroupFieldDefinition, CheckboxGroupFieldOptions } from '../types/field.js';
+export declare function checkboxGroup<const T extends string>(options: CheckboxGroupFieldOptions<T>): CheckboxGroupFieldDefinition<T>;

package/dist/runtime/fields/checkbox-group.js

@@ -0,0 +1,3 @@
+export function checkboxGroup(options) {
+  return { type: "checkboxGroup", options };
+}

package/dist/runtime/fields/color.d.ts

@@ -0,0 +1,2 @@
+import type { ColorFieldDefinition, ColorFieldOptions } from '../types/field.js';
+export declare function color(options?: ColorFieldOptions): ColorFieldDefinition;

package/dist/runtime/fields/color.js

@@ -0,0 +1,3 @@
+export function color(options = {}) {
+  return { type: "color", options };
+}

package/dist/runtime/fields/date.d.ts

@@ -0,0 +1,3 @@
+import type { DateFieldDefinition, DateFieldOptions, TodayDateDefault } from '../types/field.js';
+export declare function today(): TodayDateDefault;
+export declare function date(options?: DateFieldOptions): DateFieldDefinition;

package/dist/runtime/fields/date.js

@@ -0,0 +1,6 @@
+export function today() {
+  return { __eponymeDefault: "today" };
+}
+export function date(options = {}) {
+  return { type: "date", options };
+}

package/dist/runtime/fields/email.d.ts

@@ -0,0 +1,2 @@
+import type { EmailFieldDefinition, EmailFieldOptions } from '../types/field.js';
+export declare function email(options?: EmailFieldOptions): EmailFieldDefinition;

package/dist/runtime/fields/email.js

@@ -0,0 +1,3 @@
+export function email(options = {}) {
+  return { type: "email", options };
+}

package/dist/runtime/fields/image.d.ts

@@ -0,0 +1,2 @@
+import type { ImageFieldDefinition, ImageFieldOptions } from '../types/field.js';
+export declare function image(options?: ImageFieldOptions): ImageFieldDefinition;

package/dist/runtime/fields/image.js

@@ -0,0 +1,3 @@
+export function image(options = {}) {
+  return { type: "image", options };
+}

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

@@ -0,0 +1,37 @@
+import { array } from './array.js';
+import { boolean } from './boolean.js';
+import { checkboxGroup } from './checkbox-group.js';
+import { color } from './color.js';
+import { date, today } from './date.js';
+import { email } from './email.js';
+import { image } from './image.js';
+import { number } from './number.js';
+import { radio } from './radio.js';
+import { richText } from './rich-text.js';
+import { section } from './section.js';
+import { select } from './select.js';
+import { slug } from './slug.js';
+import { string } from './string.js';
+import { tab } from './tab.js';
+import { textarea } from './textarea.js';
+import { url } from './url.js';
+export declare const field: {
+    string: typeof string;
+    slug: typeof slug;
+    email: typeof email;
+    url: typeof url;
+    textarea: typeof textarea;
+    richText: typeof richText;
+    number: typeof number;
+    boolean: typeof boolean;
+    image: typeof image;
+    select: typeof select;
+    radio: typeof radio;
+    checkboxGroup: typeof checkboxGroup;
+    date: typeof date;
+    color: typeof color;
+    array: typeof array;
+    section: typeof section;
+    tab: typeof tab;
+};
+export { today };

package/dist/runtime/fields/index.js

@@ -0,0 +1,19 @@
+import { array } from "./array.js";
+import { boolean } from "./boolean.js";
+import { checkboxGroup } from "./checkbox-group.js";
+import { color } from "./color.js";
+import { date, today } from "./date.js";
+import { email } from "./email.js";
+import { image } from "./image.js";
+import { number } from "./number.js";
+import { radio } from "./radio.js";
+import { richText } from "./rich-text.js";
+import { section } from "./section.js";
+import { select } from "./select.js";
+import { slug } from "./slug.js";
+import { string } from "./string.js";
+import { tab } from "./tab.js";
+import { textarea } from "./textarea.js";
+import { url } from "./url.js";
+export const field = { string, slug, email, url, textarea, richText, number, boolean, image, select, radio, checkboxGroup, date, color, array, section, tab };
+export { today };

package/dist/runtime/fields/number.d.ts

@@ -0,0 +1,2 @@
+import type { NumberFieldDefinition, NumberFieldOptions } from '../types/field.js';
+export declare function number(options?: NumberFieldOptions): NumberFieldDefinition;

package/dist/runtime/fields/number.js

@@ -0,0 +1,3 @@
+export function number(options = {}) {
+  return { type: "number", options };
+}

package/dist/runtime/fields/radio.d.ts

@@ -0,0 +1,2 @@
+import type { RadioFieldDefinition, RadioFieldOptions } from '../types/field.js';
+export declare function radio<const T extends string>(options: RadioFieldOptions<T>): RadioFieldDefinition<T>;

package/dist/runtime/fields/radio.js

@@ -0,0 +1,3 @@
+export function radio(options) {
+  return { type: "radio", options };
+}

package/dist/runtime/fields/rich-text.d.ts

@@ -0,0 +1,2 @@
+import type { RichTextFieldDefinition, RichTextFieldOptions } from '../types/field.js';
+export declare function richText(options?: RichTextFieldOptions): RichTextFieldDefinition;

package/dist/runtime/fields/rich-text.js

@@ -0,0 +1,3 @@
+export function richText(options = {}) {
+  return { type: "richText", options };
+}

package/dist/runtime/fields/section.d.ts

@@ -0,0 +1,2 @@
+import type { SectionFieldDefinition, SectionFieldOptions, SectionSchema } from '../types/field.js';
+export declare function section<const T extends SectionSchema>(options: SectionFieldOptions<T>): SectionFieldDefinition<T>;

package/dist/runtime/fields/section.js

@@ -0,0 +1,3 @@
+export function section(options) {
+  return { type: "section", options };
+}

package/dist/runtime/fields/select.d.ts

@@ -0,0 +1,2 @@
+import type { SelectFieldDefinition, SelectFieldOptions } from '../types/field.js';
+export declare function select<const T extends string>(options: SelectFieldOptions<T>): SelectFieldDefinition<T>;

package/dist/runtime/fields/select.js

@@ -0,0 +1,3 @@
+export function select(options) {
+  return { type: "select", options };
+}

package/dist/runtime/fields/slug.d.ts

@@ -0,0 +1,2 @@
+import type { SlugFieldDefinition, SlugFieldOptions } from '../types/field.js';
+export declare function slug(options?: SlugFieldOptions): SlugFieldDefinition;

package/dist/runtime/fields/slug.js

@@ -0,0 +1,3 @@
+export function slug(options = {}) {
+  return { type: "slug", options };
+}

package/dist/runtime/fields/string.d.ts

@@ -0,0 +1,2 @@
+import type { StringFieldDefinition, StringFieldOptions } from '../types/field.js';
+export declare function string(options?: StringFieldOptions): StringFieldDefinition;

package/dist/runtime/fields/string.js

@@ -0,0 +1,3 @@
+export function string(options = {}) {
+  return { type: "string", options };
+}

package/dist/runtime/fields/tab.d.ts

@@ -0,0 +1,2 @@
+import type { TabFieldDefinition, TabFieldOptions, TabsSchema } from '../types/field.js';
+export declare function tab<const T extends TabsSchema>(options: TabFieldOptions<T>): TabFieldDefinition<T>;

package/dist/runtime/fields/tab.js

@@ -0,0 +1,3 @@
+export function tab(options) {
+  return { type: "tabs", options };
+}

package/dist/runtime/fields/textarea.d.ts

@@ -0,0 +1,2 @@
+import type { TextareaFieldDefinition, TextareaFieldOptions } from '../types/field.js';
+export declare function textarea(options?: TextareaFieldOptions): TextareaFieldDefinition;

package/dist/runtime/fields/textarea.js

@@ -0,0 +1,3 @@
+export function textarea(options = {}) {
+  return { type: "textarea", options };
+}

package/dist/runtime/fields/url.d.ts

@@ -0,0 +1,2 @@
+import type { UrlFieldDefinition, UrlFieldOptions } from '../types/field.js';
+export declare function url(options?: UrlFieldOptions): UrlFieldDefinition;

package/dist/runtime/fields/url.js

@@ -0,0 +1,3 @@
+export function url(options = {}) {
+  return { type: "url", options };
+}

package/dist/runtime/middleware/eponyme-auth.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/eponyme-auth.js

@@ -0,0 +1,13 @@
+import { defineNuxtRouteMiddleware, navigateTo, useRuntimeConfig } from "#app";
+import { useEponymeAuth } from "../composables/useEponymeAuth.js";
+export default defineNuxtRouteMiddleware(async (to) => {
+  const auth = useEponymeAuth();
+  const user = await auth.ensureLoaded();
+  const dashboardPath = (useRuntimeConfig().public.eponyme?.dashboardPath ?? "/__eponyme").replace(/\/$/, "");
+  const loginPath = `${dashboardPath}/login`;
+  const changePasswordPath = `${dashboardPath}/change-password`;
+  if (!user)
+    return navigateTo({ path: loginPath, query: { redirect: to.fullPath } });
+  if (user.mustChangePassword && to.path !== changePasswordPath)
+    return navigateTo(changePasswordPath);
+});

package/dist/runtime/middleware/eponyme-owner.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/eponyme-owner.js

@@ -0,0 +1,7 @@
+import { createError, defineNuxtRouteMiddleware } from "#app";
+import { useEponymeAuth } from "../composables/useEponymeAuth.js";
+export default defineNuxtRouteMiddleware(async () => {
+  const user = await useEponymeAuth().ensureLoaded();
+  if (user?.role !== "owner")
+    throw createError({ statusCode: 403, statusMessage: "Owner access required." });
+});

package/dist/runtime/pages/EponymeChangePasswordPage.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/pages/EponymeChangePasswordPage.vue

@@ -0,0 +1,118 @@
+<script setup>
+import { navigateTo, useRuntimeConfig, useSeoMeta } from "#app";
+import { computed, ref } from "vue";
+import { useEponymeAuth } from "../composables/useEponymeAuth";
+import EPButton from "../components/ui/EPButton.vue";
+import EPFormField from "../components/ui/EPFormField.vue";
+import EPInputText from "../components/ui/EPInputText.vue";
+useSeoMeta({ title: "Change password \xB7 Eponyme" });
+const auth = useEponymeAuth();
+const currentPassword = ref("");
+const newPassword = ref("");
+const confirmation = ref("");
+const error = ref("");
+const dashboardPath = computed(() => useRuntimeConfig().public.eponyme?.dashboardPath ?? "/__eponyme");
+async function submit() {
+  error.value = "";
+  if (newPassword.value !== confirmation.value) {
+    error.value = "Password confirmation does not match.";
+    return;
+  }
+  try {
+    await auth.changePassword(currentPassword.value, newPassword.value);
+    await navigateTo(dashboardPath.value);
+  } catch (caught) {
+    const fetchError = caught;
+    error.value = fetchError.statusMessage ?? "Unable to change password.";
+  }
+}
+async function logout() {
+  await auth.logout();
+  await navigateTo(`${dashboardPath.value}/login`);
+}
+</script>
+
+<template>
+  <main class="eponyme-root ep:flex ep:min-h-screen ep:items-center ep:justify-center ep:bg-theme-ep ep:px-6 ep:py-12 ep:font-sans ep:text-text-ep">
+    <section class="ep:w-full ep:max-w-md">
+      <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:mb-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
+        Choose a new password
+      </h1>
+      <p class="ep:mt-0 ep:mb-8 ep:text-sm ep:leading-relaxed ep:text-muted-ep">
+        Your temporary password must be replaced before you can use the dashboard. Use at least 12 characters.
+      </p>
+      <form
+        class="ep:grid ep:gap-5"
+        @submit.prevent="submit"
+      >
+        <EPFormField
+          id="eponyme-current-password"
+          label="Current password"
+          required
+        >
+          <EPInputText
+            id="eponyme-current-password"
+            v-model="currentPassword"
+            type="password"
+            autocomplete="current-password"
+            required
+          />
+        </EPFormField>
+        <EPFormField
+          id="eponyme-new-password"
+          label="New password"
+          description="12 to 128 characters, different from the current password."
+          required
+        >
+          <EPInputText
+            id="eponyme-new-password"
+            v-model="newPassword"
+            type="password"
+            autocomplete="new-password"
+            required
+          />
+        </EPFormField>
+        <EPFormField
+          id="eponyme-confirm-password"
+          label="Confirm new password"
+          required
+        >
+          <EPInputText
+            id="eponyme-confirm-password"
+            v-model="confirmation"
+            type="password"
+            autocomplete="new-password"
+            required
+          />
+        </EPFormField>
+        <p
+          v-if="error"
+          class="ep:m-0 ep:text-sm ep:text-danger-ep"
+          role="alert"
+        >
+          {{ error }}
+        </p>
+        <div class="ep:flex ep:flex-wrap ep:gap-2">
+          <EPButton
+            type="submit"
+            variant="primary"
+            :loading="auth.pending.value"
+            :disabled="!currentPassword || !newPassword || !confirmation"
+          >
+            Change password
+          </EPButton>
+          <EPButton @click="logout">
+            Sign out
+          </EPButton>
+        </div>
+      </form>
+    </section>
+  </main>
+</template>
+
+<style scoped>
+:global(body){margin:0}
+</style>

package/dist/runtime/pages/EponymeChangePasswordPage.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/pages/EponymeDetailPage.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;