fuma-content 0.0.2 → 1.0.1

package/dist/config/index.d.ts

@@ -0,0 +1,10 @@
+export { G as GlobalConfig, W as WorkspaceConfig, D as defineConfig } 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';

package/dist/config/index.js

@@ -0,0 +1,7 @@
+// src/config/index.ts
+function defineConfig(config = {}) {
+  return config;
+}
+export {
+  defineConfig
+};

package/dist/core-Bo8KaWQz.d.ts

@@ -0,0 +1,411 @@
+import { FSWatcher } from 'chokidar';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { VFile } from 'vfile';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Processor } from 'unified';
+import { Root } from 'mdast';
+import * as Vite from 'vite';
+import { NextConfig } from 'next';
+import { LoadHook } from 'node:module';
+
+interface JSONSchemaOptions {
+    /**
+     * insert `$schema` field to JSON files on creation.
+     *
+     * @defaultValue false
+     */
+    insert?: boolean;
+}
+interface JSONSchemaHandler {
+    create: () => object | undefined | Promise<object | undefined>;
+}
+/**
+ * Generate JSON schemas locally for collection schemas
+ *
+ * note: **it only works with Zod**
+ */
+declare function jsonSchema({ insert, }?: JSONSchemaOptions): Plugin;
+
+interface FileHandlerConfig {
+    /**
+     * Directory to scan
+     */
+    dir: string;
+    /**
+     * what files to include/exclude (glob patterns)
+     *
+     * Include all files if not specified
+     */
+    files?: string[];
+}
+interface FIleCollectionHandler {
+    /**
+     * content directory (absolute)
+     */
+    dir: string;
+    hasFile: (filePath: string) => boolean;
+    isFileSupported: (filePath: string) => boolean;
+    patterns: string[];
+}
+declare function buildFileHandler({ workspace }: InitOptions, config: FileHandlerConfig, supportedFormats: string[]): FIleCollectionHandler;
+
+interface ExtractedReference {
+    href: string;
+}
+interface PostprocessOptions {
+    _format: "md" | "mdx";
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    /**
+     * stringify MDAST and export via `_markdown`.
+     */
+    includeProcessedMarkdown?: boolean;
+    /**
+     * extract link references, export via `extractedReferences`.
+     */
+    extractLinkReferences?: boolean;
+    /**
+     * store MDAST and export via `_mdast`.
+     */
+    includeMDAST?: boolean | {
+        removePosition?: boolean;
+    };
+}
+
+interface PreprocessOptions {
+    preprocessor?: Processor<Root>;
+}
+declare module "vfile" {
+    interface DataMap {
+        _preprocessed?: boolean;
+    }
+}
+
+type Awaitable$2<T> = T | PromiseLike<T>;
+interface CompilationContext {
+    collection: Collection;
+    filePath: string;
+    source: string;
+}
+interface MDXCollectionHandler {
+    readonly cwd: string;
+    readonly dynamic: boolean;
+    readonly lazy: boolean;
+    preprocess?: PreprocessOptions;
+    postprocess?: Partial<PostprocessOptions>;
+    getMDXOptions?: (environment: "bundler" | "runtime") => Awaitable$2<ProcessorOptions>;
+    /**
+     * Transform frontmatter
+     */
+    frontmatter?: (this: CompilationContext, data: Record<string, unknown>) => Awaitable$2<Record<string, unknown> | undefined>;
+    /**
+     * Transform `vfile` on compilation stage
+     */
+    vfile?: (this: CompilationContext, file: VFile) => Awaitable$2<VFile>;
+    onGenerateStore?: (this: EmitCodeGeneratorContext & {
+        environment: "browser" | "server" | "dynamic";
+    }, initializer: string) => string;
+}
+interface MDXCollectionConfig<FrontmatterSchema extends StandardSchemaV1 | undefined = undefined> extends FileHandlerConfig {
+    postprocess?: Partial<PostprocessOptions>;
+    frontmatter?: FrontmatterSchema;
+    options?: (environment: "bundler" | "runtime") => Awaitable$2<ProcessorOptions>;
+    lazy?: boolean;
+    dynamic?: boolean;
+}
+type MDXCollection<Frontmatter> = Collection & {
+    _frontmatter?: Frontmatter;
+};
+declare function defineMDX<FrontmatterSchema extends StandardSchemaV1 | undefined = undefined>(config: MDXCollectionConfig<FrontmatterSchema>): MDXCollection<FrontmatterSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<FrontmatterSchema> : Record<string, unknown>>;
+
+type Awaitable$1<T> = T | PromiseLike<T>;
+interface MetaContext {
+    path: string;
+    source: string;
+}
+interface MetaCollectionHandler {
+    /**
+     * Transform metadata
+     */
+    transform?: (this: MetaContext, data: unknown) => Awaitable$1<unknown | undefined>;
+    schema?: StandardSchemaV1;
+}
+interface MetaCollectionConfig<Schema extends StandardSchemaV1> extends FileHandlerConfig {
+    schema?: Schema;
+}
+type MetaCollection<_Data> = Collection & {
+    _type?: _Data;
+};
+declare function defineMeta<Schema extends StandardSchemaV1>(config: MetaCollectionConfig<Schema>): MetaCollection<Schema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Schema> : Record<string, unknown>>;
+
+interface VersionControlFileData {
+    /**
+     * Last modified date of file, obtained from version control.
+     */
+    lastModified: Date | null;
+    /**
+     * Creation date of file, obtained from version control.
+     */
+    creationDate: Date | null;
+}
+interface VersionControlHandler {
+    /**
+     * receive the version control client.
+     */
+    client: (context: {
+        client: VersionControlClient;
+    }) => void | Promise<void>;
+}
+interface GitPluginOptions {
+    /**
+     * Filter the collections to include by names
+     */
+    filter?: (collection: string) => boolean;
+}
+/**
+ * Add version control integration for Git.
+ * 1. Injects `creationDate` & `lastModified` properties to page exports.
+ *
+ * @remarks If you are using Vercel, please set `VERCEL_DEEP_CLONE` environment variable to `true`. This ensures the client can access the full commit history of Git.
+ */
+declare function git(options?: GitPluginOptions): Plugin;
+interface VersionControlClient {
+    getFileData: (options: {
+        filePath: string;
+    }) => Promise<VersionControlFileData>;
+}
+
+interface InitOptions {
+    name: string;
+    workspace?: WorkspaceConfig;
+}
+interface Collection {
+    name: string;
+    init?: (options: InitOptions) => void;
+    readonly handlers: CollectionHandlers;
+    /**
+     * information for the collection type, can be shared for all collections of same type.
+     */
+    readonly typeInfo: CollectionTypeInfo;
+}
+interface CollectionTypeInfo {
+    /**
+     * ID for collection type.
+     *
+     * @example `my-package:my-collection-type`
+     */
+    readonly id: string;
+    /**
+     * plugins to register, registered once for each collection type.
+     */
+    readonly plugins?: PluginOption;
+}
+interface CollectionHandlers {
+    fs?: FIleCollectionHandler;
+    mdx?: MDXCollectionHandler;
+    meta?: MetaCollectionHandler;
+    "json-schema"?: JSONSchemaHandler;
+    "version-control"?: VersionControlHandler;
+}
+declare function createCollection(info: CollectionTypeInfo, init: (collection: Collection, options: InitOptions) => void): Collection;
+
+interface GlobalConfig<Collections extends Record<string, Collection> = Record<string, Collection>> {
+    plugins?: PluginOption[];
+    collections?: Collections;
+    workspaces?: Record<string, Omit<WorkspaceConfig, "name">>;
+    /**
+     * specify a directory to access & store cache (disabled during development mode).
+     *
+     * The cache will never be updated, delete the cache folder to clean.
+     */
+    experimentalBuildCache?: string;
+}
+interface WorkspaceConfig {
+    name: string;
+    dir: string;
+    config: GlobalConfig | {
+        default: GlobalConfig;
+    };
+}
+declare function defineConfig<Collections extends Record<string, Collection> = Record<string, Collection>>(config?: GlobalConfig<Collections>): GlobalConfig<Collections>;
+
+interface LoadedConfig extends Omit<GlobalConfig, "workspaces" | "collections"> {
+    collections: Map<string, Collection>;
+    workspaces: Record<string, {
+        dir: string;
+        config: LoadedConfig;
+    }>;
+}
+
+interface GlobImportOptions {
+    base: string;
+    query?: Record<string, string | undefined>;
+    import?: string;
+    eager?: boolean;
+}
+interface CodeGeneratorOptions {
+    target: "default" | "vite";
+    outDir: string;
+    /**
+     * add .js extenstion to imports
+     */
+    jsExtension: boolean;
+    globCache: Map<string, Promise<string[]>>;
+}
+/**
+ * Code generator (one instance per file)
+ */
+declare class CodeGenerator {
+    private readonly lines;
+    private readonly globCache;
+    private readonly importInfos;
+    private eagerImportId;
+    readonly options: CodeGeneratorOptions;
+    constructor({ target, jsExtension, globCache, outDir, }: Partial<CodeGeneratorOptions>);
+    addNamespaceImport(namespace: string, specifier: string, types?: boolean): void;
+    addNamedImport(names: string[], specifier: string, types?: boolean): void;
+    push(...insert: string[]): void;
+    pushAsync(insert: Promise<string | undefined>[]): Promise<void>;
+    generateGlobImport(patterns: string | string[], options: GlobImportOptions): Promise<string>;
+    private generateViteGlobImport;
+    private generateNodeGlobImport;
+    formatImportPath(file: string): string;
+    toString(): string;
+}
+
+type Awaitable<T> = T | PromiseLike<T>;
+interface EmitEntry {
+    /**
+     * path relative to output directory
+     */
+    path: string;
+    content: string;
+}
+interface PluginContext {
+    core: Core;
+}
+interface EmitContext extends PluginContext {
+    createCodeGenerator: (path: string, content: (ctx: EmitCodeGeneratorContext) => Promise<void>) => Promise<EmitEntry>;
+}
+interface EmitCodeGeneratorContext {
+    core: Core;
+    workspace?: string;
+    codegen: CodeGenerator;
+}
+interface Plugin {
+    /**
+     * unique name for plugin
+     *
+     * @example `my-package:my-plugin`
+     */
+    name: string;
+    /**
+     * on config loaded/updated
+     */
+    config?: (this: PluginContext, config: LoadedConfig) => Awaitable<void | LoadedConfig>;
+    collection?: (this: PluginContext, collection: Collection) => Awaitable<void>;
+    /**
+     * Generate files (e.g. types, index file, or JSON schemas)
+     */
+    emit?: (this: EmitContext) => Awaitable<EmitEntry[]>;
+    /**
+     * Configure Fumadocs dev server
+     */
+    configureServer?: (this: PluginContext, server: ServerContext) => Awaitable<void>;
+    vite?: {
+        createPlugin?: (this: PluginContext) => Vite.PluginOption;
+    };
+    bun?: {
+        build?: (this: PluginContext, build: Bun.PluginBuilder) => Awaitable<void>;
+    };
+    next?: {
+        config?: (this: PluginContext, config: NextConfig) => NextConfig;
+    };
+    node?: {
+        createLoad?: (this: PluginContext) => Awaitable<LoadHook>;
+    };
+}
+type PluginOption = Awaitable<Plugin | PluginOption[] | false | undefined>;
+interface ServerContext {
+    /**
+     * the file watcher, by default all content files are watched, along with other files.
+     *
+     * make sure to filter when listening to events
+     */
+    watcher?: FSWatcher;
+}
+interface CoreOptions {
+    configPath: string;
+    outDir: string;
+    plugins?: PluginOption[];
+    emit?: {
+        target?: "default" | "vite";
+        /**
+         * add .js extenstion to imports
+         */
+        jsExtension?: boolean;
+    };
+    /**
+     * the workspace info if this instance is created as a workspace
+     */
+    workspace?: {
+        parent: Core;
+        name: string;
+        dir: string;
+    };
+}
+interface EmitOptions {
+    /**
+     * filter the plugins to run emit
+     */
+    filterPlugin?: (plugin: Plugin) => boolean;
+    /**
+     * filter the workspaces to run emit
+     */
+    filterWorkspace?: (workspace: string) => boolean;
+    /**
+     * write files
+     */
+    write?: boolean;
+}
+interface EmitOutput {
+    entries: EmitEntry[];
+    workspaces: Record<string, EmitEntry[]>;
+}
+declare class Core {
+    private readonly workspaces;
+    private readonly options;
+    private plugins;
+    private config;
+    static defaultOptions: {
+        configPath: string;
+        outDir: string;
+    };
+    /**
+     * Convenient cache store, reset when config changes.
+     *
+     * You can group namespaces in cache key with ":", like `my-plugin:data`
+     */
+    readonly cache: Map<string, unknown>;
+    constructor(options: CoreOptions);
+    init({ config: newConfig }: {
+        config: Awaitable<LoadedConfig>;
+    }): Promise<void>;
+    getWorkspaces(): Map<string, Core>;
+    getOptions(): CoreOptions;
+    getConfig(): LoadedConfig;
+    /**
+     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
+     */
+    getCompiledConfigPath(): string;
+    getPlugins(workspace?: boolean): Plugin[];
+    getCollections(workspace?: boolean): Collection[];
+    getCollection(name: string): Collection | undefined;
+    getPluginContext(): PluginContext;
+    initServer(server: ServerContext): Promise<void>;
+    emit(emitOptions?: EmitOptions): Promise<EmitOutput>;
+}
+
+export { type CollectionHandlers as A, createCollection as B, type CoreOptions as C, defineConfig as D, type ExtractedReference as E, type FileHandlerConfig as F, type GlobalConfig as G, type InitOptions as I, type JSONSchemaOptions as J, type MDXCollection as M, type PluginContext as P, type ServerContext as S, type VersionControlFileData as V, type WorkspaceConfig as W, Core as a, type MetaCollection as b, type Plugin as c, type Collection as d, type EmitEntry as e, type EmitContext as f, type EmitCodeGeneratorContext as g, type PluginOption as h, type EmitOptions as i, type EmitOutput as j, jsonSchema as k, type JSONSchemaHandler as l, type FIleCollectionHandler as m, buildFileHandler as n, type MDXCollectionHandler as o, type MDXCollectionConfig as p, defineMDX as q, type MetaContext as r, type MetaCollectionHandler as s, type MetaCollectionConfig as t, defineMeta as u, git as v, type VersionControlHandler as w, type GitPluginOptions as x, type VersionControlClient as y, type CollectionTypeInfo as z };

