fuma-content 0.0.2 → 1.0.1

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-I4NROXCF.js

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

package/dist/bun/index.d.ts

@@ -0,0 +1,16 @@
+import { BunPlugin } from 'bun';
+import { C as CoreOptions } from '../core-Bo8KaWQz.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,37 @@
+import {
+  buildConfig
+} from "../chunk-W6HENTK7.js";
+import {
+  Core
+} from "../chunk-NRZ4GE5O.js";
+import "../chunk-MT7RY65Y.js";
+import "../chunk-JBZTQ55D.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-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
+};

package/dist/chunk-ERBMAQYP.js

@@ -0,0 +1,33 @@
+// src/plugins/with-loader/index.ts
+function withLoader(plugin, { test, createLoader }) {
+  let loader;
+  return {
+    bun: {
+      async build(build) {
+        const { toBun } = await import("./bun-DMNX4PBC.js");
+        toBun(test, await (loader ??= createLoader.call(this, "bun")))(build);
+      }
+    },
+    node: {
+      async createLoad() {
+        const { toNode } = await import("./node-DCMYL4DL.js");
+        return toNode(test, await (loader ??= createLoader.call(this, "node")));
+      }
+    },
+    vite: {
+      async createPlugin() {
+        const { toVite } = await import("./vite-QCUPZHHB.js");
+        return toVite(
+          plugin.name,
+          test,
+          await (loader ??= createLoader.call(this, "vite"))
+        );
+      }
+    },
+    ...plugin
+  };
+}
+
+export {
+  withLoader
+};

package/dist/chunk-GGL4EF6H.js

@@ -0,0 +1,38 @@
+// src/config/dynamic.ts
+import fs from "fs/promises";
+function createDynamicCore({
+  core,
+  buildConfig,
+  mode
+}) {
+  let prev;
+  async function getConfigHash() {
+    if (mode === "production") return "static";
+    const stats = await fs.stat(core.getOptions().configPath).catch(() => {
+      throw new Error("Cannot find config file");
+    });
+    return stats.mtime.getTime().toString();
+  }
+  return {
+    async getCore() {
+      const hash = await getConfigHash();
+      if (!prev || hash !== prev.hash) {
+        prev = {
+          hash,
+          init: (async () => {
+            const { loadConfig } = await import("./load-from-file-HL2VEY3M.js");
+            await core.init({
+              config: loadConfig(core, buildConfig)
+            });
+          })()
+        };
+      }
+      await prev.init;
+      return core;
+    }
+  };
+}
+
+export {
+  createDynamicCore
+};

package/dist/chunk-JBZTQ55D.js

@@ -0,0 +1,30 @@
+// src/utils/async-cache.ts
+function createCache(store = /* @__PURE__ */ new Map()) {
+  return {
+    cached(key, fn) {
+      let cached = store.get(key);
+      if (cached) return cached;
+      cached = fn();
+      if (cached instanceof Promise) {
+        cached = cached.then((out) => {
+          if (store.has(key)) {
+            store.set(key, out);
+          }
+          return out;
+        });
+      }
+      store.set(key, cached);
+      return cached;
+    },
+    invalidate(key) {
+      store.delete(key);
+    },
+    $value() {
+      return this;
+    }
+  };
+}
+
+export {
+  createCache
+};

package/dist/chunk-KH5GT2Y5.js

