fuma-content 1.0.1 → 1.0.3

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
-};

package/dist/chunk-RMSV4HP6.js

@@ -1,85 +0,0 @@
-import {
-  validate
-} from "./chunk-OUJENWQ4.js";
-
-// src/collections/meta/loader.ts
-import { dump, load } from "js-yaml";
-import { z } from "zod";
-var querySchema = z.object({
-  collection: z.string().optional(),
-  workspace: z.string().optional()
-}).loose();
-function createMetaLoader({ getCore }, resolve = {}) {
-  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
-  function parse(filePath, source) {
-    try {
-      if (filePath.endsWith(".json")) return JSON.parse(source);
-      if (filePath.endsWith(".yaml")) return load(source);
-    } catch (e) {
-      throw new Error(`invalid data in ${filePath}`, { cause: e });
-    }
-    throw new Error(`Unknown file type ${filePath}`);
-  }
-  function onMeta(source, { filePath, query }) {
-    const parsed = querySchema.safeParse(query);
-    if (!parsed.success || !parsed.data.collection) return null;
-    const { collection: collectionName, workspace } = parsed.data;
-    return async () => {
-      let core = await getCore();
-      if (workspace) {
-        core = core.getWorkspaces().get(workspace) ?? core;
-      }
-      const collection = core.getCollection(collectionName);
-      const handler = collection?.handlers.meta;
-      let data = parse(filePath, source);
-      if (!handler) return data;
-      const context = {
-        path: filePath,
-        source
-      };
-      if (handler.schema) {
-        data = await validate(
-          handler.schema,
-          data,
-          context,
-          `invalid data in ${filePath}`
-        );
-      }
-      return handler.transform?.call(context, data);
-    };
-  }
-  return {
-    async load(input) {
-      const result = onMeta(await input.getSource(), input);
-      if (result === null) return null;
-      const data = await result();
-      if (input.filePath.endsWith(".json")) {
-        return {
-          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
-        };
-      } else {
-        return {
-          code: resolveYaml === "yaml" ? dump(data) : `export default ${JSON.stringify(data)}`
-        };
-      }
-    },
-    bun: {
-      load(source, input) {
-        const result = onMeta(source, input);
-        if (result === null)
-          return {
-            loader: "object",
-            exports: parse(input.filePath, source)
-          };
-        return result().then((data) => ({
-          loader: "object",
-          exports: { default: data }
-        }));
-      }
-    }
-  };
-}
-
-export {
-  createMetaLoader
-};

package/dist/chunk-RXR7OL76.js

@@ -1,37 +0,0 @@
-import {
-  SimpleCollectionStore
-} from "./chunk-3VQS3KSP.js";
-
-// src/collections/runtime/file-store.ts
-import path from "path";
-function fileInfo(base, globKey) {
-  if (globKey.startsWith("./")) {
-    globKey = globKey.slice(2);
-  }
-  return {
-    path: globKey,
-    fullPath: path.join(base, globKey)
-  };
-}
-var FileCollectionStore = class extends SimpleCollectionStore {
-  constructor(base, glob) {
-    const data = /* @__PURE__ */ new Map();
-    for (const [key, value] of Object.entries(glob)) {
-      data.set(key, {
-        ...value,
-        ...fileInfo(base, key)
-      });
-    }
-    super(data);
-  }
-  transform(fn) {
-    return super.transform(fn);
-  }
-  $data(_cast) {
-    return super.$data(_cast);
-  }
-};
-
-export {
-  FileCollectionStore
-};

package/dist/chunk-VWJKRQZR.js

@@ -1,19 +0,0 @@
-// src/utils/fuma-matter.ts
-import { load } from "js-yaml";
-var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
-function fumaMatter(input) {
-  const output = { matter: "", data: {}, content: input };
-  const match = regex.exec(input);
-  if (!match) {
-    return output;
-  }
-  output.matter = match[0];
-  output.content = input.slice(match[0].length);
-  const loaded = load(match[1]);
-  output.data = loaded ?? {};
-  return output;
-}
-
-export {
-  fumaMatter
-};

package/dist/chunk-W6HENTK7.js

@@ -1,44 +0,0 @@
-// src/config/build.ts
-function buildConfig(config, workspace) {
-  const collections = /* @__PURE__ */ new Map();
-  const loaded = {};
-  let globalConfig;
-  if ("default" in config) {
-    globalConfig = config.default;
-    for (const [k, v] of Object.entries(config)) {
-      if (k === "default") continue;
-      globalConfig.collections ??= {};
-      globalConfig.collections[k] = v;
-    }
-  } else {
-    globalConfig = config;
-  }
-  if (globalConfig.collections) {
-    for (const [name, collection] of Object.entries(globalConfig.collections)) {
-      collection.init?.({ name, workspace });
-      collections.set(name, collection);
-    }
-  }
-  return {
-    ...globalConfig,
-    collections,
-    workspaces: Object.fromEntries(
-      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
-        return [
-          key,
-          {
-            dir: value.dir,
-            config: buildConfig(value.config, {
-              ...value,
-              name: key
-            })
-          }
-        ];
-      })
-    )
-  };
-}
-
-export {
-  buildConfig
-};

package/dist/chunk-XR5N6ZXJ.js

@@ -1,50 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-OUJENWQ4.js";
-import {
-  Core
-} from "./chunk-NRZ4GE5O.js";
-
-// src/plugins/with-loader/webpack.ts
-import { parse } from "querystring";
-import path from "path";
-var core;
-function getCore(options) {
-  return core ??= new Core({
-    outDir: options.outDir,
-    configPath: options.configPath
-  });
-}
-function toWebpack(loader) {
-  return async function(source, callback) {
-    try {
-      const result = await loader.load({
-        filePath: this.resourcePath,
-        query: parse(this.resourceQuery.slice(1)),
-        getSource() {
-          return source;
-        },
-        development: this.mode === "development",
-        compiler: this
-      });
-      if (result === null) {
-        callback(void 0, source);
-      } else {
-        callback(void 0, result.code, result.map);
-      }
-    } catch (error) {
-      if (error instanceof ValidationError) {
-        return callback(new Error(await error.toStringFormatted()));
-      }
-      if (!(error instanceof Error)) throw error;
-      const fpath = path.relative(this.context, this.resourcePath);
-      error.message = `${fpath}:${error.name}: ${error.message}`;
-      callback(error);
-    }
-  };
-}
-
-export {
-  getCore,
-  toWebpack
-};