package/dist/index.d.ts

@@ -1,33 +1,17 @@
-import { AnyZodObject, z } from 'zod';
-import { MDXContent } from 'mdx/types';
+import { d as Collection, G as GlobalConfig } from './core-Bo8KaWQz.js';
+export { a as Core, C as CoreOptions, g as EmitCodeGeneratorContext, f as EmitContext, e as EmitEntry, i as EmitOptions, j as EmitOutput, c as Plugin, P as PluginContext, h as PluginOption, S as ServerContext } 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';
 
-interface CreateOptions {
-    schema?: AnyZodObject;
-    /**
-     * Filter file paths
-     */
-    include?: string | string[];
-}
-interface Document<Info = unknown> {
-    info: Info;
-    /**
-     * Render data, should be accepted by renderer
-     */
-    renderer: MDXContent;
-    /**
-     * File Path
-     */
-    file: string;
-}
-interface Json<Info = unknown> {
-    info: Info;
-    /**
-     * File Path
-     */
-    file: string;
-}
-type GetInfoType<T extends CreateOptions> = T["schema"] extends AnyZodObject ? z.infer<T["schema"]> : Record<string, unknown>;
-declare function document<T extends CreateOptions>(entryPoint: unknown, options?: T): Document<GetInfoType<T>>[];
-declare function json<T extends CreateOptions>(entryPoint: unknown, options?: T): Json<GetInfoType<T>>[];
+type GetCollectionConfig<Config, Name extends string> = Config extends Record<Name, Collection> ? Config[Name] : Config extends {
+    default: GlobalConfig<infer Collections>;
+} ? Collections[Name] : never;
 
