fuma-content 0.0.0 → 0.0.2

package/dist/index.js

@@ -13,8 +13,7 @@ function document(entryPoint, options) {
       ...rest
     } = item;
     const result = schema.safeParse(frontmatter);
-    if (!result.success)
-      throw createError(file, result.error);
+    if (!result.success) throw createError(file, result.error);
     return {
       file,
       info: result.data,
@@ -28,8 +27,7 @@ function json(entryPoint, options) {
   return read(entryPoint, ["json"], include).map(
     ({ file, default: data }) => {
       const result = schema.safeParse(data);
-      if (!result.success)
-        throw createError(file, result.error);
+      if (!result.success) throw createError(file, result.error);
       return {
         file,
         info: result.data
@@ -38,10 +36,9 @@ function json(entryPoint, options) {
   );
 }
 function createError(file, err) {
-  return new Error(
-    `${file}:
-${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ")}`).join("\n")}`
-  );
+  const message = `${file}:
+${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ") ?? ""}`).join("\n")}`;
+  return new Error(message);
 }
 function read(entryPoint, format, include) {
   const cast = entryPoint;

package/dist/internal.d.ts

@@ -3,7 +3,21 @@ import { ProcessorOptions } from '@mdx-js/mdx';
 import { VFile } from '@mdx-js/mdx/internal-create-format-aware-processors';
 import { FSWatcher } from 'chokidar';
 
+interface OutputEntry extends Output {
+    /**
+     * extension of file, like: `md`
+     */
+    format: string;
+    file: string;
+}
+interface CompilerWithCache$1 extends Compiler {
+    _compileCache?: Map<string, OutputEntry>;
+}
+declare function compile(this: Compiler): Promise<OutputEntry[]>;
+declare function compileFile(this: CompilerWithCache$1, file: string): Promise<OutputEntry>;
+
 interface Output {
+    dependencies?: OutputEntry[];
     content: string;
     _entryPoint?: unknown;
     _mdx?: {
@@ -19,24 +33,20 @@ interface Options extends ProcessorOptions {
      */
     lastModifiedTime?: "git" | "none";
     /**
-     * @defaultValue `['frontmatter']`
+     * @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, ...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>;
+declare const loadMDX: ({ lastModifiedTime, format: forceFormat, remarkExports, enableAbsoluteImport, ...rest }?: Options) => Transformer;
 
 interface EntryPointOptions {
     /**
@@ -57,8 +67,11 @@ declare function loadEntryPoint(this: Compiler, entries: OutputEntry[]): OutputE
 interface EmitEntry extends OutputEntry {
     outputPath: string;
 }
+interface CompilerWithCache extends Compiler {
+    _emitCache?: WeakMap<OutputEntry, EmitEntry>;
+}
 declare function emit(this: Compiler): Promise<void>;
-declare function emitEntry(this: Compiler, entry: OutputEntry): Promise<EmitEntry>;
+declare function emitEntry(this: CompilerWithCache, entry: OutputEntry): Promise<EmitEntry>;
 
 declare function watch(this: Compiler): FSWatcher;
 
@@ -86,7 +99,6 @@ interface Compiler {
     loaders: Record<string, Transformer>;
     _output?: OutputEntry[];
     _emit?: EmitEntry[];
-    _cache: Map<string, OutputEntry>;
 }
 
 declare const defaultOptions: {
@@ -98,6 +110,5 @@ type CreateCompilerOptions = Pick<Partial<CompilerOptions>, keyof typeof default
 declare function createCompiler(options: CreateCompilerOptions): Promise<Compiler>;
 
 declare const defaultConfig: CreateCompilerOptions;
-declare const defaultConfigPath = "./fc.config.js";
 
-export { type CreateCompilerOptions, type EntryPointOptions, type Options, createCompiler, defaultConfig, defaultConfigPath, loadEntryPoint, loadMDX };
+export { type CreateCompilerOptions, type EntryPointOptions, type Options, createCompiler, defaultConfig, loadEntryPoint, loadMDX };

package/dist/internal.js

@@ -1,14 +1,420 @@
-import {
-  createCompiler,
-  defaultConfig,
-  defaultConfigPath,
-  loadEntryPoint,
-  loadMDX
-} from "./chunk-UDFHC2Y3.js";
+// 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({
+  compiler,
+  transformFormats
+}) {
+  return async (tree, vfile) => {
+    const transforms = [];
+    visit(tree, "mdxjsEsm", (node) => {
+      const body = node.data?.estree?.body ?? [];
+      for (const statement of body) {
+        if (statement.type !== "ImportDeclaration" || typeof statement.source.value !== "string")
+          continue;
+        const value = statement.source.value;
+        if (!value.startsWith("./") && !value.startsWith("../")) continue;
+        const file = path3.join(path3.dirname(vfile.path), value);
+        if (transformFormats.includes(path3.extname(file).slice(1))) {
+          const transform = compiler.compileFile(file).then((entry) => {
+            statement.source.value = getImportPath(
+              getOutputPath(compiler, entry)
+            );
+            delete statement.source.raw;
+            return entry;
+          });
+          transforms.push(transform);
+          continue;
+        }
+        const replace = getImportPath(file);
+        statement.source.value = replace;
+        delete statement.source.raw;
+      }
+    });
+    vfile.data.ctx = { dependencies: await Promise.all(transforms) };
+  };
+}
+
+// src/loader/mdx.ts
+function pluggable(enable, value) {
+  return enable ? [value] : [];
+}
+function getProcessor(compiler, options) {
+  if (!options.format) throw new Error("format is required");
+  compiler._mdxCache ||= /* @__PURE__ */ new Map();
+  let processor = compiler._mdxCache.get(options.format);
+  if (!processor) {
+    processor = createProcessor(options);
+    compiler._mdxCache.set(options.format, processor);
+  }
+  return processor;
+}
+var loadMDX = ({
+  lastModifiedTime,
+  format: forceFormat,
+  remarkExports = ["frontmatter", "lastModified"],
+  enableAbsoluteImport = true,
+  ...rest
+} = {}) => {
+  return async function transform(file, source) {
+    const { content, data: frontmatter } = grayMatter(source);
+    const detectedFormat = file.endsWith(".mdx") ? "mdx" : "md";
+    const format = forceFormat ?? detectedFormat;
+    let timestamp;
+    const processor = getProcessor(this, {
+      format,
+      development: process.env.NODE_ENV === "development",
+      ...rest,
+      remarkPlugins: [
+        ...rest.remarkPlugins ?? [],
+        ...pluggable(enableAbsoluteImport, [
+          remarkAbsoluteImport,
+          {
+            compiler: this,
+            transformFormats: Object.keys(this.loaders)
+          }
+        ]),
+        [remarkMdxExport, { values: remarkExports }]
+      ]
+    });
+    if (lastModifiedTime === "git")
+      timestamp = (await getGitTimestamp(file))?.getTime();
+    const vfile = await processor.process({
+      value: content,
+      path: file,
+      data: {
+        lastModified: timestamp,
+        frontmatter
+      }
+    });
+    return {
+      dependencies: vfile.data.ctx.dependencies,
+      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) {
+  this._emitCache ||= /* @__PURE__ */ new WeakMap();
+  const cached = this._emitCache.get(entry);
+  if (cached) return cached;
+  const outputPath = getOutputPath(this, entry);
+  await fs2.mkdir(path4.dirname(outputPath), { recursive: true });
+  await fs2.writeFile(outputPath, entry.content);
+  if (entry.dependencies) {
+    await Promise.all(entry.dependencies.map((dep) => this.emitEntry(dep)));
+  }
+  const output = {
+    ...entry,
+    outputPath
+  };
+  this._emitCache.set(entry, output);
+  return output;
+}
+
+// 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.toString()}`;
+    b.imports.push(`import * as ${name} from ${JSON.stringify(importPath)};`);
+    b.entries.push(`{
+...${name},
+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() {
+  const output = [];
+  await Promise.all(
+    this.files.map(async (file) => {
+      const entry = await this.compileFile(file);
+      output.push(entry);
+    })
+  );
+  output.push(loadEntryPoint.call(this, output));
+  this._output = output;
+  return output;
+}
+async function compileFile(file) {
+  this._compileCache ||= /* @__PURE__ */ new Map();
+  const cache2 = this._compileCache.get(file);
+  if (cache2) return cache2;
+  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._compileCache.set(file, entry);
+  return entry;
+}
+function removeCache(compiler, file) {
+  compiler._compileCache?.delete(file);
+}
+
+// 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);
+      removeCache(this, absolutePath);
+      void this.emit();
+    }
+    if (eventName === "change") {
+      console.log("update", relativePath);
+      removeCache(this, 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)
+  };
+}
+function createLoaders(options) {
+  const mdx = loadMDX(options.mdxOptions);
+  return {
+    mdx,
+    md: mdx,
+    json: loadJson(),
+    ...options.loaders
+  };
+}
 export {
   createCompiler,
   defaultConfig,
-  defaultConfigPath,
   loadEntryPoint,
   loadMDX
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuma-content",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Write content for web apps",
   "keywords": [
     "Content",
@@ -9,7 +9,6 @@
   "repository": "github:fuma-nama/fuma-content",
   "license": "MIT",
   "type": "module",
-  "bin": "./dist/cli/index.js",
   "author": "Fuma Nama",
   "files": [
     "dist/*"
@@ -36,12 +35,12 @@
   "dependencies": {
     "@mdx-js/mdx": "^3.0.0",
     "chokidar": "^3.5.3",
-    "clipanion": "4.0.0-rc.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",
+    "unist-util-visit": "^5.0.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {

package/dist/chunk-UDFHC2Y3.js

@@ -1,347 +0,0 @@
-// src/constants.ts
-var defaultConfig = {
-  files: ["./content/**/*"]
-};
-var defaultConfigPath = "./fc.config.js";
-
-// src/loader/mdx.ts
-import { createProcessor } from "@mdx-js/mdx";
-import grayMatter from "gray-matter";
-
-// src/utils/git-timpstamp.ts
-import path 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 = path.dirname(file);
-    if (!fs.existsSync(cwd)) {
-      resolve(void 0);
-      return;
-    }
-    const fileName = path.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/loader/mdx.ts
-var cache2 = /* @__PURE__ */ new Map();
-var loadMDX = ({
-  lastModifiedTime,
-  format: forceFormat,
-  remarkExports = ["frontmatter"],
-  ...rest
-} = {}) => {
-  return async (filePath, source) => {
-    const { content, data: frontmatter } = grayMatter(source);
-    const detectedFormat = filePath.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 ?? [],
-          [remarkMdxExport, { values: remarkExports }]
-        ]
-      });
-      cache2.set(format, processor);
-    }
-    if (lastModifiedTime === "git")
-      timestamp = (await getGitTimestamp(filePath))?.getTime();
-    const file = await processor.process({
-      value: content,
-      path: filePath,
-      data: {
-        lastModified: timestamp,
-        frontmatter
-      }
-    });
-    return {
-      content: String(file),
-      _mdx: {
-        vfile: file
-      }
-    };
-  };
-};
-
-// src/loader/entry-point.ts
-import { pathToFileURL } from "node:url";
-
-// src/utils/path.ts
-import * as path2 from "node:path";
-import FastGlob from "fast-glob";
-function getAbsolutePath(cwd, relativePath) {
-  return FastGlob.escapePath(path2.join(cwd, relativePath));
-}
-function getRelativePath(cwd, absolutePath) {
-  return path2.join(
-    path2.relative(cwd, path2.dirname(absolutePath)),
-    path2.basename(absolutePath)
-  );
-}
-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 path2.join(
-    options.cwd,
-    options.outputDir,
-    path2.relative(options.cwd, path2.dirname(entry.file)),
-    `${path2.basename(entry.file, path2.extname(entry.file))}${options.outputExt}`
-  );
-}
-
-// 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 = pathToFileURL(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 = pathToFileURL(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/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 path3 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(path3.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 path4 from "node:path";
-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 = path4.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, path5) => {
-    const absolutePath = getAbsolutePath(this.options.cwd, path5);
-    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", path5);
-      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 {
-  defaultConfig,
-  defaultConfigPath,
-  loadMDX,
-  loadEntryPoint,
-  createCompiler
-};

package/dist/cli/index.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/cli/index.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-import {
-  createCompiler,
-  defaultConfig,
-  defaultConfigPath
-} from "../chunk-UDFHC2Y3.js";
-
-// src/cli/index.ts
-import { Cli, Command, Option } from "clipanion";
-
-// src/utils/load-config.ts
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import * as fs from "node:fs";
-async function loadConfig(configFile = defaultConfigPath) {
-  const configPath = path.resolve(configFile);
-  if (!fs.existsSync(configPath))
-    return defaultConfig;
-  const importPath = pathToFileURL(configPath).href;
-  const result = await import(`${importPath}?x=${Date.now()}`);
-  return "default" in result ? result.default : result;
-}
-
-// src/cli/index.ts
-var BuildCommand = class extends Command {
-  static paths = [[`build`]];
-  config = Option.String({ required: false });
-  async execute() {
-    const config = await loadConfig(this.config);
-    const compiler = await createCompiler(config);
-    await compiler.emit();
-    this.context.stdout.write(`Build successful
-`);
-  }
-};
-var WatchCommand = class extends Command {
-  static paths = [[`watch`]];
-  config = Option.String({ required: false });
-  async execute() {
-    const config = await loadConfig(this.config);
-    const compiler = await createCompiler(config);
-    this.context.stdout.write(`Started server
-`);
-    compiler.watch();
-  }
-};
-var [node, app, ...args] = process.argv;
-var cli = new Cli({
-  binaryLabel: `fuma-content-cli`,
-  binaryName: `${node} ${app}`,
-  binaryVersion: `1.0.0`
-});
-cli.register(BuildCommand);
-cli.register(WatchCommand);
-void cli.runExit(args);