astro-xmdx 0.0.5 → 0.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 knj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-xmdx",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Astro integration for xmdx - high-performance MDX compiler",
   "type": "module",
   "main": "./index.ts",
@@ -40,16 +40,8 @@
   "files": [
     "index.ts",
     "src",
-    "!src/**/*.test.ts",
-    "!src/tests/",
     "template"
   ],
-  "scripts": {
-    "build": "tsc",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
-    "typecheck": "tsc --noEmit"
-  },
   "keywords": [
     "astro",
     "astro-integration",
@@ -64,10 +56,6 @@
     "type": "git",
     "url": "https://github.com/jp-knj/xmdx"
   },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
   "peerDependencies": {
     "astro": ">=4.0.0",
     "vite": ">=5.0.0"
@@ -75,19 +63,25 @@
   "dependencies": {
     "@mdx-js/mdx": "^3.1.1",
     "expressive-code": "^0.41.0",
-    "glob": "^13.0.0",
+    "glob": "^11.0.0",
     "gray-matter": "^4.0.3",
-    "xmdx": "workspace:*",
-    "@xmdx/napi": "workspace:*",
-    "remark-directive": "^4.0.0",
+    "remark-directive": "^3.0.0",
     "remark-gfm": "^4.0.0",
-    "shiki": "^3.22.0"
+    "shiki": "^3.20.0",
+    "xmdx": "0.0.5",
+    "@xmdx/napi": "0.0.5"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "esbuild": ">=0.21.0",
     "magic-string": "^0.30.0",
     "rollup": ">=4.0.0",
-    "typescript": "^5.9.0"
+    "typescript": "^5.7.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/src/constants.ts

@@ -66,15 +66,3 @@ export const DEFAULT_IGNORE_PATTERNS = ['node_modules/**', 'dist/**'] as const;
  * Injected as inline <style> in dev mode, Head.astro overlay in build.
  */
 export const STARLIGHT_LAYER_ORDER = '@layer starlight.base, starlight.reset, starlight.core, starlight.content, starlight.components, starlight.utils;';
-
-/**
- * Public specifier for ExpressiveCode collected CSS styles.
- * Used in generated import statements — does NOT include the \0 prefix.
- */
-export const EC_STYLES_MODULE_ID = 'xmdx:ec-styles.css';
-
-/**
- * Virtual module ID for ExpressiveCode collected CSS styles.
- * The \0-prefixed resolved ID used internally by Vite hooks.
- */
-export const EC_STYLES_VIRTUAL_ID = '\0xmdx:ec-styles.css';

package/src/index.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from 'bun:test';
+import xmdx from './index.js';
+
+// Helper to invoke the setup hook with a mocked Astro config
+async function invokeSetup(
+  integration: ReturnType<typeof xmdx>,
+  configOverrides: Record<string, unknown> = {}
+) {
+  const setupHook = integration.hooks['astro:config:setup'];
+  const renderers: Array<{ name: string; serverEntrypoint: string }> = [];
+  const updatedConfigs: unknown[] = [];
+
+  await setupHook?.({
+    config: {
+      integrations: [],
+      ...configOverrides,
+    },
+    updateConfig: (config: unknown) => {
+      updatedConfigs.push(config);
+    },
+    addRenderer: (renderer: { name: string; serverEntrypoint: string }) => {
+      renderers.push(renderer);
+    },
+  } as unknown as Parameters<NonNullable<typeof setupHook>>[0]);
+
+  return { renderers, updatedConfigs };
+}
+
+describe('xmdx integration setup', () => {
+  test('registers renderer using built server file URL entrypoint', async () => {
+    const integration = xmdx();
+    const { renderers, updatedConfigs } = await invokeSetup(integration);
+
+    expect(renderers).toHaveLength(1);
+    expect(renderers[0]?.name).toBe('astro:jsx');
+    expect(renderers[0]?.serverEntrypoint.startsWith('file://')).toBe(true);
+    expect(renderers[0]?.serverEntrypoint.endsWith('/server.js')).toBe(true);
+    expect(updatedConfigs).toHaveLength(1);
+  });
+});
+
+describe('Starlight auto-detection', () => {
+  test('auto-enables starlightComponents when Starlight is detected', async () => {
+    const integration = xmdx();
+    const { updatedConfigs } = await invokeSetup(integration, {
+      integrations: [{ name: '@astrojs/starlight' }],
+    });
+
+    // The vite plugin receives the resolved options
+    const viteConfig = updatedConfigs[0] as { vite: { plugins: Array<{ name: string }> } };
+    expect(viteConfig.vite.plugins).toHaveLength(1);
+    expect(viteConfig.vite.plugins[0]?.name).toBe('vite-plugin-xmdx');
+  });
+
+  test('auto-registers libraries when Starlight detected and none provided', async () => {
+    // Access resolved options via plugin creation
+    const integration = xmdx();
+
+    // Verify that setup completes without errors when Starlight is detected
+    const { updatedConfigs } = await invokeSetup(integration, {
+      integrations: [{ name: '@astrojs/starlight' }],
+    });
+    expect(updatedConfigs).toHaveLength(1);
+  });
+
+  test('does not override user-provided libraries', async () => {
+    const customLibrary = {
+      id: 'custom',
+      name: 'Custom',
+      defaultModulePath: 'custom/module',
+      components: [{ name: 'Custom', modulePath: 'custom/module', exportType: 'named' as const }],
+    };
+
+    const integration = xmdx({ libraries: [customLibrary] });
+    const { updatedConfigs } = await invokeSetup(integration, {
+      integrations: [{ name: '@astrojs/starlight' }],
+    });
+    expect(updatedConfigs).toHaveLength(1);
+  });
+
+  test('detects Starlight component overrides from integration config', async () => {
+    const integration = xmdx();
+    const { updatedConfigs } = await invokeSetup(integration, {
+      integrations: [{
+        name: '@astrojs/starlight',
+        config: {
+          components: {
+            Aside: './src/components/CustomAside.astro',
+          },
+        },
+      }],
+    });
+    // Should complete without errors - override detection adjusts import paths
+    expect(updatedConfigs).toHaveLength(1);
+  });
+});

package/src/pipeline/orchestrator.test.ts

@@ -0,0 +1,324 @@
+import { describe, it, expect } from 'bun:test';
+import { createPipeline, createCustomPipeline, createContext } from './orchestrator.js';
+import type { TransformContext } from './types.js';
+
+describe('createContext', () => {
+  it('should create context with default values', () => {
+    const ctx = createContext();
+
+    expect(ctx.code).toBe('');
+    expect(ctx.source).toBe('');
+    expect(ctx.filename).toBe('');
+    expect(ctx.frontmatter).toEqual({});
+    expect(ctx.headings).toEqual([]);
+    expect(ctx.registry).toBeUndefined();
+    expect(ctx.config).toEqual({
+      expressiveCode: null,
+      starlightComponents: false,
+      shiki: null,
+    });
+  });
+
+  it('should override default values with provided values', () => {
+    const ctx = createContext({
+      code: '<h1>Hello</h1>',
+      source: '# Hello',
+      filename: '/path/to/file.md',
+      frontmatter: { title: 'Test' },
+      headings: [{ depth: 1, text: 'Hello', slug: 'hello' }],
+    });
+
+    expect(ctx.code).toBe('<h1>Hello</h1>');
+    expect(ctx.source).toBe('# Hello');
+    expect(ctx.filename).toBe('/path/to/file.md');
+    expect(ctx.frontmatter).toEqual({ title: 'Test' });
+    expect(ctx.headings).toEqual([{ depth: 1, text: 'Hello', slug: 'hello' }]);
+  });
+
+  it('should merge config with defaults', () => {
+    const ctx = createContext({
+      config: {
+        expressiveCode: { component: 'Code', moduleId: 'test' },
+        starlightComponents: false,
+        shiki: null,
+      },
+    });
+
+    expect(ctx.config.expressiveCode).toEqual({ component: 'Code', moduleId: 'test' });
+    expect(ctx.config.starlightComponents).toBe(false);
+    expect(ctx.config.shiki).toBeNull();
+  });
+
+  it('should preserve registry when provided', () => {
+    const mockRegistry = { lookup: () => null } as unknown as TransformContext['registry'];
+    const ctx = createContext({ registry: mockRegistry });
+
+    expect(ctx.registry).toBe(mockRegistry);
+  });
+});
+
+describe('createPipeline', () => {
+  it('should create pipeline with empty hooks', async () => {
+    const pipeline = createPipeline();
+    const ctx = createContext({
+      code: '<p>test</p>',
+      source: 'test',
+      filename: 'test.md',
+    });
+
+    const result = await pipeline(ctx);
+
+    // Pipeline should return context (transforms may or may not modify it)
+    expect(result).toBeDefined();
+    expect(result.code).toBeDefined();
+  });
+
+  it('should execute afterParse hooks first', async () => {
+    const order: string[] = [];
+    const afterParseHook = (ctx: TransformContext): TransformContext => {
+      order.push('afterParse');
+      return { ...ctx, code: ctx.code + ':afterParse' };
+    };
+
+    const pipeline = createPipeline({
+      afterParse: [afterParseHook],
+    });
+
+    const ctx = createContext({ code: 'start' });
+    const result = await pipeline(ctx);
+
+    expect(order).toEqual(['afterParse']);
+    expect(result.code).toContain('afterParse');
+  });
+
+  it('should execute hooks in correct order', async () => {
+    const order: string[] = [];
+
+    const afterParseHook = (ctx: TransformContext): TransformContext => {
+      order.push('afterParse');
+      return ctx;
+    };
+
+    const beforeInjectHook = (ctx: TransformContext): TransformContext => {
+      order.push('beforeInject');
+      return ctx;
+    };
+
+    const beforeOutputHook = (ctx: TransformContext): TransformContext => {
+      order.push('beforeOutput');
+      return ctx;
+    };
+
+    const pipeline = createPipeline({
+      afterParse: [afterParseHook],
+      beforeInject: [beforeInjectHook],
+      beforeOutput: [beforeOutputHook],
+    });
+
+    const ctx = createContext({ code: 'test' });
+    await pipeline(ctx);
+
+    // Verify hook order: afterParse -> (built-in transforms) -> beforeInject -> (built-in transforms) -> beforeOutput
+    expect(order.indexOf('afterParse')).toBeLessThan(order.indexOf('beforeInject'));
+    expect(order.indexOf('beforeInject')).toBeLessThan(order.indexOf('beforeOutput'));
+  });
+
+  it('should handle multiple hooks per phase', async () => {
+    const order: string[] = [];
+
+    const pipeline = createPipeline({
+      afterParse: [
+        (ctx: TransformContext) => { order.push('afterParse1'); return ctx; },
+        (ctx: TransformContext) => { order.push('afterParse2'); return ctx; },
+      ],
+      beforeOutput: [
+        (ctx: TransformContext) => { order.push('beforeOutput1'); return ctx; },
+        (ctx: TransformContext) => { order.push('beforeOutput2'); return ctx; },
+      ],
+    });
+
+    const ctx = createContext({ code: 'test' });
+    await pipeline(ctx);
+
+    // Hooks should run in order within each phase
+    expect(order.indexOf('afterParse1')).toBeLessThan(order.indexOf('afterParse2'));
+    expect(order.indexOf('beforeOutput1')).toBeLessThan(order.indexOf('beforeOutput2'));
+  });
+
+  it('should handle async hooks', async () => {
+    const asyncHook = async (ctx: TransformContext): Promise<TransformContext> => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      return { ...ctx, code: ctx.code + ':async' };
+    };
+
+    const pipeline = createPipeline({
+      afterParse: [asyncHook],
+    });
+
+    const ctx = createContext({ code: 'start' });
+    const result = await pipeline(ctx);
+
+    expect(result.code).toContain('async');
+  });
+
+  it('should pass context through all transforms', async () => {
+    const addMetadata = (ctx: TransformContext): TransformContext => ({
+      ...ctx,
+      frontmatter: { ...ctx.frontmatter, transformed: true },
+    });
+
+    const pipeline = createPipeline({
+      afterParse: [addMetadata],
+    });
+
+    const ctx = createContext({
+      code: 'test',
+      frontmatter: { title: 'Original' },
+    });
+    const result = await pipeline(ctx);
+
+    expect(result.frontmatter.title).toBe('Original');
+    expect(result.frontmatter.transformed).toBe(true);
+  });
+});
+
+describe('createCustomPipeline', () => {
+  it('should create pipeline with only specified transforms', async () => {
+    const transform1 = (ctx: TransformContext): TransformContext => ({ ...ctx, code: ctx.code + ':t1' });
+    const transform2 = (ctx: TransformContext): TransformContext => ({ ...ctx, code: ctx.code + ':t2' });
+
+    const pipeline = createCustomPipeline(transform1, transform2);
+    const ctx = createContext({ code: 'start' });
+    const result = await pipeline(ctx);
+
+    expect(result.code).toBe('start:t1:t2');
+  });
+
+  it('should not include any built-in transforms', async () => {
+    // Create a custom pipeline with only a simple transform
+    const simpleTransform = (ctx: TransformContext): TransformContext & { customOnly: boolean } => ({ ...ctx, customOnly: true });
+
+    const pipeline = createCustomPipeline(simpleTransform);
+    const ctx = createContext({ code: '<pre><code>test</code></pre>' });
+    const result = await pipeline(ctx);
+
+    // The code should not be modified by built-in transforms
+    expect(result.code).toBe('<pre><code>test</code></pre>');
+    expect((result as TransformContext & { customOnly?: boolean }).customOnly).toBe(true);
+  });
+
+  it('should compose async transforms', async () => {
+    const asyncTransform1 = async (ctx: TransformContext): Promise<TransformContext> => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return { ...ctx, code: ctx.code + ':async1' };
+    };
+
+    const asyncTransform2 = async (ctx: TransformContext): Promise<TransformContext> => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return { ...ctx, code: ctx.code + ':async2' };
+    };
+
+    const pipeline = createCustomPipeline(asyncTransform1, asyncTransform2);
+    const ctx = createContext({ code: 'start' });
+    const result = await pipeline(ctx);
+
+    expect(result.code).toBe('start:async1:async2');
+  });
+
+  it('should work with empty transforms', async () => {
+    const pipeline = createCustomPipeline();
+    const ctx = createContext({ code: 'unchanged' });
+    const result = await pipeline(ctx);
+
+    expect(result.code).toBe('unchanged');
+  });
+});
+
+describe('standalone usage', () => {
+  it('should work without Vite context', async () => {
+    // Simulate standalone usage: create context manually and run pipeline
+    const ctx = createContext({
+      code: `
+import { Fragment } from 'astro/jsx-runtime';
+export default function Content() {
+  return <Fragment><h1>Hello</h1><p>World</p></Fragment>;
+}`,
+      source: '# Hello\n\nWorld',
+      filename: '/standalone/test.md',
+      frontmatter: { title: 'Standalone Test' },
+      headings: [{ depth: 1, text: 'Hello', slug: 'hello' }],
+    });
+
+    const pipeline = createPipeline();
+    const result = await pipeline(ctx);
+
+    expect(result.code).toBeDefined();
+    expect(result.filename).toBe('/standalone/test.md');
+    expect(result.frontmatter.title).toBe('Standalone Test');
+  });
+
+  it('should allow custom transforms in standalone mode', async () => {
+    const addBanner = (ctx: TransformContext): TransformContext => ({
+      ...ctx,
+      code: `// Generated by custom pipeline\n${ctx.code}`,
+    });
+
+    const pipeline = createCustomPipeline(addBanner);
+
+    const ctx = createContext({
+      code: 'export default function() {}',
+      source: 'test',
+      filename: 'test.md',
+    });
+
+    const result = await pipeline(ctx);
+
+    expect(result.code).toStartWith('// Generated by custom pipeline');
+  });
+
+  it('should support composing multiple custom pipelines', async () => {
+    const pipeline1 = createCustomPipeline(
+      (ctx: TransformContext) => ({ ...ctx, code: ctx.code + ':p1' })
+    );
+
+    const pipeline2 = createCustomPipeline(
+      (ctx: TransformContext) => ({ ...ctx, code: ctx.code + ':p2' })
+    );
+
+    // Compose pipelines manually
+    const combinedPipeline = async (ctx: TransformContext): Promise<TransformContext> => {
+      const intermediate = await pipeline1(ctx);
+      return pipeline2(intermediate);
+    };
+
+    const ctx = createContext({ code: 'start' });
+    const result = await combinedPipeline(ctx);
+
+    expect(result.code).toBe('start:p1:p2');
+  });
+});
+
+describe('error handling', () => {
+  it('should propagate errors from transforms', async () => {
+    const failingTransform = (): TransformContext => {
+      throw new Error('Transform failed');
+    };
+
+    const pipeline = createCustomPipeline(failingTransform);
+    const ctx = createContext({ code: 'test' });
+
+    await expect(pipeline(ctx)).rejects.toThrow('Transform failed');
+  });
+
+  it('should propagate errors from async transforms', async () => {
+    const asyncFailingTransform = async (): Promise<TransformContext> => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      throw new Error('Async transform failed');
+    };
+
+    const pipeline = createCustomPipeline(asyncFailingTransform);
+    const ctx = createContext({ code: 'test' });
+
+    await expect(pipeline(ctx)).rejects.toThrow('Async transform failed');
+  });
+});