-export { type CreateOptions, type Document, type Json, document, json };
+export type { GetCollectionConfig };

package/dist/index.js

@@ -1,51 +1,8 @@
-// src/source/index.ts
-import { z } from "zod";
-import micromatch from "micromatch";
-var defaultSchema = z.record(z.string(), z.unknown());
-function document(entryPoint, options) {
-  const { schema = defaultSchema, include } = options ?? {};
-  return read(entryPoint, ["md", "mdx"], include).map((item) => {
-    const {
-      default: render,
-      format: _format,
-      file,
-      frontmatter,
-      ...rest
-    } = item;
-    const result = schema.safeParse(frontmatter);
-    if (!result.success) throw createError(file, result.error);
-    return {
-      file,
-      info: result.data,
-      renderer: render,
-      ...rest
-    };
-  });
-}
-function json(entryPoint, options) {
-  const { schema = defaultSchema, include } = options ?? {};
-  return read(entryPoint, ["json"], include).map(
-    ({ file, default: data }) => {
-      const result = schema.safeParse(data);
-      if (!result.success) throw createError(file, result.error);
-      return {
-        file,
-        info: result.data
-      };
-    }
-  );
-}
-function createError(file, err) {
-  const message = `${file}:
-${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ") ?? ""}`).join("\n")}`;
-  return new Error(message);
-}
-function read(entryPoint, format, include) {
-  const cast = entryPoint;
-  const entries = format.flatMap((f) => cast[f] ?? []);
-  return entries.filter((e) => !include || micromatch.isMatch(e.file, include));
-}
+import {
+  Core
+} from "./chunk-NRZ4GE5O.js";
+import "./chunk-MT7RY65Y.js";
+import "./chunk-JBZTQ55D.js";
 export {
-  document,
-  json
+  Core
 };

package/dist/load-from-file-HL2VEY3M.js

@@ -0,0 +1,7 @@
+import {
+  loadConfig
+} from "./chunk-LUM7SIZN.js";
+import "./chunk-W6HENTK7.js";
+export {
+  loadConfig
+};

package/dist/loader-NFSL6P5I.js

@@ -0,0 +1,7 @@
+import {
+  createMdxLoader
+} from "./chunk-KH5GT2Y5.js";
+import "./chunk-VWJKRQZR.js";
+export {
+  createMdxLoader
+};

package/dist/loader-T756NSCS.js

@@ -0,0 +1,7 @@
+import {
+  createMetaLoader
+} from "./chunk-RMSV4HP6.js";
+import "./chunk-OUJENWQ4.js";
+export {
+  createMetaLoader
+};