@ztl-uwu/nuxt-content 2.13.5

package/dist/runtime/legacy/plugins/documentDriven.js

@@ -0,0 +1,231 @@
+import { withoutTrailingSlash, hasProtocol } from "ufo";
+import { pascalCase } from "scule";
+import { callWithNuxt } from "#app/nuxt";
+import { useContentState } from "../../composables/content.js";
+import { useContentHelpers } from "../../composables/helpers.js";
+import { fetchContentNavigation } from "../composables/navigation.js";
+import { queryContent } from "../composables/query.js";
+import { defineNuxtPlugin } from "nuxt/app";
+import { useRuntimeConfig, addRouteMiddleware, navigateTo, useRoute, prefetchComponents, useRouter } from "#imports";
+import { componentNames } from "#components";
+import layouts from "#build/layouts";
+export default defineNuxtPlugin((nuxt) => {
+  const moduleOptions = useRuntimeConfig()?.public?.content.documentDriven;
+  const isClientDBEnabled = useRuntimeConfig()?.public?.content.experimental.clientDB;
+  const { navigation, pages, globals, surrounds } = useContentState();
+  const findLayout = (to, page, navigation2, globals2) => {
+    if (page && page?.layout) {
+      return page.layout;
+    }
+    if (to.matched[0] && to.matched[0].meta?.layout) {
+      return to.matched[0].meta.layout;
+    }
+    if (navigation2 && page) {
+      const { navKeyFromPath } = useContentHelpers();
+      const layoutFromNav = navKeyFromPath(page._path, "layout", navigation2);
+      if (layoutFromNav) {
+        return layoutFromNav;
+      }
+    }
+    if (moduleOptions.layoutFallbacks && globals2) {
+      let layoutFallback;
+      for (const fallback of moduleOptions.layoutFallbacks) {
+        if (globals2[fallback] && globals2[fallback].layout) {
+          layoutFallback = globals2[fallback].layout;
+          break;
+        }
+      }
+      if (layoutFallback) {
+        return layoutFallback;
+      }
+    }
+    return "default";
+  };
+  const refresh = async (to, dedup = false) => {
+    nuxt.callHook("content:document-driven:start", { route: to, dedup });
+    const routeConfig = to.meta.documentDriven || {};
+    if (to.meta.documentDriven === false) {
+      return;
+    }
+    const _path = withoutTrailingSlash(to.path);
+    const promises = [];
+    if (moduleOptions.navigation && routeConfig.navigation !== false) {
+      const navigationQuery = () => {
+        const { navigation: navigation2 } = useContentState();
+        if (navigation2.value && !dedup) {
+          return navigation2.value;
+        }
+        return fetchContentNavigation().then((_navigation) => {
+          navigation2.value = _navigation;
+          return _navigation;
+        }).catch(() => null);
+      };
+      promises.push(navigationQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    if (moduleOptions.globals) {
+      const globalsQuery = () => {
+        const { globals: globals2 } = useContentState();
+        if (typeof moduleOptions.globals === "object" && Array.isArray(moduleOptions.globals)) {
+          console.log("Globals must be a list of keys with QueryBuilderParams as a value.");
+          return;
+        }
+        return Promise.all(
+          Object.entries(moduleOptions.globals).map(
+            ([key, query]) => {
+              if (!dedup && globals2.value[key]) {
+                return globals2.value[key];
+              }
+              let type = "findOne";
+              if (query?.type) {
+                type = query.type;
+              }
+              return queryContent(query)[type]().catch(() => null);
+            }
+          )
+        ).then(
+          (values) => {
+            return values.reduce(
+              (acc, value, index) => {
+                const key = Object.keys(moduleOptions.globals)[index];
+                if (key) {
+                  acc[key] = value;
+                }
+                return acc;
+              },
+              {}
+            );
+          }
+        );
+      };
+      promises.push(globalsQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    if (moduleOptions.page && routeConfig.page !== false) {
+      let where = { _path };
+      if (typeof routeConfig.page === "string") {
+        where = { _path: routeConfig.page };
+      }
+      if (typeof routeConfig.page === "object") {
+        where = routeConfig.page;
+      }
+      const pageQuery = () => {
+        const { pages: pages2 } = useContentState();
+        if (!dedup && pages2.value[_path] && pages2.value[_path]._path === _path) {
+          return pages2.value[_path];
+        }
+        return queryContent().where(where).findOne().catch(() => null);
+      };
+      promises.push(pageQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    if (moduleOptions.surround && routeConfig.surround !== false) {
+      let surround = _path;
+      if (["string", "object"].includes(typeof routeConfig.page)) {
+        surround = routeConfig.page;
+      }
+      if (["string", "object"].includes(typeof routeConfig.surround)) {
+        surround = routeConfig.surround;
+      }
+      const surroundQuery = () => {
+        const { surrounds: surrounds2 } = useContentState();
+        if (!dedup && surrounds2.value[_path]) {
+          return surrounds2.value[_path];
+        }
+        return queryContent().where({
+          _partial: { $not: true },
+          navigation: { $not: false }
+        }).without(["body"]).findSurround(surround).catch(() => null);
+      };
+      promises.push(surroundQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    return await Promise.all(promises.map((promise) => promise())).then(async ([
+      _navigation,
+      _globals,
+      _page,
+      _surround
+    ]) => {
+      if (_navigation) {
+        navigation.value = _navigation;
+      }
+      if (_globals) {
+        globals.value = _globals;
+      }
+      if (_surround) {
+        surrounds.value[_path] = _surround;
+      }
+      const redirectTo = _page?.redirect || _page?._dir?.navigation?.redirect;
+      if (redirectTo) {
+        pages.value[_path] = _page;
+        return redirectTo;
+      }
+      if (_page) {
+        const layoutName = findLayout(to, _page, _navigation, _globals);
+        const layout = layouts[layoutName];
+        if (layout && typeof layout === "function") {
+          await layout();
+        }
+        to.meta.layout = layoutName;
+        _page.layout = layoutName;
+      }
+      pages.value[_path] = _page;
+      await nuxt.callHook("content:document-driven:finish", { route: to, dedup, page: _page, navigation: _navigation, globals: _globals, surround: _surround });
+    });
+  };
+  if (import.meta.client) {
+    const router = useRouter();
+    nuxt.hook("link:prefetch", (link) => {
+      if (!(link in pages.value) && !hasProtocol(link)) {
+        const route = router.resolve(link);
+        if (route.matched.length > 0) {
+          refresh(route);
+        }
+      }
+    });
+    nuxt.hooks.hook("content:document-driven:finish", ({ page }) => {
+      if (page?.body?.children) {
+        prefetchBodyComponents(page.body.children);
+      }
+    });
+  }
+  addRouteMiddleware(async (to, from) => {
+    if (import.meta.client && !isClientDBEnabled && to.path === from.path) {
+      if (!to.meta.layout) {
+        const _path = withoutTrailingSlash(to.path);
+        if (pages.value[_path]) {
+          to.meta.layout = pages.value[_path].layout;
+        }
+      }
+      return;
+    }
+    const redirect = await refresh(to, false);
+    if (redirect) {
+      if (hasProtocol(redirect)) {
+        return callWithNuxt(nuxt, navigateTo, [redirect, { external: true }]);
+      } else {
+        return redirect;
+      }
+    }
+  });
+  nuxt.hook("app:data:refresh", async () => import.meta.client && await refresh(useRoute(), true));
+});
+function prefetchBodyComponents(nodes) {
+  for (const node of nodes) {
+    if (node.children) {
+      prefetchBodyComponents(node.children);
+    }
+    if (node.type === "element" && node.tag) {
+      const el = pascalCase(node.tag);
+      for (const name of ["Prose" + el, el]) {
+        if (componentNames.includes(name)) {
+          prefetchComponents(name);
+        }
+      }
+    }
+  }
+}

package/dist/runtime/legacy/server.d.ts

@@ -0,0 +1,3 @@
+import type { serverQueryContent as legacyServerQueryContent } from './types';
+export { parseContent } from '../server/storage';
+export declare const serverQueryContent: typeof legacyServerQueryContent;

package/dist/runtime/legacy/server.js

@@ -0,0 +1,3 @@
+import { serverQueryContent as _serverQueryContent } from "../server/storage.js";
+export { parseContent } from "../server/storage.js";
+export const serverQueryContent = _serverQueryContent;

package/dist/runtime/legacy/types.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedContent, QueryBuilder, QueryBuilderParams } from "@nuxt/content"
+import type { H3Event } from 'h3'
+
+export function serverQueryContent<T = ParsedContent>(event: H3Event, params?: QueryBuilderParams): QueryBuilder<T>;
+export function serverQueryContent<T = ParsedContent>(event: H3Event, query?: string, ...pathParts: string[]): QueryBuilder<T>;

package/dist/runtime/pages/document-driven.vue

@@ -0,0 +1,27 @@
+<script setup>
+import { useRuntimeConfig, useContent, useContentHead, useRequestEvent } from "#imports";
+const { contentHead } = useRuntimeConfig().public.content;
+const { page, layout } = useContent();
+if (!page.value && import.meta.server) {
+  const event = useRequestEvent();
+  if (event) {
+    event.node.res.statusCode = 404;
+  }
+}
+if (contentHead) {
+  useContentHead(page);
+}
+</script>
+
+<template>
+  <div class="document-driven-page">
+    <NuxtLayout :name="layout || 'default'">
+      <ContentRenderer v-if="page" :key="page._id" :value="page">
+        <template #empty="{ value }">
+          <DocumentDrivenEmpty :value="value" />
+        </template>
+      </ContentRenderer>
+      <DocumentDrivenNotFound v-else />
+    </NuxtLayout>
+  </div>
+</template>

package/dist/runtime/pages/document-driven.vue.d.ts

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

package/dist/runtime/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;

package/dist/runtime/plugins/documentDriven.js

@@ -0,0 +1,222 @@
+import { withoutTrailingSlash, hasProtocol } from "ufo";
+import { pascalCase } from "scule";
+import { callWithNuxt } from "#app/nuxt";
+import { useContentState } from "../composables/content.js";
+import { useContentHelpers } from "../composables/helpers.js";
+import { fetchContentNavigation } from "../composables/navigation.js";
+import { queryContent } from "../composables/query.js";
+import { defineNuxtPlugin } from "nuxt/app";
+import { useRuntimeConfig, addRouteMiddleware, navigateTo, useRoute, prefetchComponents, useRouter } from "#imports";
+import { componentNames } from "#components";
+import layouts from "#build/layouts";
+export default defineNuxtPlugin((nuxt) => {
+  const moduleOptions = useRuntimeConfig()?.public?.content.documentDriven;
+  const isClientDBEnabled = useRuntimeConfig()?.public?.content.experimental.clientDB;
+  const { navigation, pages, globals, surrounds } = useContentState();
+  const findLayout = (to, page, navigation2, globals2) => {
+    if (page && page?.layout) {
+      return page.layout;
+    }
+    if (to.matched[0] && to.matched[0].meta?.layout) {
+      return to.matched[0].meta.layout;
+    }
+    if (navigation2 && page) {
+      const { navKeyFromPath } = useContentHelpers();
+      const layoutFromNav = navKeyFromPath(page._path, "layout", navigation2);
+      if (layoutFromNav) {
+        return layoutFromNav;
+      }
+    }
+    if (moduleOptions.layoutFallbacks && globals2) {
+      let layoutFallback;
+      for (const fallback of moduleOptions.layoutFallbacks) {
+        if (globals2[fallback] && globals2[fallback].layout) {
+          layoutFallback = globals2[fallback].layout;
+          break;
+        }
+      }
+      if (layoutFallback) {
+        return layoutFallback;
+      }
+    }
+    return "default";
+  };
+  const refresh = async (to, dedup = false) => {
+    nuxt.callHook("content:document-driven:start", { route: to, dedup });
+    const routeConfig = to.meta.documentDriven || {};
+    if (to.meta.documentDriven === false) {
+      return;
+    }
+    const _path = withoutTrailingSlash(to.path);
+    const promises = [];
+    if (moduleOptions.navigation && routeConfig.navigation !== false) {
+      const navigationQuery = () => {
+        const { navigation: navigation2 } = useContentState();
+        if (navigation2.value && !dedup) {
+          return navigation2.value;
+        }
+        return fetchContentNavigation().then((_navigation) => {
+          navigation2.value = _navigation;
+          return _navigation;
+        }).catch(() => null);
+      };
+      promises.push(navigationQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    if (moduleOptions.globals) {
+      const globalsQuery = () => {
+        const { globals: globals2 } = useContentState();
+        if (typeof moduleOptions.globals === "object" && Array.isArray(moduleOptions.globals)) {
+          console.log("Globals must be a list of keys with QueryBuilderParams as a value.");
+          return;
+        }
+        return Promise.all(
+          Object.entries(moduleOptions.globals).map(
+            ([key, query]) => {
+              if (!dedup && globals2.value[key]) {
+                return globals2.value[key];
+              }
+              let type = "findOne";
+              if (query?.type) {
+                type = query.type;
+              }
+              return queryContent(query)[type]().catch(() => null);
+            }
+          )
+        ).then(
+          (values) => {
+            return values.reduce(
+              (acc, value, index) => {
+                const key = Object.keys(moduleOptions.globals)[index];
+                if (key) {
+                  acc[key] = value;
+                }
+                return acc;
+              },
+              {}
+            );
+          }
+        );
+      };
+      promises.push(globalsQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    if (moduleOptions.page && routeConfig.page !== false) {
+      let where = { _path };
+      if (typeof routeConfig.page === "string") {
+        where = { _path: routeConfig.page };
+      }
+      if (typeof routeConfig.page === "object") {
+        where = routeConfig.page;
+      }
+      const pageQuery = () => {
+        const { pages: pages2 } = useContentState();
+        if (!dedup && pages2.value[_path] && pages2.value[_path]._path === _path) {
+          return {
+            result: pages2.value[_path],
+            surround: surrounds.value[_path]
+          };
+        }
+        const query = queryContent().where(where).withDirConfig();
+        if (moduleOptions.surround && routeConfig.surround !== false) {
+          let surround = _path;
+          if (["string", "object"].includes(typeof routeConfig.page)) {
+            surround = routeConfig.page;
+          }
+          if (["string", "object"].includes(typeof routeConfig.surround)) {
+            surround = routeConfig.surround;
+          }
+          query.withSurround(surround);
+        }
+        return query.findOne().catch(() => null);
+      };
+      promises.push(pageQuery);
+    } else {
+      promises.push(() => Promise.resolve(null));
+    }
+    return await Promise.all(promises.map((promise) => promise())).then(async ([
+      _navigation,
+      _globals,
+      _page
+    ]) => {
+      if (_navigation) {
+        navigation.value = _navigation;
+      }
+      if (_globals) {
+        globals.value = _globals;
+      }
+      if (_page?.surround) {
+        surrounds.value[_path] = _page.surround;
+      }
+      const redirectTo = _page?.result?.redirect || _page?.dirConfig?.navigation?.redirect;
+      if (redirectTo) {
+        pages.value[_path] = _page.result;
+        return redirectTo;
+      }
+      if (_page?.result) {
+        const layoutName = findLayout(to, _page.result, _navigation, _globals);
+        const layout = layouts[layoutName];
+        if (layout && typeof layout === "function") {
+          await layout();
+        }
+        to.meta.layout = layoutName;
+        _page.result.layout = layoutName;
+      }
+      pages.value[_path] = _page?.result;
+      await nuxt.callHook("content:document-driven:finish", { route: to, dedup, page: _page?.result, navigation: _navigation, globals: _globals, surround: _page?.surround });
+    });
+  };
+  if (import.meta.client) {
+    const router = useRouter();
+    nuxt.hook("link:prefetch", (link) => {
+      if (!(link in pages.value) && !hasProtocol(link)) {
+        const route = router.resolve(link);
+        if (route.matched.length > 0) {
+          refresh(route);
+        }
+      }
+    });
+    nuxt.hooks.hook("content:document-driven:finish", ({ page }) => {
+      if (page?.body?.children) {
+        prefetchBodyComponents(page.body.children);
+      }
+    });
+  }
+  addRouteMiddleware(async (to, from) => {
+    if (import.meta.client && !isClientDBEnabled && to.path === from.path) {
+      if (!to.meta.layout) {
+        const _path = withoutTrailingSlash(to.path);
+        if (pages.value[_path]) {
+          to.meta.layout = pages.value[_path].layout;
+        }
+      }
+      return;
+    }
+    const redirect = await refresh(to, false);
+    if (redirect) {
+      if (hasProtocol(redirect)) {
+        return callWithNuxt(nuxt, navigateTo, [redirect, { external: true }]);
+      } else {
+        return redirect;
+      }
+    }
+  });
+  nuxt.hook("app:data:refresh", async () => import.meta.client && await refresh(useRoute(), true));
+});
+function prefetchBodyComponents(nodes) {
+  for (const node of nodes) {
+    if (node.children) {
+      prefetchBodyComponents(node.children);
+    }
+    if (node.type === "element" && node.tag) {
+      const el = pascalCase(node.tag);
+      for (const name of ["Prose" + el, el]) {
+        if (componentNames.includes(name)) {
+          prefetchComponents(name);
+        }
+      }
+    }
+  }
+}

package/dist/runtime/plugins/ws.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;

package/dist/runtime/plugins/ws.js

@@ -0,0 +1,7 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+export default defineNuxtPlugin(() => {
+  const publicConfig = useRuntimeConfig().public;
+  if (import.meta.client && publicConfig.content.wsUrl) {
+    import("../composables/web-socket.js").then(({ useContentWebSocket }) => useContentWebSocket());
+  }
+});

package/dist/runtime/query/match/index.d.ts

@@ -0,0 +1,6 @@
+import type { QueryMatchOperator } from '@nuxt/content';
+interface MatchFactoryOptions {
+    operators?: Record<string, QueryMatchOperator>;
+}
+export declare function createMatch(opts?: MatchFactoryOptions): (item: any, conditions: any) => boolean;
+export {};

package/dist/runtime/query/match/index.js

@@ -0,0 +1,123 @@
+import { assertArray, ensureArray, get } from "./utils.js";
+export function createMatch(opts = {}) {
+  const operators = createOperators(match, opts.operators);
+  function match(item, conditions) {
+    if (typeof conditions !== "object" || conditions instanceof RegExp) {
+      return operators.$eq(item, conditions);
+    }
+    return Object.keys(conditions || {}).every((key) => {
+      const condition = conditions[key];
+      if (key.startsWith("$") && operators[key]) {
+        const fn = operators[key];
+        return typeof fn === "function" ? fn(item, condition) : false;
+      }
+      return match(get(item, key), condition);
+    });
+  }
+  return match;
+}
+function createOperators(match, operators = {}) {
+  return {
+    $match: (item, condition) => match(item, condition),
+    /**
+     * Match if item equals condition
+     **/
+    $eq: (item, condition) => condition instanceof RegExp ? condition.test(item) : item === condition,
+    /**
+     * Match if item not equals condition
+     **/
+    $ne: (item, condition) => condition instanceof RegExp ? !condition.test(item) : item !== condition,
+    /**
+     * Match is condition is false
+     **/
+    $not: (item, condition) => !match(item, condition),
+    /**
+     * Match only if all of nested conditions are true
+     **/
+    $and: (item, condition) => {
+      assertArray(condition, "$and requires an array as condition");
+      return condition.every((cond) => match(item, cond));
+    },
+    /**
+     * Match if any of nested conditions is true
+     **/
+    $or: (item, condition) => {
+      assertArray(condition, "$or requires an array as condition");
+      return condition.some((cond) => match(item, cond));
+    },
+    /**
+     * Match if item is in condition array
+     **/
+    $in: (item, condition) => ensureArray(condition).some(
+      (cond) => Array.isArray(item) ? match(item, { $contains: cond }) : match(item, cond)
+    ),
+    /**
+     * Match if item contains every condition or match every rule in condition array
+     **/
+    $contains: (item, condition) => {
+      item = Array.isArray(item) ? item : String(item);
+      return ensureArray(condition).every((i) => item.includes(i));
+    },
+    /**
+     * Ignore case contains
+     **/
+    $icontains: (item, condition) => {
+      if (typeof condition !== "string") {
+        throw new TypeError("$icontains requires a string, use $contains instead");
+      }
+      item = String(item).toLocaleLowerCase();
+      return ensureArray(condition).every((i) => item.includes(i.toLocaleLowerCase()));
+    },
+    /**
+     * Match if item contains at least one rule from condition array
+     */
+    $containsAny: (item, condition) => {
+      assertArray(condition, "$containsAny requires an array as condition");
+      item = Array.isArray(item) ? item : String(item);
+      return condition.some((i) => item.includes(i));
+    },
+    /**
+     * Check key existence
+     */
+    $exists: (item, condition) => condition ? typeof item !== "undefined" : typeof item === "undefined",
+    /**
+     * Match if type of item equals condition
+     */
+    $type: (item, condition) => typeof item === String(condition),
+    /**
+     * Provides regular expression capabilities for pattern matching strings.
+     */
+    $regex: (item, condition) => {
+      if (!(condition instanceof RegExp)) {
+        const matched = String(condition).match(/\/(.*)\/([dgimsuy]*)$/);
+        condition = matched?.[1] ? new RegExp(matched[1], matched[2] || "") : new RegExp(condition);
+      }
+      return condition.test(String(item || ""));
+    },
+    /**
+     * Check if item is less than condition
+     */
+    $lt: (item, condition) => {
+      return item < condition;
+    },
+    /**
+     * Check if item is less than or equal to condition
+     */
+    $lte: (item, condition) => {
+      return item <= condition;
+    },
+    /**
+     * Check if item is greater than condition
+     */
+    $gt: (item, condition) => {
+      return item > condition;
+    },
+    /**
+     * Check if item is greater than or equal to condition
+     */
+    $gte: (item, condition) => {
+      return item >= condition;
+    },
+    ...operators || {}
+  };
+}

package/dist/runtime/query/match/pipeline-legacy.d.ts

@@ -0,0 +1,2 @@
+import type { QueryBuilder } from '@nuxt/content';
+export declare function createPipelineFetcherLegacy<T>(getContentsList: () => Promise<T[]>): (query: QueryBuilder<T>) => Promise<T | T[]>;

package/dist/runtime/query/match/pipeline-legacy.js

@@ -0,0 +1,22 @@
+import { createPipelineFetcher } from "./pipeline.js";
+export function createPipelineFetcherLegacy(getContentsList) {
+  const _pipelineFetcher = createPipelineFetcher(getContentsList);
+  return async (query) => {
+    if (query.params().first) {
+      query.withDirConfig();
+    }
+    const params = query.params();
+    const result = await _pipelineFetcher(query);
+    if (params.surround) {
+      return result?.surround;
+    }
+    if (result?.dirConfig) {
+      result.result = {
+        _path: result.dirConfig?._path,
+        ...result.result,
+        _dir: result.dirConfig
+      };
+    }
+    return result?.result;
+  };
+}

package/dist/runtime/query/match/pipeline.d.ts

@@ -0,0 +1,2 @@
+import type { ContentQueryResponse, ContentQueryBuilder } from '@nuxt/content';
+export declare function createPipelineFetcher<T>(getContentsList: () => Promise<T[]>): (query: ContentQueryBuilder<T>) => Promise<ContentQueryResponse<T>>;