katecms 0.0.0-stage → 1.0.0-beta.1

package/dist/runtime/composables/getTerms.js

@@ -0,0 +1,148 @@
+import { computed } from "vue";
+import { useAsyncData, useRequestFetch } from "#imports";
+function asList(value) {
+  if (value == null) {
+    return [];
+  }
+  const raw = Array.isArray(value) ? value : [value];
+  return [...new Set(raw.map((item) => String(item).trim()).filter(Boolean))];
+}
+function csv(value) {
+  const list = asList(value);
+  return list.length > 0 ? list.join(",") : void 0;
+}
+function flag(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value ? "1" : "0";
+}
+export async function getTerms(options) {
+  const dictionary = computed(() => asList(options.dictionary).join(","));
+  const perPage = computed(() => options.perPage);
+  const offset = computed(() => options.offset);
+  const includeIds = computed(() => csv(options.includeIds));
+  const excludeIds = computed(() => csv(options.excludeIds));
+  const excludeTreeIds = computed(() => csv(options.excludeTreeIds));
+  const parentId = computed(() => {
+    if (options.parentId === void 0) {
+      return void 0;
+    }
+    if (options.parentId == null || options.parentId === 0) {
+      return "0";
+    }
+    return String(options.parentId);
+  });
+  const childOf = computed(() => options.childOf != null && options.childOf > 0 ? String(options.childOf) : void 0);
+  const childless = computed(() => flag(options.childless));
+  const slug = computed(() => csv(options.slug));
+  const title = computed(() => csv(options.title));
+  const search = computed(() => options.search);
+  const hideEmpty = computed(() => flag(options.hideEmpty));
+  const hierarchical = computed(() => flag(options.hierarchical));
+  const padCounts = computed(() => flag(options.padCounts));
+  const fieldsQuery = computed(() => options.fieldsQuery ? JSON.stringify(options.fieldsQuery) : void 0);
+  const orderBy = computed(() => options.orderBy);
+  const orderByField = computed(() => options.orderByField ? JSON.stringify(options.orderByField) : void 0);
+  const order = computed(() => options.order);
+  const returnMode = computed(() => options.return);
+  const includeIdsSet = computed(() => options.includeIds !== void 0);
+  const excludeIdsSet = computed(() => options.excludeIds !== void 0);
+  const excludeTreeIdsSet = computed(() => options.excludeTreeIds !== void 0);
+  const slugSet = computed(() => options.slug !== void 0);
+  const titleSet = computed(() => options.title !== void 0);
+  const requestFetch = useRequestFetch();
+  const { data, pending, error, refresh } = await useAsyncData(
+    [
+      "katecms-terms",
+      dictionary.value,
+      perPage.value ?? "",
+      offset.value ?? "",
+      includeIdsSet.value ? includeIds.value ?? "" : "-",
+      excludeIdsSet.value ? excludeIds.value ?? "" : "-",
+      excludeTreeIdsSet.value ? excludeTreeIds.value ?? "" : "-",
+      parentId.value ?? "-",
+      childOf.value ?? "",
+      childless.value ?? "",
+      slugSet.value ? slug.value ?? "" : "-",
+      titleSet.value ? title.value ?? "" : "-",
+      search.value ?? "",
+      hideEmpty.value ?? "",
+      hierarchical.value ?? "",
+      padCounts.value ?? "",
+      fieldsQuery.value ?? "",
+      orderBy.value ?? "",
+      orderByField.value ?? "",
+      order.value ?? "",
+      returnMode.value ?? ""
+    ].join(":"),
+    () => requestFetch("/api/_katecms/terms", {
+      query: {
+        dictionary: dictionary.value,
+        ...perPage.value != null ? { perPage: perPage.value } : {},
+        ...offset.value != null ? { offset: offset.value } : {},
+        ...includeIdsSet.value ? { includeIds: includeIds.value ?? "" } : {},
+        ...excludeIdsSet.value ? { excludeIds: excludeIds.value ?? "" } : {},
+        ...excludeTreeIdsSet.value ? { excludeTreeIds: excludeTreeIds.value ?? "" } : {},
+        ...parentId.value != null ? { parentId: parentId.value } : {},
+        ...childOf.value ? { childOf: childOf.value } : {},
+        ...childless.value != null ? { childless: childless.value } : {},
+        ...slugSet.value ? { slug: slug.value ?? "" } : {},
+        ...titleSet.value ? { title: title.value ?? "" } : {},
+        ...search.value ? { search: search.value } : {},
+        ...hideEmpty.value != null ? { hideEmpty: hideEmpty.value } : {},
+        ...hierarchical.value != null ? { hierarchical: hierarchical.value } : {},
+        ...padCounts.value != null ? { padCounts: padCounts.value } : {},
+        ...fieldsQuery.value ? { fieldsQuery: fieldsQuery.value } : {},
+        ...orderBy.value ? { orderBy: orderBy.value } : {},
+        ...orderByField.value ? { orderByField: orderByField.value } : {},
+        ...order.value ? { order: order.value } : {},
+        ...returnMode.value ? { return: returnMode.value } : {}
+      }
+    }),
+    {
+      watch: [
+        dictionary,
+        perPage,
+        offset,
+        includeIds,
+        includeIdsSet,
+        excludeIds,
+        excludeIdsSet,
+        excludeTreeIds,
+        excludeTreeIdsSet,
+        parentId,
+        childOf,
+        childless,
+        slug,
+        slugSet,
+        title,
+        titleSet,
+        search,
+        hideEmpty,
+        hierarchical,
+        padCounts,
+        fieldsQuery,
+        orderBy,
+        orderByField,
+        order,
+        returnMode
+      ]
+    }
+  );
+  const terms = computed(() => data.value?.terms ?? []);
+  const ids = computed(() => data.value?.ids ?? []);
+  const titles = computed(() => data.value?.titles ?? []);
+  const map = computed(() => data.value?.map ?? {});
+  const total = computed(() => data.value?.total ?? 0);
+  return {
+    terms,
+    ids,
+    titles,
+    map,
+    total,
+    pending,
+    error,
+    refresh
+  };
+}

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

