@ztl-uwu/nuxt-content 2.13.5

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

@@ -0,0 +1,130 @@
+import { type Options as MiniSearchOptions } from 'minisearch';
+import { type MaybeRefOrGetter, type Ref } from '#imports';
+export declare const defineMiniSearchOptions: <DataItem>(options: MiniSearchOptions<DataItem>) => Ref<{
+    fields: string[];
+    idField?: string | undefined;
+    storeFields?: string[] | undefined;
+    extractField?: ((document: DataItem, fieldName: string) => string) | undefined;
+    tokenize?: ((text: string, fieldName?: string) => string[]) | undefined;
+    processTerm?: ((term: string, fieldName?: string) => string | string[] | null | undefined | false) | undefined;
+    logger?: ((level: "error" | "debug" | "info" | "warn", message: string, code?: string) => void) | undefined;
+    autoVacuum?: boolean | {
+        batchSize?: number | undefined;
+        batchWait?: number | undefined;
+        minDirtCount?: number | undefined;
+        minDirtFactor?: number | undefined;
+    } | undefined;
+    searchOptions?: {
+        fields?: string[] | undefined;
+        filter?: ((result: import("minisearch").SearchResult) => boolean) | undefined;
+        boost?: {
+            [fieldName: string]: number;
+        } | undefined;
+        boostTerm?: ((term: string, i: number, terms: string[]) => number) | undefined;
+        weights?: {
+            fuzzy: number;
+            prefix: number;
+        } | undefined;
+        boostDocument?: ((documentId: any, term: string, storedFields?: Record<string, unknown>) => number) | undefined;
+        prefix?: boolean | ((term: string, index: number, terms: string[]) => boolean) | undefined;
+        fuzzy?: boolean | number | ((term: string, index: number, terms: string[]) => boolean | number) | undefined;
+        maxFuzzy?: number | undefined;
+        combineWith?: import("minisearch").CombinationOperator | undefined;
+        tokenize?: ((text: string) => string[]) | undefined;
+        processTerm?: ((term: string) => string | string[] | null | undefined | false) | undefined;
+        bm25?: {
+            k: number;
+            b: number;
+            d: number;
+        } | undefined;
+    } | undefined;
+    autoSuggestOptions?: {
+        fields?: string[] | undefined;
+        filter?: ((result: import("minisearch").SearchResult) => boolean) | undefined;
+        boost?: {
+            [fieldName: string]: number;
+        } | undefined;
+        boostTerm?: ((term: string, i: number, terms: string[]) => number) | undefined;
+        weights?: {
+            fuzzy: number;
+            prefix: number;
+        } | undefined;
+        boostDocument?: ((documentId: any, term: string, storedFields?: Record<string, unknown>) => number) | undefined;
+        prefix?: boolean | ((term: string, index: number, terms: string[]) => boolean) | undefined;
+        fuzzy?: boolean | number | ((term: string, index: number, terms: string[]) => boolean | number) | undefined;
+        maxFuzzy?: number | undefined;
+        combineWith?: import("minisearch").CombinationOperator | undefined;
+        tokenize?: ((text: string) => string[]) | undefined;
+        processTerm?: ((term: string) => string | string[] | null | undefined | false) | undefined;
+        bm25?: {
+            k: number;
+            b: number;
+            d: number;
+        } | undefined;
+    } | undefined;
+}, MiniSearchOptions<DataItem> | {
+    fields: string[];
+    idField?: string | undefined;
+    storeFields?: string[] | undefined;
+    extractField?: ((document: DataItem, fieldName: string) => string) | undefined;
+    tokenize?: ((text: string, fieldName?: string) => string[]) | undefined;
+    processTerm?: ((term: string, fieldName?: string) => string | string[] | null | undefined | false) | undefined;
+    logger?: ((level: "error" | "debug" | "info" | "warn", message: string, code?: string) => void) | undefined;
+    autoVacuum?: boolean | {
+        batchSize?: number | undefined;
+        batchWait?: number | undefined;
+        minDirtCount?: number | undefined;
+        minDirtFactor?: number | undefined;
+    } | undefined;
+    searchOptions?: {
+        fields?: string[] | undefined;
+        filter?: ((result: import("minisearch").SearchResult) => boolean) | undefined;
+        boost?: {
+            [fieldName: string]: number;
+        } | undefined;
+        boostTerm?: ((term: string, i: number, terms: string[]) => number) | undefined;
+        weights?: {
+            fuzzy: number;
+            prefix: number;
+        } | undefined;
+        boostDocument?: ((documentId: any, term: string, storedFields?: Record<string, unknown>) => number) | undefined;
+        prefix?: boolean | ((term: string, index: number, terms: string[]) => boolean) | undefined;
+        fuzzy?: boolean | number | ((term: string, index: number, terms: string[]) => boolean | number) | undefined;
+        maxFuzzy?: number | undefined;
+        combineWith?: import("minisearch").CombinationOperator | undefined;
+        tokenize?: ((text: string) => string[]) | undefined;
+        processTerm?: ((term: string) => string | string[] | null | undefined | false) | undefined;
+        bm25?: {
+            k: number;
+            b: number;
+            d: number;
+        } | undefined;
+    } | undefined;
+    autoSuggestOptions?: {
+        fields?: string[] | undefined;
+        filter?: ((result: import("minisearch").SearchResult) => boolean) | undefined;
+        boost?: {
+            [fieldName: string]: number;
+        } | undefined;
+        boostTerm?: ((term: string, i: number, terms: string[]) => number) | undefined;
+        weights?: {
+            fuzzy: number;
+            prefix: number;
+        } | undefined;
+        boostDocument?: ((documentId: any, term: string, storedFields?: Record<string, unknown>) => number) | undefined;
+        prefix?: boolean | ((term: string, index: number, terms: string[]) => boolean) | undefined;
+        fuzzy?: boolean | number | ((term: string, index: number, terms: string[]) => boolean | number) | undefined;
+        maxFuzzy?: number | undefined;
+        combineWith?: import("minisearch").CombinationOperator | undefined;
+        tokenize?: ((text: string) => string[]) | undefined;
+        processTerm?: ((term: string) => string | string[] | null | undefined | false) | undefined;
+        bm25?: {
+            k: number;
+            b: number;
+            d: number;
+        } | undefined;
+    } | undefined;
+}>;
+export declare const searchContent: <DataItem>(search: MaybeRefOrGetter<string>, options?: {
+    miniSearch?: MaybeRefOrGetter<MiniSearchOptions<DataItem>>;
+}) => Promise<import("vue").ComputedRef<import("minisearch").SearchResult[]>>;

