katecms 0.0.0-stage → 1.0.0-beta.1

package/dist/runtime/assets/img/katecms-logo.svg

@@ -0,0 +1,17 @@
+<svg width="601" height="113" viewBox="0 0 601 113" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M0 73.5024C0 67.1551 7.03756 63.3357 12.3596 66.7947L32.4495 79.8518C35.2876 81.6964 37 84.8516 37 88.2365V104.416C37 110.681 30.1253 114.515 24.7955 111.222L4.74437 98.8355C1.79524 97.0136 0 93.7944 0 90.3279V73.5024Z" fill="#2F6FED"/>
+  <path d="M124 73.7263C124 67.3334 116.872 63.523 111.556 67.074L92.4454 79.8399C89.6678 81.6953 88 84.815 88 88.1553V104.206C88 110.515 94.9619 114.341 100.288 110.96L119.36 98.8506C122.25 97.016 124 93.8311 124 90.4084V73.7263Z" fill="#2F6FED"/>
+  <path d="M15.9111 36.6614C19.8909 33.9187 25.1276 33.8313 29.1966 36.4397L53.1869 51.8182C56.629 54.0247 58.7108 57.832 58.7108 61.9207L58.7108 76.0704C58.7108 81.59 52.6207 84.9382 47.9602 81.9808L4.69729 54.5268C1.06676 52.223 0.966882 46.9603 4.50738 44.5204L15.9111 36.6614Z" fill="#2F6FED"/>
+  <path d="M108.017 36.6761C104.036 33.9251 98.7925 33.8341 94.7186 36.4454L70.7378 51.8173C67.2955 54.0238 65.2136 57.8312 65.2136 61.92L65.2136 76.0955C65.2136 81.6097 71.2931 84.9588 75.9541 82.0123L119.291 54.6165C122.926 52.3184 123.034 47.0542 119.496 44.609L108.017 36.6761Z" fill="#2F6FED"/>
+  <path d="M30 23.9492C30 20.3616 31.8302 17.0219 34.8541 15.0915L55.5429 1.88389C59.4806 -0.629939 64.5194 -0.629935 68.4571 1.88389L89.1459 15.0915C92.1698 17.0219 94 20.3616 94 23.9492C94 27.5737 92.1322 30.9424 89.058 32.8624L68.3568 45.7915C64.4671 48.2209 59.5329 48.2209 55.6432 45.7915L34.942 32.8624C31.8678 30.9424 30 27.5737 30 23.9492Z" fill="#2F6FED"/>
+  <path d="M157 32.7617C157 23.9252 164.163 16.7617 173 16.7617H174.5L201.5 65.7617L223.463 25.1504C226.258 19.9822 231.661 16.7617 237.537 16.7617H245V84.7617C245 93.046 238.284 99.7617 230 99.7617V43.2617L212.591 75.1775C210.377 79.2363 206.123 81.7617 201.5 81.7617C196.862 81.7617 192.58 79.2766 190.279 75.2499L172 43.2617V84.7617C172 93.046 165.284 99.7617 157 99.7617V32.7617Z" fill="#141A2A"/>
+  <path d="M257 52.7617C257 44.4774 263.716 37.7617 272 37.7617V84.7617C272 93.046 265.284 99.7617 257 99.7617V52.7617Z" fill="#141A2A"/>
+  <path d="M257 28.7617C257 22.1343 262.373 16.7617 269 16.7617H272V20.7617C272 27.3891 266.627 32.7617 260 32.7617H257V28.7617Z" fill="#141A2A"/>
+  <path d="M282 53.7617C282 44.9252 289.163 37.7617 298 37.7617H324C324 44.3891 318.627 49.7617 312 49.7617H304C300.134 49.7617 297 52.8957 297 56.7617V84.7617C297 93.046 290.284 99.7617 282 99.7617V53.7617Z" fill="#141A2A"/>
+  <path d="M366 37.7617C374.284 37.7617 381 44.4774 381 52.7617V82.7617C381 92.1506 373.389 99.7617 364 99.7617H339C330.716 99.7617 324 93.046 324 84.7617V76.7617C324 68.4774 330.716 61.7617 339 61.7617H367V55.7617C367 52.448 364.314 49.7617 361 49.7617H327C327 43.1343 332.373 37.7617 339 37.7617H366ZM342 72.7617C339.239 72.7617 337 75.0003 337 77.7617V83.7617C337 86.5231 339.239 88.7617 342 88.7617H362C364.761 88.7617 367 86.5231 367 83.7617V72.7617H342Z" fill="#141A2A"/>
+  <path d="M391 52.7617C391 44.4774 397.716 37.7617 406 37.7617V84.7617C406 93.046 399.284 99.7617 391 99.7617V52.7617Z" fill="#141A2A"/>
+  <path d="M391 28.7617C391 22.1343 396.373 16.7617 403 16.7617H406V20.7617C406 27.3891 400.627 32.7617 394 32.7617H391V28.7617Z" fill="#141A2A"/>
+  <path d="M416 57.7617C416 46.716 424.954 37.7617 436 37.7617H465C465 44.3891 459.627 49.7617 453 49.7617H436C432.134 49.7617 429 52.8957 429 56.7617V81.7617C429 85.6277 432.134 88.7617 436 88.7617H465C465 94.8369 460.075 99.7617 454 99.7617H436C424.954 99.7617 416 90.8074 416 79.7617V57.7617Z" fill="#2F6FED"/>
+  <path d="M475 50.8867C475 43.638 480.876 37.7617 488.125 37.7617L508.375 74.3641L523.708 46.1267C526.507 40.9717 531.903 37.7617 537.769 37.7617H541V88.5117C541 94.7249 535.963 99.7617 529.75 99.7617V57.5569L516.702 81.3823C515.036 84.4245 511.843 86.3159 508.375 86.3159C504.896 86.3159 501.682 84.4548 499.951 81.4369L486.25 57.5569V88.5117C486.25 94.7249 481.213 99.7617 475 99.7617V50.8867Z" fill="#2F6FED"/>
+  <path d="M551 56.2901C551 46.0572 559.295 37.7617 569.528 37.7617H599C599 43.8369 594.075 48.7617 588 48.7617H568C564.686 48.7617 562 51.448 562 54.7617V57.7617C562 61.0754 564.686 63.7617 568 63.7617H583C592.941 63.7617 601 71.8206 601 81.7617C601 91.7028 592.941 99.7617 583 99.7617H551C551 93.6866 555.925 88.7617 562 88.7617H584C587.314 88.7617 590 86.0754 590 82.7617V80.7784C590 77.4582 587.304 74.7692 583.983 74.7784L569.58 74.8185C559.327 74.847 551 66.5432 551 56.2901Z" fill="#2F6FED"/>
+</svg>

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

