@ztl-uwu/nuxt-content 2.13.5

package/dist/runtime/server/search.js

@@ -0,0 +1,70 @@
+import { serverQueryContent } from "#content/server";
+export async function serverSearchContent(event, filterQuery) {
+  if (filterQuery) {
+    return await serverQueryContent(event).where(filterQuery).find();
+  } else {
+    return await serverQueryContent(event).find();
+  }
+}
+const HEADING = /^h([1-6])$/;
+const isHeading = (tag) => HEADING.test(tag);
+export function splitPageIntoSections(page, { ignoredTags }) {
+  const path = page._path ?? "";
+  const sections = [{
+    id: path,
+    title: page.title || "",
+    titles: [],
+    content: (page.description || "").trim(),
+    level: 1
+  }];
+  if (!page?.body?.children) {
+    return sections;
+  }
+  let section = 1;
+  let previousHeadingLevel = 0;
+  const titles = [page.title ?? ""];
+  for (const item of page.body.children) {
+    const tag = item.tag || "";
+    if (isHeading(tag)) {
+      const currentHeadingLevel = Number(tag.match(HEADING)?.[1] ?? 0);
+      const title = extractTextFromAst(item).trim();
+      if (currentHeadingLevel === 1) {
+        titles.splice(0, titles.length);
+      } else if (currentHeadingLevel < previousHeadingLevel) {
+        titles.splice(currentHeadingLevel - 1, titles.length - 1);
+      } else if (currentHeadingLevel === previousHeadingLevel) {
+        titles.pop();
+      }
+      sections.push({
+        id: `${path}#${item.props?.id}`,
+        title,
+        titles: [...titles],
+        content: "",
+        level: currentHeadingLevel
+      });
+      titles.push(title);
+      previousHeadingLevel = currentHeadingLevel;
+      section += 1;
+    } else {
+      const content = extractTextFromAst(item, ignoredTags).trim();
+      if (section === 1 && sections[section - 1]?.content === content) {
+        continue;
+      }
+      sections[section - 1].content = `${sections[section - 1].content} ${content}`.trim();
+    }
+  }
+  return sections;
+}
+function extractTextFromAst(node, ignoredTags = []) {
+  let text = "";
+  if (node.type === "text") {
+    text += node.value || "";
+  }
+  if (ignoredTags.includes(node.tag ?? "")) {
+    return "";
+  }
+  if (node.children?.length) {
+    text += node.children.map((child) => extractTextFromAst(child, ignoredTags)).filter(Boolean).join("");
+  }
+  return text;
+}

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

@@ -0,0 +1,35 @@
+import { type StorageValue, type Storage } from 'unstorage';
+import type { H3Event } from 'h3';
+import type { ParsedContent, ContentTransformer, ContentQueryBuilder, ContentQueryBuilderParams, ModuleOptions } from '@nuxt/content';
+interface ParseContentOptions {
+    csv?: ModuleOptions['csv'];
+    yaml?: ModuleOptions['yaml'];
+    highlight?: ModuleOptions['highlight'];
+    markdown?: ModuleOptions['markdown'];
+    transformers?: ContentTransformer[];
+    pathMeta?: {
+        locales?: ModuleOptions['locales'];
+        defaultLocale?: ModuleOptions['defaultLocale'];
+        respectPathCase?: ModuleOptions['respectPathCase'];
+    };
+    [key: string]: any;
+}
+export declare const sourceStorage: () => Storage<StorageValue>;
+export declare const cacheStorage: () => Storage<StorageValue>;
+export declare const cacheParsedStorage: () => Storage<StorageValue>;
+export declare const getContentsIds: (event: H3Event, prefix?: string) => Promise<string[]>;
+export declare function chunksFromArray<T>(arr: T[], n: number): Generator<T[], void>;
+export declare const cleanCachedContents: () => void;
+export declare const getContentsList: (event: H3Event, prefix?: string) => any;
+export declare const getContent: (event: H3Event, id: string) => Promise<ParsedContent>;
+/**
+ * Parse content file using registered plugins
+ */
+export declare const parseContent: (id: string, content: StorageValue, opts?: ParseContentOptions) => Promise<any>;
+export declare const createServerQueryFetch: <T = ParsedContent>(event: H3Event) => (query: ContentQueryBuilder<T>) => Promise<ContentQueryResponse<T_1>>;
+/**
+ * Query contents
+ */
+export declare function serverQueryContent<T = ParsedContent>(event: H3Event, params?: ContentQueryBuilderParams): ContentQueryBuilder<T>;
+export declare function serverQueryContent<T = ParsedContent>(event: H3Event, query?: string, ...pathParts: string[]): ContentQueryBuilder<T>;
+export {};