@@ -0,0 +1,14 @@
+import type { AuthState, SafeUser } from '@katecms/core';
+/**
+ * Shared auth snapshot for admin UI (header profile, logout, etc.).
+ * Uses a stable fetch key so multiple consumers share one request.
+ */
+export declare function useAuth(): {
+    user: import("vue").ComputedRef<SafeUser | null>;
+    authState: import("vue").Ref<AuthState | undefined, AuthState | undefined>;
+    refresh: (opts?: import("nuxt/app").AsyncDataExecuteOptions) => Promise<void>;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+    loggingOut: import("vue").Ref<boolean, boolean>;
+    logout: () => Promise<void>;
+};

package/dist/runtime/composables/useAuth.js

@@ -0,0 +1,33 @@
+import { computed, ref } from "vue";
+import { $fetch, navigateTo, useFetch } from "#imports";
+import { useCmsPaths } from "./useCmsPaths.js";
+export function useAuth() {
+  const paths = useCmsPaths();
+  const { data, refresh, pending, error, clear } = useFetch("/api/_katecms/auth/state", {
+    key: "katecms-auth-state"
+  });
+  const user = computed(() => data.value?.user ?? null);
+  const loggingOut = ref(false);
+  async function logout() {
+    if (loggingOut.value) {
+      return;
+    }
+    loggingOut.value = true;
+    try {
+      await $fetch("/api/_katecms/auth/logout", { method: "POST" });
+      clear();
+      await navigateTo(paths.login);
+    } finally {
+      loggingOut.value = false;
+    }
+  }
+  return {
+    user,
+    authState: data,
+    refresh,
+    pending,
+    error,
+    loggingOut,
+    logout
+  };
+}

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