@@ -0,0 +1,62 @@
+import type { AdminEntry } from '../utils/collections.js';
+export interface GetCollectionOptions {
+    /** Override the path (default: current route). */
+    path?: string;
+    /**
+     * Include drafts when the requester may `collections:read` the matched
+     * collection. Also read from `?preview=1` on the current route.
+     */
+    preview?: boolean;
+    /**
+     * Narrow statuses. `draft` is ignored unless preview is granted.
+     * Also read from `?status=` on the current route.
+     */
+    status?: 'published' | 'draft' | Array<'published' | 'draft'>;
+    /** Archive listing page. Also read from `?page=` on the current route. */
+    page?: number;
+    /**
+     * Archive listing page size. Also read from `?perPage=` on the current route.
+     * Default: the matched collection's `perPage` (10). `-1` returns every entry.
+     */
+    perPage?: number;
+}
+/**
+ * Resolve the CMS entry or archive for the current (or given) path via
+ * collection `rewrite` / `has_archive`.
+ *
+ * Public pages stay published-only unless `preview` is set (option or
+ * `?preview=1`) and the visitor is signed in with read access.
+ * Collections with `public: false` do not resolve.
+ *
+ * A call for the current route emits `katecms:collection` with the resolved
+ * page. Addons use that hook to apply document head.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { entry, link } = await getCollection()
+ * const preview = await getCollection({ preview: true, status: 'draft' })
+ * const { isArchive, entries } = await getCollection()
+ * </script>
+ * ```
+ */
+export declare function getCollection(options?: GetCollectionOptions): Promise<never[] | {
+    kind: import("vue").ComputedRef<"entry" | "archive" | "term">;
+    isArchive: import("vue").ComputedRef<boolean>;
+    isTerm: import("vue").ComputedRef<boolean>;
+    entry: import("vue").ComputedRef<AdminEntry | null>;
+    term: import("vue").ComputedRef<import("../utils/collections.js").PublicDictionaryTerm | null>;
+    termPath: import("vue").ComputedRef<string | null>;
+    entries: import("vue").ComputedRef<AdminEntry[] | import("../utils/collections.js").PublicTermEntry[]>;
+    collection: import("vue").ComputedRef<import("../utils/collections.js").AdminCollectionMeta | null>;
+    link: import("vue").ComputedRef<string | null>;
+    permalink: (item: AdminEntry) => string | null;
+    preview: import("vue").ComputedRef<boolean>;
+    page: import("vue").ComputedRef<number>;
+    perPage: import("vue").ComputedRef<number>;
+    total: import("vue").ComputedRef<number>;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+    refresh: (opts?: import("nuxt/app").AsyncDataExecuteOptions) => Promise<void>;
+    path: import("vue").ComputedRef<string>;
+}>;

