fuma-content 0.0.1 → 1.0.0

package/dist/collections/meta.js

@@ -0,0 +1,166 @@
+import {
+  withLoader
+} from "../chunk-ERBMAQYP.js";
+import {
+  buildFileHandler
+} from "../chunk-E4HRKSP4.js";
+import {
+  createCollection
+} from "../chunk-BTRE6MOX.js";
+
+// src/collections/meta.ts
+import path from "path";
+var metaTypeInfo = {
+  id: "meta",
+  plugins: [plugin()]
+};
+function defineMeta(config) {
+  return createCollection(metaTypeInfo, (collection, options) => {
+    const handlers = collection.handlers;
+    handlers.fs = buildFileHandler(options, config, ["json", "yaml"]);
+    handlers.meta = {
+      schema: config.schema
+    };
+    handlers["json-schema"] = {
+      async create() {
+        const { z, ZodType } = await import("zod");
+        if (config.schema instanceof ZodType)
+          return z.toJSONSchema(config.schema, {
+            io: "input",
+            unrepresentable: "any"
+          });
+      }
+    };
+  });
+}
+function plugin() {
+  const metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+  async function generateCollectionStore(context, collection) {
+    const fsHandler = collection.handlers.fs;
+    if (!fsHandler) return;
+    const { codegen, core } = context;
+    codegen.addNamedImport(
+      ["metaStore"],
+      "fuma-content/collections/meta/runtime"
+    );
+    codegen.addNamedImport(
+      ["default as Config"],
+      codegen.formatImportPath(core.getOptions().configPath),
+      true
+    );
+    const base2 = path.relative(process.cwd(), fsHandler.dir);
+    const glob = await codegen.generateGlobImport(fsHandler.patterns, {
+      query: {
+        collection: collection.name,
+        workspace: context.workspace
+      },
+      import: "default",
+      base: fsHandler.dir,
+      eager: true
+    });
+    const initializer = `metaStore<typeof Config, "${collection.name}">("${collection.name}", "${base2}", ${glob})`;
+    codegen.push(`export const ${collection.name} = ${initializer};`);
+  }
+  const base = {
+    name: "meta",
+    configureServer(server) {
+      if (!server.watcher) return;
+      server.watcher.on("all", async (event, file) => {
+        if (event === "change") return;
+        const updatedCollection = this.core.getCollections().find((collection) => {
+          const handlers = collection.handlers;
+          if (!handlers.meta || !handlers.fs) return false;
+          return handlers.fs.hasFile(file);
+        });
+        if (!updatedCollection) return;
+        await this.core.emit({
+          filterPlugin: (plugin2) => plugin2.name === "meta",
+          filterWorkspace: () => false,
+          write: true
+        });
+      });
+    },
+    emit() {
+      return Promise.all([
+        this.createCodeGenerator("meta.ts", async (ctx) => {
+          for (const collection of this.core.getCollections()) {
+            await generateCollectionStore(ctx, collection);
+          }
+        })
+      ]);
+    },
+    next: {
+      config(nextConfig) {
+        const { configPath, outDir } = this.core.getOptions();
+        const loaderPath = "fuma-content/collections/meta/loader-webpack";
+        const loaderOptions = {
+          configPath,
+          outDir,
+          absoluteCompiledConfigPath: path.resolve(
+            this.core.getCompiledConfigPath()
+          ),
+          isDev: process.env.NODE_ENV === "development"
+        };
+        return {
+          ...nextConfig,
+          turbopack: {
+            ...nextConfig.turbopack,
+            rules: {
+              ...nextConfig.turbopack?.rules,
+              "*.json": {
+                loaders: [
+                  {
+                    loader: loaderPath,
+                    options: loaderOptions
+                  }
+                ],
+                as: "*.json"
+              },
+              "*.yaml": {
+                loaders: [
+                  {
+                    loader: loaderPath,
+                    options: loaderOptions
+                  }
+                ],
+                as: "*.js"
+              }
+            }
+          },
+          webpack(config, options) {
+            config.module ||= {};
+            config.module.rules ||= [];
+            config.module.rules.push({
+              test: metaLoaderGlob,
+              enforce: "pre",
+              use: [
+                {
+                  loader: loaderPath,
+                  options: loaderOptions
+                }
+              ]
+            });
+            return nextConfig.webpack?.(config, options) ?? config;
+          }
+        };
+      }
+    }
+  };
+  return withLoader(base, {
+    test: metaLoaderGlob,
+    async createLoader(environment) {
+      const { createMetaLoader } = await import("../loader-T756NSCS.js");
+      return createMetaLoader(
+        {
+          getCore: () => this.core
+        },
+        {
+          json: environment === "vite" ? "json" : "js"
+        }
+      );
+    }
+  });
+}
+export {
+  defineMeta
+};