@@ -0,0 +1,6 @@
+/** Client-side wait after the server reports `retryAfterMs` on a failed auth attempt. */
+export declare function useAuthCooldown(): {
+    remainingSec: import("vue").ComputedRef<number>;
+    locked: import("vue").ComputedRef<boolean>;
+    start: (retryAfterMs: number, unlock?: () => void) => void;
+};

package/dist/runtime/composables/useAuthCooldown.js

@@ -0,0 +1,44 @@
+import { computed, onUnmounted, ref } from "vue";
+export function useAuthCooldown() {
+  const cooldownUntil = ref(0);
+  const now = ref(Date.now());
+  let timer;
+  let onUnlock;
+  const remainingMs = computed(() => Math.max(0, cooldownUntil.value - now.value));
+  const remainingSec = computed(() => Math.ceil(remainingMs.value / 1e3));
+  const locked = computed(() => remainingMs.value > 0);
+  function finish() {
+    if (!timer) {
+      return;
+    }
+    clearInterval(timer);
+    timer = void 0;
+    const done = onUnlock;
+    onUnlock = void 0;
+    done?.();
+  }
+  function tick() {
+    now.value = Date.now();
+    if (remainingMs.value <= 0) {
+      finish();
+    }
+  }
+  function start(retryAfterMs, unlock) {
+    if (retryAfterMs <= 0) {
+      return;
+    }
+    onUnlock = unlock;
+    cooldownUntil.value = Date.now() + retryAfterMs;
+    now.value = Date.now();
+    if (!timer) {
+      timer = setInterval(tick, 250);
+    }
+  }
+  onUnmounted(() => {
+    if (timer) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+  });
+  return { remainingSec, locked, start };
+}

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

@@ -0,0 +1,15 @@
+export declare function useCmsPaths(): {
+    admin: string;
+    media: string;
+    users: string;
+    user: (id: number | string) => string;
+    demoFields: string;
+    collection: (slug: string) => string;
+    collectionCreate: (slug: string) => string;
+    collectionEntry: (slug: string, id: number | string) => string;
+    dictionary: (slug: string) => string;
+    dictionaryTerm: (slug: string, id: number | string) => string;
+    option: (slug: string) => string;
+    login: string;
+    register: string;
+};

package/dist/runtime/composables/useCmsPaths.js

@@ -0,0 +1,21 @@
+import { useRuntimeConfig } from "#imports";
+import { cmsAdminChildPath, cmsRoutePath } from "../utils/cms-paths.js";
+export function useCmsPaths() {
+  const config = useRuntimeConfig().public.katecms;
+  const admin = cmsRoutePath(config?.adminPath || "admin");
+  return {
+    admin,
+    media: `${admin}/media`,
+    users: `${admin}/users`,
+    user: (id) => `${admin}/users/${id}`,
+    demoFields: `${admin}/demo-fields`,
+    collection: (slug) => `${admin}/collections/${encodeURIComponent(slug)}`,
+    collectionCreate: (slug) => `${admin}/collections/${encodeURIComponent(slug)}/create`,
+    collectionEntry: (slug, id) => `${admin}/collections/${encodeURIComponent(slug)}/${id}`,
+    dictionary: (slug) => `${admin}/dictionaries/${encodeURIComponent(slug)}`,
+    dictionaryTerm: (slug, id) => `${admin}/dictionaries/${encodeURIComponent(slug)}/${id}`,
+    option: (slug) => `${admin}/options/${encodeURIComponent(slug)}`,
+    login: cmsAdminChildPath(config?.adminPath || "admin", config?.loginPath || "login"),
+    register: cmsAdminChildPath(config?.adminPath || "admin", config?.registerPath || "register")
+  };
+}

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