package/dist/runtime/composables/getCollection.js

@@ -0,0 +1,167 @@
+import { computed, getCurrentInstance } from "vue";
+import { useAsyncData, useNuxtApp, useRequestFetch, useRoute } from "#imports";
+import { buildPublicPath, resolveArchivePath } from "@katecms/core";
+import { isTruthyQueryParam, parsePublicStatusParam } from "../utils/preview.js";
+import { MIRAICMS_COLLECTION_HOOK } from "./useKateCmsExtensions.js";
+const collectionHookTargets = /* @__PURE__ */ new WeakSet();
+function samePublicPath(left, right) {
+  const normalize = (path) => {
+    const withSlash = path.startsWith("/") ? path : `/${path}`;
+    return withSlash.length > 1 && withSlash.endsWith("/") ? withSlash.slice(0, -1) : withSlash;
+  };
+  return normalize(left) === normalize(right);
+}
+function useCurrentPublicPath() {
+  const route = useRoute();
+  return computed(() => {
+    const slugParam = route.params.slug;
+    if (Array.isArray(slugParam) && slugParam.length > 0) {
+      return `/${slugParam.map(String).join("/")}`;
+    }
+    if (typeof slugParam === "string" && slugParam) {
+      return `/${slugParam}`;
+    }
+    const path = route.path || "/";
+    return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+  });
+}
+function statusQueryValue(status) {
+  if (!status) {
+    return void 0;
+  }
+  return Array.isArray(status) ? status.join(",") : status;
+}
+function pageQueryValue(value, fallback, allowUnlimited = false) {
+  if (typeof fallback === "number" && Number.isInteger(fallback) && (fallback >= 1 || allowUnlimited && fallback === -1)) {
+    return fallback;
+  }
+  const raw = Array.isArray(value) ? value[0] : value;
+  const n = Number(raw);
+  if (allowUnlimited && n === -1) {
+    return -1;
+  }
+  if (!Number.isInteger(n) || n < 1) {
+    return void 0;
+  }
+  return n;
+}
+export async function getCollection(options = {}) {
+  const nuxtApp = useNuxtApp();
+  const caller = getCurrentInstance();
+  const route = useRoute();
+  const currentPath = useCurrentPublicPath();
+  const tracksDocument = options.path == null || samePublicPath(options.path, currentPath.value);
+  const path = computed(() => options.path || currentPath.value);
+  const preview = computed(() => options.preview ?? isTruthyQueryParam(route.query.preview));
+  const status = computed(
+    () => statusQueryValue(options.status) ?? ((parsePublicStatusParam(route.query.status) ?? []).join(",") || void 0)
+  );
+  const page = computed(() => pageQueryValue(route.query.page, options.page));
+  const perPage = computed(() => pageQueryValue(route.query.perPage, options.perPage, true));
+  const requestFetch = useRequestFetch();
+  const { data, pending, error, refresh } = await useAsyncData(
+    `katecms-resolve:${path.value}:${preview.value ? "1" : "0"}:${status.value ?? ""}:${page.value ?? ""}:${perPage.value ?? ""}`,
+    () => requestFetch("/api/_katecms/resolve", {
+      query: {
+        path: path.value,
+        ...preview.value ? { preview: "1" } : {},
+        ...status.value ? { status: status.value } : {},
+        ...page.value ? { page: page.value } : {},
+        ...perPage.value ? { perPage: perPage.value } : {}
+      }
+    }),
+    { watch: [path, preview, status, page, perPage] }
+  );
+  const resolved = data.value;
+  const isArchivePayload = resolved?.kind === "archive";
+  const isTermPayload = resolved?.kind === "term";
+  if (error.value || !resolved || !isArchivePayload && !isTermPayload && resolved.kind !== "entry") {
+    return [];
+  }
+  if (resolved.kind === "entry" && !resolved.entry) {
+    return [];
+  }
+  if (resolved.kind === "term" && !resolved.term) {
+    return [];
+  }
+  const kind = computed(() => data.value?.kind ?? "entry");
+  const isArchive = computed(() => data.value?.kind === "archive");
+  const isTerm = computed(() => data.value?.kind === "term");
+  const entry = computed(() => data.value?.kind === "entry" ? data.value.entry : null);
+  const term = computed(() => data.value?.kind === "term" ? data.value.term : null);
+  const termPath = computed(() => data.value?.kind === "term" ? data.value.path : null);
+  const entries = computed(() => {
+    if (data.value?.kind === "archive" || data.value?.kind === "term") {
+      return data.value.entries;
+    }
+    return [];
+  });
+  const collection = computed(() => {
+    const resolvedPage = data.value;
+    if (resolvedPage?.kind === "entry" || resolvedPage?.kind === "archive") {
+      return resolvedPage.collection;
+    }
+    return null;
+  });
+  const isPreview = computed(() => {
+    const resolvedPage = data.value;
+    if (resolvedPage?.kind === "entry" || resolvedPage?.kind === "archive") {
+      return resolvedPage.preview;
+    }
+    return false;
+  });
+  const archivePage = computed(() => data.value?.kind === "archive" ? data.value.page : 1);
+  const archivePerPage = computed(() => data.value?.kind === "archive" ? data.value.perPage : 0);
+  const total = computed(() => data.value?.kind === "archive" ? data.value.total : 0);
+  const link = computed(() => {
+    if (data.value?.kind === "term") {
+      return data.value.path;
+    }
+    const meta = collection.value;
+    if (!meta) {
+      return null;
+    }
+    if (data.value?.kind === "archive") {
+      return resolveArchivePath(meta, meta.slug);
+    }
+    const resolvedEntry = entry.value;
+    if (!resolvedEntry) {
+      return null;
+    }
+    return buildPublicPath(meta.rewrite, meta.slug, resolvedEntry.slugPath || resolvedEntry.slug);
+  });
+  function permalink(item) {
+    const meta = collection.value;
+    if (!meta || !meta.public) {
+      return null;
+    }
+    return buildPublicPath(meta.rewrite, meta.slug, item.slugPath || item.slug);
+  }
+  if (tracksDocument && caller && !collectionHookTargets.has(caller)) {
+    collectionHookTargets.add(caller);
+    const page2 = { isArchive, isTerm, entry, term, collection, link };
+    nuxtApp.runWithContext(() => {
+      void nuxtApp.callHook(MIRAICMS_COLLECTION_HOOK, page2);
+    });
+  }
+  return {
+    kind,
+    isArchive,
+    isTerm,
+    entry,
+    term,
+    termPath,
+    entries,
+    collection,
+    link,
+    permalink,
+    preview: isPreview,
+    page: archivePage,
+    perPage: archivePerPage,
+    total,
+    pending,
+    error,
+    refresh,
+    path
+  };
+}

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

