@ztl-uwu/nuxt-content 2.13.5

package/dist/runtime/transformers/csv/parser.js

@@ -0,0 +1,154 @@
+import { markdownLineEnding, markdownSpace } from "micromark-util-character";
+import { createTokenizer } from "./create-tokenizer.js";
+function initializeDocument(effects) {
+  const self = this;
+  const delimiter = (this.parser.delimiter || ",").charCodeAt(0);
+  return enterRow;
+  function enterRow(code) {
+    return effects.attempt(
+      { tokenize: attemptLastLine },
+      (code2) => {
+        effects.consume(code2);
+        return enterRow;
+      },
+      (code2) => {
+        effects.enter("row");
+        return enterColumn(code2);
+      }
+    )(code);
+  }
+  function enterColumn(code) {
+    effects.enter("column");
+    return content(code);
+  }
+  function content(code) {
+    if (code === null) {
+      effects.exit("column");
+      effects.exit("row");
+      effects.consume(code);
+      return content;
+    }
+    if (code === 34) {
+      return quotedData(code);
+    }
+    if (code === delimiter) {
+      if (self.previous === delimiter || markdownLineEnding(self.previous) || self.previous === null) {
+        effects.enter("data");
+        effects.exit("data");
+      }
+      effects.exit("column");
+      effects.enter("columnSeparator");
+      effects.consume(code);
+      effects.exit("columnSeparator");
+      effects.enter("column");
+      return content;
+    }
+    if (markdownLineEnding(code)) {
+      effects.exit("column");
+      effects.enter("newline");
+      effects.consume(code);
+      effects.exit("newline");
+      effects.exit("row");
+      return enterRow;
+    }
+    return data(code);
+  }
+  function data(code) {
+    effects.enter("data");
+    return dataChunk(code);
+  }
+  function dataChunk(code) {
+    if (code === null || markdownLineEnding(code) || code === delimiter) {
+      effects.exit("data");
+      return content(code);
+    }
+    if (code === 92) {
+      return escapeCharacter(code);
+    }
+    effects.consume(code);
+    return dataChunk;
+  }
+  function escapeCharacter(code) {
+    effects.consume(code);
+    return function(code2) {
+      effects.consume(code2);
+      return content;
+    };
+  }
+  function quotedData(code) {
+    effects.enter("quotedData");
+    effects.enter("quotedDataChunk");
+    effects.consume(code);
+    return quotedDataChunk;
+  }
+  function quotedDataChunk(code) {
+    if (code === 92) {
+      return escapeCharacter(code);
+    }
+    if (code === 34) {
+      return effects.attempt(
+        { tokenize: attemptDoubleQuote },
+        (code2) => {
+          effects.exit("quotedDataChunk");
+          effects.enter("quotedDataChunk");
+          return quotedDataChunk(code2);
+        },
+        (code2) => {
+          effects.consume(code2);
+          effects.exit("quotedDataChunk");
+          effects.exit("quotedData");
+          return content;
+        }
+      )(code);
+    }
+    effects.consume(code);
+    return quotedDataChunk;
+  }
+}
+function attemptDoubleQuote(effects, ok, nok) {
+  return startSequence;
+  function startSequence(code) {
+    if (code !== 34) {
+      return nok(code);
+    }
+    effects.enter("quoteFence");
+    effects.consume(code);
+    return sequence;
+  }
+  function sequence(code) {
+    if (code !== 34) {
+      return nok(code);
+    }
+    effects.consume(code);
+    effects.exit("quoteFence");
+    return (code2) => ok(code2);
+  }
+}
+function attemptLastLine(effects, ok, nok) {
+  return enterLine;
+  function enterLine(code) {
+    if (!markdownSpace(code) && code !== null) {
+      return nok(code);
+    }
+    effects.enter("emptyLine");
+    return continueLine(code);
+  }
+  function continueLine(code) {
+    if (markdownSpace(code)) {
+      effects.consume(code);
+      return continueLine;
+    }
+    if (code === null) {
+      effects.exit("emptyLine");
+      return ok(code);
+    }
+    return nok(code);
+  }
+}
+export const parse = (options) => {
+  return createTokenizer(
+    { ...options },
+    { tokenize: initializeDocument },
+    void 0
+  );
+};

package/dist/runtime/transformers/index.d.ts

