fix: count reading units and share Vite compiler

Author: jikkai

native/src/document.rs

@@ -29,6 +29,7 @@ pub struct PreparedMdx {
     pub code_blocks: Vec<CodeBlock>,
     pub dependencies: Vec<PathBuf>,
     pub diagnostics: Vec<Diagnostic>,
+    pub reading_words: usize,
     pub(crate) tree: mdxjs::hast::Node,
 }
 
@@ -94,6 +95,7 @@ pub fn prepare_mdx(
     let options = mdx_options(file, config);
     let mdast = mdxjs::mdast_util_from_mdx(body, &options)
         .map_err(|error| vec![mdx_diagnostic(file, error)])?;
+    let reading_words = reading_units(&mdast);
     let mut code_blocks = Vec::new();
     if highlight {
         collect_code_blocks(&mdast, document_id, &mut code_blocks);
@@ -108,10 +110,47 @@ pub fn prepare_mdx(
         code_blocks,
         dependencies: media.dependencies,
         diagnostics: media.diagnostics,
+        reading_words,
         tree,
     })
 }
 
+fn reading_units(node: &markdown::mdast::Node) -> usize {
+    match node {
+        markdown::mdast::Node::Code(_) | markdown::mdast::Node::InlineCode(_) => 0,
+        markdown::mdast::Node::Text(text) => count_reading_units(&text.value),
+        _ => node
+            .children()
+            .map(|children| children.iter().map(reading_units).sum())
+            .unwrap_or_default(),
+    }
+}
+
+fn count_reading_units(text: &str) -> usize {
+    let mut count = 0;
+    let mut in_english_word = false;
+    for character in text.chars() {
+        if matches!(
+            character,
+            '\u{4e00}'..='\u{9fff}'
+                | '\u{3040}'..='\u{309f}'
+                | '\u{30a0}'..='\u{30ff}'
+                | '\u{ac00}'..='\u{d7af}'
+        ) {
+            count += 1;
+            in_english_word = false;
+        } else if character.is_ascii_alphabetic() {
+            if !in_english_word {
+                count += 1;
+                in_english_word = true;
+            }
+        } else {
+            in_english_word = false;
+        }
+    }
+    count
+}
+
 pub fn finish_mdx(
     prepared: PreparedMdx,
     file: &str,

native/src/lib.rs

@@ -348,12 +348,12 @@ pub fn prepare_batch(config_json: String, inputs_json: String) -> Result<Prepare
         .map_err(diagnostic_error)?;
         let mut derived = serde_json::Map::new();
         if config.derived.reading_time {
-            let words = parsed.body.split_whitespace().count();
+            let words = prepared.reading_words;
             derived.insert(
                 "readingTime".into(),
                 serde_json::json!({
                     "words": words,
-                    "minutes": words.div_ceil(200).max(1),
+                    "minutes": words.div_ceil(300).max(1),
                 }),
             );
         }

src/__tests__/native.test.ts

@@ -72,6 +72,35 @@ test('maps schema failures to structured diagnostics', () => {
   )
 })
 
+test('counts CJK text but excludes code from reading time', () => {
+  const readingConfig = normalizeConfig({
+    cache: false,
+    highlight: false,
+    root: '/project',
+    collections: {
+      posts: {
+        directory: 'content/posts',
+        schema: {
+          type: 'object',
+          properties: { title: { type: 'string' } },
+          required: ['title'],
+        },
+      },
+    },
+    derived: { readingTime: true },
+  })
+  const batch = prepareNativeBatch(readingConfig, [
+    {
+      collection: 'posts',
+      file: '/project/content/posts/cjk.mdx',
+      key: 'cjk',
+      source: `---\ntitle: CJK\n---\n${'字'.repeat(201)}\n\n\`\`\`text\n${'字'.repeat(500)}\n\`\`\`\n`,
+    },
+  ])
+
+  assert.deepEqual(batch.finish([])[0]?.derived.readingTime, { minutes: 1, words: 201 })
+})
+
 test('injects real Shiki HAST into the compiled module', async () => {
   const batch = prepareNativeBatch(config, [
     {

src/__tests__/vite.test.ts

@@ -3,7 +3,7 @@ import { createRequire } from 'node:module'
 import { readFile, stat, unlink, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 
-import { build, createServer } from 'vite'
+import { build, createBuilder, createServer } from 'vite'
 import { test } from 'vitest'
 
 import { amamoMdx } from '../vite.js'
@@ -45,6 +45,32 @@ test('Vite builds MDX without rewriting unchanged generated outputs', async () =
   }
 })
 
+test('Vite reuses one compiler across client and SSR environments', async () => {
+  const fixture = await createCompilerFixture()
+  const entry = path.join(fixture.root, 'main.js')
+  await writeFile(entry, "import Post from './content/posts/hello.mdx'; console.log(Post)\n")
+
+  try {
+    const builder = await createBuilder({
+      root: fixture.root,
+      builder: { sharedPlugins: true },
+      environments: {
+        client: { build: { outDir: 'dist/client', rollupOptions: { input: entry } } },
+        ssr: { build: { outDir: 'dist/server', rollupOptions: { input: entry }, ssr: true } },
+      },
+      logLevel: 'silent',
+      plugins: [amamoMdx(fixture.config)],
+      resolve: { alias: { 'react/jsx-runtime': reactJsxRuntime } },
+    })
+
+    await builder.buildApp()
+    assert.ok((await stat(path.join(fixture.root, 'dist/client'))).isDirectory())
+    assert.ok((await stat(path.join(fixture.root, 'dist/server'))).isDirectory())
+  } finally {
+    await fixture.cleanup()
+  }
+})
+
 test('Vite dev watcher updates generated output for create, update, and delete', async () => {
   const fixture = await createCompilerFixture()
   const secondPost = path.join(path.dirname(fixture.post), 'second.mdx')

src/vite.ts

@@ -73,9 +73,6 @@ export function amamoMdx(config: IAmamoMdxConfig): Plugin {
         }
       })
     },
-    async closeBundle() {
-      await dispose()
-    },
   }
 }