@@ -0,0 +1,49 @@
+import type { ComputedRef } from 'vue';
+import type { AdminCollectionMeta, AdminEntry, PublicDictionaryTerm } from '../utils/collections.js';
+/** Nuxt hook fired by `getCollection()` for the current route. */
+export declare const MIRAICMS_COLLECTION_HOOK: "katecms:collection";
+/** Page resolved by `getCollection()` for the current route. */
+export interface KateCmsPublicPage {
+    isArchive: ComputedRef<boolean>;
+    isTerm: ComputedRef<boolean>;
+    entry: ComputedRef<AdminEntry | null>;
+    term: ComputedRef<PublicDictionaryTerm | null>;
+    collection: ComputedRef<AdminCollectionMeta | null>;
+    link: ComputedRef<string | null>;
+}
+declare module '#app' {
+    interface RuntimeNuxtHooks {
+        'katecms:collection': (page: KateCmsPublicPage) => void;
+    }
+}
+/** Extra admin menu items, registered by addons. */
+export interface KateCmsMenuExtra {
+    key: string;
+    label: string;
+    to: string;
+    /** Inline SVG markup, same shape as the built-in menu icons. */
+    icon?: string;
+    /**
+     * Resource the user must be allowed to read (`GET /api/_katecms/menu`).
+     * Omit to show the item to everyone who can open the admin.
+     */
+    access?: string;
+}
+/**
+ * Addon tab in the collection entry sidebar.
+ * The form supplies the "Page" tab. `key: "page"` is reserved for that tab.
+ */
+export interface KateCmsEntrySidebarTab {
+    key: string;
+    label: string;
+    /** Component name already registered on the Vue app. */
+    component: string;
+}
+export declare function useKateCmsEntrySidebar(): import("vue").Ref<KateCmsEntrySidebarTab[], KateCmsEntrySidebarTab[]>;
+/** Register or replace one collection-entry sidebar tab. Addons call this from a plugin. */
+export declare function registerKateCmsEntrySidebarTab(tab: KateCmsEntrySidebarTab): void;
+/** Extra panels under a dictionary term form, registered by addons as component names. */
+export declare function useKateCmsTermPanels(): import("vue").Ref<string[], string[]>;
+export declare function useKateCmsMenuItems(): import("vue").Ref<KateCmsMenuExtra[], KateCmsMenuExtra[]>;
+export { registerKateCmsField } from '../utils/helpers.js';
+export { provideKateCmsFieldErrors } from '../utils/field-errors.js';

package/dist/runtime/composables/useKateCmsExtensions.js

@@ -0,0 +1,29 @@
+import { useState } from "#imports";
+export const MIRAICMS_COLLECTION_HOOK = "katecms:collection";
+export function useKateCmsEntrySidebar() {
+  return useState("katecms:entry-sidebar", () => []);
+}
+export function registerKateCmsEntrySidebarTab(tab) {
+  const key = tab.key.trim();
+  const label = tab.label.trim();
+  const component = tab.component.trim();
+  if (!key || key === "page" || !label || !component) {
+    return;
+  }
+  const tabs = useKateCmsEntrySidebar();
+  const next = { key, label, component };
+  const index = tabs.value.findIndex((item) => item.key === key);
+  if (index === -1) {
+    tabs.value.push(next);
+    return;
+  }
+  tabs.value[index] = next;
+}
+export function useKateCmsTermPanels() {
+  return useState("katecms:term-panels", () => []);
+}
+export function useKateCmsMenuItems() {
+  return useState("katecms:menu-items", () => []);
+}
+export { registerKateCmsField } from "../utils/helpers.js";
+export { provideKateCmsFieldErrors } from "../utils/field-errors.js";

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

