fuma-content 1.0.1 → 1.0.3

package/dist/next/index.cjs

@@ -1,594 +1,497 @@
-"use strict";
+//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createContent: () => createContent,
-  createStandaloneCore: () => createStandaloneCore
-});
-module.exports = __toCommonJS(next_exports);
-var path3 = __toESM(require("path"), 1);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/config/load-from-file.ts
-var import_node_url = require("url");
-
-// 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
-            })
-          }
-        ];
-      })
-    )
-  };
-}
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_url = require("node:url");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let tinyglobby = require("tinyglobby");
 
-// src/config/load-from-file.ts
+//#region src/config/load-from-file.ts
 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");
-  }
+	const { build } = await import("esbuild");
+	const { configPath, outDir } = core.getOptions();
+	if ((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
+	})).errors.length > 0) throw new Error("failed to compile configuration file");
 }
+/**
+* Load config
+*
+* @param build - By default, it assumes the config file has been compiled. Set this `true` to compile the config first.
+*/
 async function loadConfig(core, build = false) {
-  if (build) await compileConfig(core);
-  const url = (0, import_node_url.pathToFileURL)(core.getCompiledConfigPath());
-  url.searchParams.set("hash", Date.now().toString());
-  const config = import(url.href).then(
-    (loaded) => buildConfig(loaded)
-  );
-  return await config;
+	if (build) await compileConfig(core);
+	const url = (0, node_url.pathToFileURL)(core.getCompiledConfigPath());
+	url.searchParams.set("hash", Date.now().toString());
+	return import(url.href);
 }
 
-// src/core.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-
-// src/utils/code-generator.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_tinyglobby = require("tinyglobby");
-
-// src/utils/async-cache.ts
+//#endregion
+//#region src/utils/async-cache.ts
+/**
+* cache for async resources, finished promises will be resolved into original value, otherwise wrapped with a promise.
+*/
 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;
-    }
-  };
+	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;
+		}
+	};
 }
 
-// src/utils/code-generator.ts
+//#endregion
+//#region src/utils/code-generator.ts
 function importInfo() {
-  return {
-    named: /* @__PURE__ */ new Map(),
-    namespaces: /* @__PURE__ */ new Set(),
-    isUsed: /* @__PURE__ */ new Set()
-  };
+	return {
+		named: /* @__PURE__ */ new Map(),
+		namespaces: /* @__PURE__ */ new Set(),
+		isUsed: /* @__PURE__ */ new Set()
+	};
 }
+/**
+* Code generator (one instance per file)
+*/
 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(import_node_path.default.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 }),
-      () => (0, import_tinyglobby.glob)(patterns, {
-        cwd: base
-      })
-    );
-    let code = "{";
-    for (const item of files) {
-      const fullPath = import_node_path.default.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 = import_node_path.default.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(import_node_path.default.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");
-  }
+	lines = [];
+	globCache;
+	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(node_path.default.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
+		}), () => (0, tinyglobby.glob)(patterns, { cwd: base }));
+		let code = "{";
+		for (const item of files) {
+			const fullPath = node_path.default.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 = node_path.default.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(node_path.default.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");
+	}
 };
+/**
+* convert into POSIX & relative file paths, such that Vite can accept it.
+*/
 function normalizeViteGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
+	file = slash(file);
+	if (file.startsWith("./")) return file;
+	if (file.startsWith("/")) return `.${file}`;
+	return `./${file}`;
 }
-function slash(path4) {
-  const isExtendedLengthPath = path4.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path4;
-  }
-  return path4.replaceAll("\\", "/");
+function slash(path$3) {
+	if (path$3.startsWith("\\\\?\\")) return path$3;
+	return path$3.replaceAll("\\", "/");
 }
 
-// src/core.ts
+//#endregion
+//#region src/core.ts
 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;