package/dist/runtime/composables/search.js

@@ -0,0 +1,59 @@
+import { createError } from "h3";
+import MiniSearch from "minisearch";
+import { useRuntimeConfig, useFetch, ref, computed, toValue } from "#imports";
+export const defineMiniSearchOptions = (options) => {
+  return ref(options);
+};
+export const searchContent = async (search, options = {}) => {
+  const runtimeConfig = useRuntimeConfig();
+  const { content } = runtimeConfig.public;
+  const { integrity, api: { baseURL: baseAPI }, search: searchOptions } = content;
+  const { indexed: useIndexedSearch } = searchOptions || {};
+  const searchRoute = `${baseAPI}/search${integrity ? "-" + integrity : ""}`;
+  if (useIndexedSearch) {
+    const { options: miniSearchOptions } = searchOptions || {};
+    const { data: data2 } = await useFetch(searchRoute, { responseType: "text" });
+    if (!data2.value) {
+      throw createError({
+        statusCode: 500,
+        message: "Missing search data"
+      });
+    }
+    const results2 = useIndexedMiniSearch(search, data2, miniSearchOptions);
+    return results2;
+  }
+  if (!options.miniSearch) {
+    throw createError({
+      statusCode: 500,
+      message: "Missing miniSearch options"
+    });
+  }
+  const { data } = await useFetch(searchRoute);
+  if (!data.value) {
+    throw createError({
+      statusCode: 500,
+      message: "Missing search data"
+    });
+  }
+  const results = useMiniSearch(search, data, options.miniSearch);
+  return results;
+};
+const useIndexedMiniSearch = (search, indexedData, options) => {
+  const indexedMiniSearch = computed(() => {
+    return MiniSearch.loadJSON(toValue(indexedData), toValue(options));
+  });
+  const results = computed(() => {
+    return indexedMiniSearch.value.search(toValue(search));
+  });
+  return results;
+};
+const useMiniSearch = function(search, data, options) {
+  const miniSearch = computed(() => {
+    return new MiniSearch(toValue(options));
+  });
+  miniSearch.value.addAll(toValue(data));
+  const results = computed(() => {
+    return miniSearch.value.search(toValue(search));
+  });
+  return results;
+};

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

