fuma-content 0.0.1 → 1.0.0

package/dist/chunk-Z7KHD7MS.js

@@ -0,0 +1,368 @@
+import {
+  createCache
+} from "./chunk-6XDQG2GV.js";
+
+// src/core.ts
+import path2 from "path";
+import fs from "fs/promises";
+
+// 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(path3) {
+  const isExtendedLengthPath = path3.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path3;
+  }
+  return path3.replaceAll("\\", "/");
+}
+
+// src/core.ts
+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: path2.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 path2.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 (path3, content) => {
+        const codegen = new CodeGenerator({
+          target,
+          outDir,
+          jsExtension,
+          globCache
+        });
+        await content({
+          core: this,
+          codegen,
+          workspace: workspace?.name
+        });
+        return {
+          path: path3,
+          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 = path2.join(outDir, entry.path);
+          await fs.mkdir(path2.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/collections/handlers/fs.d.ts

@@ -0,0 +1,10 @@
+export { m as FIleCollectionHandler, F as FileHandlerConfig, n as buildFileHandler } 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/collections/handlers/fs.js

@@ -0,0 +1,6 @@
+import {
+  buildFileHandler
+} from "../../chunk-E4HRKSP4.js";
+export {
+  buildFileHandler
+};

package/dist/collections/index.d.ts

@@ -0,0 +1,10 @@
+export { y as Collection, A as CollectionHandlers, z as CollectionTypeInfo, I as InitOptions, B as createCollection } 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/collections/index.js

@@ -0,0 +1,6 @@
+import {
+  createCollection
+} from "../chunk-BTRE6MOX.js";
+export {
+  createCollection
+};

package/dist/collections/mdx/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/mdx/loader-webpack.js

@@ -0,0 +1,38 @@
+import {
+  createMdxLoader
+} from "../../chunk-PNA5UGSL.js";
+import {
+  getCore,
+  toWebpack
+} from "../../chunk-4RMSJCK2.js";
+import "../../chunk-OUJENWQ4.js";
+import {
+  createDynamicCore
+} from "../../chunk-LDBQ66H3.js";
+import "../../chunk-VWJKRQZR.js";
+import "../../chunk-Z7KHD7MS.js";
+import "../../chunk-6XDQG2GV.js";
+
+// src/collections/mdx/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(
+      createMdxLoader(
+        createDynamicCore({
+          core: getCore(options),
+          buildConfig: false,
+          mode: options.isDev ? "dev" : "production"
+        })
+      )
+    );
+  }
+  await instance.call(this, source, callback);
+}
+export {
+  loader as default
+};

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