+	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: import_node_path2.default.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 import_node_path2.default.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 (path4, content) => {
-        const codegen = new CodeGenerator({
-          target,
-          outDir,
-          jsExtension,
-          globCache
-        });
-        await content({
-          core: this,
-          codegen,
-          workspace: workspace?.name
-        });
-        return {
-          path: path4,
-          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 = import_node_path2.default.join(outDir, entry.path);
-          await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-          await import_promises.default.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;
-  }
+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 = {}) {
+		const cwd = options.cwd ? node_path.default.resolve(options.cwd) : process.cwd();
+		this.options = {
+			...options,
+			cwd,
+			outDir: node_path.default.resolve(cwd, options.outDir ?? Core.defaultOptions.outDir),
+			configPath: node_path.default.resolve(cwd, options.configPath ?? Core.defaultOptions.configPath)
+		};
+	}
+	async init({ config: newConfig, plugins: customPlugins }) {
+		this.config = this.buildConfig(await newConfig);
+		this.cache.clear();
+		this.workspaces.clear();
+		const loadedCollectionTypeIds = /* @__PURE__ */ new Set();
+		this.plugins = await getPlugins([
+			customPlugins,
+			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;
+		}
+		if (!this.options.workspace && this.config.workspaces) await Promise.all(Object.entries(this.config.workspaces).map(async ([name, workspace]) => {
+			const child = new Core({
+				...this.options,
+				cwd: node_path.default.resolve(this.options.cwd, workspace.dir),
+				workspace: {
+					name,
+					parent: this,
+					dir: workspace.dir
+				}
+			});
+			await child.init({ config: workspace.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 node_path.default.join(this.options.outDir, "content.config.mjs");
+	}
+	getPlugins(workspace = false) {
+		if (workspace) {
+			const plugins = [...this.plugins];
+			for (const workspace$1 of this.workspaces.values()) plugins.push(...workspace$1.plugins);
+			return plugins;
+		}
+		return this.plugins;
+	}
+	getCollections(workspace = false) {
+		const list = Array.from(this.config.collections.values());
+		if (workspace) for (const workspace$1 of this.workspaces.values()) list.push(...workspace$1.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 } = this.options;
+		const { target, jsExtension } = this.config.emit ?? {};
+		const { filterPlugin, filterWorkspace, write = false } = emitOptions;
+		const start = performance.now();
+		const globCache = /* @__PURE__ */ new Map();
+		const ctx = {
+			...this.getPluginContext(),
+			createCodeGenerator: async (path$3, content) => {
+				const codegen = new CodeGenerator({
+					target,
+					outDir,
+					jsExtension,
+					globCache
+				});
+				await content({
+					core: this,
+					codegen,
+					workspace: workspace?.name
+				});
+				return {
+					path: path$3,
+					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 = node_path.default.join(outDir, entry.path);
+				await node_fs_promises.default.mkdir(node_path.default.dirname(file), { recursive: true });
+				await node_fs_promises.default.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, workspace$1]) => {
+			if (filterWorkspace && !filterWorkspace(name)) return;
+			out.workspaces[name] = (await workspace$1.emit(emitOptions)).entries;
+		}));
+		return out;
+	}
+	/**
+	* convert absolute path into a runtime path (relative to **runtime** cwd)
+	*/
+	_toRuntimePath(absolutePath) {
+		return node_path.default.relative(process.cwd(), absolutePath);
+	}
+	buildConfig(config) {
+		const collections = /* @__PURE__ */ new Map();
+		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,
+				core: this
+			});
+			collections.set(name, collection);
+		}
+		return {
+			...globalConfig,
+			collections
+		};
+	}
 };
 
-// src/next/index.ts
+//#endregion
+//#region src/next/index.ts
 async function createContent(nextOptions = {}) {
-  const core = createNextCore(applyDefaults(nextOptions));
-  await core.init({
-    config: loadConfig(core, true)
-  });
-  if (process.env._FUMADOCS_MDX !== "1") {
-    process.env._FUMADOCS_MDX = "1";
-    await core.emit({ write: true });
-    await init(process.env.NODE_ENV === "development", core);
-  }
-  return (nextConfig = {}) => {
-    const ctx = core.getPluginContext();
-    for (const plugin of core.getPlugins(true)) {
-      nextConfig = plugin.next?.config?.call(ctx, nextConfig) ?? nextConfig;
-    }
-    return nextConfig;
-  };
+	const core = createNextCore(applyDefaults(nextOptions));
+	await core.init({ config: loadConfig(core, true) });
+	if (process.env._FUMADOCS_MDX !== "1") {
+		process.env._FUMADOCS_MDX = "1";
+		await core.emit({ write: true });
+		await init(process.env.NODE_ENV === "development", core);
+	}
+	return (nextConfig = {}) => {
+		const ctx = core.getPluginContext();
+		for (const plugin of core.getPlugins(true)) nextConfig = plugin.next?.config?.call(ctx, nextConfig) ?? nextConfig;
+		return nextConfig;
+	};
 }
 async function init(dev, core) {
-  if (!dev) return;
-  const { FSWatcher } = await import("chokidar");
-  const { configPath, outDir } = core.getOptions();
-  const absoluteConfigPath = path3.resolve(configPath);
-  let watcher;
-  async function devServer() {
-    if (watcher && !watcher.closed) {
-      await watcher.close();
-    }
-    watcher = new FSWatcher({
-      ignoreInitial: true,
-      persistent: true,
-      ignored: [outDir]
-    });
-    watcher.add(configPath);
-    for (const collection of core.getCollections(true)) {
-      const handler = collection.handlers.fs;
-      if (handler) {
-        watcher.add(handler.dir);
-      }
-    }
-    watcher.once("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    watcher.on("all", (_event, file) => {
-      if (path3.resolve(file) === absoluteConfigPath) {
-        console.log("[MDX] restarting dev server");
-        watcher?.removeAllListeners();
-        void (async () => {
-          await core.init({
-            config: loadConfig(core, true)
-          });
-          await devServer();
-          await core.emit({ write: true });
-        })();
-      }
-    });
-    await core.initServer({ watcher });
-  }
-  process.on("exit", () => {
-    if (!watcher || watcher.closed) return;
-    console.log("[MDX] closing dev server");
-    void watcher.close();
-  });
-  await devServer();
+	if (!dev) return;
+	const { FSWatcher } = await import("chokidar");
+	const { configPath, outDir } = core.getOptions();
+	const absoluteConfigPath = node_path.default.resolve(configPath);
+	let watcher;
+	async function devServer() {
+		if (watcher && !watcher.closed) await watcher.close();
+		watcher = new FSWatcher({
+			ignoreInitial: true,
+			persistent: true,
+			ignored: [outDir]
+		});
+		watcher.add(configPath);
+		for (const collection of core.getCollections(true)) {
+			const handler = collection.handlers.fs;
+			if (handler) watcher.add(handler.dir);
+		}
+		watcher.once("ready", () => {
+			console.log("[MDX] started dev server");
+		});
+		watcher.on("all", (_event, file) => {
+			if (node_path.default.resolve(file) === absoluteConfigPath) {
+				console.log("[MDX] restarting dev server");
+				watcher?.removeAllListeners();
+				(async () => {
+					await core.init({ config: loadConfig(core, true) });
+					await devServer();
+					await core.emit({ write: true });
+				})();
+			}
+		});
+		await core.initServer({ watcher });
+	}
+	process.on("exit", () => {
+		if (!watcher || watcher.closed) return;
+		console.log("[MDX] closing dev server");
+		watcher.close();
+	});
+	await devServer();
 }
 async function createStandaloneCore(options) {
-  const core = createNextCore(applyDefaults(options));
-  await core.init({
-    config: loadConfig(core, true)
-  });
-  return core;
+	const core = createNextCore(applyDefaults(options));
+	await core.init({ config: loadConfig(core, true) });
+	return core;
 }
 function applyDefaults(options) {
-  return {
-    outDir: options.outDir ?? Core.defaultOptions.outDir,
-    configPath: options.configPath ?? Core.defaultOptions.configPath
-  };
+	return {
+		outDir: options.outDir ?? Core.defaultOptions.outDir,
+		configPath: options.configPath ?? Core.defaultOptions.configPath
+	};
 }
 function createNextCore(options) {
-  return new Core({
-    outDir: options.outDir,
-    configPath: options.configPath
-  });
+	return new Core({
+		outDir: options.outDir,
+		configPath: options.configPath
+	});
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createContent,
-  createStandaloneCore
-});
+
+//#endregion
+exports.createContent = createContent;
+exports.createStandaloneCore = createStandaloneCore;