fuma-content 1.0.1 → 1.0.2

package/dist/chunk-NRZ4GE5O.js

@@ -1,207 +0,0 @@
-import {
-  CodeGenerator
-} from "./chunk-MT7RY65Y.js";
-
-// src/core.ts
-import path from "path";
-import fs from "fs/promises";
-async function getPlugins(pluginOptions) {
-  const plugins = [];
-  for (const option of await Promise.all(pluginOptions)) {
-    if (!option) continue;
-    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
-    else plugins.push(option);
-  }
-  return plugins;
-}
-var Core = class _Core {
-  workspaces = /* @__PURE__ */ new Map();
-  options;
-  plugins = [];
-  config;
-  static defaultOptions = {
-    configPath: "content.config.ts",
-    outDir: ".content"
-  };
-  /**
-   * Convenient cache store, reset when config changes.
-   *
-   * You can group namespaces in cache key with ":", like `my-plugin:data`
-   */
-  cache = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options;
-  }
-  async init({ config: newConfig }) {
-    this.config = await newConfig;
-    this.cache.clear();
-    this.workspaces.clear();
-    const loadedCollectionTypeIds = /* @__PURE__ */ new Set();
-    this.plugins = await getPlugins([
-      this.options.plugins,
-      this.config.plugins,
-      ...this.config.collections.values().map(({ typeInfo }) => {
-        if (loadedCollectionTypeIds.has(typeInfo.id)) return false;
-        loadedCollectionTypeIds.add(typeInfo.id);
-        return typeInfo.plugins;
-      })
-    ]);
-    const ctx = this.getPluginContext();
-    for (const plugin of this.plugins) {
-      const out = await plugin.config?.call(ctx, this.config);
-      if (out) this.config = out;
-    }
-    const { workspace, outDir } = this.options;
-    if (!workspace) {
-      await Promise.all(
-        Object.entries(this.config.workspaces).map(
-          async ([name, workspace2]) => {
-            const child = new _Core({
-              ...this.options,
-              outDir: path.join(outDir, name),
-              workspace: {
-                name,
-                parent: this,
-                dir: workspace2.dir
-              }
-            });
-            await child.init({ config: workspace2.config });
-            this.workspaces.set(name, child);
-          }
-        )
-      );
-    }
-    await Promise.all(
-      this.config.collections.values().map(async (collection) => {
-        for (const plugin of this.plugins) {
-          await plugin.collection?.call(ctx, collection);
-        }
-      })
-    );
-  }
-  getWorkspaces() {
-    return this.workspaces;
-  }
-  getOptions() {
-    return this.options;
-  }
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
-   */
-  getCompiledConfigPath() {
-    return path.join(this.options.outDir, "content.config.mjs");
-  }
-  getPlugins(workspace = false) {
-    if (workspace) {
-      const plugins = [...this.plugins];
-      for (const workspace2 of this.workspaces.values()) {
-        plugins.push(...workspace2.plugins);
-      }
-      return plugins;
-    }
-    return this.plugins;
-  }
-  getCollections(workspace = false) {
-    const list = Array.from(this.config.collections.values());
-    if (workspace) {
-      for (const workspace2 of this.workspaces.values()) {
-        list.push(...workspace2.getCollections());
-      }
-    }
-    return list;
-  }
-  getCollection(name) {
-    return this.config.collections.get(name);
-  }
-  getPluginContext() {
-    return {
-      core: this
-    };
-  }
-  async initServer(server) {
-    const ctx = this.getPluginContext();
-    const promises = [];
-    for (const plugin of this.plugins) {
-      promises.push(plugin.configureServer?.call(ctx, server));
-    }
-    for (const workspace of this.workspaces.values()) {
-      promises.push(workspace.initServer(server));
-    }
-    await Promise.all(promises);
-  }
-  async emit(emitOptions = {}) {
-    const {
-      workspace,
-      outDir,
-      emit: { target, jsExtension } = {}
-    } = this.options;
-    const { filterPlugin, filterWorkspace, write = false } = emitOptions;
-    const start = performance.now();
-    const globCache = /* @__PURE__ */ new Map();
-    const ctx = {
-      ...this.getPluginContext(),
-      createCodeGenerator: async (path2, content) => {
-        const codegen = new CodeGenerator({
-          target,
-          outDir,
-          jsExtension,
-          globCache
-        });
-        await content({
-          core: this,
-          codegen,
-          workspace: workspace?.name
-        });
-        return {
-          path: path2,
-          content: codegen.toString()
-        };
-      }
-    };
-    const added = /* @__PURE__ */ new Set();
-    const out = {
-      entries: [],
-      workspaces: {}
-    };
-    for (const li of await Promise.all(
-      this.plugins.map((plugin) => {
-        if (filterPlugin && !filterPlugin(plugin) || !plugin.emit)
-          return null;
-        return plugin.emit.call(ctx);
-      })
-    )) {
-      if (!li) continue;
-      for (const item of li) {
-        if (added.has(item.path)) continue;
-        out.entries.push(item);
-        added.add(item.path);
-      }
-    }
-    if (write) {
-      await Promise.all(
-        out.entries.map(async (entry) => {
-          const file = path.join(outDir, entry.path);
-          await fs.mkdir(path.dirname(file), { recursive: true });
-          await fs.writeFile(file, entry.content);
-        })
-      );
-      console.log(
-        workspace ? `[MDX: ${workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
-      );
-    }
-    await Promise.all(
-      this.workspaces.entries().map(async ([name, workspace2]) => {
-        if (filterWorkspace && !filterWorkspace(name)) return;
-        out.workspaces[name] = (await workspace2.emit(emitOptions)).entries;
-      })
-    );
-    return out;
-  }
-};
-
-export {
-  Core
-};

package/dist/chunk-OQQNA7L7.js

@@ -1,412 +0,0 @@
-import {
-  fumaMatter
-} from "./chunk-VWJKRQZR.js";
-import {
-  createCache
-} from "./chunk-JBZTQ55D.js";
-
-// src/collections/mdx/build-mdx.ts
-import { createProcessor } from "@mdx-js/mdx";
-import { VFile as VFile2 } from "vfile";
-
-// src/collections/mdx/remark-include.ts
-import {
-  unified
-} from "unified";
-import { visit as visit2 } from "unist-util-visit";
-import * as path from "path";
-import * as fs from "fs/promises";
-import { VFile } from "vfile";
-
-// src/collections/mdx/remark-unravel.ts
-import { visit } from "unist-util-visit";
-function remarkMarkAndUnravel() {
-  return (tree) => {
-    visit(tree, (node, index, parent) => {
-      let offset = -1;
-      let all = true;
-      let oneOrMore = false;
-      if (parent && typeof index === "number" && node.type === "paragraph") {
-        const children = node.children;
-        while (++offset < children.length) {
-          const child = children[offset];
-          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
-            oneOrMore = true;
-          } else if (child.type === "text" && child.value.trim().length === 0) {
-          } else {
-            all = false;
-            break;
-          }
-        }
-        if (all && oneOrMore) {
-          offset = -1;
-          const newChildren = [];
-          while (++offset < children.length) {
-            const child = children[offset];
-            if (child.type === "mdxJsxTextElement") {
-              child.type = "mdxJsxFlowElement";
-            }
-            if (child.type === "mdxTextExpression") {
-              child.type = "mdxFlowExpression";
-            }
-            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
-            } else {
-              newChildren.push(child);
-            }
-          }
-          parent.children.splice(index, 1, ...newChildren);
-          return index;
-        }
-      }
-    });
-  };
-}
-
-// src/collections/mdx/mdast-utils.ts
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
-
-// src/collections/mdx/remark-include.ts
-var ElementLikeTypes = [
-  "mdxJsxFlowElement",
-  "mdxJsxTextElement",
-  "containerDirective",
-  "textDirective",
-  "leafDirective"
-];
-function isElementLike(node) {
-  return ElementLikeTypes.includes(node.type);
-}
-function parseElementAttributes(element) {
-  if (Array.isArray(element.attributes)) {
-    const attributes = {};
-    for (const attr of element.attributes) {
-      if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
-        attributes[attr.name] = attr.value;
-      }
-    }
-    return attributes;
-  }
-  return element.attributes ?? {};
-}
-function parseSpecifier(specifier) {
-  const idx = specifier.lastIndexOf("#");
-  if (idx === -1) return { file: specifier };
-  return {
-    file: specifier.slice(0, idx),
-    section: specifier.slice(idx + 1)
-  };
-}
-function extractSection(root, section) {
-  let nodes;
-  let capturingHeadingContent = false;
-  visit2(root, (node) => {
-    if (node.type === "heading") {
-      if (capturingHeadingContent) {
-        return false;
-      }
-      if (node.data?.hProperties?.id === section) {
-        capturingHeadingContent = true;
-        nodes = [node];
-        return "skip";
-      }
-      return;
-    }
-    if (capturingHeadingContent) {
-      nodes?.push(node);
-      return "skip";
-    }
-    if (isElementLike(node) && node.name === "section") {
-      const attributes = parseElementAttributes(node);
-      if (attributes.id === section) {
-        nodes = node.children;
-        return false;
-      }
-    }
-  });
-  if (nodes)
-    return {
-      type: "root",
-      children: nodes
-    };
-}
-function remarkInclude({ preprocess = [] } = {}) {
-  const TagName = "include";
-  const preprocessor = unified().use(remarkMarkAndUnravel).use(preprocess);
-  const embedContent = async (targetPath, heading, params, parent) => {
-    const { _getProcessor = () => this, _compiler } = parent.data;
-    let content;
-    try {
-      content = (await fs.readFile(targetPath)).toString();
-    } catch (e) {
-      throw new Error(
-        `failed to read file ${targetPath}
-${e instanceof Error ? e.message : String(e)}`,
-        { cause: e }
-      );
-    }
-    const ext = path.extname(targetPath);
-    _compiler?.addDependency(targetPath);
-    if (params.lang || ext !== ".md" && ext !== ".mdx") {
-      const lang = params.lang ?? ext.slice(1);
-      return {
-        type: "code",
-        lang,
-        meta: params.meta,
-        value: content,
-        data: {}
-      };
-    }
-    const parser = await _getProcessor(ext === ".mdx" ? "mdx" : "md");
-    const parsed = fumaMatter(content);
-    const targetFile = new VFile({
-      path: targetPath,
-      value: parsed.content,
-      data: {
-        ...parent.data,
-        frontmatter: parsed.data
-      }
-    });
-    let mdast = await preprocessor.run(
-      parser.parse(targetFile),
-      targetFile
-    );
-    if (heading) {
-      const extracted = extractSection(mdast, heading);
-      if (!extracted)
-        throw new Error(
-          `Cannot find section ${heading} in ${targetPath}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
-        );
-      mdast = extracted;
-    }
-    await update(mdast, targetFile);
-    return mdast;
-  };
-  async function update(tree, file) {
-    const queue = [];
-    visit2(tree, ElementLikeTypes, (_node, _, parent) => {
-      const node = _node;
-      if (node.name !== TagName) return;
-      const specifier = flattenNode(node);
-      if (specifier.length === 0) return "skip";
-      const attributes = parseElementAttributes(node);
-      const { file: relativePath, section } = parseSpecifier(specifier);
-      const targetPath = path.resolve(
-        "cwd" in attributes ? file.cwd : file.dirname ?? "",
-        relativePath
-      );
-      queue.push(
-        embedContent(targetPath, section, attributes, file).then((replace) => {
-          Object.assign(
-            parent && parent.type === "paragraph" ? parent : node,
-            replace
-          );
-        })
-      );
-      return "skip";
-    });
-    await Promise.all(queue);
-  }
-  return async (tree, file) => {
-    await update(tree, file);
-  };
-}
-
-// src/collections/mdx/remark-postprocess.ts
-import { visit as visit3 } from "unist-util-visit";
-import { toMarkdown } from "mdast-util-to-markdown";
-import { valueToEstree } from "estree-util-value-to-estree";
-import { removePosition } from "unist-util-remove-position";
-import remarkMdx from "remark-mdx";
-function remarkPostprocess({
-  _format,
-  includeProcessedMarkdown = false,
-  includeMDAST = false,
-  extractLinkReferences = false,
-  valueToExport = []
-}) {
-  let _stringifyProcessor;
-  const getStringifyProcessor = () => {
-    return _stringifyProcessor ??= _format === "mdx" ? this : (
-      // force Markdown processor to stringify MDX nodes
-      this().use(remarkMdx).freeze()
-    );
-  };
-  return (tree, file) => {
-    const frontmatter = file.data.frontmatter ??= {};
-    if (!frontmatter.title) {
-      visit3(tree, "heading", (node) => {
-        if (node.depth === 1) {
-          frontmatter.title = flattenNode(node);
-          return false;
-        }
-      });
-    }
-    file.data["mdx-export"] ??= [];
-    file.data["mdx-export"].push({
-      name: "frontmatter",
-      value: frontmatter
-    });
-    if (extractLinkReferences) {
-      const urls = [];
-      visit3(tree, "link", (node) => {
-        urls.push({
-          href: node.url
-        });
-        return "skip";
-      });
-      file.data["mdx-export"].push({
-        name: "extractedReferences",
-        value: urls
-      });
-    }
-    if (includeProcessedMarkdown) {
-      const processor = getStringifyProcessor();
-      const markdown = toMarkdown(tree, {
-        ...processor.data("settings"),
-        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
-        extensions: processor.data("toMarkdownExtensions") || []
-      });
-      file.data["mdx-export"].push({
-        name: "_markdown",
-        value: markdown
-      });
-    }
-    if (includeMDAST) {
-      const options = includeMDAST === true ? {} : includeMDAST;
-      const mdast = JSON.stringify(
-        options.removePosition ? removePosition(structuredClone(tree)) : tree
-      );
-      file.data["mdx-export"].push({
-        name: "_mdast",
-        value: mdast
-      });
-    }
-    for (const { name, value } of file.data["mdx-export"]) {
-      tree.children.unshift(getMdastExport(name, value));
-    }
-    file.data["mdx-export"] = [];
-    for (const name of valueToExport) {
-      if (!(name in file.data)) continue;
-      tree.children.unshift(getMdastExport(name, file.data[name]));
-    }
-  };
-}
-function getMdastExport(name, value) {
-  return {
-    type: "mdxjsEsm",
-    value: "",
-    data: {
-      estree: {
-        type: "Program",
-        sourceType: "module",
-        body: [
-          {
-            type: "ExportNamedDeclaration",
-            specifiers: [],
-            attributes: [],
-            source: null,
-            declaration: {
-              type: "VariableDeclaration",
-              kind: "let",
-              declarations: [
-                {
-                  type: "VariableDeclarator",
-                  id: {
-                    type: "Identifier",
-                    name
-                  },
-                  init: valueToEstree(value)
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  };
-}
-
-// src/collections/mdx/remark-preprocess.ts
-function remarkPreprocess(options) {
-  return async (tree, file) => {
-    if (file.data._preprocessed) return;
-    file.data._preprocessed = true;
-    if (options?.preprocessor) {
-      return await options.preprocessor.run(tree);
-    }
-  };
-}
-
-// src/collections/mdx/build-mdx.ts
-async function buildMDX(core, collection, {
-  filePath,
-  frontmatter,
-  source,
-  _compiler,
-  environment,
-  isDevelopment
-}) {
-  const handler = collection?.handlers.mdx;
-  const processorCache = createCache(core.cache);
-  function getProcessor(format) {
-    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
-    return processorCache.cached(key, async () => {
-      const mdxOptions = await handler?.getMDXOptions?.(environment);
-      const preprocessPlugin = [
-        remarkPreprocess,
-        handler?.preprocess
-      ];
-      const postprocessOptions = {
-        _format: format,
-        ...handler?.postprocess
-      };
-      const remarkIncludeOptions = {
-        preprocess: [preprocessPlugin]
-      };
-      return createProcessor({
-        outputFormat: "program",
-        development: isDevelopment,
-        ...mdxOptions,
-        remarkPlugins: [
-          preprocessPlugin,
-          [remarkInclude, remarkIncludeOptions],
-          ...mdxOptions?.remarkPlugins ?? [],
-          [remarkPostprocess, postprocessOptions]
-        ],
-        format
-      });
-    });
-  }
-  let vfile = new VFile2({
-    value: source,
-    path: filePath,
-    cwd: handler?.cwd,
-    data: {
-      frontmatter,
-      _compiler,
-      _getProcessor: getProcessor
-    }
-  });
-  if (collection && handler?.vfile) {
-    vfile = await handler.vfile.call(
-      {
-        collection,
-        filePath,
-        source
-      },
-      vfile
-    );
-  }
-  return (await getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md")).process(
-    vfile
-  );
-}
-
-export {
-  buildMDX
-};

package/dist/chunk-OUJENWQ4.js

@@ -1,45 +0,0 @@
-// src/utils/validation.ts
-var ValidationError = class extends Error {
-  title;
-  issues;
-  constructor(message, issues) {
-    super(
-      `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
-    );
-    this.title = message;
-    this.issues = issues;
-  }
-  async toStringFormatted() {
-    const picocolorsModule = await import("picocolors");
-    const picocolors = picocolorsModule.default ?? picocolorsModule;
-    return [
-      picocolors.bold(`[MDX] ${this.title}:`),
-      ...this.issues.map(
-        (issue) => picocolors.redBright(
-          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
-        )
-      )
-    ].join("\n");
-  }
-};
-async function validate(schema, data, context, errorMessage) {
-  if (typeof schema === "function" && !("~standard" in schema)) {
-    schema = schema(context);
-  }
-  if ("~standard" in schema) {
-    const result = await schema["~standard"].validate(
-      data
-    );
-    if (result.issues) {
-      throw new ValidationError(errorMessage, result.issues);
-    }
-    return result.value;
-  }
-  return data;
-}
-
-export {
-  ValidationError,
-  validate
-};