fuma-content 0.0.2 → 1.0.1

package/dist/collections/mdx/runtime.js

@@ -0,0 +1,45 @@
+import {
+  FileCollectionStore
+} from "../../chunk-RXR7OL76.js";
+import "../../chunk-3VQS3KSP.js";
+
+// src/collections/mdx/runtime.ts
+function mdxStore(_name, base, _input) {
+  const input = _input;
+  const merged = input;
+  for (const [key, value] of Object.entries(input)) {
+    merged[key] = {
+      id: key,
+      compiled: value
+    };
+  }
+  return new FileCollectionStore(base, merged);
+}
+function mdxStoreLazy(_name, base, _input) {
+  const input = _input;
+  const merged = {};
+  for (const [key, value] of Object.entries(input.head)) {
+    merged[key] = {
+      id: key,
+      frontmatter: value,
+      load: input.body[key]
+    };
+  }
+  return new FileCollectionStore(base, merged);
+}
+function $attachCompiled() {
+  return (data) => data;
+}
+function $extractedReferences() {
+  return $attachCompiled();
+}
+function $versionControl() {
+  return $attachCompiled();
+}
+export {
+  $attachCompiled,
+  $extractedReferences,
+  $versionControl,
+  mdxStore,
+  mdxStoreLazy
+};

package/dist/collections/mdx.d.ts

@@ -0,0 +1,10 @@
+export { E as ExtractedReference, M as MDXCollection, p as MDXCollectionConfig, o as MDXCollectionHandler, q as defineMDX } from '../core-Bo8KaWQz.js';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'chokidar';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';

package/dist/collections/mdx.js