package/dist/collections/runtime/file-store.d.ts

@@ -0,0 +1,19 @@
+import { SimpleCollectionStore } from './store.js';
+
+interface FileInfo {
+    /**
+     * path relative to content directory
+     */
+    path: string;
+    /**
+     * the full file path in file system
+     */
+    fullPath: string;
+}
+declare class FileCollectionStore<V> extends SimpleCollectionStore<FileInfo & V> {
+    constructor(base: string, glob: Record<string, V>);
+    transform<T>(fn: (input: FileInfo & V) => FileInfo & T): FileCollectionStore<T>;
+    $data<T>(_cast: (input: FileInfo & V) => FileInfo & T): FileCollectionStore<T>;
+}
+
+export { FileCollectionStore, type FileInfo };

package/dist/collections/runtime/file-store.js

@@ -0,0 +1,7 @@
+import {
+  FileCollectionStore
+} from "../../chunk-RXR7OL76.js";
+import "../../chunk-3VQS3KSP.js";
+export {
+  FileCollectionStore
+};

package/dist/collections/runtime/store.d.ts

@@ -0,0 +1,28 @@
+type Awaitable<T> = T | PromiseLike<T>;
+interface CollectionStore<Id, Data> {
+    /**
+     * type-only operation to change data type, doesn't do any runtime transformation.
+     */
+    $data: <T>(_cast: (input: Data) => T) => CollectionStore<Id, T>;
+    get: (id: Id) => Awaitable<Data | undefined>;
+    list: () => Awaitable<Data[]>;
+    /**
+     * For typescript to infer data types, can be anything
+     */
+    $inferData: Data;
+}
+declare class SimpleCollectionStore<Data> implements CollectionStore<string, Data> {
+    private readonly dataMap;
+    private readonly dataList;
+    constructor(input: Map<string, Data>);
+    get(id: string): Data | undefined;
+    list(): Data[];
+    $data<T>(_cast: (input: Data) => T): SimpleCollectionStore<T>;
+    /**
+     * in-place transformation on all data
+     */
+    transform<T>(fn: (input: Data) => T): SimpleCollectionStore<T>;
+    get $inferData(): Data;
+}
+
+export { type CollectionStore, SimpleCollectionStore };

package/dist/collections/runtime/store.js

@@ -0,0 +1,6 @@
+import {
+  SimpleCollectionStore
+} from "../../chunk-3VQS3KSP.js";
+export {
+  SimpleCollectionStore
+};

package/dist/config/index.d.ts

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

package/dist/config/index.js

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

package/dist/core-DxnSmTRe.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 | ((context: MetaContext) => StandardSchemaV1);
+}
+interface MetaCollectionConfig<Schema extends StandardSchemaV1> extends FileHandlerConfig {
+    schema?: Schema | ((context: MetaContext) => 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 MDXCollectionConfig as b, type MetaCollection as c, type Plugin 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, defineMDX as p, type MetaContext as q, type MetaCollectionHandler as r, type MetaCollectionConfig as s, defineMeta as t, git as u, type VersionControlHandler as v, type GitPluginOptions as w, type VersionControlClient as x, type Collection as y, type CollectionTypeInfo as z };