fuma-content 0.0.1 → 1.0.0

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { existsSync } from "fs";
+async function start() {
+  const [configPath, outDir] = process.argv.slice(2);
+  const isNext = existsSync("next.config.js") || existsSync("next.config.mjs") || existsSync("next.config.mts") || existsSync("next.config.ts");
+  if (isNext) {
+    const { createStandaloneCore } = await import("./next/index.js");
+    const core = await createStandaloneCore({ configPath, outDir });
+    await core.emit({ write: true });
+  } else {
+    const { createStandaloneCore } = await import("./vite/index.js");
+    const core = await createStandaloneCore({ configPath, outDir });
+    await core.emit({ write: true });
+  }
+}
+void start();

package/dist/build-mdx-Q4RMDWYK.js

@@ -0,0 +1,8 @@
+import {
+  buildMDX
+} from "./chunk-AMBGM4OK.js";
+import "./chunk-VWJKRQZR.js";
+import "./chunk-6XDQG2GV.js";
+export {
+  buildMDX
+};

package/dist/bun/index.d.ts

@@ -0,0 +1,16 @@
+import { BunPlugin } from 'bun';
+import { C as CoreOptions } from '../core-DxnSmTRe.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+
+type ContentPluginOptions = Partial<CoreOptions>;
+declare function createContentPlugin(options?: ContentPluginOptions): BunPlugin;
+
+export { type ContentPluginOptions, createContentPlugin };

package/dist/bun/index.js

@@ -0,0 +1,36 @@
+import {
+  buildConfig
+} from "../chunk-IGLM4N4P.js";
+import {
+  Core
+} from "../chunk-Z7KHD7MS.js";
+import "../chunk-6XDQG2GV.js";
+
+// src/bun/index.ts
+import { pathToFileURL } from "url";
+function createContentPlugin(options = {}) {
+  const {
+    outDir = Core.defaultOptions.outDir,
+    configPath = Core.defaultOptions.configPath
+  } = options;
+  return {
+    name: "fuma-content",
+    async setup(build) {
+      const importPath = pathToFileURL(configPath).href;
+      const core = new Core({
+        outDir,
+        configPath
+      });
+      await core.init({
+        config: buildConfig(await import(importPath))
+      });
+      const ctx = core.getPluginContext();
+      for (const plugin of core.getPlugins(true)) {
+        await plugin.bun?.build?.call(ctx, build);
+      }
+    }
+  };
+}
+export {
+  createContentPlugin
+};

package/dist/bun-DMNX4PBC.js

@@ -0,0 +1,40 @@
+// src/plugins/with-loader/bun.ts
+import { parse } from "querystring";
+import { readFileSync } from "fs";
+function toBun(test = /.+/, loader) {
+  function toResult(output) {
+    if (!output) return;
+    return {
+      contents: output.code,
+      loader: "js"
+    };
+  }
+  return (build) => {
+    build.onLoad({ filter: test }, (args) => {
+      const [filePath, query = ""] = args.path.split("?", 2);
+      const input = {
+        async getSource() {
+          return Bun.file(filePath).text();
+        },
+        query: parse(query),
+        filePath,
+        development: false,
+        compiler: {
+          addDependency() {
+          }
+        }
+      };
+      if (loader.bun?.load) {
+        return loader.bun.load(readFileSync(filePath).toString(), input);
+      }
+      const result = loader.load(input);
+      if (result instanceof Promise) {
+        return result.then(toResult);
+      }
+      return toResult(result);
+    });
+  };
+}
+export {
+  toBun
+};

package/dist/chunk-3VQS3KSP.js

@@ -0,0 +1,39 @@
+// src/collections/runtime/store.ts
+var SimpleCollectionStore = class {
+  dataMap;
+  dataList;
+  constructor(input) {
+    this.dataMap = input;
+    this.dataList = Array.from(input.values());
+  }
+  get(id) {
+    return this.dataMap.get(id);
+  }
+  list() {
+    return this.dataList;
+  }
+  $data(_cast) {
+    return this;
+  }
+  /**
+   * in-place transformation on all data
+   */
+  transform(fn) {
+    this.dataList.length = 0;
+    const dataMap = this.dataMap;
+    const dataList = this.dataList;
+    for (const [k, v] of this.dataMap) {
+      const updated = fn(v);
+      dataMap.set(k, updated);
+      dataList.push(updated);
+    }
+    return this;
+  }
+  get $inferData() {
+    return void 0;
+  }
+};
+
+export {
+  SimpleCollectionStore
+};

package/dist/chunk-4RMSJCK2.js

@@ -0,0 +1,50 @@
+import {
+  ValidationError
+} from "./chunk-OUJENWQ4.js";
+import {
+  Core
+} from "./chunk-Z7KHD7MS.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
+};

package/dist/chunk-6XDQG2GV.js

@@ -0,0 +1,17 @@
+// src/utils/async-cache.ts
+function createCache(store = /* @__PURE__ */ new Map()) {
+  return {
+    store,
+    cached(key, fn) {
+      let cached = store.get(key);
+      if (cached) return cached;
+      cached = fn();
+      store.set(key, cached);
+      return cached;
+    }
+  };
+}
+
+export {
+  createCache
+};

package/dist/chunk-AMBGM4OK.js

@@ -0,0 +1,412 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+import {
+  createCache
+} from "./chunk-6XDQG2GV.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-BTRE6MOX.js

@@ -0,0 +1,16 @@
+// src/collections/index.ts
+function createCollection(info, init) {
+  return {
+    name: "",
+    handlers: {},
+    init(options) {
+      this.name = options.name;
+      init(this, options);
+    },
+    typeInfo: info
+  };
+}
+
+export {
+  createCollection
+};

package/dist/chunk-E4HRKSP4.js

@@ -0,0 +1,24 @@
+// src/collections/handlers/fs.ts
+import picomatch from "picomatch";
+import path from "path";
+function buildFileHandler({ workspace }, config, supportedFormats) {
+  const patterns = config.files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matcher;
+  return {
+    patterns,
+    dir: workspace ? path.resolve(workspace.dir, config.dir) : config.dir,
+    isFileSupported(filePath) {
+      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+    },
+    hasFile(filePath) {
+      if (!this.isFileSupported(filePath)) return false;
+      const relativePath = path.relative(this.dir, filePath);
+      if (relativePath.startsWith(`..${path.sep}`)) return false;
+      return (matcher ??= picomatch(patterns))(relativePath);
+    }
+  };
+}
+
+export {
+  buildFileHandler
+};