fuma-content 1.0.0 → 1.0.1

package/dist/{build-mdx-Q4RMDWYK.js → build-mdx-I4NROXCF.js}

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

package/dist/bun/index.d.ts

@@ -1,5 +1,5 @@
 import { BunPlugin } from 'bun';
-import { C as CoreOptions } from '../core-DxnSmTRe.js';
+import { C as CoreOptions } from '../core-Bo8KaWQz.js';
 import 'chokidar';
 import '@mdx-js/mdx';
 import 'vfile';

package/dist/bun/index.js

@@ -1,10 +1,11 @@
 import {
   buildConfig
-} from "../chunk-IGLM4N4P.js";
+} from "../chunk-W6HENTK7.js";
 import {
   Core
-} from "../chunk-Z7KHD7MS.js";
-import "../chunk-6XDQG2GV.js";
+} from "../chunk-NRZ4GE5O.js";
+import "../chunk-MT7RY65Y.js";
+import "../chunk-JBZTQ55D.js";
 
 // src/bun/index.ts
 import { pathToFileURL } from "url";

package/dist/{chunk-LDBQ66H3.js → chunk-GGL4EF6H.js}

@@ -20,7 +20,7 @@ function createDynamicCore({
         prev = {
           hash,
           init: (async () => {
-            const { loadConfig } = await import("./load-from-file-MLL4WQ5J.js");
+            const { loadConfig } = await import("./load-from-file-HL2VEY3M.js");
             await core.init({
               config: loadConfig(core, buildConfig)
             });

package/dist/{chunk-6XDQG2GV.js → chunk-JBZTQ55D.js}

@@ -1,13 +1,26 @@
 // 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();
+      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;
     }
   };
 }

package/dist/{chunk-PNA5UGSL.js → chunk-KH5GT2Y5.js}

@@ -70,7 +70,7 @@ function createMdxLoader({ getCore }) {
         };
       }
       const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      const { buildMDX } = await import("./build-mdx-Q4RMDWYK.js");
+      const { buildMDX } = await import("./build-mdx-I4NROXCF.js");
       const compiled = await buildMDX(core, collection, {
         isDevelopment,
         source: "\n".repeat(lineOffset) + matter.content,

package/dist/{chunk-M72VQL5M.js → chunk-LUM7SIZN.js}

@@ -1,6 +1,6 @@
 import {
   buildConfig
-} from "./chunk-IGLM4N4P.js";
+} from "./chunk-W6HENTK7.js";
 
 // src/config/load-from-file.ts
 import { pathToFileURL } from "url";

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

package/dist/chunk-NRZ4GE5O.js

@@ -0,0 +1,207 @@
+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-AMBGM4OK.js → chunk-OQQNA7L7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-VWJKRQZR.js";
 import {
   createCache
-} from "./chunk-6XDQG2GV.js";
+} from "./chunk-JBZTQ55D.js";
 
 // src/collections/mdx/build-mdx.ts
 import { createProcessor } from "@mdx-js/mdx";

package/dist/{chunk-IGLM4N4P.js → chunk-W6HENTK7.js}

@@ -2,7 +2,17 @@
 function buildConfig(config, workspace) {
   const collections = /* @__PURE__ */ new Map();
   const loaded = {};
-  const globalConfig = config.default ?? config;
+  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 });

package/dist/{chunk-4RMSJCK2.js → chunk-XR5N6ZXJ.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-OUJENWQ4.js";
 import {
   Core
-} from "./chunk-Z7KHD7MS.js";
+} from "./chunk-NRZ4GE5O.js";
 
 // src/plugins/with-loader/webpack.ts
 import { parse } from "querystring";

package/dist/collections/handlers/fs.d.ts

@@ -1,4 +1,4 @@
-export { m as FIleCollectionHandler, F as FileHandlerConfig, n as buildFileHandler } from '../../core-DxnSmTRe.js';
+export { m as FIleCollectionHandler, F as FileHandlerConfig, n as buildFileHandler } from '../../core-Bo8KaWQz.js';
 import 'chokidar';
 import '@mdx-js/mdx';
 import 'vfile';

package/dist/collections/index.d.ts

@@ -1,4 +1,4 @@
-export { y as Collection, A as CollectionHandlers, z as CollectionTypeInfo, I as InitOptions, B as createCollection } from '../core-DxnSmTRe.js';
+export { d as Collection, A as CollectionHandlers, z as CollectionTypeInfo, I as InitOptions, B as createCollection } from '../core-Bo8KaWQz.js';
 import 'chokidar';
 import '@mdx-js/mdx';
 import 'vfile';