@@ -0,0 +1,104 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/collections/mdx/loader.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+var querySchema = z.object({
+  only: z.literal(["frontmatter", "all"]).default("all"),
+  collection: z.string().optional(),
+  workspace: z.string().optional()
+}).loose();
+var cacheEntry = z.object({
+  code: z.string(),
+  map: z.any().optional(),
+  hash: z.string().optional()
+});
+function createMdxLoader({ getCore }) {
+  return {
+    async load({
+      getSource,
+      development: isDevelopment,
+      query,
+      compiler,
+      filePath
+    }) {
+      let core = await getCore();
+      const value = await getSource();
+      const matter = fumaMatter(value);
+      const {
+        collection: collectionName,
+        workspace,
+        only
+      } = querySchema.parse(query);
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      let after;
+      const { experimentalBuildCache = false } = core.getConfig();
+      if (!isDevelopment && experimentalBuildCache) {
+        const cacheDir = experimentalBuildCache;
+        const cacheKey = `${collectionName ?? "global"}_${generateCacheHash(filePath)}`;
+        const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+        if (cached && cached.hash === generateCacheHash(value)) return cached;
+        after = async () => {
+          await fs.mkdir(cacheDir, { recursive: true });
+          await fs.writeFile(
+            path.join(cacheDir, cacheKey),
+            JSON.stringify({
+              ...out,
+              hash: generateCacheHash(value)
+            })
+          );
+        };
+      }
+      const collection = collectionName ? core.getCollection(collectionName) : void 0;
+      const handler = collection?.handlers.mdx;
+      if (collection && handler?.frontmatter) {
+        matter.data = await handler.frontmatter.call(
+          { collection, filePath, source: value },
+          matter.data
+        );
+      }
+      if (only === "frontmatter") {
+        return {
+          code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+          map: null
+        };
+      }
+      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+      const { buildMDX } = await import("./build-mdx-I4NROXCF.js");
+      const compiled = await buildMDX(core, collection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
+      const out = {
+        code: String(compiled.value),
+        map: compiled.map
+      };
+      await after?.();
+      return out;
+    }
+  };
+}
+function generateCacheHash(input) {
+  return createHash("md5").update(input).digest("hex");
+}
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+export {
+  createMdxLoader
+};

package/dist/chunk-LUM7SIZN.js

@@ -0,0 +1,40 @@
+import {
+  buildConfig
+} from "./chunk-W6HENTK7.js";
+
+// src/config/load-from-file.ts
+import { pathToFileURL } from "url";
+async function compileConfig(core) {
+  const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "content.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+}
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = pathToFileURL(core.getCompiledConfigPath());
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
+  return await config;
+}
+
+export {
+  loadConfig
+};

package/dist/chunk-MT7RY65Y.js

@@ -0,0 +1,167 @@
+import {
+  createCache
+} from "./chunk-JBZTQ55D.js";
+
+// src/utils/code-generator.ts
+import path from "path";
+import { glob } from "tinyglobby";
+function importInfo() {
+  return {
+    named: /* @__PURE__ */ new Map(),
+    namespaces: /* @__PURE__ */ new Set(),
+    isUsed: /* @__PURE__ */ new Set()
+  };
+}
+var CodeGenerator = class {
+  lines = [];
+  globCache;
+  // specifier -> imported members/info
+  importInfos = /* @__PURE__ */ new Map();
+  eagerImportId = 0;
+  options;
+  constructor({
+    target = "default",
+    jsExtension = false,
+    globCache = /* @__PURE__ */ new Map(),
+    outDir = ""
+  }) {
+    this.options = {
+      target,
+      jsExtension,
+      globCache,
+      outDir
+    };
+    this.globCache = createCache(globCache);
+  }
+  addNamespaceImport(namespace, specifier, types = false) {
+    const info = this.importInfos.get(specifier) ?? importInfo();
+    this.importInfos.set(specifier, info);
+    if (!types) info.isUsed.add(namespace);
+    info.namespaces.add(namespace);
+  }
+  addNamedImport(names, specifier, types = false) {
+    const info = this.importInfos.get(specifier) ?? importInfo();
+    this.importInfos.set(specifier, info);
+    for (const name of names) {
+      const [memberName, importName = memberName] = name.split(/\s+as\s+/, 2);
+      info.named.set(importName, memberName);
+      if (!types) info.isUsed.add(importName);
+    }
+  }
+  push(...insert) {
+    this.lines.push(...insert);
+  }
+  async pushAsync(insert) {
+    for (const line of await Promise.all(insert)) {
+      if (line === void 0) continue;
+      this.lines.push(line);
+    }
+  }
+  async generateGlobImport(patterns, options) {
+    if (this.options.target === "vite") {
+      return this.generateViteGlobImport(patterns, options);
+    }
+    return this.generateNodeGlobImport(patterns, options);
+  }
+  generateViteGlobImport(patterns, { base, ...rest }) {
+    patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
+      normalizeViteGlobPath
+    );
+    return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+      {
+        base: normalizeViteGlobPath(path.relative(this.options.outDir, base)),
+        ...rest
+      },
+      null,
+      2
+    )})`;
+  }
+  async generateNodeGlobImport(patterns, { base, eager = false, query = {}, import: importName }) {
+    const files = await this.globCache.cached(
+      JSON.stringify({ patterns, base }),
+      () => glob(patterns, {
+        cwd: base
+      })
+    );
+    let code = "{";
+    for (const item of files) {
+      const fullPath = path.join(base, item);
+      const searchParams = new URLSearchParams();
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0) searchParams.set(k, v);
+      }
+      const importPath = `${this.formatImportPath(fullPath)}?${searchParams.toString()}`;
+      if (eager) {
+        const name = `__fd_glob_${this.eagerImportId++}`;
+        this.lines.unshift(
+          importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
+        );
+        code += `${JSON.stringify(item)}: ${name}, `;
+      } else {
+        let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
+        if (importName) {
+          line += `.then(mod => mod.${importName})`;
+        }
+        code += `${line}, `;
+      }
+    }
+    code += "}";
+    return code;
+  }
+  formatImportPath(file) {
+    const ext = path.extname(file);
+    let filename;
+    if (ext === ".ts") {
+      filename = file.substring(0, file.length - ext.length);
+      if (this.options.jsExtension) filename += ".js";
+    } else {
+      filename = file;
+    }
+    const importPath = slash(path.relative(this.options.outDir, filename));
+    return importPath.startsWith(".") ? importPath : `./${importPath}`;
+  }
+  toString() {
+    const final = ["// @ts-nocheck"];
+    if (this.options.target === "vite") {
+      final.push('/// <reference types="vite/client" />');
+    }
+    for (const [specifier, info] of this.importInfos) {
+      const { namespaces, named, isUsed } = info;
+      for (const namespace of namespaces) {
+        final.push(
+          isUsed.has(namespace) ? `import * as ${namespace} from "${specifier}";` : `import type * as ${namespace} from "${specifier}";`
+        );
+      }
+      const namedImports = [];
+      for (const [importName, memberName] of named) {
+        const item = importName === memberName ? importName : `${memberName} as ${importName}`;
+        namedImports.push(isUsed.has(importName) ? item : `type ${item}`);
+      }
+      if (namedImports.length > 0) {
+        final.push(
+          `import { ${namedImports.join(", ")} } from "${specifier}";`
+        );
+      }
+    }
+    final.push(...this.lines);
+    return final.join("\n");
+  }
+};
+function normalizeViteGlobPath(file) {
+  file = slash(file);
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function slash(path2) {
+  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path2;
+  }
+  return path2.replaceAll("\\", "/");
+}
+
+export {
+  CodeGenerator,
+  slash
+};