@@ -0,0 +1,44 @@
+import { FC, 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 { SimpleCollectionStore } from '../runtime/store.js';
+import '../runtime/file-store.js';
+import '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';
+
+interface MDXStoreBrowserData<Frontmatter, CustomData> {
+    preload: () => Promise<CompiledMDXProperties<Frontmatter> & CustomData>;
+    _renderer: {
+        id: string;
+        renderers?: Map<string, FC>;
+        getStoreData: () => StoreData;
+    };
+}
+interface StoreData {
+    preloaded: Map<string, Promise<CompiledMDXProperties>>;
+}
+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>>;
+/**
+ * Renders content with `React.lazy`.
+ */
+declare function useRenderer<Frontmatter, CustomData>(entry: MDXStoreBrowserData<Frontmatter, CustomData> | undefined, renderFn: (data: CompiledMDXProperties<Frontmatter> & CustomData) => ReactNode): ReactNode;
+declare function $attachCompiled<Add>(): <T>(data: T) => T extends MDXStoreBrowserData<infer Frontmatter, infer CustomData> ? MDXStoreBrowserData<Frontmatter, CustomData & Add> : T;
+declare function $extractedReferences(): <T>(data: T) => T extends MDXStoreBrowserData<infer Frontmatter, infer CustomData> ? MDXStoreBrowserData<Frontmatter, CustomData & {
+    /**
+     * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+     */
+    extractedReferences: ExtractedReference[];
+}> : T;
+declare function $versionControl(): <T>(data: T) => T extends MDXStoreBrowserData<infer Frontmatter, infer CustomData> ? MDXStoreBrowserData<Frontmatter, CustomData & VersionControlFileData> : T;
+
+export { $attachCompiled, $extractedReferences, $versionControl, type MDXStoreBrowserData, _internal_data, mdxStoreBrowser, useRenderer };

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

@@ -0,0 +1,74 @@
+"use client";
+import {
+  SimpleCollectionStore
+} from "../../chunk-3VQS3KSP.js";
+
+// src/collections/mdx/runtime-browser.ts
+import { lazy, createElement } from "react";
+var _internal_data = /* @__PURE__ */ new Map();
+function mdxStoreBrowser(name, _input) {
+  const input = _input;
+  const merged = /* @__PURE__ */ new Map();
+  function getStoreData() {
+    const store = _internal_data.get(name) ?? {
+      preloaded: /* @__PURE__ */ new Map()
+    };
+    _internal_data.set(name, store);
+    return store;
+  }
+  for (const [key, value] of Object.entries(input)) {
+    merged.set(key, {
+      preload() {
+        const data = getStoreData();
+        const loaded = value();
+        data.preloaded.set(key, loaded);
+        return loaded;
+      },
+      _renderer: {
+        id: key,
+        getStoreData
+      }
+    });
+  }
+  return new SimpleCollectionStore(merged);
+}
+function useRenderer(entry, renderFn) {
+  if (!entry) return null;
+  entry._renderer.renderers ??= /* @__PURE__ */ new Map();
+  const { id, renderers, getStoreData } = entry._renderer;
+  let renderer = renderers.get(id);
+  if (!renderer) {
+    const OnDemand = lazy(async () => {
+      const loaded = await entry.preload();
+      return { default: () => renderFn(loaded) };
+    });
+    renderer = () => {
+      const data = getStoreData();
+      let cached;
+      data.preloaded.get(id)?.then((v) => {
+        cached = v;
+      });
+      if (!cached) return createElement(OnDemand);
+      return renderFn(cached);
+    };
+    renderers.set(id, renderer);
+  }
+  return createElement(renderer);
+}
+function $attachCompiled() {
+  return (data) => data;
+}
+function $extractedReferences() {
+  return $attachCompiled();
+}
+function $versionControl() {
+  return $attachCompiled();
+}
+export {
+  $attachCompiled,
+  $extractedReferences,
+  $versionControl,
+  _internal_data,
+  mdxStoreBrowser,
+  useRenderer
+};

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

@@ -0,0 +1,42 @@
+import { C as CoreOptions, b as MDXCollectionConfig, E as ExtractedReference, V as VersionControlFileData } from '../../core-DxnSmTRe.js';
+import { MDXComponents } from 'mdx/types';
+import { FC } from 'react';
+import { FileCollectionStore } from '../runtime/file-store.js';
+import { CompiledMDXProperties } from './runtime.js';
+import { GetCollectionConfig } from '../../index.js';
+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';
+
+interface MDXStoreDynamicData<Frontmatter> {
+    id: string;
+    frontmatter: Frontmatter;
+    compile: () => Promise<CompiledMDXProperties<Frontmatter>>;
+}
+declare function mdxStoreDynamic<Config, Name extends string>(config: Config, coreOptions: CoreOptions, name: Name, base: string, _frontmatter: Record<string, unknown>): Promise<FileCollectionStore<MDXStoreDynamicData<GetCollectionConfig<Config, Name> extends MDXCollectionConfig<infer Frontmatter> ? Frontmatter : never>>>;
+type MdxContent = FC<{
+    components?: MDXComponents;
+}>;
+declare function $attachCompiled<Add>(): <T>(data: T) => T extends MDXStoreDynamicData<unknown> ? T & {
+    compile: () => Promise<Awaited<ReturnType<T["compile"]>> & Add>;
+} : T;
+declare function $extractedReferences(): <T>(data: T) => T extends MDXStoreDynamicData<unknown> ? T & {
+    compile: () => Promise<Awaited<ReturnType<T["compile"]>> & {
+        /**
+         * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+         */
+        extractedReferences: ExtractedReference[];
+    }>;
+} : T;
+declare function $versionControl(): <T>(data: T) => T extends MDXStoreDynamicData<unknown> ? T & {
+    compile: () => Promise<Awaited<ReturnType<T["compile"]>> & VersionControlFileData>;
+} : T;
+
+export { $attachCompiled, $extractedReferences, $versionControl, type MDXStoreDynamicData, type MdxContent, mdxStoreDynamic };