qarpeo 0.0.0-alpha.10

package/dist/runtime/app/composables/cms.d.ts

@@ -0,0 +1,307 @@
+import type { CMSEntry, CMSQueryOptions, CMSNavigationOptions, CMSNavigationItem, DocsSearchSection, CMSLocaleConfig } from "../../../types";
+export declare function useCMS(collectionId?: string): {
+    entries: import("vue").Ref<{
+        id: string;
+        collectionId: string;
+        slug: string;
+        path?: string | undefined;
+        title: string;
+        description?: string | null | undefined;
+        coverImage?: string | null | undefined;
+        tags?: string | null | undefined;
+        order: number;
+        contentMd: string;
+        contentHtml: string;
+        body?: {
+            [x: string]: any;
+            toc?: {
+                links: {
+                    id: string;
+                    text: string;
+                    depth: number;
+                    children?: /*elided*/ any[] | undefined;
+                }[];
+            } | undefined;
+        } | undefined;
+        toc?: {
+            links: {
+                id: string;
+                text: string;
+                depth: number;
+                children?: /*elided*/ any[] | undefined;
+            }[];
+        } | undefined;
+        navigation?: {
+            title?: string | undefined;
+            icon?: string | undefined;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        metadataJson?: string | undefined;
+        status: import("../../../types").CMSEntryStatus;
+        source: "file" | "db";
+        filePath?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        authorId?: string | null | undefined;
+        publishedAt?: number | null | undefined;
+        tenantId?: string | null | undefined;
+        locale?: string | undefined;
+        version?: string | undefined;
+        createdAt: number;
+        updatedAt: number;
+    }[], CMSEntry[] | {
+        id: string;
+        collectionId: string;
+        slug: string;
+        path?: string | undefined;
+        title: string;
+        description?: string | null | undefined;
+        coverImage?: string | null | undefined;
+        tags?: string | null | undefined;
+        order: number;
+        contentMd: string;
+        contentHtml: string;
+        body?: {
+            [x: string]: any;
+            toc?: {
+                links: {
+                    id: string;
+                    text: string;
+                    depth: number;
+                    children?: /*elided*/ any[] | undefined;
+                }[];
+            } | undefined;
+        } | undefined;
+        toc?: {
+            links: {
+                id: string;
+                text: string;
+                depth: number;
+                children?: /*elided*/ any[] | undefined;
+            }[];
+        } | undefined;
+        navigation?: {
+            title?: string | undefined;
+            icon?: string | undefined;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        metadataJson?: string | undefined;
+        status: import("../../../types").CMSEntryStatus;
+        source: "file" | "db";
+        filePath?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        authorId?: string | null | undefined;
+        publishedAt?: number | null | undefined;
+        tenantId?: string | null | undefined;
+        locale?: string | undefined;
+        version?: string | undefined;
+        createdAt: number;
+        updatedAt: number;
+    }[]>;
+    entry: import("vue").Ref<{
+        id: string;
+        collectionId: string;
+        slug: string;
+        path?: string | undefined;
+        title: string;
+        description?: string | null | undefined;
+        coverImage?: string | null | undefined;
+        tags?: string | null | undefined;
+        order: number;
+        contentMd: string;
+        contentHtml: string;
+        body?: {
+            [x: string]: any;
+            toc?: {
+                links: {
+                    id: string;
+                    text: string;
+                    depth: number;
+                    children?: /*elided*/ any[] | undefined;
+                }[];
+            } | undefined;
+        } | undefined;
+        toc?: {
+            links: {
+                id: string;
+                text: string;
+                depth: number;
+                children?: /*elided*/ any[] | undefined;
+            }[];
+        } | undefined;
+        navigation?: {
+            title?: string | undefined;
+            icon?: string | undefined;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        metadataJson?: string | undefined;
+        status: import("../../../types").CMSEntryStatus;
+        source: "file" | "db";
+        filePath?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        authorId?: string | null | undefined;
+        publishedAt?: number | null | undefined;
+        tenantId?: string | null | undefined;
+        locale?: string | undefined;
+        version?: string | undefined;
+        createdAt: number;
+        updatedAt: number;
+    } | null, CMSEntry | {
+        id: string;
+        collectionId: string;
+        slug: string;
+        path?: string | undefined;
+        title: string;
+        description?: string | null | undefined;
+        coverImage?: string | null | undefined;
+        tags?: string | null | undefined;
+        order: number;
+        contentMd: string;
+        contentHtml: string;
+        body?: {
+            [x: string]: any;
+            toc?: {
+                links: {
+                    id: string;
+                    text: string;
+                    depth: number;
+                    children?: /*elided*/ any[] | undefined;
+                }[];
+            } | undefined;
+        } | undefined;
+        toc?: {
+            links: {
+                id: string;
+                text: string;
+                depth: number;
+                children?: /*elided*/ any[] | undefined;
+            }[];
+        } | undefined;
+        navigation?: {
+            title?: string | undefined;
+            icon?: string | undefined;
+        } | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        metadataJson?: string | undefined;
+        status: import("../../../types").CMSEntryStatus;
+        source: "file" | "db";
+        filePath?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        authorId?: string | null | undefined;
+        publishedAt?: number | null | undefined;
+        tenantId?: string | null | undefined;
+        locale?: string | undefined;
+        version?: string | undefined;
+        createdAt: number;
+        updatedAt: number;
+    } | null>;
+    total: import("vue").Ref<number, number>;
+    status: import("vue").Ref<"error" | "success" | "idle" | "loading", "error" | "success" | "idle" | "loading">;
+    error: import("vue").Ref<Error | null, Error | null>;
+    fetchEntries: (options?: CMSQueryOptions & {
+        collection?: string;
+    }) => Promise<{
+        entries: CMSEntry[];
+        total: number;
+        page: number;
+        limit: number;
+    }>;
+    fetchEntry: (slug: string, options?: {
+        collection?: string;
+        preview?: boolean;
+        previewToken?: string;
+        expires?: number | string;
+    }) => Promise<CMSEntry>;
+    search: (q: string, options?: {
+        collection?: string;
+        limit?: number;
+        offset?: number;
+    }) => Promise<{
+        results: CMSEntry[];
+        total: number;
+    }>;
+};
+/**
+ * Fetches the navigation tree for a "page" collection. Drop-in replacement for @nuxt/content's
+ * queryCollectionNavigation().
+ *
+ * Supports:
+ *
+ * - `levels`: Max tree depth (e.g. `levels: 1` for top-level navbar links)
+ * - `path`: Scope to a specific branch/subtree for lazy loading (e.g. `path: "/docs/cms"`)
+ * - `limit` / `skip`: Pagination for large navigation sets
+ */
+export declare function queryCollectionNavigation(collection: string, options?: CMSNavigationOptions): Promise<CMSNavigationItem[]>;
+/**
+ * Returns a chainable query builder for a "page" collection. Drop-in replacement for
+ *
+ * @nuxt/content's queryCollection().
+ *
+ * Usage: const page = await queryCollection("docs").path("/docs/getting-started").first()
+ */
+export declare function queryCollection(collection: string): {
+    locale(loc: string): /*elided*/ any;
+    preview(enabled?: boolean, token?: string, expires?: string | number): /*elided*/ any;
+    path(p: string): /*elided*/ any;
+    where(field: string, opOrValue: any, value?: any): /*elided*/ any;
+    order(field: string, direction?: "ASC" | "DESC"): /*elided*/ any;
+    select(..._fields: string[]): /*elided*/ any;
+    limit(n: number): /*elided*/ any;
+    first(): Promise<CMSEntry | null>;
+    all(): Promise<CMSEntry[]>;
+};
+/**
+ * Returns [prev, next] navigation items surrounding the entry at `path`. Drop-in replacement for
+ *
+ * @nuxt/content's queryCollectionItemSurroundings().
+ */
+export declare function queryCollectionItemSurroundings(collection: string, path: string, options?: {
+    fields?: string[];
+}): Promise<[CMSEntry | null, CMSEntry | null]>;
+/**
+ * Reactive composable for managing multi-language CMS localization state.
+ * Allows reading active locale, switching locales, and persisting preferences across requests.
+ */
+export declare function useCMSLocale(): {
+    locale: import("vue").Ref<string, string>;
+    locales: import("vue").ComputedRef<string[]>;
+    defaultLocale: import("vue").ComputedRef<string>;
+    localeConfigs: import("vue").ComputedRef<CMSLocaleConfig[]>;
+    setLocale: (newLocale: string) => void;
+};
+/**
+ * Reactive client composable for searching documentation entries and heading sections.
+ */
+export declare function useDocsSearch(options?: {
+    collection?: string;
+    locale?: string;
+}): {
+    query: import("vue").Ref<string, string>;
+    results: import("vue").Ref<{
+        id: string;
+        path: string;
+        title: string;
+        pageTitle: string;
+        titles: string[];
+        content: string;
+        section?: string | undefined;
+        locale?: string | undefined;
+        level?: number | undefined;
+        score: number;
+    }[], DocsSearchSection[] | {
+        id: string;
+        path: string;
+        title: string;
+        pageTitle: string;
+        titles: string[];
+        content: string;
+        section?: string | undefined;
+        locale?: string | undefined;
+        level?: number | undefined;
+        score: number;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    total: import("vue").Ref<number, number>;
+    error: import("vue").Ref<Error | null, Error | null>;
+    search: (q: string) => Promise<void>;
+    searchDebounced: (q: string, delay?: number) => void;
+};

package/dist/runtime/app/composables/cms.mjs

@@ -0,0 +1,355 @@
+import { ref, computed } from "vue";
+import { useCMSPreview } from "./cms-preview.mjs";
+export function useCMS(collectionId) {
+  const runtimeConfig = useRuntimeConfig();
+  const publicCms = runtimeConfig.public?.qarpeo?.cms || {};
+  const apiPath = publicCms.apiPath || "/api/cms";
+  const entries = ref([]);
+  const entry = ref(null);
+  const total = ref(0);
+  const status = ref("idle");
+  const error = ref(null);
+  const fetchEntries = async (options = {}) => {
+    const targetCollection = options.collection || collectionId;
+    if (!targetCollection) {
+      throw new Error("Collection ID must be provided to useCMS or fetchEntries");
+    }
+    status.value = "loading";
+    error.value = null;
+    try {
+      const params = new URLSearchParams();
+      if (options.page) params.set("page", String(options.page));
+      if (options.limit) params.set("limit", String(options.limit));
+      if (options.sort) params.set("sort", options.sort);
+      if (options.status) params.set("status", options.status);
+      if (options.tag) params.set("tag", options.tag);
+      const qs = params.toString() ? `?${params.toString()}` : "";
+      const res = await $fetch(`${apiPath}/${targetCollection}${qs}`);
+      entries.value = res.entries || [];
+      total.value = res.total || 0;
+      status.value = "success";
+      return res;
+    } catch (err) {
+      status.value = "error";
+      error.value = err;
+      throw err;
+    }
+  };
+  const fetchEntry = async (slug, options = {}) => {
+    const targetCollection = options.collection || collectionId;
+    if (!targetCollection) {
+      throw new Error("Collection ID must be provided to useCMS or fetchEntry");
+    }
+    status.value = "loading";
+    error.value = null;
+    try {
+      const params = new URLSearchParams();
+      if (options.preview) params.set("preview", "true");
+      if (options.previewToken) params.set("preview_token", options.previewToken);
+      if (options.expires) params.set("expires", String(options.expires));
+      const qs = params.toString() ? `?${params.toString()}` : "";
+      const res = await $fetch(`${apiPath}/${targetCollection}/${slug}${qs}`);
+      entry.value = res.entry;
+      status.value = "success";
+      return res.entry;
+    } catch (err) {
+      status.value = "error";
+      error.value = err;
+      throw err;
+    }
+  };
+  const search = async (q, options = {}) => {
+    status.value = "loading";
+    error.value = null;
+    try {
+      const params = new URLSearchParams({ q });
+      const targetCollection = options.collection || collectionId;
+      if (targetCollection) params.set("collection", targetCollection);
+      if (options.limit) params.set("limit", String(options.limit));
+      if (options.offset) params.set("offset", String(options.offset));
+      const res = await $fetch(`${apiPath}/search?${params.toString()}`);
+      status.value = "success";
+      return res;
+    } catch (err) {
+      status.value = "error";
+      error.value = err;
+      throw err;
+    }
+  };
+  return {
+    entries,
+    entry,
+    total,
+    status,
+    error,
+    fetchEntries,
+    fetchEntry,
+    search
+  };
+}
+export async function queryCollectionNavigation(collection, options) {
+  const runtimeConfig = useRuntimeConfig();
+  const publicCms = runtimeConfig.public?.qarpeo?.cms || {};
+  const apiPath = publicCms.apiPath || "/api/cms";
+  const params = new URLSearchParams({ collection });
+  if (options?.levels != null) params.set("levels", String(options.levels));
+  if (options?.path) params.set("path", options.path);
+  if (options?.limit != null) params.set("limit", String(options.limit));
+  if (options?.skip != null) params.set("skip", String(options.skip));
+  if (options?.status) params.set("status", options.status);
+  if (options?.locale) params.set("locale", options.locale);
+  if (options?.unwrap != null) params.set("unwrap", String(options.unwrap));
+  if (options?.where && Object.keys(options.where).length > 0) {
+    params.set("where", JSON.stringify(options.where));
+  }
+  const res = await $fetch(`${apiPath}/navigation?${params.toString()}`);
+  return res?.navigation || [];
+}
+export function queryCollection(collection) {
+  const runtimeConfig = useRuntimeConfig();
+  const publicCms = runtimeConfig.public?.qarpeo?.cms || {};
+  const apiPath = publicCms.apiPath || "/api/cms";
+  let _path = null;
+  let _targetCollection = collection;
+  const _wheres = [];
+  let _orderField = null;
+  let _orderDirection = "ASC";
+  let _limit = null;
+  let _locale = null;
+  let _preview = null;
+  let _previewToken = null;
+  let _previewExpires = null;
+  const builder = {
+    locale(loc) {
+      _locale = loc;
+      return builder;
+    },
+    preview(enabled = true, token, expires) {
+      _preview = enabled;
+      if (token) _previewToken = token;
+      if (expires) _previewExpires = String(expires);
+      return builder;
+    },
+    path(p) {
+      _path = p;
+      if (_targetCollection === "content") {
+        const parts = p.replace(/^\//, "").split("/");
+        if (parts.length > 1 && parts[0]) {
+          _targetCollection = parts[0];
+        }
+      }
+      return builder;
+    },
+    where(field, opOrValue, value) {
+      if (value !== void 0) {
+        _wheres.push({ field, op: opOrValue, value });
+      } else {
+        _wheres.push({ field, op: "=", value: opOrValue });
+      }
+      if (_targetCollection === "content" && field === "path") {
+        const val = String(value !== void 0 ? value : opOrValue);
+        const seg = val.replace(/^\//, "").split(/[/_%]/)[0];
+        if (seg) _targetCollection = seg;
+      }
+      return builder;
+    },
+    order(field, direction = "ASC") {
+      _orderField = field;
+      _orderDirection = direction;
+      return builder;
+    },
+    select(..._fields) {
+      return builder;
+    },
+    limit(n) {
+      _limit = n;
+      return builder;
+    },
+    async first() {
+      let isPreviewActive = false;
+      let effectiveToken = null;
+      let effectiveExpires = null;
+      try {
+        const previewState = useCMSPreview();
+        isPreviewActive = _preview !== null ? _preview : previewState.isPreview.value;
+        effectiveToken = _previewToken || previewState.token.value;
+        effectiveExpires = _previewExpires || previewState.expires.value;
+      } catch {
+      }
+      if (_path) {
+        const params = new URLSearchParams({ path: _path });
+        if (_locale) params.set("locale", _locale);
+        if (isPreviewActive) params.set("preview", "true");
+        if (effectiveToken) params.set("preview_token", effectiveToken);
+        if (effectiveExpires) params.set("expires", String(effectiveExpires));
+        const res = await $fetch(
+          `${apiPath}/${_targetCollection}/by-path?${params.toString()}`
+        );
+        return res?.entry || null;
+      }
+      const items = await builder.all();
+      return items[0] || null;
+    },
+    async all() {
+      let isPreviewActive = false;
+      try {
+        const previewState = useCMSPreview();
+        isPreviewActive = _preview !== null ? _preview : previewState.isPreview.value;
+      } catch {
+      }
+      const params = new URLSearchParams();
+      if (isPreviewActive) params.set("preview", "true");
+      if (_limit) params.set("limit", String(_limit));
+      if (_orderField) params.set("sort", `${_orderField}:${_orderDirection.toLowerCase()}`);
+      if (_locale) params.set("locale", _locale);
+      const qs = params.toString() ? `?${params.toString()}` : "";
+      const res = await $fetch(`${apiPath}/${_targetCollection}${qs}`);
+      let list = res?.entries || [];
+      if (_wheres.length) {
+        for (const w of _wheres) {
+          if (w.op === "!=") {
+            list = list.filter((item) => item[w.field] !== w.value);
+          } else if (w.op === "=") {
+            list = list.filter((item) => item[w.field] === w.value);
+          } else if (w.op?.toUpperCase() === "LIKE") {
+            const pattern = String(w.value).replace(/%/g, ".*");
+            const reg = new RegExp(`^${pattern}$`);
+            list = list.filter((item) => reg.test(item[w.field] || ""));
+          }
+        }
+      }
+      return list;
+    }
+  };
+  return builder;
+}
+export async function queryCollectionItemSurroundings(collection, path, options = {}) {
+  const runtimeConfig = useRuntimeConfig();
+  const publicCms = runtimeConfig.public?.qarpeo?.cms || {};
+  const apiPath = publicCms.apiPath || "/api/cms";
+  const params = new URLSearchParams({ path });
+  if (options.fields?.length) params.set("fields", options.fields.join(","));
+  const res = await $fetch(`${apiPath}/${collection}/surroundings?${params.toString()}`);
+  return [res?.prev || null, res?.next || null];
+}
+export function useCMSLocale() {
+  const runtimeConfig = useRuntimeConfig();
+  const publicCms = runtimeConfig.public?.qarpeo?.cms || {};
+  const locales = computed(() => publicCms.locales || ["en"]);
+  const defaultLocale = computed(() => publicCms.defaultLocale || "en");
+  const initialLocale = (() => {
+    if (typeof document !== "undefined") {
+      const match = document.cookie.match(/(?:^|;\s*)qarpeo_locale=([^;]+)/);
+      if (match && match[1]) {
+        return decodeURIComponent(match[1]);
+      }
+      try {
+        const stored = localStorage.getItem("qarpeo_locale");
+        if (stored) return stored;
+      } catch {
+      }
+    }
+    return defaultLocale.value;
+  })();
+  const locale = ref(initialLocale);
+  function setLocale(newLocale) {
+    locale.value = newLocale;
+    if (typeof document !== "undefined") {
+      document.cookie = `qarpeo_locale=${encodeURIComponent(newLocale)}; path=/; max-age=31536000; SameSite=Lax`;
+      try {
+        localStorage.setItem("qarpeo_locale", newLocale);
+      } catch {
+      }
+    }
+  }
+  const localeConfigs = computed(() => {
+    const list = [];
+    const names = {
+      en: "English",
+      es: "Espa\xC3\xB1ol",
+      fr: "Fran\xC3\xA7ais",
+      de: "Deutsch",
+      it: "Italiano",
+      pt: "Portugu\xC3\xAAs",
+      ja: "\xE6\u2014\xA5\xE6\u0153\xAC\xE8\xAA\u017E",
+      zh: "\xE4\xB8\xAD\xE6\u2013\u2021",
+      ru: "\xD0\xA0\xD1\u0192\xD1\x81\xD1\x81\xD0\xBA\xD0\xB8\xD0\xB9",
+      ar: "\xD8\xA7\xD9\u201E\xD8\xB9\xD8\xB1\xD8\xA8\xD9\u0160\xD8\xA9"
+    };
+    const flags = {
+      en: "\xF0\u0178\u2021\xAC\xF0\u0178\u2021\xA7",
+      es: "\xF0\u0178\u2021\xAA\xF0\u0178\u2021\xB8",
+      fr: "\xF0\u0178\u2021\xAB\xF0\u0178\u2021\xB7",
+      de: "\xF0\u0178\u2021\xA9\xF0\u0178\u2021\xAA",
+      it: "\xF0\u0178\u2021\xAE\xF0\u0178\u2021\xB9",
+      pt: "\xF0\u0178\u2021\xB5\xF0\u0178\u2021\xB9",
+      ja: "\xF0\u0178\u2021\xAF\xF0\u0178\u2021\xB5",
+      zh: "\xF0\u0178\u2021\xA8\xF0\u0178\u2021\xB3",
+      ru: "\xF0\u0178\u2021\xB7\xF0\u0178\u2021\xBA",
+      ar: "\xF0\u0178\u2021\xB8\xF0\u0178\u2021\xA6"
+    };
+    for (const code of locales.value) {
+      list.push({
+        code,
+        name: names[code] || code.toUpperCase(),
+        flag: flags[code] || "\xF0\u0178\u0152\x90",
+        dir: code === "ar" || code === "he" ? "rtl" : "ltr"
+      });
+    }
+    return list;
+  });
+  return {
+    locale,
+    locales,
+    defaultLocale,
+    localeConfigs,
+    setLocale
+  };
+}
+export function useDocsSearch(options) {
+  const query = ref("");
+  const results = ref([]);
+  const loading = ref(false);
+  const total = ref(0);
+  const error = ref(null);
+  let timer = null;
+  async function search(q) {
+    query.value = q;
+    if (!q || !q.trim()) {
+      results.value = [];
+      total.value = 0;
+      return;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      const params = new URLSearchParams({ q: q.trim() });
+      if (options?.collection) params.set("collection", options.collection);
+      if (options?.locale) params.set("locale", options.locale);
+      const res = await $fetch(`/api/docs/search?${params.toString()}`);
+      results.value = res?.results || [];
+      total.value = res?.total || 0;
+    } catch (err) {
+      error.value = err;
+      results.value = [];
+      total.value = 0;
+    } finally {
+      loading.value = false;
+    }
+  }
+  function searchDebounced(q, delay = 150) {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      search(q);
+    }, delay);
+  }
+  return {
+    query,
+    results,
+    loading,
+    total,
+    error,
+    search,
+    searchDebounced
+  };
+}

package/dist/runtime/app/composables/docs-version.d.ts

@@ -0,0 +1,35 @@
+import type { DocsVersionItem } from "../../../types";
+/**
+ * Reactive client composable for docs versioning.
+ * Automatically parses active version from router path (/docs/v1/... vs /docs/...),
+ * provides list of versions, and seamlessly switches versions while preserving subpaths.
+ *
+ * Version list resolution order:
+ *  1. Explicit `options.versions` passed to this composable
+ *  2. `runtimeConfig.public.qarpeo.docsVersions` (manual override in nuxt.config)
+ *  3. Auto-derived from `runtimeConfig.public.qarpeoVersion` (injected by the qarpeo
+ *     module from its own package.json) — a single "latest" entry, no dropdown shown.
+ */
+export declare function useDocsVersion(options?: {
+    versions?: DocsVersionItem[];
+}): {
+    currentVersion: import("vue").ComputedRef<string>;
+    isLatest: import("vue").ComputedRef<boolean>;
+    isArchived: import("vue").ComputedRef<boolean>;
+    versions: import("vue").Ref<{
+        id: string;
+        label: string;
+        prefix: string;
+        isLatest?: boolean | undefined;
+        isArchived?: boolean | undefined;
+    }[], DocsVersionItem[] | {
+        id: string;
+        label: string;
+        prefix: string;
+        isLatest?: boolean | undefined;
+        isArchived?: boolean | undefined;
+    }[]>;
+    activeVersionItem: import("vue").ComputedRef<DocsVersionItem>;
+    getVersionPath: (targetVersionId: string) => string;
+    switchVersion: (targetVersionId: string) => Promise<void>;
+};