@@ -0,0 +1,7 @@
+import type { StorageValue } from 'unstorage';
+import type { TransformContentOptions } from '@nuxt/content';
+/**
+ * Parse content file using registered plugins
+ */
+export declare function transformContent(id: string, content: StorageValue, options?: TransformContentOptions): Promise<any>;
+export { defineTransformer } from './utils';

package/dist/runtime/transformers/index.js

@@ -0,0 +1,50 @@
+import { extname } from "pathe";
+import { camelCase } from "scule";
+import csv from "./csv/index.js";
+import markdown from "./markdown.js";
+import yaml from "./yaml.js";
+import pathMeta from "./path-meta.js";
+import json from "./json.js";
+const TRANSFORMERS = [
+  csv,
+  markdown,
+  json,
+  yaml,
+  pathMeta
+];
+function getParser(ext, additionalTransformers = []) {
+  let parser = additionalTransformers.find((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.parse);
+  if (!parser) {
+    parser = TRANSFORMERS.find((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.parse);
+  }
+  return parser;
+}
+function getTransformers(ext, additionalTransformers = []) {
+  return [
+    ...additionalTransformers.filter((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.transform),
+    ...TRANSFORMERS.filter((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.transform)
+  ];
+}
+export async function transformContent(id, content, options = {}) {
+  const { transformers = [] } = options;
+  const file = { _id: id, body: content };
+  const ext = extname(id);
+  const parser = getParser(ext, transformers);
+  if (!parser) {
+    console.warn(`${ext} files are not supported, "${id}" falling back to raw content`);
+    return file;
+  }
+  const parserOptions = options[camelCase(parser.name)] || {};
+  const parsed = await parser.parse(file._id, file.body, parserOptions);
+  const matchedTransformers = getTransformers(ext, transformers);
+  const result = await matchedTransformers.reduce(async (prev, cur) => {
+    const next = await prev || parsed;
+    const transformOptions = options[camelCase(cur.name)];
+    if (transformOptions === false) {
+      return next;
+    }
+    return cur.transform(next, transformOptions || {});
+  }, Promise.resolve(parsed));
+  return result;
+}
+export { defineTransformer } from "./utils.js";

package/dist/runtime/transformers/json.d.ts

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

package/dist/runtime/transformers/json.js

@@ -0,0 +1,29 @@
+import { destr } from "destr";
+import { defineTransformer } from "./utils.js";
+export default defineTransformer({
+  name: "Json",
+  extensions: [".json", ".json5"],
+  parse: async (_id, content) => {
+    let parsed;
+    if (typeof content === "string") {
+      if (_id.endsWith("json5")) {
+        parsed = (await import("json5").then((m) => m.default || m)).parse(content);
+      } else if (_id.endsWith("json")) {
+        parsed = destr(content);
+      }
+    } else {
+      parsed = content;
+    }
+    if (Array.isArray(parsed)) {
+      console.warn(`JSON array is not supported in ${_id}, moving the array into the \`body\` key`);
+      parsed = {
+        body: parsed
+      };
+    }
+    return {
+      ...parsed,
+      _id,
+      _type: "json"
+    };
+  }
+});

package/dist/runtime/transformers/markdown.d.ts

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

package/dist/runtime/transformers/markdown.js

@@ -0,0 +1,88 @@
+import { parseMarkdown } from "@nuxtjs/mdc/runtime";
+import { normalizeUri } from "micromark-util-sanitize-uri";
+import { isRelative } from "ufo";
+import { defineTransformer } from "./utils.js";
+import { generatePath } from "./path-meta.js";
+export default defineTransformer({
+  name: "markdown",
+  extensions: [".md"],
+  parse: async (_id, content, options = {}) => {
+    const config = { ...options };
+    config.rehypePlugins = await importPlugins(config.rehypePlugins);
+    config.remarkPlugins = await importPlugins(config.remarkPlugins);
+    const highlightOptions = options.highlight ? {
+      ...options.highlight,
+      // Pass only when it's an function. String values are handled by `@nuxtjs/mdc`
+      highlighter: typeof options.highlight?.highlighter === "function" ? options.highlight.highlighter : void 0
+    } : void 0;
+    const parsed = await parseMarkdown(content, {
+      ...config,
+      highlight: highlightOptions,
+      remark: {
+        plugins: config.remarkPlugins
+      },
+      rehype: {
+        options: {
+          handlers: {
+            link
+          }
+        },
+        plugins: config.rehypePlugins
+      },
+      toc: config.toc
+    });
+    return {
+      ...parsed.data,
+      excerpt: parsed.excerpt,
+      body: {
+        ...parsed.body,
+        toc: parsed.toc
+      },
+      _type: "markdown",
+      _id
+    };
+  }
+});
+async function importPlugins(plugins = {}) {
+  const resolvedPlugins = {};
+  for (const [name, plugin] of Object.entries(plugins)) {
+    if (plugin) {
+      resolvedPlugins[name] = {
+        instance: plugin.instance || await import(
+          /* @vite-ignore */
+          name
+        ).then((m) => m.default || m),
+        options: plugin
+      };
+    } else {
+      resolvedPlugins[name] = false;
+    }
+  }
+  return resolvedPlugins;
+}
+function link(state, node) {
+  const properties = {
+    ...node.attributes || {},
+    href: normalizeUri(normalizeLink(node.url))
+  };
+  if (node.title !== null && node.title !== void 0) {
+    properties.title = node.title;
+  }
+  const result = {
+    type: "element",
+    tagName: "a",
+    properties,
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+function normalizeLink(link2) {
+  const match = link2.match(/#.+$/);
+  const hash = match ? match[0] : "";
+  if (link2.replace(/#.+$/, "").endsWith(".md") && (isRelative(link2) || !/^https?/.test(link2) && !link2.startsWith("/"))) {
+    return generatePath(link2.replace(".md" + hash, ""), { forceLeadingSlash: false }) + hash;
+  } else {
+    return link2;
+  }
+}

package/dist/runtime/transformers/path-meta.d.ts

@@ -0,0 +1,27 @@
+export declare const describeId: (id: string) => {
+    _source: string | undefined;
+    _path: string;
+    _extension: string | undefined;
+    _file: string;
+    _basename: string;
+};
+declare const _default: ContentTransformer;
+export default _default;
+/**
+ * Generate path from file name
+ *
+ * @param path file full path
+ * @returns generated slug
+ */
+export declare const generatePath: (path: string, { forceLeadingSlash, respectPathCase }?: {
+    forceLeadingSlash?: boolean | undefined;
+    respectPathCase?: boolean | undefined;
+}) => string;
+/**
+ * generate title from file path
+ */
+export declare const generateTitle: (path: string) => string;
+/**
+ * Clean up special keywords from path part
+ */
+export declare function refineUrlPart(name: string): string;

package/dist/runtime/transformers/path-meta.js

@@ -0,0 +1,59 @@
+import { pascalCase } from "scule";
+import slugify from "slugify";
+import { withoutTrailingSlash, withLeadingSlash } from "ufo";
+import { defineTransformer } from "./utils.js";
+const SEMVER_REGEX = /^(\d+)(\.\d+)*(\.x)?$/;
+export const describeId = (id) => {
+  const [_source, ...parts] = id.split(":");
+  const [, basename, _extension] = parts[parts.length - 1]?.match(/(.*)\.([^.]+)$/) || [];
+  if (basename) {
+    parts[parts.length - 1] = basename;
+  }
+  const _path = (parts || []).join("/");
+  return {
+    _source,
+    _path,
+    _extension,
+    _file: _extension ? `${_path}.${_extension}` : _path,
+    _basename: basename || ""
+  };
+};
+export default defineTransformer({
+  name: "path-meta",
+  extensions: [".*"],
+  transform(content, options = {}) {
+    const { locales = [], defaultLocale = "en", respectPathCase = false } = options;
+    const { _source, _file, _path, _extension, _basename } = describeId(content._id);
+    const parts = _path.split("/");
+    const _locale = locales.includes(parts[0]) ? parts.shift() : defaultLocale;
+    const filePath = generatePath(parts.join("/"), { respectPathCase });
+    return {
+      _path: filePath,
+      _dir: filePath.split("/").slice(-2)[0],
+      _draft: content._draft || content.draft || isDraft(_path),
+      _partial: isPartial(_path),
+      _locale,
+      ...content,
+      // TODO: move title to Markdown parser
+      title: content.title || generateTitle(refineUrlPart(_basename)),
+      _source,
+      _file,
+      _stem: _path,
+      _extension
+    };
+  }
+});
+const isDraft = (path) => !!path.match(/\.draft(\/|\.|$)/);
+const isPartial = (path) => path.split(/[:/]/).some((part) => part.match(/^_.*/));
+export const generatePath = (path, { forceLeadingSlash = true, respectPathCase = false } = {}) => {
+  path = path.split("/").map((part) => slugify(refineUrlPart(part), { lower: !respectPathCase })).join("/");
+  return forceLeadingSlash ? withLeadingSlash(withoutTrailingSlash(path)) : path;
+};
+export const generateTitle = (path) => path.split(/[\s-]/g).map(pascalCase).join(" ");
+export function refineUrlPart(name) {
+  name = name.split(/[/:]/).pop();
+  if (SEMVER_REGEX.test(name)) {
+    return name;
+  }
+  return name.replace(/(\d+\.)?(.*)/, "$2").replace(/^index(\.draft)?$/, "").replace(/\.draft$/, "");
+}

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

@@ -0,0 +1,3 @@
+import type { ContentTransformer } from '@nuxt/content';
+export declare const defineTransformer: (transformer: ContentTransformer) => ContentTransformer;
+export declare const createSingleton: <T, Params extends Array<any>>(fn: (...arg: Params) => T) => (...args: Params) => T;

package/dist/runtime/transformers/utils.js

@@ -0,0 +1,12 @@
+export const defineTransformer = (transformer) => {
+  return transformer;
+};
+export const createSingleton = (fn) => {
+  let instance;
+  return (...args) => {
+    if (!instance) {
+      instance = fn(...args);
+    }
+    return instance;
+  };
+};

package/dist/runtime/transformers/yaml.d.ts

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

package/dist/runtime/transformers/yaml.js

@@ -0,0 +1,21 @@
+import { parseFrontMatter } from "remark-mdc";
+import { defineTransformer } from "./utils.js";
+export default defineTransformer({
+  name: "Yaml",
+  extensions: [".yml", ".yaml"],
+  parse: (_id, content) => {
+    const { data } = parseFrontMatter(`---
+${content}
+---`);
+    let parsed = data;
+    if (Array.isArray(data)) {
+      console.warn(`YAML array is not supported in ${_id}, moving the array into the \`body\` key`);
+      parsed = { body: data };
+    }
+    return {
+      ...parsed,
+      _id,
+      _type: "yaml"
+    };
+  }
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Creates a predicate to test storage keys `foo:bar:baz` against configured `ignores` patterns
+ */
+export declare function makeIgnored(ignores: string[]): (key: string) => boolean;

package/dist/runtime/utils/config.js

@@ -0,0 +1,7 @@
+export function makeIgnored(ignores) {
+  const rxAll = ["/\\.", "/-", ...ignores.filter((p) => p)].map((p) => new RegExp(p));
+  return function isIgnored(key) {
+    const path = "/" + key.replace(/:/g, "/");
+    return rxAll.some((rx) => rx.test(path));
+  };
+}

package/dist/runtime/utils/html-tags.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/runtime/utils/html-tags.js

@@ -0,0 +1,119 @@
+export default [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "math",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rb",
+  "rp",
+  "rt",
+  "rtc",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+];

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

@@ -0,0 +1,10 @@
+/**
+ * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+ * This function is equivalent to `JSON.stringify`, but it also handles RegExp objects.
+ */
+export declare function jsonStringify(value: any): string;
+/**
+ * Converts a JavaScript Object Notation (JSON) string into an object.
+ * This function is equivalent to `JSON.parse`, but it also handles RegExp objects.
+ */
+export declare function jsonParse(value: string): any;

package/dist/runtime/utils/json.js

@@ -0,0 +1,20 @@
+export function jsonStringify(value) {
+  return JSON.stringify(value, regExpReplacer);
+}
+export function jsonParse(value) {
+  return JSON.parse(value, regExpReviver);
+}
+function regExpReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return `--REGEX ${value.toString()}`;
+  }
+  return value;
+}
+function regExpReviver(_key, value) {
+  const withOperator = typeof value === "string" && value.match(/^--([A-Z]+) (.+)$/) || [];
+  if (withOperator[1] === "REGEX") {
+    const regex = withOperator[2]?.match(/\/(.*)\/([dgimsuy]*)$/);
+    return regex?.[1] ? new RegExp(regex[1], regex[2] || "") : value;
+  }
+  return value;
+}

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

@@ -0,0 +1,5 @@
+import { type H3Event } from 'h3';
+import type { ContentQueryBuilderParams } from '@nuxt/content';
+export declare const encodeQueryParams: (params: ContentQueryBuilderParams) => string;
+export declare const decodeQueryParams: (encoded: string) => any;
+export declare const getContentQuery: (event: H3Event) => ContentQueryBuilderParams;