@@ -0,0 +1,22 @@
+export interface GetOptionsOptions {
+    /** Option page slug from CMS config (e.g. `site`). */
+    option: string;
+}
+/**
+ * Load stored values for an options page.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { values } = await getOptions({ option: 'site' })
+ * </script>
+ * ```
+ */
+export declare function getOptions(options: GetOptionsOptions): Promise<{
+    slug: import("vue").ComputedRef<string>;
+    values: import("vue").ComputedRef<Record<string, unknown>>;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+    refresh: (opts?: import("nuxt/app").AsyncDataExecuteOptions) => Promise<void>;
+    option: import("vue").ComputedRef<string>;
+}>;

package/dist/runtime/composables/getOptions.js

@@ -0,0 +1,22 @@
+import { computed } from "vue";
+import { useAsyncData, useRequestFetch } from "#imports";
+import { optionApi } from "../utils/options.js";
+export async function getOptions(options) {
+  const option = computed(() => options.option);
+  const requestFetch = useRequestFetch();
+  const { data, pending, error, refresh } = await useAsyncData(
+    `katecms-options:${option.value}`,
+    () => requestFetch(optionApi(option.value)),
+    { watch: [option] }
+  );
+  const values = computed(() => data.value?.values ?? {});
+  const slug = computed(() => data.value?.page.slug ?? option.value);
+  return {
+    slug,
+    values,
+    pending,
+    error,
+    refresh,
+    option
+  };
+}

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