@@ -0,0 +1,84 @@
+import type { MediaItem } from '@katecms/core';
+import type { MediaLibraryFilterState } from '../utils/media-library-query.js';
+/** Page size for media pickers. The library page uses the same size. */
+export declare const MEDIA_LIBRARY_PAGE_SIZE = 40;
+/**
+ * Paged media library for pickers.
+ * `matches` runs on each loaded page so a field can hide files it cannot use.
+ * `fetched` counts raw API rows, so scrolling continues past pages that were filtered out.
+ */
+export declare function useMediaLibrary(matches: () => (item: MediaItem) => boolean, options?: {
+    baseType?: 'image';
+}): {
+    items: import("vue").Ref<{
+        id: number;
+        filename: string;
+        mime_type: string;
+        filesize: number;
+        width: number | null;
+        height: number | null;
+        url: string;
+        alt: string | null;
+        caption: string | null;
+        uploaded_by: number | null;
+        uploaded_by_name: string | null;
+        variants_status: import("@katecms/core").MediaVariantsStatus;
+        variants: {
+            url: string;
+            size: string;
+            format: string;
+            filename: string;
+            width: number;
+            height: number;
+            filesize: number;
+        }[];
+        created_at: string;
+    }[], MediaItem[] | {
+        id: number;
+        filename: string;
+        mime_type: string;
+        filesize: number;
+        width: number | null;
+        height: number | null;
+        url: string;
+        alt: string | null;
+        caption: string | null;
+        uploaded_by: number | null;
+        uploaded_by_name: string | null;
+        variants_status: import("@katecms/core").MediaVariantsStatus;
+        variants: {
+            url: string;
+            size: string;
+            format: string;
+            filename: string;
+            width: number;
+            height: number;
+            filesize: number;
+        }[];
+        created_at: string;
+    }[]>;
+    total: import("vue").Ref<number, number>;
+    months: import("vue").Ref<string[], string[]>;
+    filters: import("vue").Ref<{
+        type: import("../utils/media-library-query.js").MediaTypeFilter;
+        month: string;
+        search: string;
+        sort: import("../utils/media-library-query.js").MediaSort;
+    }, MediaLibraryFilterState | {
+        type: import("../utils/media-library-query.js").MediaTypeFilter;
+        month: string;
+        search: string;
+        sort: import("../utils/media-library-query.js").MediaSort;
+    }>;
+    loading: import("vue").Ref<boolean, boolean>;
+    loadingMore: import("vue").Ref<boolean, boolean>;
+    hasMore: import("vue").ComputedRef<boolean>;
+    load: (loadOptions?: {
+        resetFilters?: boolean;
+        silent?: boolean;
+    }) => Promise<void>;
+    loadMore: () => Promise<void>;
+    applyFilters: (next: MediaLibraryFilterState) => Promise<void>;
+    prepend: (item: MediaItem) => void;
+    replace: (item: MediaItem) => void;
+};

package/dist/runtime/composables/useMediaLibrary.js

