fuma-content 0.0.1 → 1.0.0

package/dist/collections/mdx/runtime-dynamic.js

@@ -0,0 +1,94 @@
+import {
+  buildMDX
+} from "../../chunk-AMBGM4OK.js";
+import {
+  FileCollectionStore
+} from "../../chunk-RXR7OL76.js";
+import {
+  fumaMatter
+} from "../../chunk-VWJKRQZR.js";
+import "../../chunk-3VQS3KSP.js";
+import {
+  buildConfig
+} from "../../chunk-IGLM4N4P.js";
+import {
+  Core
+} from "../../chunk-Z7KHD7MS.js";
+import {
+  createCache
+} from "../../chunk-6XDQG2GV.js";
+
+// src/collections/mdx/runtime-dynamic.ts
+import { pathToFileURL } from "url";
+import fs from "fs/promises";
+import jsxRuntimeDefault from "react/jsx-runtime";
+import path from "path";
+var core;
+async function mdxStoreDynamic(config, coreOptions, name, base, _frontmatter) {
+  core ??= (async () => {
+    const core2 = new Core(coreOptions);
+    await core2.init({
+      config: buildConfig(config)
+    });
+    return core2;
+  })();
+  const frontmatter = _frontmatter;
+  const collection = (await core).getCollection(name);
+  if (!collection || !collection.handlers.mdx)
+    throw new Error("invalid collection name");
+  const merged = {};
+  const cache = createCache();
+  for (const [k, v] of Object.entries(frontmatter)) {
+    merged[k] = {
+      id: k,
+      frontmatter: v,
+      async compile() {
+        return cache.cached(k, async () => {
+          const filePath = path.join(base, k);
+          let content = (await fs.readFile(filePath)).toString();
+          content = fumaMatter(content).content;
+          const compiled = await buildMDX(await core, collection, {
+            filePath,
+            source: content,
+            frontmatter: v,
+            isDevelopment: false,
+            environment: "runtime"
+          });
+          return await executeMdx(String(compiled.value), {
+            baseUrl: pathToFileURL(filePath)
+          });
+        });
+      }
+    };
+  }
+  return new FileCollectionStore(base, merged);
+}
+var AsyncFunction = Object.getPrototypeOf(executeMdx).constructor;
+async function executeMdx(compiled, options = {}) {
+  const { opts: scopeOpts, ...scope } = options.scope ?? {};
+  const fullScope = {
+    opts: {
+      ...scopeOpts,
+      ...options.jsxRuntime ?? jsxRuntimeDefault,
+      baseUrl: options.baseUrl
+    },
+    ...scope
+  };
+  const hydrateFn = new AsyncFunction(...Object.keys(fullScope), compiled);
+  return await hydrateFn.apply(hydrateFn, Object.values(fullScope));
+}
+function $attachCompiled() {
+  return (data) => data;
+}
+function $extractedReferences() {
+  return $attachCompiled();
+}
+function $versionControl() {
+  return $attachCompiled();
+}
+export {
+  $attachCompiled,
+  $extractedReferences,
+  $versionControl,
+  mdxStoreDynamic
+};

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

