fuma-content 0.0.1 → 1.0.0

package/package.json

@@ -1,64 +1,131 @@
 {
   "name": "fuma-content",
-  "version": "0.0.1",
-  "description": "Write content for web apps",
+  "version": "1.0.0",
+  "description": "The content processing layer for your app.",
   "keywords": [
-    "Content",
-    "Docs"
+    "Docs",
+    "Contentlayer"
   ],
   "repository": "github:fuma-nama/fuma-content",
   "license": "MIT",
-  "type": "module",
   "author": "Fuma Nama",
-  "files": [
-    "dist/*"
-  ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "homepage": "https://fuma-content.vercel.app",
+  "type": "module",
   "exports": {
+    "./config": {
+      "import": "./dist/config/index.js",
+      "types": "./dist/config/index.d.ts"
+    },
+    "./next": {
+      "import": "./dist/next/index.js",
+      "types": "./dist/next/index.d.ts",
+      "require": "./dist/next/index.cjs"
+    },
+    "./vite": {
+      "import": "./dist/vite/index.js",
+      "types": "./dist/vite/index.d.ts"
+    },
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./internal": {
-      "import": "./dist/internal.js",
-      "types": "./dist/internal.d.ts"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "internal": [
-        "./dist/internal.d.ts"
-      ]
+    "./collections": {
+      "import": "./dist/collections/index.js",
+      "types": "./dist/collections/index.d.ts"
+    },
+    "./collections/*": {
+      "import": "./dist/collections/*.js",
+      "types": "./dist/collections/*.d.ts",
+      "default": "./dist/collections/*.js"
+    },
+    "./node/loader": {
+      "import": "./dist/node/loader.js",
+      "types": "./dist/node/loader.d.ts"
+    },
+    "./bun": {
+      "import": "./dist/bun/index.js",
+      "types": "./dist/bun/index.d.ts"
+    },
+    "./plugins/with-loader": {
+      "import": "./dist/plugins/with-loader/index.js",
+      "types": "./dist/plugins/with-loader/index.d.ts"
+    },
+    "./plugins/*": {
+      "import": "./dist/plugins/*.js",
+      "types": "./dist/plugins/*.d.ts"
     }
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "./dist/bin.js",
+  "files": [
+    "dist/*",
+    "loader-mdx.cjs",
+    "loader-meta.cjs"
+  ],
   "dependencies": {
-    "@mdx-js/mdx": "^3.0.0",
-    "chokidar": "^3.5.3",
-    "cross-spawn": "^7.0.3",
-    "estree-util-value-to-estree": "^3.0.1",
-    "fast-glob": "^3.3.2",
-    "gray-matter": "^4.0.3",
-    "micromatch": "^4.0.5",
+    "@mdx-js/mdx": "^3.1.1",
+    "@standard-schema/spec": "^1.0.0",
+    "chokidar": "^5.0.0",
+    "esbuild": "^0.27.1",
+    "estree-util-value-to-estree": "^3.5.0",
+    "js-yaml": "^4.1.1",
+    "mdast-util-to-markdown": "^2.1.2",
+    "picocolors": "^1.1.1",
+    "picomatch": "^4.0.3",
+    "remark-mdx": "^3.1.1",
+    "tinyexec": "^1.0.2",
+    "tinyglobby": "^0.2.15",
+    "unified": "^11.0.5",
+    "unist-util-remove-position": "^5.0.0",
     "unist-util-visit": "^5.0.0",
-    "zod": "^3.22.4"
+    "vfile": "^6.0.3",
+    "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@types/cross-spawn": "^6.0.6",
-    "@types/mdast": "^4.0.3",
-    "@types/mdx": "^2.0.11",
-    "@types/micromatch": "^4.0.6",
-    "typescript": "^5.3.3",
-    "unified": "^11.0.4",
-    "eslint-config": "0.0.0",
+    "@types/bun": "^1.3.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mdast": "^4.0.4",
+    "@types/mdx": "^2.0.13",
+    "@types/node": "^24.10.2",
+    "@types/picomatch": "^4.0.2",
+    "@types/react": "^19.2.7",
+    "fumadocs-core": "^16.2.5",
+    "mdast-util-directive": "^3.1.0",
+    "mdast-util-mdx-jsx": "^3.2.0",
+    "next": "16.0.10",
+    "react": "^19.2.3",
+    "remark": "^15.0.1",
+    "remark-directive": "^4.0.0",
+    "remark-stringify": "^11.0.0",
+    "rollup": "^4.53.3",
+    "vite": "^7.2.7",
+    "webpack": "^5.103.0",
     "typescript-config": "0.0.0"
   },
+  "peerDependencies": {
+    "next": "^15.3.0 || ^16.0.0",
+    "react": "*",
+    "vite": "6.x.x || 7.x.x"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "tsup",
+    "clean": "rimraf dist",
     "dev": "tsup --watch",
-    "lint": "eslint ."
+    "types:check": "tsc --noEmit"
   }
 }

package/dist/internal.d.ts

@@ -1,108 +0,0 @@
-import { Options as Options$1 } from 'fast-glob';
-import { ProcessorOptions } from '@mdx-js/mdx';
-import { VFile } from '@mdx-js/mdx/internal-create-format-aware-processors';
-import { FSWatcher } from 'chokidar';
-
-interface Output {
-    content: string;
-    _entryPoint?: unknown;
-    _mdx?: {
-        vfile: VFile;
-    };
-}
-type Transformer = (this: Compiler, file: string, source: string) => Output | Promise<Output>;
-
-interface Options extends ProcessorOptions {
-    /**
-     * Fetch last modified time with specified version control
-     * @defaultValue 'none'
-     */
-    lastModifiedTime?: "git" | "none";
-    /**
-     * @defaultValue `['frontmatter', 'lastModified']`
-     */
-    remarkExports?: string[];
-    /**
-     * Convert relative imports into absolute imports
-     *
-     * @defaultValue true
-     */
-    enableAbsoluteImport?: boolean;
-}
-/**
- * Load MDX/markdown files
- */
-declare const loadMDX: ({ lastModifiedTime, format: forceFormat, remarkExports, enableAbsoluteImport, ...rest }?: Options) => Transformer;
-
-interface OutputEntry extends Output {
-    /**
-     * extension of file, like: `md`
-     */
-    format: string;
-    file: string;
-}
-declare function compile(this: Compiler): Promise<OutputEntry[]>;
-declare function compileFile(this: Compiler, file: string): Promise<OutputEntry>;
-
-interface EntryPointOptions {
-    /**
-     * Notice that `lazy` mode is not supported by `source` function
-     *
-     * @defaultValue 'import'
-     */
-    mode?: "lazy" | "import";
-    /**
-     * Use full-path for `file` property
-     *
-     * @defaultValue false
-     */
-    fullPath?: string;
-}
-declare function loadEntryPoint(this: Compiler, entries: OutputEntry[]): OutputEntry;
-
-interface EmitEntry extends OutputEntry {
-    outputPath: string;
-}
-declare function emit(this: Compiler): Promise<void>;
-declare function emitEntry(this: Compiler, entry: OutputEntry): Promise<EmitEntry>;
-
-declare function watch(this: Compiler): FSWatcher;
-
-interface CompilerOptions {
-    files: string[];
-    cwd: string;
-    outputDir: string;
-    outputExt: string;
-    loaders?: Record<string, Transformer>;
-    entryPoint?: EntryPointOptions;
-    mdxOptions?: Options;
-    globOptions?: Options$1;
-}
-interface Compiler {
-    options: CompilerOptions;
-    /**
-     * Files to compile
-     */
-    files: string[];
-    compile: typeof compile;
-    compileFile: typeof compileFile;
-    emit: typeof emit;
-    emitEntry: typeof emitEntry;
-    watch: typeof watch;
-    loaders: Record<string, Transformer>;
-    _output?: OutputEntry[];
-    _emit?: EmitEntry[];
-    _cache: Map<string, OutputEntry>;
-}
-
-declare const defaultOptions: {
-    cwd: string;
-    outputDir: string;
-    outputExt: string;
-};
-type CreateCompilerOptions = Pick<Partial<CompilerOptions>, keyof typeof defaultOptions> & Omit<CompilerOptions, keyof typeof defaultOptions>;
-declare function createCompiler(options: CreateCompilerOptions): Promise<Compiler>;
-
-declare const defaultConfig: CreateCompilerOptions;
-
-export { type CreateCompilerOptions, type EntryPointOptions, type Options, createCompiler, defaultConfig, loadEntryPoint, loadMDX };

package/dist/internal.js

@@ -1,384 +0,0 @@
-// src/constants.ts
-var defaultConfig = {
-  files: ["./content/**/*"]
-};
-
-// src/utils/path.ts
-import * as path from "node:path";
-import FastGlob from "fast-glob";
-function getAbsolutePath(cwd, relativePath) {
-  return path.join(cwd, relativePath);
-}
-function getRelativePath(cwd, absolutePath) {
-  return slash(
-    path.join(
-      path.relative(cwd, path.dirname(absolutePath)),
-      path.basename(absolutePath)
-    )
-  );
-}
-function getImportPath(absolutePath) {
-  return slash(absolutePath);
-}
-function slash(anyPath) {
-  const isExtendedLengthPath = anyPath.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return anyPath;
-  }
-  return anyPath.replaceAll("\\", "/");
-}
-async function globFiles({
-  cwd,
-  globOptions,
-  files
-}) {
-  return FastGlob.glob(files, {
-    cwd,
-    ...globOptions
-  }).then((result) => result.map((file) => getAbsolutePath(cwd, file)));
-}
-function getOutputPath({ options }, entry) {
-  return path.join(
-    options.cwd,
-    options.outputDir,
-    path.relative(options.cwd, path.dirname(entry.file)),
-    `${path.basename(entry.file, path.extname(entry.file))}${options.outputExt}`
-  );
-}
-
-// src/loader/mdx.ts
-import { createProcessor } from "@mdx-js/mdx";
-import grayMatter from "gray-matter";
-
-// src/utils/git-timpstamp.ts
-import path2 from "node:path";
-import fs from "node:fs";
-import { spawn } from "cross-spawn";
-var cache = /* @__PURE__ */ new Map();
-function getGitTimestamp(file) {
-  const cachedTimestamp = cache.get(file);
-  if (cachedTimestamp)
-    return Promise.resolve(cachedTimestamp);
-  return new Promise((resolve, reject) => {
-    const cwd = path2.dirname(file);
-    if (!fs.existsSync(cwd)) {
-      resolve(void 0);
-      return;
-    }
-    const fileName = path2.basename(file);
-    const child = spawn("git", ["log", "-1", '--pretty="%ai"', fileName], {
-      cwd
-    });
-    let output;
-    child.stdout.on("data", (d) => output = new Date(String(d)));
-    child.on("close", () => {
-      if (output)
-        cache.set(file, output);
-      resolve(output);
-    });
-    child.on("error", reject);
-  });
-}
-
-// src/remark-plugins/utils.ts
-import { valueToEstree } from "estree-util-value-to-estree";
-function getMdastExport(name, value) {
-  return {
-    type: "mdxjsEsm",
-    value: "",
-    data: {
-      estree: {
-        type: "Program",
-        sourceType: "module",
-        body: [
-          {
-            type: "ExportNamedDeclaration",
-            specifiers: [],
-            source: null,
-            declaration: {
-              type: "VariableDeclaration",
-              kind: "const",
-              declarations: [
-                {
-                  type: "VariableDeclarator",
-                  id: {
-                    type: "Identifier",
-                    name
-                  },
-                  init: valueToEstree(value)
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  };
-}
-
-// src/remark-plugins/remark-exports.ts
-function remarkMdxExport({ values }) {
-  return (tree, vfile) => {
-    for (const name of values) {
-      if (!(name in vfile.data))
-        return;
-      tree.children.unshift(getMdastExport(name, vfile.data[name]));
-    }
-  };
-}
-
-// src/remark-plugins/remark-absolute-import.ts
-import * as path3 from "node:path";
-import { visit } from "unist-util-visit";
-function remarkAbsoluteImport({ enabled }) {
-  return (tree, vfile) => {
-    if (!enabled)
-      return;
-    visit(tree, ["mdxjsEsm"], (node) => {
-      if (node.type !== "mdxjsEsm")
-        return;
-      const body = node.data?.estree?.body ?? [];
-      body.forEach((statement) => {
-        if (statement.type === "ImportDeclaration" && typeof statement.source.value === "string") {
-          const value = statement.source.value;
-          if (value.startsWith("./") || value.startsWith("../")) {
-            const replace = getImportPath(
-              path3.join(path3.dirname(vfile.path), value)
-            );
-            statement.source.value = replace;
-            statement.source.raw = JSON.stringify(replace);
-          }
-        }
-      });
-    });
-  };
-}
-
-// src/loader/mdx.ts
-var cache2 = /* @__PURE__ */ new Map();
-var loadMDX = ({
-  lastModifiedTime,
-  format: forceFormat,
-  remarkExports = ["frontmatter", "lastModified"],
-  enableAbsoluteImport = true,
-  ...rest
-} = {}) => {
-  return async (file, source) => {
-    const { content, data: frontmatter } = grayMatter(source);
-    const detectedFormat = file.endsWith(".mdx") ? "mdx" : "md";
-    const format = forceFormat ?? detectedFormat;
-    let timestamp;
-    let processor = cache2.get(format);
-    if (processor === void 0) {
-      processor = createProcessor({
-        format,
-        development: process.env.NODE_ENV === "development",
-        ...rest,
-        remarkPlugins: [
-          ...rest.remarkPlugins ?? [],
-          [remarkAbsoluteImport, { enabled: enableAbsoluteImport }],
-          [remarkMdxExport, { values: remarkExports }]
-        ]
-      });
-      cache2.set(format, processor);
-    }
-    if (lastModifiedTime === "git")
-      timestamp = (await getGitTimestamp(file))?.getTime();
-    const vfile = await processor.process({
-      value: content,
-      path: file,
-      data: {
-        lastModified: timestamp,
-        frontmatter
-      }
-    });
-    return {
-      content: String(vfile),
-      _mdx: {
-        vfile
-      }
-    };
-  };
-};
-
-// src/loader/json.ts
-var loadJson = () => {
-  return (_file, source) => {
-    const parsed = JSON.parse(source);
-    return {
-      content: `export default ${JSON.stringify(parsed)}`
-    };
-  };
-};
-
-// src/compiler/emit.ts
-import * as path4 from "node:path";
-import * as fs2 from "node:fs/promises";
-async function emit() {
-  const entires = await this.compile();
-  const emits = entires.map(async (entry) => this.emitEntry(entry));
-  this._emit = await Promise.all(emits);
-}
-async function emitEntry(entry) {
-  const outputPath = getOutputPath(this, entry);
-  await fs2.mkdir(path4.dirname(outputPath), { recursive: true });
-  await fs2.writeFile(outputPath, entry.content);
-  return {
-    ...entry,
-    outputPath
-  };
-}
-
-// src/compiler/compile.ts
-import * as fs3 from "node:fs/promises";
-import * as path5 from "node:path";
-
-// src/loader/entry-point.ts
-function loadEntryPoint(entries) {
-  const { mode = "import" } = this.options.entryPoint ?? {};
-  let content;
-  switch (mode) {
-    case "import":
-      content = generateImport(this, entries);
-      break;
-    default:
-      content = generateLazy(this, entries);
-      break;
-  }
-  return {
-    format: "js",
-    file: getAbsolutePath(this.options.cwd, "./index.js"),
-    content,
-    _entryPoint: {}
-  };
-}
-function generateImport(compiler, output) {
-  const { fullPath = false } = compiler.options.entryPoint ?? {};
-  const formats = /* @__PURE__ */ new Map();
-  output.forEach((entry, i) => {
-    const b = formats.get(entry.format) ?? { imports: [], entries: [] };
-    formats.set(entry.format, b);
-    const importPath = getImportPath(getOutputPath(compiler, entry));
-    const file = fullPath ? entry.file : getRelativePath(compiler.options.cwd, entry.file);
-    const name = `p_${i}`;
-    b.imports.push(`import * as ${name} from ${JSON.stringify(importPath)};`);
-    b.entries.push(`{
-...${name},
-format: ${JSON.stringify(entry.format)},
-file: ${JSON.stringify(file)},
-}`);
-  });
-  const imports = Array.from(formats.values()).flatMap((f) => f.imports).join("\n");
-  const entires = Array.from(formats.entries()).map(([k, v]) => `${k}: [${v.entries.join(",")}]`).join(",");
-  return `${imports}
-export default {${entires}};`;
-}
-function generateLazy(compiler, output) {
-  const entries = [];
-  for (const entry of output) {
-    const fronmatter = entry._mdx ? entry._mdx.vfile.data.frontmatter : {};
-    const importPath = getImportPath(getOutputPath(compiler, entry));
-    const line = `{
-file: ${JSON.stringify(entry.file)},
-info: ${JSON.stringify(fronmatter)},
-load: () => import(${JSON.stringify(importPath)})
-}`;
-    entries.push(line);
-  }
-  return `export default [${entries.join(",\n")}]`;
-}
-
-// src/compiler/compile.ts
-async function compile() {
-  this._output = await Promise.all(
-    this.files.map((file) => this.compileFile(file))
-  );
-  this._output.push(loadEntryPoint.call(this, this._output));
-  return this._output;
-}
-async function compileFile(file) {
-  const cache3 = this._cache.get(file);
-  if (cache3)
-    return cache3;
-  const format = path5.extname(file).slice(1);
-  const content = (await fs3.readFile(file)).toString();
-  const loader = this.loaders[format];
-  const output = await loader?.call(this, file, content);
-  if (!output) {
-    throw new Error(`Unknown format: ${format}`);
-  }
-  const entry = {
-    file,
-    format,
-    ...output
-  };
-  this._cache.set(file, entry);
-  return entry;
-}
-
-// src/compiler/watch.ts
-import { watch as watchFn } from "chokidar";
-function watch() {
-  void this.emit();
-  const watcher = watchFn(this.options.files, { cwd: this.options.cwd });
-  watcher.on("all", (eventName, relativePath) => {
-    const absolutePath = getAbsolutePath(this.options.cwd, relativePath);
-    if (eventName === "add" && !this.files.includes(absolutePath)) {
-      this.files.push(absolutePath);
-      void this.emit();
-    }
-    if (eventName === "unlink") {
-      this.files = this.files.filter((file) => file !== absolutePath);
-      this._cache.delete(absolutePath);
-      void this.emit();
-    }
-    if (eventName === "change") {
-      console.log("update", relativePath);
-      this._cache.delete(absolutePath);
-      void this.compileFile(absolutePath).then(async (entry) => {
-        await this.emitEntry(entry);
-      });
-    }
-  });
-  return watcher;
-}
-
-// src/compiler/index.ts
-var defaultOptions = {
-  cwd: process.cwd(),
-  outputDir: "./dist",
-  outputExt: ".js"
-};
-async function createCompiler(options) {
-  const compilerOptions = {
-    ...defaultOptions,
-    ...options
-  };
-  const files = await globFiles(compilerOptions);
-  return {
-    files,
-    options: compilerOptions,
-    compile,
-    emitEntry,
-    watch,
-    emit,
-    compileFile,
-    loaders: createLoaders(compilerOptions),
-    _cache: /* @__PURE__ */ new Map()
-  };
-}
-function createLoaders(options) {
-  const mdx = loadMDX(options.mdxOptions);
-  return {
-    mdx,
-    md: mdx,
-    json: loadJson(),
-    ...options.loaders
-  };
-}
-export {
-  createCompiler,
-  defaultConfig,
-  loadEntryPoint,
-  loadMDX
-};