@@ -0,0 +1,95 @@
+import type { CollectionOrderField, DictionaryQuery, FieldsQuery } from '@katecms/core';
+import type { AdminEntry } from '../utils/collections.js';
+export type QueryCollectionOrderBy = CollectionOrderField | 'date' | 'modified' | 'name' | 'includeIds';
+export type QueryCollectionSlug = 'any' | (string & {});
+export interface GetQueryCollectionOptions {
+    /** Collection slug(s). `'any'` includes every public collection. */
+    collection: QueryCollectionSlug | QueryCollectionSlug[];
+    /**
+     * Include drafts when the requester may `collections:read` every queried
+     * collection. Also read from `?preview=1` on the current route.
+     */
+    preview?: boolean;
+    /**
+     * Narrow statuses. `draft` is ignored unless preview is granted.
+     * Also read from `?status=` on the current route.
+     */
+    status?: 'published' | 'draft' | Array<'published' | 'draft'>;
+    /** Listing page. Also read from `?page=` on the current route. */
+    page?: number;
+    /**
+     * Page size. Also read from `?perPage=` on the current route.
+     * Default: the collection's `perPage` when a single type is queried,
+     * otherwise 10. `-1` returns every match.
+     */
+    perPage?: number;
+    /** Title/slug search. */
+    search?: string;
+    /** Exact title(s). */
+    title?: string | string[];
+    /** Only these entry ids. */
+    includeIds?: number | number[];
+    /** Skip these entry ids. */
+    excludeIds?: number | number[];
+    /** Parent id; `null` / `0` is top-level. */
+    parentId?: number | null;
+    /** Entries whose parent id is in this list. `0` is top-level. */
+    parentIds?: number | number[];
+    /** Skip entries whose parent id is in this list. `0` is top-level. */
+    excludeParentIds?: number | number[];
+    /** Only these authors. */
+    authorIn?: number[];
+    /** Skip these authors. */
+    authorNotIn?: number[];
+    /** Entry slug(s). */
+    slug?: string | string[];
+    /** Entry slug(s). */
+    slugs?: string | string[];
+    /** Filter by dictionary rows (`relation` + `queries`). */
+    dictionaryQuery?: DictionaryQuery;
+    /** Filter by entry `fields` JSON (`relation` + `queries`). */
+    fieldsQuery?: FieldsQuery;
+    /** Sort field. `date` → `published_at`, `modified` → `updated_at`, `name` → `slug`, `includeIds` → `includeIds` order. */
+    orderBy?: QueryCollectionOrderBy;
+    order?: 'asc' | 'desc';
+}
+/**
+ * List public collection entries by filters.
+ *
+ * Collections with `public: false` are omitted. Results stay published-only
+ * unless `preview` is set (option or `?preview=1`) and the visitor may read
+ * every queried collection.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { entries, permalink } = await getQueryCollection({
+ *   collection: 'any',
+ *   perPage: 10,
+ *   orderBy: 'date',
+ * })
+ * const mixed = await getQueryCollection({
+ *   collection: ['post', 'page'],
+ *   dictionaryQuery: {
+ *     relation: 'AND',
+ *     queries: [
+ *       { dictionary: 'services', field: 'slug', terms: 'theme-1' },
+ *       { dictionary: 'categories', operator: 'NOT IN', terms: 'category-1' },
+ *     ],
+ *   },
+ * })
+ * </script>
+ * ```
+ */
+export declare function getQueryCollection(options: GetQueryCollectionOptions): Promise<{
+    entries: import("vue").ComputedRef<AdminEntry[]>;
+    collections: import("vue").ComputedRef<import("../utils/collections.js").AdminCollectionMeta[]>;
+    permalink: (item: AdminEntry) => string | null;
+    preview: import("vue").ComputedRef<boolean>;
+    page: import("vue").ComputedRef<number>;
+    perPage: import("vue").ComputedRef<number>;
+    total: import("vue").ComputedRef<number>;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+    refresh: (opts?: import("nuxt/app").AsyncDataExecuteOptions) => Promise<void>;
+}>;