@@ -0,0 +1,5 @@
+import { unwrap, flatUnwrap } from '@nuxtjs/mdc/dist/runtime/utils/node';
+export declare const useUnwrap: () => {
+    unwrap: typeof unwrap;
+    flatUnwrap: typeof flatUnwrap;
+};

package/dist/runtime/composables/useUnwrap.js

@@ -0,0 +1,5 @@
+import { unwrap, flatUnwrap } from "@nuxtjs/mdc/dist/runtime/utils/node";
+export const useUnwrap = () => ({
+  unwrap,
+  flatUnwrap
+});

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

@@ -0,0 +1,6 @@
+import type { useContent } from './content';
+export declare const withContentBase: (url: string) => string;
+export declare const useContentDisabled: () => ReturnType<typeof useContent>;
+export declare const navigationDisabled: () => never;
+export declare const addPrerenderPath: (path: string) => void;
+export declare const shouldUseClientDB: () => boolean;

package/dist/runtime/composables/utils.js

@@ -0,0 +1,36 @@
+import { withBase } from "ufo";
+import { useContentPreview } from "./preview.js";
+import { useRuntimeConfig, useRequestEvent } from "#imports";
+export const withContentBase = (url) => withBase(url, useRuntimeConfig().public.content.api.baseURL);
+export const useContentDisabled = () => {
+  console.warn("useContent is only accessible when you are using `documentDriven` mode.");
+  console.warn("Learn more by visiting: https://content.nuxt.com/document-driven");
+  throw new Error("useContent is only accessible when you are using `documentDriven` mode.");
+};
+export const navigationDisabled = () => {
+  console.warn("Navigation is only accessible when you enable it in module options.");
+  console.warn("Learn more by visiting: https://content.nuxt.com/get-started/configuration#navigation");
+  throw new Error("Navigation is only accessible when you enable it in module options.");
+};
+export const addPrerenderPath = (path) => {
+  const event = useRequestEvent();
+  if (event) {
+    event.node.res.setHeader(
+      "x-nitro-prerender",
+      [
+        event.node.res.getHeader("x-nitro-prerender"),
+        path
+      ].filter(Boolean).join(",")
+    );
+  }
+};
+export const shouldUseClientDB = () => {
+  const { experimental } = useRuntimeConfig().public.content;
+  if (import.meta.server) {
+    return false;
+  }
+  if (experimental.clientDB) {
+    return true;
+  }
+  return useContentPreview().isEnabled();
+};

package/dist/runtime/composables/web-socket.d.ts

@@ -0,0 +1,3 @@
+export declare function useContentWebSocket(): {
+    connect: (retry?: boolean) => void;
+} | undefined;

package/dist/runtime/composables/web-socket.js