@@ -0,0 +1,69 @@
+import { GetCollectionConfig } from '../../index.js';
+import { M as MDXCollection, E as ExtractedReference, V as VersionControlFileData } from '../../core-DxnSmTRe.js';
+import { FileCollectionStore } from '../runtime/file-store.js';
+import { FC } from 'react';
+import { MDXProps } from 'mdx/types';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+import '../runtime/store.js';
+
+type CompiledMDXProperties<Frontmatter = Record<string, unknown>> = {
+    frontmatter: Frontmatter;
+    default: FC<MDXProps>;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _markdown?: string;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _mdast?: string;
+} & Record<string, unknown>;
+interface MDXStoreData<Frontmatter> {
+    id: string;
+    compiled: CompiledMDXProperties<Frontmatter>;
+}
+declare function mdxStore<Config, Name extends string>(_name: Name, base: string, _input: Record<string, unknown>): FileCollectionStore<MDXStoreData<GetCollectionConfig<Config, Name> extends MDXCollection<infer Frontmatter> ? Frontmatter : never>>;
+interface MDXStoreLazyData<Frontmatter> {
+    id: string;
+    frontmatter: Frontmatter;
+    load: () => Promise<CompiledMDXProperties<Frontmatter>>;
+}
+declare function mdxStoreLazy<Config, Name extends string>(_name: Name, base: string, _input: {
+    head: Record<string, unknown>;
+    body: Record<string, () => Promise<unknown>>;
+}): FileCollectionStore<MDXStoreLazyData<GetCollectionConfig<Config, Name> extends MDXCollection<infer Frontmatter> ? Frontmatter : never>>;
+declare function $attachCompiled<Add>(): <T>(data: T) => T extends MDXStoreData<unknown> ? T & {
+    compiled: Add;
+} : T extends MDXStoreLazyData<unknown> ? T & {
+    load: () => Promise<Awaited<ReturnType<T["load"]>> & Add>;
+} : T;
+declare function $extractedReferences(): <T>(data: T) => T extends MDXStoreData<unknown> ? T & {
+    compiled: {
+        /**
+         * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+         */
+        extractedReferences: ExtractedReference[];
+    };
+} : T extends MDXStoreLazyData<unknown> ? T & {
+    load: () => Promise<Awaited<ReturnType<T["load"]>> & {
+        /**
+         * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+         */
+        extractedReferences: ExtractedReference[];
+    }>;
+} : T;
+declare function $versionControl(): <T>(data: T) => T extends MDXStoreData<unknown> ? T & {
+    compiled: VersionControlFileData;
+} : T extends MDXStoreLazyData<unknown> ? T & {
+    load: () => Promise<Awaited<ReturnType<T["load"]>> & VersionControlFileData>;
+} : T;
+
+export { $attachCompiled, $extractedReferences, $versionControl, type CompiledMDXProperties, type MDXStoreData, type MDXStoreLazyData, mdxStore, mdxStoreLazy };

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 { M as MDXCollection, b as MDXCollectionConfig, o as MDXCollectionHandler, p as defineMDX } from '../core-DxnSmTRe.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,287 @@
+import {
+  withLoader
+} from "../chunk-ERBMAQYP.js";
+import {
+  buildFileHandler
+} from "../chunk-E4HRKSP4.js";
+import {
+  createCollection
+} from "../chunk-BTRE6MOX.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 = path.relative(process.cwd(), fsHandler.dir);
+    let initializer;
+    codegen.addNamedImport(
+      ["default as 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.addNamedImport(
+      ["default as 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 = path.relative(process.cwd(), fsHandler.dir);
+    codegen.addNamedImport(
+      ["default as Config"],
+      codegen.formatImportPath(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-VGDLYG4T.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-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';
+
+declare function loader(this: LoaderContext<WebpackLoaderOptions>, source: string): Promise<void>;
+
+export { loader as default };

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

@@ -0,0 +1,41 @@
+import {
+  createMetaLoader
+} from "../../chunk-RMSV4HP6.js";
+import {
+  getCore,
+  toWebpack
+} from "../../chunk-4RMSJCK2.js";
+import "../../chunk-OUJENWQ4.js";
+import {
+  createDynamicCore
+} from "../../chunk-LDBQ66H3.js";
+import "../../chunk-Z7KHD7MS.js";
+import "../../chunk-6XDQG2GV.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 { c as MetaCollection } from '../../core-DxnSmTRe.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 { c as MetaCollection, s as MetaCollectionConfig, r as MetaCollectionHandler, q as MetaContext, t as defineMeta } from '../core-DxnSmTRe.js';
+import '@standard-schema/spec';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';