@@ -0,0 +1,291 @@
+import {
+  withLoader
+} from "../chunk-ERBMAQYP.js";
+import {
+  buildFileHandler
+} from "../chunk-E4HRKSP4.js";
+import {
+  createCollection
+} from "../chunk-BTRE6MOX.js";
+import {
+  slash
+} from "../chunk-MT7RY65Y.js";
+import "../chunk-JBZTQ55D.js";
+
+// src/collections/mdx.ts
+import path from "path";
+var mdxTypeInfo = {
+  id: "mdx",
+  plugins: [plugin()]
+};
+var RuntimePaths = {
+  browser: "fuma-content/collections/mdx/runtime-browser",
+  dynamic: "fuma-content/collections/mdx/runtime-dynamic",
+  server: "fuma-content/collections/mdx/runtime"
+};
+function defineMDX(config) {
+  const { lazy = false, dynamic = false } = config;
+  return createCollection(mdxTypeInfo, (collection, options) => {
+    collection.handlers.fs = buildFileHandler(options, config, ["mdx", "md"]);
+    collection.handlers.mdx = {
+      cwd: options.workspace ? path.resolve(options.workspace.dir) : process.cwd(),
+      postprocess: config.postprocess,
+      getMDXOptions: config.options,
+      dynamic,
+      lazy,
+      onGenerateStore(initializer) {
+        const mdxHandler = collection.handlers.mdx;
+        if (mdxHandler?.postprocess?.extractLinkReferences) {
+          this.codegen.addNamedImport(
+            ["$extractedReferences"],
+            RuntimePaths[this.environment]
+          );
+          initializer += ".$data($extractedReferences())";
+        }
+        return initializer;
+      }
+    };
+    collection.handlers["version-control"] = {
+      client({ client }) {
+        const mdxHandler = collection.handlers.mdx;
+        if (!mdxHandler) return;
+        const { onGenerateStore, vfile } = mdxHandler;
+        mdxHandler.onGenerateStore = function(initializer) {
+          this.codegen.addNamedImport(
+            ["$versionControl"],
+            RuntimePaths[this.environment]
+          );
+          initializer += ".$data($versionControl())";
+          return onGenerateStore?.call(this, initializer) ?? initializer;
+        };
+        mdxHandler.vfile = async function(file) {
+          const vcData = await client.getFileData({ filePath: file.path });
+          file.data["mdx-export"] ??= [];
+          file.data["mdx-export"].push(
+            {
+              name: "lastModified",
+              value: vcData.lastModified
+            },
+            {
+              name: "creationDate",
+              value: vcData.creationDate
+            }
+          );
+          if (vfile) return vfile?.call(this, file);
+          return file;
+        };
+      }
+    };
+  });
+}
+function plugin() {
+  const mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+  function generateDocCollectionFrontmatterGlob(context, collection, eager = false) {
+    const handler = collection.handlers.fs;
+    if (!handler) return "";
+    return context.codegen.generateGlobImport(handler.patterns, {
+      query: {
+        collection: collection.name,
+        only: "frontmatter",
+        workspace: context.workspace
+      },
+      import: "frontmatter",
+      base: handler.dir,
+      eager
+    });
+  }
+  function generateDocCollectionGlob(context, collection, eager = false) {
+    const handler = collection.handlers.fs;
+    if (!handler) return "";
+    return context.codegen.generateGlobImport(handler.patterns, {
+      query: {
+        collection: collection.name,
+        workspace: context.workspace
+      },
+      base: handler.dir,
+      eager
+    });
+  }
+  async function generateCollectionStoreServer(context, collection) {
+    const mdxHandler = collection.handlers.mdx;
+    const fsHandler = collection.handlers.fs;
+    if (!fsHandler || !mdxHandler) return;
+    const { core, codegen } = context;
+    const runtimePath = RuntimePaths.server;
+    const base2 = slash(path.relative(process.cwd(), fsHandler.dir));
+    let initializer;
+    codegen.addNamespaceImport(
+      "Config",
+      codegen.formatImportPath(core.getOptions().configPath),
+      true
+    );
+    if (mdxHandler.lazy) {
+      codegen.addNamedImport(["mdxStoreLazy"], runtimePath);
+      const [headGlob, bodyGlob] = await Promise.all([
+        generateDocCollectionFrontmatterGlob(context, collection, true),
+        generateDocCollectionGlob(context, collection)
+      ]);
+      initializer = `mdxStoreLazy<typeof Config, "${collection.name}">("${collection.name}", "${base2}", { head: ${headGlob}, body: ${bodyGlob} })`;
+    } else {
+      codegen.addNamedImport(["mdxStore"], runtimePath);
+      initializer = `mdxStore<typeof Config, "${collection.name}">("${collection.name}", "${base2}", ${await generateDocCollectionGlob(context, collection, true)})`;
+    }
+    initializer = mdxHandler.onGenerateStore?.call(
+      { ...context, environment: "server" },
+      initializer
+    ) ?? initializer;
+    codegen.push(`export const ${collection.name} = ${initializer};`);
+  }
+  async function generateCollectionStoreBrowser(context, collection) {
+    const mdxHandler = collection.handlers.mdx;
+    const fsHandler = collection.handlers.fs;
+    if (!fsHandler || !mdxHandler) return;
+    const { core, codegen } = context;
+    const runtimePath = RuntimePaths.browser;
+    codegen.addNamedImport(["mdxStoreBrowser"], runtimePath);
+    codegen.addNamespaceImport(
+      "Config",
+      codegen.formatImportPath(core.getOptions().configPath),
+      true
+    );
+    let initializer = `mdxStoreBrowser<typeof Config, "${collection.name}">("${collection.name}", ${await generateDocCollectionGlob(context, collection)})`;
+    initializer = mdxHandler.onGenerateStore?.call(
+      { ...context, environment: "browser" },
+      initializer
+    ) ?? initializer;
+    codegen.push(`export const ${collection.name} = ${initializer};`);
+  }
+  async function generateCollectionStoreDynamic(context, collection) {
+    const mdxHandler = collection.handlers.mdx;
+    const fsHandler = collection.handlers.fs;
+    if (!fsHandler || !mdxHandler || !mdxHandler.dynamic) return;
+    const { core, codegen } = context;
+    const { configPath, workspace, outDir } = core.getOptions();
+    const runtimePath = RuntimePaths.dynamic;
+    const base2 = slash(path.relative(process.cwd(), fsHandler.dir));
+    codegen.addNamespaceImport(
+      "Config",
+      codegen.formatImportPath(core.getOptions().configPath)
+    );
+    codegen.addNamedImport(["mdxStoreDynamic"], runtimePath);
+    const coreOptions = {
+      configPath,
+      workspace,
+      outDir
+    };
+    let initializer = `mdxStoreDynamic<typeof Config, "${collection.name}">(Config, ${JSON.stringify(
+      coreOptions
+    )}, "${collection.name}", "${base2}", ${await generateDocCollectionFrontmatterGlob(context, collection, true)})`;
+    initializer = mdxHandler.onGenerateStore?.call(
+      { ...context, environment: "dynamic" },
+      initializer
+    ) ?? initializer;
+    codegen.push(`export const ${collection.name} = ${initializer};`);
+  }
+  const base = {
+    name: "mdx",
+    configureServer(server) {
+      if (!server.watcher) return;
+      server.watcher.on("all", async (event, file) => {
+        const updatedCollection = this.core.getCollections().find((collection) => {
+          const handlers = collection.handlers;
+          if (!handlers.mdx || !handlers.fs) return false;
+          if (event === "change" && !handlers.mdx.dynamic) return false;
+          return handlers.fs.hasFile(file);
+        });
+        if (!updatedCollection) return;
+        await this.core.emit({
+          filterPlugin: (plugin2) => plugin2.name === base.name,
+          filterWorkspace: () => false,
+          write: true
+        });
+      });
+    },
+    emit() {
+      return Promise.all([
+        this.createCodeGenerator("mdx.ts", async (ctx) => {
+          for (const collection of this.core.getCollections()) {
+            await generateCollectionStoreServer(ctx, collection);
+          }
+        }),
+        this.createCodeGenerator("mdx-browser.ts", async (ctx) => {
+          for (const collection of this.core.getCollections()) {
+            await generateCollectionStoreBrowser(ctx, collection);
+          }
+          ctx.codegen.push(
+            `export { useRenderer } from "${RuntimePaths.browser}";`
+          );
+        }),
+        this.createCodeGenerator("mdx-dynamic.ts", async (ctx) => {
+          for (const collection of this.core.getCollections()) {
+            await generateCollectionStoreDynamic(ctx, collection);
+          }
+        })
+      ]);
+    },
+    next: {
+      config(nextConfig) {
+        const { configPath, outDir } = this.core.getOptions();
+        const loaderPath = "fuma-content/collections/mdx/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,
+              "*.{md,mdx}": {
+                loaders: [
+                  {
+                    loader: loaderPath,
+                    options: loaderOptions
+                  }
+                ],
+                as: "*.js"
+              }
+            }
+          },
+          pageExtensions: [
+            ...nextConfig.pageExtensions ?? ["js", "jsx", "tsx", "ts"],
+            "mdx",
+            "md"
+          ],
+          webpack(config, options) {
+            config.module ||= {};
+            config.module.rules ||= [];
+            config.module.rules.push({
+              test: mdxLoaderGlob,
+              use: [
+                options.defaultLoaders.babel,
+                {
+                  loader: loaderPath,
+                  options: loaderOptions
+                }
+              ]
+            });
+            return nextConfig.webpack?.(config, options) ?? config;
+          }
+        };
+      }
+    }
+  };
+  return withLoader(base, {
+    test: mdxLoaderGlob,
+    async createLoader() {
+      const { createMdxLoader } = await import("../loader-NFSL6P5I.js");
+      return createMdxLoader({
+        getCore: () => this.core
+      });
+    }
+  });
+}
+export {
+  defineMDX
+};

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