@@ -0,0 +1,65 @@
+import { useRuntimeConfig, refreshNuxtData } from "#imports";
+const logger = {
+  log: (...args) => console.log("[Content]", ...args),
+  warn: (...args) => console.warn("[Content]", ...args)
+};
+let ws;
+export function useContentWebSocket() {
+  if (!window.WebSocket) {
+    logger.warn("Could not enable hot reload, your browser does not support WebSocket.");
+    return;
+  }
+  const onMessage = (message) => {
+    try {
+      const data = JSON.parse(message.data);
+      if (!data) {
+        return;
+      }
+      refreshNuxtData();
+    } catch {
+    }
+  };
+  const onOpen = () => logger.log("WS connected!");
+  const onError = (e) => {
+    switch (e.code) {
+      case "ECONNREFUSED":
+        connect(true);
+        break;
+      default:
+        logger.warn("WS Error:", e);
+        break;
+    }
+  };
+  const onClose = (e) => {
+    if (e.code === 1e3 || e.code === 1005) {
+      logger.log("WS closed!");
+    } else {
+      connect(true);
+    }
+  };
+  const connect = (retry = false) => {
+    if (retry) {
+      logger.log("WS reconnecting..");
+      setTimeout(connect, 1e3);
+      return;
+    }
+    if (ws) {
+      try {
+        ws.close();
+      } catch {
+      }
+      ws = void 0;
+    }
+    const wsURL = `${useRuntimeConfig().public.content.wsUrl}ws`;
+    logger.log(`WS connect to ${wsURL}`);
+    ws = new WebSocket(wsURL);
+    ws.onopen = onOpen;
+    ws.onmessage = onMessage;
+    ws.onerror = onError;
+    ws.onclose = onClose;
+  };
+  connect();
+  return {
+    connect
+  };
+}

package/dist/runtime/legacy/composables/client-db.d.ts

@@ -0,0 +1,12 @@
+import { type Storage } from 'unstorage';
+import type { NavItem, ParsedContent, QueryBuilder, QueryBuilderParams } from '@nuxt/content';
+export declare const contentStorage: Storage;
+interface ClientDB {
+    storage: Storage;
+    fetch: (query: QueryBuilder<ParsedContent>) => Promise<ParsedContent | ParsedContent[]>;
+    query: (query?: QueryBuilderParams) => QueryBuilder<ParsedContent>;
+}
+export declare function createDB(storage: Storage): ClientDB;
+export declare function useContentDatabase(): Promise<ClientDB>;
+export declare function generateNavigation(query?: QueryBuilderParams): Promise<Array<NavItem>>;
+export {};

package/dist/runtime/legacy/composables/client-db.js