package/dist/collections/mdx/loader-webpack.d.ts

@@ -1,7 +1,7 @@
 import { LoaderContext } from 'webpack';
 import { WebpackLoaderOptions } from '../../plugins/with-loader/webpack.js';
 import '../../plugins/with-loader/index.js';
-import '../../core-DxnSmTRe.js';
+import '../../core-Bo8KaWQz.js';
 import 'chokidar';
 import '@mdx-js/mdx';
 import 'vfile';

package/dist/collections/mdx/loader-webpack.js

@@ -1,17 +1,18 @@
 import {
   createMdxLoader
-} from "../../chunk-PNA5UGSL.js";
+} from "../../chunk-KH5GT2Y5.js";
 import {
   getCore,
   toWebpack
-} from "../../chunk-4RMSJCK2.js";
+} from "../../chunk-XR5N6ZXJ.js";
 import "../../chunk-OUJENWQ4.js";
 import {
   createDynamicCore
-} from "../../chunk-LDBQ66H3.js";
+} from "../../chunk-GGL4EF6H.js";
 import "../../chunk-VWJKRQZR.js";
-import "../../chunk-Z7KHD7MS.js";
-import "../../chunk-6XDQG2GV.js";
+import "../../chunk-NRZ4GE5O.js";
+import "../../chunk-MT7RY65Y.js";
+import "../../chunk-JBZTQ55D.js";
 
 // src/collections/mdx/loader-webpack.ts
 var instance;

package/dist/collections/mdx/runtime-browser.d.ts

@@ -1,7 +1,7 @@
-import { FC, ReactNode } from 'react';
+import { ReactNode } from 'react';
 import { CompiledMDXProperties } from './runtime.js';
 import { GetCollectionConfig } from '../../index.js';
-import { M as MDXCollection, E as ExtractedReference, V as VersionControlFileData } from '../../core-DxnSmTRe.js';
+import { M as MDXCollection, E as ExtractedReference, V as VersionControlFileData } from '../../core-Bo8KaWQz.js';
 import { SimpleCollectionStore } from '../runtime/store.js';
 import '../runtime/file-store.js';
 import 'mdx/types';
@@ -15,19 +15,30 @@ import 'vite';
 import 'next';
 import 'node:module';
 
+interface AsyncCache<V> {
+    cached: (key: string, fn: () => V | Promise<V>) => V | Promise<V>;
+    $value: <T>() => AsyncCache<T>;
+    invalidate: (key: string) => void;
+}
+
 interface MDXStoreBrowserData<Frontmatter, CustomData> {
-    preload: () => Promise<CompiledMDXProperties<Frontmatter> & CustomData>;
-    _renderer: {
-        id: string;
-        renderers?: Map<string, FC>;
-        getStoreData: () => StoreData;
-    };
+    id: string;
+    preload: () => (CompiledMDXProperties<Frontmatter> & CustomData) | Promise<CompiledMDXProperties<Frontmatter> & CustomData>;
+    _renderer: StoreRendererData;
+}
+interface StoreRendererData {
+    storeId: string;
+    renderers: Map<string, {
+        fn: () => ReactNode;
+        forceOnDemand: boolean;
+    }>;
 }
 interface StoreData {
-    preloaded: Map<string, Promise<CompiledMDXProperties>>;
+    preloaded: AsyncCache<CompiledMDXProperties>;
 }
+type GetFrontmatter<Config, Name extends string> = GetCollectionConfig<Config, Name> extends MDXCollection<infer _Frontmatter> ? _Frontmatter : never;
 declare const _internal_data: Map<string, StoreData>;
-declare function mdxStoreBrowser<Config, Name extends string>(name: Name, _input: Record<string, () => Promise<unknown>>): SimpleCollectionStore<MDXStoreBrowserData<GetCollectionConfig<Config, Name> extends MDXCollection<infer Frontmatter> ? Frontmatter : never, unknown>>;
+declare function mdxStoreBrowser<Config, Name extends string>(name: Name, _input: Record<string, () => Promise<unknown>>): SimpleCollectionStore<MDXStoreBrowserData<GetFrontmatter<Config, Name>, unknown>>;
 /**
  * Renders content with `React.lazy`.
  */