package/dist/runtime/composables/getQueryCollection.js

@@ -0,0 +1,199 @@
+import { computed } from "vue";
+import { useAsyncData, useRequestFetch, useRoute } from "#imports";
+import { buildPublicPath } from "@katecms/core";
+import { isTruthyQueryParam, parsePublicStatusParam } from "../utils/preview.js";
+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 csvAll(...values) {
+  const list = [...new Set(values.flatMap((value) => asList(value)))];
+  return list.length > 0 ? list.join(",") : void 0;
+}
+function parentIdToken(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value == null || value === 0) {
+    return 0;
+  }
+  return value;
+}
+function parentIdsCsv(parentId, parentIds) {
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (value) => {
+    if (value === void 0 || seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    tokens.push(value);
+  };
+  const list = parentIds == null ? [] : Array.isArray(parentIds) ? parentIds : [parentIds];
+  for (const id of list) {
+    push(parentIdToken(id));
+  }
+  push(parentIdToken(parentId));
+  return tokens.length > 0 ? tokens.join(",") : void 0;
+}
+function statusQueryValue(status) {
+  if (!status) {
+    return void 0;
+  }
+  return Array.isArray(status) ? status.join(",") : status;
+}
+function pageQueryValue(value, fallback, allowUnlimited = false) {
+  if (typeof fallback === "number" && Number.isInteger(fallback) && (fallback >= 1 || allowUnlimited && fallback === -1)) {
+    return fallback;
+  }
+  const raw = Array.isArray(value) ? value[0] : value;
+  const n = Number(raw);
+  if (allowUnlimited && n === -1) {
+    return -1;
+  }
+  if (!Number.isInteger(n) || n < 1) {
+    return void 0;
+  }
+  return n;
+}
+export async function getQueryCollection(options) {
+  const route = useRoute();
+  const collection = computed(() => asList(options.collection).join(","));
+  const preview = computed(() => options.preview ?? isTruthyQueryParam(route.query.preview));
+  const status = computed(
+    () => statusQueryValue(options.status) ?? ((parsePublicStatusParam(route.query.status) ?? []).join(",") || void 0)
+  );
+  const page = computed(() => pageQueryValue(route.query.page, options.page));
+  const perPage = computed(() => pageQueryValue(route.query.perPage, options.perPage, true));
+  const search = computed(() => options.search);
+  const title = computed(() => csv(options.title));
+  const includeIds = computed(() => csv(options.includeIds));
+  const excludeIds = computed(() => csv(options.excludeIds));
+  const parentIds = computed(() => parentIdsCsv(options.parentId, options.parentIds));
+  const excludeParentIds = computed(() => csv(options.excludeParentIds));
+  const authorIn = computed(() => csv(options.authorIn));
+  const authorNotIn = computed(() => csv(options.authorNotIn));
+  const slug = computed(() => csvAll(options.slugs, options.slug));
+  const dictionaryQuery = computed(() => options.dictionaryQuery ? JSON.stringify(options.dictionaryQuery) : void 0);
+  const fieldsQuery = computed(() => options.fieldsQuery ? JSON.stringify(options.fieldsQuery) : void 0);
+  const orderBy = computed(() => options.orderBy);
+  const order = computed(() => options.order);
+  const titleSet = computed(() => options.title !== void 0);
+  const includeIdsSet = computed(() => options.includeIds !== void 0);
+  const excludeIdsSet = computed(() => options.excludeIds !== void 0);
+  const parentIdsSet = computed(
+    () => options.parentId !== void 0 || options.parentIds !== void 0
+  );
+  const excludeParentIdsSet = computed(() => options.excludeParentIds !== void 0);
+  const authorInSet = computed(() => options.authorIn !== void 0);
+  const authorNotInSet = computed(() => options.authorNotIn !== void 0);
+  const slugSet = computed(() => options.slug !== void 0 || options.slugs !== void 0);
+  const requestFetch = useRequestFetch();
+  const { data, pending, error, refresh } = await useAsyncData(
+    [
+      "katecms-query",
+      collection.value,
+      preview.value ? "1" : "0",
+      status.value ?? "",
+      page.value ?? "",
+      perPage.value ?? "",
+      search.value ?? "",
+      titleSet.value ? title.value ?? "" : "-",
+      includeIdsSet.value ? includeIds.value ?? "" : "-",
+      excludeIdsSet.value ? excludeIds.value ?? "" : "-",
+      parentIdsSet.value ? parentIds.value ?? "" : "-",
+      excludeParentIdsSet.value ? excludeParentIds.value ?? "" : "-",
+      authorInSet.value ? authorIn.value ?? "" : "-",
+      authorNotInSet.value ? authorNotIn.value ?? "" : "-",
+      slugSet.value ? slug.value ?? "" : "-",
+      dictionaryQuery.value ?? "",
+      fieldsQuery.value ?? "",
+      orderBy.value ?? "",
+      order.value ?? ""
+    ].join(":"),
+    () => requestFetch("/api/_katecms/query", {
+      query: {
+        collection: collection.value,
+        ...preview.value ? { preview: "1" } : {},
+        ...status.value ? { status: status.value } : {},
+        ...page.value ? { page: page.value } : {},
+        ...perPage.value ? { perPage: perPage.value } : {},
+        ...search.value ? { search: search.value } : {},
+        ...titleSet.value ? { title: title.value ?? "" } : {},
+        ...includeIdsSet.value ? { includeIds: includeIds.value ?? "" } : {},
+        ...excludeIdsSet.value ? { excludeIds: excludeIds.value ?? "" } : {},
+        ...parentIdsSet.value ? { parentIds: parentIds.value ?? "" } : {},
+        ...excludeParentIdsSet.value ? { excludeParentIds: excludeParentIds.value ?? "" } : {},
+        ...authorInSet.value ? { authorIn: authorIn.value ?? "" } : {},
+        ...authorNotInSet.value ? { authorNotIn: authorNotIn.value ?? "" } : {},
+        ...slugSet.value ? { slug: slug.value ?? "" } : {},
+        ...dictionaryQuery.value ? { dictionaryQuery: dictionaryQuery.value } : {},
+        ...fieldsQuery.value ? { fieldsQuery: fieldsQuery.value } : {},
+        ...orderBy.value ? { orderBy: orderBy.value } : {},
+        ...order.value ? { order: order.value } : {}
+      }
+    }),
+    {
+      watch: [
+        collection,
+        preview,
+        status,
+        page,
+        perPage,
+        search,
+        title,
+        titleSet,
+        includeIds,
+        includeIdsSet,
+        excludeIds,
+        excludeIdsSet,
+        parentIds,
+        parentIdsSet,
+        excludeParentIds,
+        excludeParentIdsSet,
+        authorIn,
+        authorInSet,
+        authorNotIn,
+        authorNotInSet,
+        slug,
+        slugSet,
+        dictionaryQuery,
+        fieldsQuery,
+        orderBy,
+        order
+      ]
+    }
+  );
+  const entries = computed(() => data.value?.entries ?? []);
+  const collections = computed(() => data.value?.collections ?? []);
+  const isPreview = computed(() => data.value?.preview === true);
+  const queryPage = computed(() => data.value?.page ?? 1);
+  const queryPerPage = computed(() => data.value?.perPage ?? 0);
+  const total = computed(() => data.value?.total ?? 0);
+  function permalink(item) {
+    const meta = collections.value.find((entry) => entry.slug === item.type);
+    if (!meta || !meta.public) {
+      return null;
+    }
+    return buildPublicPath(meta.rewrite, meta.slug, item.slugPath || item.slug);
+  }
+  return {
+    entries,
+    collections,
+    permalink,
+    preview: isPreview,
+    page: queryPage,
+    perPage: queryPerPage,
+    total,
+    pending,
+    error,
+    refresh
+  };
+}

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

@@ -0,0 +1,79 @@
+import type { FieldsQuery, TermOrderBy, TermOrderField, TermsReturn } from '@katecms/core';
+export interface GetTermsOptions {
+    /** Dictionary slug(s). */
+    dictionary: string | string[];
+    /**
+     * Page size. Omitted or `-1` returns every match.
+     */
+    perPage?: number;
+    /** How many matches to skip. Default: `0`. */
+    offset?: number;
+    /** Only these term ids. */
+    includeIds?: number | number[];
+    /** Skip these term ids. */
+    excludeIds?: number | number[];
+    /** Skip these terms and every descendant. */
+    excludeTreeIds?: number | number[];
+    /** Direct parent. `null` / `0` is top-level. */
+    parentId?: number | null;
+    /** Every descendant of this term. The term itself is not included. */
+    childOf?: number;
+    /** Skip terms that have children. Default: `false`. */
+    childless?: boolean;
+    /** Exact slug(s). */
+    slug?: string | string[];
+    /** Exact title(s). */
+    title?: string | string[];
+    /** Case-insensitive substring of title or slug. */
+    search?: string;
+    /** Hide terms with no published entries. Default: `true`. */
+    hideEmpty?: boolean;
+    /**
+     * When `hideEmpty` is set, keep an empty term if a descendant has entries.
+     * Default: `true`.
+     */
+    hierarchical?: boolean;
+    /** Add descendant entry counts to each term's `count`. Default: `false`. */
+    padCounts?: boolean;
+    /** Filter term `fields`. */
+    fieldsQuery?: FieldsQuery;
+    /** Default: `title`. */
+    orderBy?: TermOrderBy;
+    /** Key used when `orderBy` is `field`. */
+    orderByField?: TermOrderField;
+    /** Default: `asc`. */
+    order?: 'asc' | 'desc';
+    /**
+     * Shape of the result. `count` is the number of matches before `perPage`.
+     * Default: `all`.
+     */
+    return?: TermsReturn;
+}
+/**
+ * List dictionary terms.
+ *
+ * `count` is the number of published entries in public collections.
+ * `hideEmpty` drops terms whose count is 0, unless `hierarchical` keeps a
+ * parent that has a non-empty descendant.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { terms } = await getTerms({
+ *   dictionary: 'services',
+ *   hideEmpty: true,
+ *   orderBy: 'title',
+ * })
+ * </script>
+ * ```
+ */
+export declare function getTerms(options: GetTermsOptions): Promise<{
+    terms: import("vue").ComputedRef<import("@katecms/core").QueryTerm[]>;
+    ids: import("vue").ComputedRef<number[]>;
+    titles: import("vue").ComputedRef<string[]>;
+    map: import("vue").ComputedRef<Record<string, string | number | null>>;
+    total: import("vue").ComputedRef<number>;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined, import("nuxt/app").NuxtError<unknown> | undefined>;
+    refresh: (opts?: import("nuxt/app").AsyncDataExecuteOptions) => Promise<void>;
+}>;