@@ -0,0 +1,105 @@
+import memoryDriver from "unstorage/drivers/memory";
+import { createStorage, prefixStorage } from "unstorage";
+import { withBase } from "ufo";
+import { createPipelineFetcherLegacy } from "../../query/match/pipeline-legacy.js";
+import { createQuery } from "../../query/query.js";
+import { createNav } from "../../server/navigation.js";
+import { useContentPreview } from "../../composables/preview.js";
+import { useRuntimeConfig, useNuxtApp } from "#imports";
+const withContentBase = (url) => withBase(url, useRuntimeConfig().public.content.api.baseURL);
+export const contentStorage = prefixStorage(createStorage({ driver: memoryDriver() }), "@content");
+export function createDB(storage) {
+  async function getItems() {
+    const keys = new Set(await storage.getKeys("cache:"));
+    const previewToken = useContentPreview().getPreviewToken();
+    if (previewToken) {
+      const previewMeta = await storage.getItem(`${previewToken}$`).then((data) => data || {});
+      if (Array.isArray(previewMeta.ignoreSources)) {
+        const sources = previewMeta.ignoreSources.map((s) => `cache:${s.trim()}:`);
+        for (const key of keys) {
+          if (sources.some((s) => key.startsWith(s))) {
+            keys.delete(key);
+          }
+        }
+      }
+      const previewKeys = await storage.getKeys(`${previewToken}:`);
+      const previewContents = await Promise.all(previewKeys.map((key) => storage.getItem(key)));
+      for (const pItem of previewContents) {
+        keys.delete(`cache:${pItem._id}`);
+        if (!pItem.__deleted) {
+          keys.add(`${previewToken}:${pItem._id}`);
+        }
+      }
+    }
+    const items = await Promise.all(Array.from(keys).map((key) => storage.getItem(key)));
+    return items;
+  }
+  return {
+    storage,
+    fetch: createPipelineFetcherLegacy(getItems),
+    query: (query) => createQuery(createPipelineFetcherLegacy(getItems), {
+      initialParams: query,
+      legacy: true
+    })
+  };
+}
+let contentDatabase = null;
+let contentDatabaseInitPromise = null;
+export async function useContentDatabase() {
+  if (contentDatabaseInitPromise) {
+    await contentDatabaseInitPromise;
+  } else if (!contentDatabase) {
+    contentDatabaseInitPromise = initContentDatabase();
+    contentDatabase = await contentDatabaseInitPromise;
+  }
+  return contentDatabase;
+}
+async function initContentDatabase() {
+  const nuxtApp = useNuxtApp();
+  const { content } = useRuntimeConfig().public;
+  const _contentDatabase = createDB(contentStorage);
+  const integrity = await _contentDatabase.storage.getItem("integrity");
+  if (content.integrity !== +(integrity || 0)) {
+    const { contents, navigation } = await $fetch(withContentBase(content.integrity ? `cache.${content.integrity}.json` : "cache.json"));
+    await Promise.all(
+      contents.map((content2) => _contentDatabase.storage.setItem(`cache:${content2._id}`, content2))
+    );
+    await _contentDatabase.storage.setItem("navigation", navigation);
+    await _contentDatabase.storage.setItem("integrity", content.integrity);
+  }
+  await nuxtApp.callHook("content:storage", _contentDatabase.storage);
+  return _contentDatabase;
+}
+export async function generateNavigation(query) {
+  const db = await useContentDatabase();
+  if (!useContentPreview().getPreviewToken() && Object.keys(query || {}).length === 0) {
+    return db.storage.getItem("navigation");
+  }
+  const contents = await db.query(query).where({
+    /**
+     * Partial contents are not included in the navigation
+     * A partial content is a content that has `_` prefix in its path
+     */
+    _partial: false,
+    /**
+    * Exclude any pages which have opted out of navigation via frontmatter.
+    */
+    navigation: {
+      $ne: false
+    }
+  }).find();
+  const dirConfigs = await db.query().where({ _path: /\/_dir$/i, _partial: true }).find();
+  const configs = dirConfigs.reduce((configs2, conf) => {
+    if (conf.title?.toLowerCase() === "dir") {
+      conf.title = void 0;
+    }
+    const key = conf._path.split("/").slice(0, -1).join("/") || "/";
+    configs2[key] = {
+      ...conf,
+      // Extract meta from body. (non MD files)
+      ...conf.body
+    };
+    return configs2;
+  }, {});
+  return createNav(contents, configs);
+}

package/dist/runtime/legacy/composables/navigation.d.ts

@@ -0,0 +1,2 @@
+import type { NavItem, QueryBuilder, QueryBuilderParams, ContentQueryBuilder } from '@nuxt/content';
+export declare const fetchContentNavigation: (queryBuilder?: QueryBuilder | QueryBuilderParams | ContentQueryBuilder) => Promise<Array<NavItem>>;

package/dist/runtime/legacy/composables/navigation.js

@@ -0,0 +1,34 @@
+import { hash } from "ohash";
+import { encodeQueryParams } from "../../utils/query.js";
+import { jsonStringify } from "../../utils/json.js";
+import { addPrerenderPath, shouldUseClientDB, withContentBase } from "../../composables/utils.js";
+import { useContentPreview } from "../../composables/preview.js";
+import { queryContent } from "./query.js";
+import { useRuntimeConfig } from "#imports";
+export const fetchContentNavigation = async (queryBuilder) => {
+  const { content } = useRuntimeConfig().public;
+  if (typeof queryBuilder?.params !== "function") {
+    queryBuilder = queryContent(queryBuilder);
+  }
+  const params = queryBuilder.params();
+  const apiPath = content.experimental.stripQueryParameters ? withContentBase(`/navigation/${import.meta.dev ? "_" : `${hash(params)}.${content.integrity}`}/${encodeQueryParams(params)}.json`) : withContentBase(import.meta.dev ? `/navigation/${hash(params)}` : `/navigation/${hash(params)}.${content.integrity}.json`);
+  if (!import.meta.dev && import.meta.server) {
+    addPrerenderPath(apiPath);
+  }
+  if (shouldUseClientDB()) {
+    const generateNavigation = await import("./client-db.js").then((m) => m.generateNavigation);
+    return generateNavigation(params);
+  }
+  const data = await $fetch(apiPath, {
+    method: "GET",
+    responseType: "json",
+    params: content.experimental.stripQueryParameters ? void 0 : {
+      _params: jsonStringify(params),
+      previewToken: useContentPreview().getPreviewToken()
+    }
+  });
+  if (typeof data === "string" && data.startsWith("<!DOCTYPE html>")) {
+    throw new Error("Not found");
+  }
+  return data;
+};

