fuma-content 0.0.1 → 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
@@ -39,7 +37,7 @@ function json(entryPoint, options) {
 }
 function createError(file, err) {
   const message = `${file}:
-${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ")}`).join("\n")}`;
+${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ") ?? ""}`).join("\n")}`;
   return new Error(message);
 }
 function read(entryPoint, format, include) {

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?: {
@@ -34,16 +48,6 @@ interface Options extends ProcessorOptions {
  */
 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
@@ -63,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;
 
@@ -92,7 +99,6 @@ interface Compiler {
     loaders: Record<string, Transformer>;
     _output?: OutputEntry[];
     _emit?: EmitEntry[];
-    _cache: Map<string, OutputEntry>;
 }
 
 declare const defaultOptions: {

package/dist/internal.js

@@ -57,8 +57,7 @@ import { spawn } from "cross-spawn";
 var cache = /* @__PURE__ */ new Map();
 function getGitTimestamp(file) {
   const cachedTimestamp = cache.get(file);
-  if (cachedTimestamp)
-    return Promise.resolve(cachedTimestamp);
+  if (cachedTimestamp) return Promise.resolve(cachedTimestamp);
   return new Promise((resolve, reject) => {
     const cwd = path2.dirname(file);
     if (!fs.existsSync(cwd)) {
@@ -72,8 +71,7 @@ function getGitTimestamp(file) {
     let output;
     child.stdout.on("data", (d) => output = new Date(String(d)));
     child.on("close", () => {
-      if (output)
-        cache.set(file, output);
+      if (output) cache.set(file, output);
       resolve(output);
     });
     child.on("error", reject);
@@ -120,8 +118,7 @@ function getMdastExport(name, value) {
 function remarkMdxExport({ values }) {
   return (tree, vfile) => {
     for (const name of values) {
-      if (!(name in vfile.data))
-        return;
+      if (!(name in vfile.data)) return;
       tree.children.unshift(getMdastExport(name, vfile.data[name]));
     }
   };
@@ -130,32 +127,54 @@ function remarkMdxExport({ values }) {
 // 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;
+function remarkAbsoluteImport({
+  compiler,
+  transformFormats
+}) {
+  return async (tree, vfile) => {
+    const transforms = [];
+    visit(tree, "mdxjsEsm", (node) => {
       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)
+      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)
             );
-            statement.source.value = replace;
-            statement.source.raw = JSON.stringify(replace);
-          }
+            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
-var cache2 = /* @__PURE__ */ new Map();
+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,
@@ -163,25 +182,27 @@ var loadMDX = ({
   enableAbsoluteImport = true,
   ...rest
 } = {}) => {
-  return async (file, source) => {
+  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;
-    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);
-    }
+    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({
@@ -193,6 +214,7 @@ var loadMDX = ({
       }
     });
     return {
+      dependencies: vfile.data.ctx.dependencies,
       content: String(vfile),
       _mdx: {
         vfile
@@ -220,13 +242,21 @@ async function emit() {
   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);
-  return {
+  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
@@ -260,11 +290,10 @@ function generateImport(compiler, output) {
     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}`;
+    const name = `p_${i.toString()}`;
     b.imports.push(`import * as ${name} from ${JSON.stringify(importPath)};`);
     b.entries.push(`{
 ...${name},
-format: ${JSON.stringify(entry.format)},
 file: ${JSON.stringify(file)},
 }`);
   });
@@ -290,16 +319,21 @@ load: () => import(${JSON.stringify(importPath)})
 
 // src/compiler/compile.ts
 async function compile() {
-  this._output = await Promise.all(
-    this.files.map((file) => this.compileFile(file))
+  const output = [];
+  await Promise.all(
+    this.files.map(async (file) => {
+      const entry = await this.compileFile(file);
+      output.push(entry);
+    })
   );
-  this._output.push(loadEntryPoint.call(this, this._output));
-  return this._output;
+  output.push(loadEntryPoint.call(this, output));
+  this._output = output;
+  return output;
 }
 async function compileFile(file) {
-  const cache3 = this._cache.get(file);
-  if (cache3)
-    return cache3;
+  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];
@@ -312,9 +346,12 @@ async function compileFile(file) {
     format,
     ...output
   };
-  this._cache.set(file, entry);
+  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";
@@ -329,12 +366,12 @@ function watch() {
     }
     if (eventName === "unlink") {
       this.files = this.files.filter((file) => file !== absolutePath);
-      this._cache.delete(absolutePath);
+      removeCache(this, absolutePath);
       void this.emit();
     }
     if (eventName === "change") {
       console.log("update", relativePath);
-      this._cache.delete(absolutePath);
+      removeCache(this, absolutePath);
       void this.compileFile(absolutePath).then(async (entry) => {
         await this.emitEntry(entry);
       });
@@ -363,8 +400,7 @@ async function createCompiler(options) {
     watch,
     emit,
     compileFile,
-    loaders: createLoaders(compilerOptions),
-    _cache: /* @__PURE__ */ new Map()
+    loaders: createLoaders(compilerOptions)
   };
 }
 function createLoaders(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuma-content",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Write content for web apps",
   "keywords": [
     "Content",