package/dist/runtime/server/storage.js

@@ -0,0 +1,238 @@
+import { prefixStorage } from "unstorage";
+import { joinURL, withLeadingSlash, withoutTrailingSlash } from "ufo";
+import { hash as ohash } from "ohash";
+import defu from "defu";
+import { createQuery } from "../query/query.js";
+import { transformContent } from "../transformers/index.js";
+import { makeIgnored } from "../utils/config.js";
+import { createPipelineFetcher } from "../query/match/pipeline.js";
+import { getPreview, isPreview } from "./preview.js";
+import { getIndexedContentsList } from "./content-index.js";
+import { useNitroApp, useRuntimeConfig, useStorage } from "#imports";
+import { transformers as customTransformers } from "#content/virtual/transformers";
+let _sourceStorage;
+let _cacheStorage;
+let _cacheParsedStorage;
+export const sourceStorage = () => {
+  if (!_sourceStorage) {
+    _sourceStorage = prefixStorage(useStorage(), "content:source");
+  }
+  return _sourceStorage;
+};
+export const cacheStorage = () => {
+  if (!_cacheStorage) {
+    _cacheStorage = prefixStorage(useStorage(), "cache:content");
+  }
+  return _cacheStorage;
+};
+export const cacheParsedStorage = () => {
+  if (!_cacheParsedStorage) {
+    _cacheParsedStorage = prefixStorage(useStorage(), "cache:content:parsed");
+  }
+  return _cacheParsedStorage;
+};
+const isProduction = process.env.NODE_ENV === "production";
+const isPrerendering = import.meta.prerender;
+const contentConfig = () => useRuntimeConfig().content;
+const invalidKeyCharacters = `'"?#/`.split("");
+const contentIgnorePredicate = (key) => {
+  const isIgnored = makeIgnored(contentConfig().ignores);
+  if (key.startsWith("preview:") || isIgnored(key)) {
+    return false;
+  }
+  if (invalidKeyCharacters.some((ik) => key.includes(ik))) {
+    console.warn(`Ignoring [${key}]. File name should not contain any of the following characters: ${invalidKeyCharacters.join(", ")}`);
+    return false;
+  }
+  return true;
+};
+export const getContentsIds = async (event, prefix) => {
+  let keys = [];
+  if (isProduction) {
+    keys = await cacheParsedStorage().getKeys(prefix);
+  }
+  const source = sourceStorage();
+  if (keys.length === 0) {
+    keys = await source.getKeys(prefix);
+  }
+  if (isPreview(event)) {
+    const { key } = getPreview(event);
+    const previewPrefix = `preview:${key}:${prefix || ""}`;
+    const previewKeys = await source.getKeys(previewPrefix);
+    if (previewKeys.length) {
+      const keysSet = new Set(keys);
+      await Promise.all(
+        previewKeys.map(async (key2) => {
+          const meta = await source.getMeta(key2);
+          if (meta?.__deleted) {
+            keysSet.delete(key2.substring(previewPrefix.length));
+          } else {
+            keysSet.add(key2.substring(previewPrefix.length));
+          }
+        })
+      );
+      keys = Array.from(keysSet);
+    }
+  }
+  return keys.filter(contentIgnorePredicate);
+};
+export function* chunksFromArray(arr, n) {
+  for (let i = 0; i < arr.length; i += n) {
+    yield arr.slice(i, i + n);
+  }
+}
+let cachedContents = [];
+export const cleanCachedContents = () => {
+  cachedContents = [];
+};
+export const getContentsList = /* @__PURE__ */ (() => {
+  let pendingContentsListPromise = null;
+  const _getContentsList = async (event, prefix) => {
+    const keys = await getContentsIds(event, prefix);
+    const keyChunks = [...chunksFromArray(keys, 10)];
+    const contents = [];
+    for (const chunk of keyChunks) {
+      const result = await Promise.all(chunk.map((key) => getContent(event, key)));
+      contents.push(...result);
+    }
+    return contents.filter((c) => c && c._path);
+  };
+  return (event, prefix) => {
+    if (event.context.__contentList) {
+      return event.context.__contentList;
+    }
+    if ((isPrerendering || !isProduction) && cachedContents.length) {
+      return cachedContents;
+    }
+    if (!pendingContentsListPromise) {
+      pendingContentsListPromise = _getContentsList(event, prefix);
+      pendingContentsListPromise.then((result) => {
+        if (isPrerendering || !isProduction) {
+          cachedContents = result;
+        }
+        event.context.__contentList = result;
+        pendingContentsListPromise = null;
+      });
+    }
+    return pendingContentsListPromise;
+  };
+})();
+const pendingPromises = {};
+export const getContent = async (event, id) => {
+  const contentId = id;
+  if (!contentIgnorePredicate(id)) {
+    return { _id: contentId, body: null };
+  }
+  const source = sourceStorage();
+  const cache = cacheParsedStorage();
+  if (isPreview(event)) {
+    const { key } = getPreview(event);
+    const previewId = `preview:${key}:${id}`;
+    const draft = await source.getItem(previewId);
+    if (draft) {
+      id = previewId;
+    }
+  }
+  const cached = await cache.getItem(id);
+  if (isProduction && cached) {
+    return cached.parsed;
+  }
+  const config = contentConfig();
+  const meta = await source.getMeta(id);
+  const mtime = meta.mtime;
+  const size = meta.size || 0;
+  const hash = ohash({
+    // Last modified time
+    mtime,
+    // File size
+    size,
+    // Add Content version to the hash, to revalidate the cache on content update
+    version: config.cacheVersion,
+    integrity: config.cacheIntegrity
+  });
+  if (cached?.hash === hash) {
+    return cached.parsed;
+  }
+  if (!pendingPromises[id + hash]) {
+    pendingPromises[id + hash] = new Promise(async (resolve) => {
+      const body = await source.getItem(id);
+      if (body === null) {
+        return resolve({ _id: contentId, body: null });
+      }
+      const parsed = await parseContent(contentId, body);
+      await cache.setItem(id, { parsed, hash }).catch(() => {
+      });
+      resolve(parsed);
+      delete pendingPromises[id + hash];
+    });
+  }
+  return pendingPromises[id + hash];
+};
+export const parseContent = async (id, content, opts = {}) => {
+  const nitroApp = useNitroApp();
+  const config = contentConfig();
+  const options = defu(
+    opts,
+    {
+      markdown: {
+        ...config.markdown,
+        highlight: config.highlight
+      },
+      csv: config.csv,
+      yaml: config.yaml,
+      transformers: customTransformers,
+      pathMeta: {
+        defaultLocale: config.defaultLocale,
+        locales: config.locales,
+        respectPathCase: config.respectPathCase
+      }
+    }
+  );
+  const file = { _id: id, body: typeof content === "string" ? content.replace(/\r\n|\r/g, "\n") : content };
+  await nitroApp.hooks.callHook("content:file:beforeParse", file);
+  const result = await transformContent(id, file.body, options);
+  await nitroApp.hooks.callHook("content:file:afterParse", result);
+  return result;
+};
+export const createServerQueryFetch = (event) => (query) => {
+  return createPipelineFetcher(() => getIndexedContentsList(event, query))(query);
+};
+export function serverQueryContent(event, query, ...pathParts) {
+  const { advanceQuery } = useRuntimeConfig().public.content.experimental;
+  const config = contentConfig();
+  const queryBuilder = advanceQuery ? createQuery(createServerQueryFetch(event), { initialParams: typeof query !== "string" ? query || {} : {}, legacy: false }) : createQuery(createServerQueryFetch(event), { 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 (!import.meta.dev) {
+      params.where = params.where || [];
+      if (!params.where.find((item) => typeof item._draft !== "undefined")) {
+        params.where.push({ _draft: { $ne: true } });
+      }
+    }
+    if (config.locales.length) {
+      const queryLocale = params.where?.find((w) => w._locale)?._locale;
+      if (!queryLocale) {
+        params.where = params.where || [];
+        params.where.push({ _locale: config.defaultLocale });
+      }
+    }
+    return params;
+  };
+  return queryBuilder;
+}

package/dist/runtime/transformers/component-resolver.d.ts

@@ -0,0 +1,2 @@
+declare const _default: ContentTransformer;
+export default _default;

package/dist/runtime/transformers/component-resolver.js

@@ -0,0 +1,44 @@
+import { pascalCase } from "scule";
+import htmlTags from "../utils/html-tags.js";
+import { defineTransformer } from "./utils.js";
+async function resolveContentComponents(body, meta) {
+  const components = Array.from(new Set(loadComponents(body, meta)));
+  const manifest = await import("#build/content-components").catch(() => ({}));
+  const resolvedComponentsEntries = await Promise.all(components.map(async ([t, c]) => {
+    const componentImporter = c && manifest[pascalCase(c)];
+    if (typeof componentImporter === "function") {
+      return [t, await componentImporter()];
+    }
+    return [t, c];
+  }));
+  return Object.fromEntries(resolvedComponentsEntries);
+  function loadComponents(node, tags) {
+    if (node.type === "text" || node.tag === "binding") {
+      return [];
+    }
+    const renderTag = typeof node.props?.__ignoreMap === "undefined" && tags[node.tag] || node.tag;
+    const components2 = [];
+    if (node.type !== "root" && !htmlTags.includes(renderTag)) {
+      components2.push([node.tag, renderTag]);
+    }
+    for (const child of node.children || []) {
+      components2.push(...loadComponents(child, tags));
+    }
+    return components2;
+  }
+}
+export default defineTransformer({
+  name: "component-resolver",
+  extensions: [".*"],
+  async transform(content, options = {}) {
+    if (import.meta.server) {
+      return content;
+    }
+    const _components = await resolveContentComponents(content.body, {
+      ...options?.tags || {},
+      ...content._components || {}
+    });
+    content._components = _components;
+    return content;
+  }
+});

package/dist/runtime/transformers/csv/create-tokenizer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Point} Point
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').ParseContext} ParseContext
+ */
+/**
+ * Create a tokenizer.
+ * Tokenizers deal with one type of data (e.g., containers, flow, text).
+ * The parser is the object dealing with it all.
+ * `initialize` works like other constructs, except that only its `tokenize`
+ * function is used, in which case it doesn’t receive an `ok` or `nok`.
+ * `from` can be given to set the point before the first character, although
+ * when further lines are indented, they must be set with `defineSkip`.
+ *
+ * @param {ParseContext} parser
+ * @param {InitialConstruct} initialize
+ * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]
+ * @returns {TokenizeContext}
+ */
+export declare function createTokenizer(parser: any, initialize: any, from: any): {
+    previous: null;
+    code: null;
+    containerState: {};
+    events: never[];
+    parser: any;
+    sliceStream: (token: any) => any;
+    sliceSerialize: (token: any, expandTabs: any) => string;
+    now: () => any;
+    defineSkip: (value: any) => void;
+    write: (slice: any) => never[];
+};