package/dist/runtime/legacy/composables/query.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedContent, QueryBuilder, QueryBuilderParams } from '@nuxt/content';
+/**
+ * Query fetcher
+ */
+export declare const createQueryFetch: <T = ParsedContent>() => (query: QueryBuilder<T>) => Promise<any>;
+/**
+ * Query contents from path
+ */
+export declare function queryContent<T = ParsedContent>(query?: QueryBuilderParams): QueryBuilder<T>;
+export declare function queryContent<T = ParsedContent>(query: string, ...pathParts: string[]): QueryBuilder<T>;

package/dist/runtime/legacy/composables/query.js

@@ -0,0 +1,61 @@
+import { joinURL, withLeadingSlash, withoutTrailingSlash } from "ufo";
+import { hash } from "ohash";
+import { createQuery } from "../../query/query.js";
+import { encodeQueryParams } from "../../utils/query.js";
+import { jsonStringify } from "../../utils/json.js";
+import { addPrerenderPath, shouldUseClientDB, withContentBase } from "../../composables/utils.js";
+import { useContentPreview } from "../../composables/preview.js";
+import { useRuntimeConfig } from "#imports";
+export const createQueryFetch = () => async (query) => {
+  const { content } = useRuntimeConfig().public;
+  const params = query.params();
+  const apiPath = content.experimental.stripQueryParameters ? withContentBase(`/query/${import.meta.dev ? "_" : `${hash(params)}.${content.integrity}`}/${encodeQueryParams(params)}.json`) : withContentBase(import.meta.dev ? "/query" : `/query/${hash(params)}.${content.integrity}.json`);
+  if (!import.meta.dev && import.meta.server) {
+    addPrerenderPath(apiPath);
+  }
+  if (shouldUseClientDB()) {
+    const db = await import("./client-db.js").then((m) => m.useContentDatabase());
+    return db.fetch(query);
+  }
+  const _query = content.experimental.stripQueryParameters ? void 0 : `_params=${encodeURIComponent(jsonStringify(params))}&previewToken=${useContentPreview().getPreviewToken()}`;
+  const data = await $fetch(apiPath + "?" + _query, { method: "GET", responseType: "json" });
+  if (typeof data === "string" && data.startsWith("<!DOCTYPE html>")) {
+    throw new Error("Not found");
+  }
+  return data;
+};
+export function queryContent(query, ...pathParts) {
+  const { content } = useRuntimeConfig().public;
+  const queryBuilder = createQuery(createQueryFetch(), {
+    initialParams: typeof query !== "string" ? query : {},
+    legacy: true
+  });
+  let path;
+  if (typeof query === "string") {
+    path = withLeadingSlash(joinURL(query, ...pathParts));
+  }
+  const originalParamsFn = queryBuilder.params;
+  queryBuilder.params = () => {
+    const params = originalParamsFn();
+    if (path) {
+      params.where = params.where || [];
+      if (params.first && (params.where || []).length === 0) {
+        params.where.push({ _path: withoutTrailingSlash(path) });
+      } else {
+        params.where.push({ _path: new RegExp(`^${path.replace(/[-[\]{}()*+.,^$\s/]/g, "\\$&")}`) });
+      }
+    }
+    if (!params.sort?.length) {
+      params.sort = [{ _stem: 1, $numeric: true }];
+    }
+    if (content.locales.length) {
+      const queryLocale = params.where?.find((w) => w._locale)?._locale;
+      if (!queryLocale) {
+        params.where = params.where || [];
+        params.where.push({ _locale: content.defaultLocale });
+      }
+    }
+    return params;
+  };
+  return queryBuilder;
+}

package/dist/runtime/legacy/plugins/documentDriven.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;