@@ -0,0 +1,140 @@
+import { computed, ref } from "vue";
+import { $fetch } from "#imports";
+import {
+  defaultMediaLibraryFilters,
+  localUtcOffsetMinutes,
+  mediaLibraryQuery,
+  mediaMatchesFilters,
+  monthKey,
+  normalizeMediaLibraryFilters
+} from "../utils/media-library-query.js";
+export const MEDIA_LIBRARY_PAGE_SIZE = 40;
+export function useMediaLibrary(matches, options) {
+  const items = ref([]);
+  const total = ref(0);
+  const fetched = ref(0);
+  const months = ref([]);
+  const filters = ref(defaultMediaLibraryFilters());
+  const loading = ref(false);
+  const loadingMore = ref(false);
+  const hasMore = computed(() => fetched.value < total.value);
+  let requestId = 0;
+  function fetchPage(offset) {
+    return $fetch("/api/_katecms/media", {
+      query: mediaLibraryQuery(filters.value, {
+        limit: MEDIA_LIBRARY_PAGE_SIZE,
+        offset
+      }, options?.baseType)
+    });
+  }
+  function accept(list) {
+    return list.filter(matches());
+  }
+  function fieldHidesType() {
+    return options?.baseType === "image" && filters.value.type !== "all" && filters.value.type !== "image";
+  }
+  function rememberMonth(iso) {
+    const key = monthKey(iso, localUtcOffsetMinutes());
+    if (!key || months.value.includes(key)) {
+      return;
+    }
+    months.value = [...months.value, key].sort((a, b) => b.localeCompare(a));
+  }
+  async function load(loadOptions) {
+    const id = ++requestId;
+    if (loadOptions?.resetFilters) {
+      filters.value = defaultMediaLibraryFilters();
+    }
+    if (!loadOptions?.silent) {
+      loading.value = true;
+      items.value = [];
+      fetched.value = 0;
+    }
+    try {
+      const res = await fetchPage(0);
+      if (id !== requestId) {
+        return;
+      }
+      total.value = res.total;
+      months.value = res.months;
+      if (fieldHidesType()) {
+        fetched.value = res.total;
+        items.value = [];
+        return;
+      }
+      fetched.value = res.media.length;
+      items.value = accept(res.media);
+    } finally {
+      if (id === requestId && !loadOptions?.silent) {
+        loading.value = false;
+      }
+    }
+  }
+  async function loadMore() {
+    if (loading.value || loadingMore.value || !hasMore.value) {
+      return;
+    }
+    const id = requestId;
+    loadingMore.value = true;
+    try {
+      const res = await fetchPage(fetched.value);
+      if (id !== requestId) {
+        return;
+      }
+      total.value = res.total;
+      if (!res.media.length) {
+        fetched.value = total.value;
+        return;
+      }
+      fetched.value += res.media.length;
+      const seen = new Set(items.value.map((item) => item.id));
+      const next = accept(res.media).filter((item) => !seen.has(item.id));
+      items.value = [...items.value, ...next];
+    } finally {
+      loadingMore.value = false;
+    }
+  }
+  async function applyFilters(next) {
+    filters.value = normalizeMediaLibraryFilters(next);
+    await load();
+  }
+  function prepend(item) {
+    if (mediaMatchesFilters(item, { ...filters.value, month: "all" })) {
+      rememberMonth(item.created_at);
+    }
+    if (!matches()(item) || !mediaMatchesFilters(item, filters.value)) {
+      return;
+    }
+    if (filters.value.sort !== "date-desc") {
+      void load({ silent: true });
+      return;
+    }
+    const index = items.value.findIndex((entry) => entry.id === item.id);
+    if (index >= 0) {
+      items.value[index] = item;
+      return;
+    }
+    items.value = [item, ...items.value];
+    total.value += 1;
+  }
+  function replace(item) {
+    const index = items.value.findIndex((entry) => entry.id === item.id);
+    if (index >= 0) {
+      items.value[index] = item;
+    }
+  }
+  return {
+    items,
+    total,
+    months,
+    filters,
+    loading,
+    loadingMore,
+    hasMore,
+    load,
+    loadMore,
+    applyFilters,
+    prepend,
+    replace
+  };
+}

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

@@ -0,0 +1,8 @@
+export interface MenuAccess {
+    visible: string[];
+}
+/**
+ * Resources the current user may read, for addon menu items.
+ * Fetched once per admin shell. A later sign-in loads it again.
+ */
+export declare function useMenuAccess(): import("nuxt/app").AsyncData<MenuAccess | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;

package/dist/runtime/composables/useMenuAccess.js

@@ -0,0 +1,16 @@
+import { useAsyncData, useRequestFetch } from "#imports";
+export function useMenuAccess() {
+  const request = useRequestFetch();
+  return useAsyncData(
+    "katecms-menu",
+    () => request("/api/_katecms/menu"),
+    {
+      getCachedData: (key, nuxtApp, ctx) => {
+        if (nuxtApp.isHydrating && ctx.cause === "initial") {
+          return nuxtApp.payload.data[key];
+        }
+        return void 0;
+      }
+    }
+  );
+}

package/dist/runtime/internal/admin/AdminHeader.d.vue.ts

@@ -0,0 +1,24 @@
+type __VLS_Props = {
+    title: string;
+    /** When set, a back button is shown before the title. */
+    backTo?: string;
+    /** Secondary line under the title. */
+    meta?: string;
+    /** Shown after the title, for example a result count. */
+    count?: string | number;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};