@@ -0,0 +1,17 @@
+import { LoaderContext } from 'webpack';
+import { WebpackLoaderOptions } from '../../plugins/with-loader/webpack.js';
+import '../../plugins/with-loader/index.js';
+import '../../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';
+
+declare function loader(this: LoaderContext<WebpackLoaderOptions>, source: string): Promise<void>;
+
+export { loader as default };

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

@@ -0,0 +1,42 @@
+import {
+  createMetaLoader
+} from "../../chunk-RMSV4HP6.js";
+import {
+  getCore,
+  toWebpack
+} from "../../chunk-XR5N6ZXJ.js";
+import "../../chunk-OUJENWQ4.js";
+import {
+  createDynamicCore
+} from "../../chunk-GGL4EF6H.js";
+import "../../chunk-NRZ4GE5O.js";
+import "../../chunk-MT7RY65Y.js";
+import "../../chunk-JBZTQ55D.js";
+
+// src/collections/meta/loader-webpack.ts
+var instance;
+async function loader(source) {
+  const callback = this.async();
+  const options = this.getOptions();
+  this.cacheable(true);
+  this.addDependency(options.absoluteCompiledConfigPath);
+  if (!instance) {
+    instance = toWebpack(
+      createMetaLoader(
+        createDynamicCore({
+          core: getCore(options),
+          buildConfig: false,
+          mode: options.isDev ? "dev" : "production"
+        }),
+        {
+          json: "json",
+          yaml: "js"
+        }
+      )
+    );
+  }
+  await instance.call(this, source, callback);
+}
+export {
+  loader as default
+};

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

@@ -0,0 +1,19 @@
+import { GetCollectionConfig } from '../../index.js';
+import { FileCollectionStore } from '../runtime/file-store.js';
+import { b as MetaCollection } from '../../core-Bo8KaWQz.js';
+import '../runtime/store.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+
+declare function metaStore<Config, Name extends string>(_name: Name, base: string, input: Record<string, unknown>): FileCollectionStore<{
+    data: GetCollectionConfig<Config, Name> extends MetaCollection<infer Data> ? Data : never;
+}>;
+
+export { metaStore };

package/dist/collections/meta/runtime.js

@@ -0,0 +1,18 @@
+import {
+  FileCollectionStore
+} from "../../chunk-RXR7OL76.js";
+import "../../chunk-3VQS3KSP.js";
+
+// src/collections/meta/runtime.ts
+function metaStore(_name, base, input) {
+  const merged = input;
+  for (const [key, value] of Object.entries(input)) {
+    merged[key] = {
+      data: value
+    };
+  }
+  return new FileCollectionStore(base, merged);
+}
+export {
+  metaStore
+};

package/dist/collections/meta.d.ts

@@ -0,0 +1,10 @@
+export { b as MetaCollection, t as MetaCollectionConfig, s as MetaCollectionHandler, r as MetaContext, u as defineMeta } from '../core-Bo8KaWQz.js';
+import '@standard-schema/spec';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';

package/dist/collections/meta.js

@@ -0,0 +1,170 @@
+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"
+          });
+        else
+          return config.schema["~standard"]?.jsonSchema.input({
+            target: "draft-2020-12"
+          });
+      }
+    };
+  });
+}
+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.addNamespaceImport(
+      "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
+};