astro-xmdx 0.0.2

package/src/utils/config.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect } from 'bun:test';
+import { resolveExpressiveCodeConfig, resolveStarlightConfig } from './config.js';
+import {
+  createRegistry,
+  starlightLibrary,
+  expressiveCodeLibrary,
+} from 'xmdx/registry';
+
+const STARLIGHT_COMPONENTS = starlightLibrary.components.map((c) => c.name);
+const STARLIGHT_COMPONENTS_MODULE = starlightLibrary.defaultModulePath;
+const EXPRESSIVE_CODE_COMPONENT = expressiveCodeLibrary.components[0]?.name ?? 'Code';
+const EXPRESSIVE_CODE_MODULE = expressiveCodeLibrary.defaultModulePath;
+
+describe('resolveExpressiveCodeConfig', () => {
+  it('should return null for falsy values', () => {
+    expect(resolveExpressiveCodeConfig(null)).toBe(null);
+    expect(resolveExpressiveCodeConfig(undefined)).toBe(null);
+    expect(resolveExpressiveCodeConfig(false)).toBe(null);
+  });
+
+  it('should return default config for true', () => {
+    const result = resolveExpressiveCodeConfig(true);
+
+    expect(result).toEqual({
+      component: EXPRESSIVE_CODE_COMPONENT,
+      moduleId: EXPRESSIVE_CODE_MODULE,
+    });
+  });
+
+  it('should use defaults for empty object', () => {
+    const result = resolveExpressiveCodeConfig({});
+
+    expect(result).toEqual({
+      component: EXPRESSIVE_CODE_COMPONENT,
+      moduleId: EXPRESSIVE_CODE_MODULE,
+    });
+  });
+
+  it('should use custom component name', () => {
+    const result = resolveExpressiveCodeConfig({
+      component: 'CustomCode',
+    });
+
+    expect(result).toEqual({
+      component: 'CustomCode',
+      moduleId: EXPRESSIVE_CODE_MODULE,
+    });
+  });
+
+  it('should use custom module path', () => {
+    const result = resolveExpressiveCodeConfig({
+      module: 'my-custom-module',
+    });
+
+    expect(result).toEqual({
+      component: EXPRESSIVE_CODE_COMPONENT,
+      moduleId: 'my-custom-module',
+    });
+  });
+
+  it('should use both custom component and module', () => {
+    const result = resolveExpressiveCodeConfig({
+      component: 'MyCode',
+      module: 'my-module',
+    });
+
+    expect(result).toEqual({
+      component: 'MyCode',
+      moduleId: 'my-module',
+    });
+  });
+
+  it('should ignore empty string component', () => {
+    const result = resolveExpressiveCodeConfig({
+      component: '',
+    });
+
+    expect(result?.component).toBe(EXPRESSIVE_CODE_COMPONENT);
+  });
+
+  it('should ignore empty string module', () => {
+    const result = resolveExpressiveCodeConfig({
+      module: '',
+    });
+
+    expect(result?.moduleId).toBe(EXPRESSIVE_CODE_MODULE);
+  });
+});
+
+describe('resolveStarlightConfig', () => {
+  it('should return null for falsy values', () => {
+    expect(resolveStarlightConfig(null)).toBe(null);
+    expect(resolveStarlightConfig(undefined)).toBe(null);
+    expect(resolveStarlightConfig(false)).toBe(null);
+  });
+
+  it('should return default config for true', () => {
+    const result = resolveStarlightConfig(true);
+
+    expect(result).toEqual({
+      components: STARLIGHT_COMPONENTS,
+      moduleId: STARLIGHT_COMPONENTS_MODULE,
+    });
+  });
+
+  it('should use defaults for empty object', () => {
+    const result = resolveStarlightConfig({});
+
+    expect(result).toEqual({
+      components: STARLIGHT_COMPONENTS,
+      moduleId: STARLIGHT_COMPONENTS_MODULE,
+    });
+  });
+
+  it('should use custom components array', () => {
+    const customComponents = ['Aside', 'Tabs'];
+    const result = resolveStarlightConfig({
+      components: customComponents,
+    });
+
+    expect(result).toEqual({
+      components: customComponents,
+      moduleId: STARLIGHT_COMPONENTS_MODULE,
+    });
+  });
+
+  it('should use custom module path', () => {
+    const result = resolveStarlightConfig({
+      module: 'my-starlight-module',
+    });
+
+    expect(result).toEqual({
+      components: STARLIGHT_COMPONENTS,
+      moduleId: 'my-starlight-module',
+    });
+  });
+
+  it('should use both custom components and module', () => {
+    const customComponents = ['CustomAside'];
+    const result = resolveStarlightConfig({
+      components: customComponents,
+      module: 'custom-module',
+    });
+
+    expect(result).toEqual({
+      components: customComponents,
+      moduleId: 'custom-module',
+    });
+  });
+
+  it('should ignore empty string module', () => {
+    const result = resolveStarlightConfig({
+      module: '',
+    });
+
+    expect(result?.moduleId).toBe(STARLIGHT_COMPONENTS_MODULE);
+  });
+
+  it('should handle empty components array', () => {
+    const result = resolveStarlightConfig({
+      components: [],
+    });
+
+    expect(result?.components).toEqual([]);
+  });
+});
+
+describe('resolveExpressiveCodeConfig with registry', () => {
+  const registry = createRegistry([expressiveCodeLibrary]);
+
+  it('should return default config from registry for true', () => {
+    const result = resolveExpressiveCodeConfig(true, registry);
+
+    expect(result).toEqual({
+      component: 'Code',
+      moduleId: 'astro-expressive-code/components',
+    });
+  });
+
+  it('should use registry defaults for empty object', () => {
+    const result = resolveExpressiveCodeConfig({}, registry);
+
+    expect(result).toEqual({
+      component: 'Code',
+      moduleId: 'astro-expressive-code/components',
+    });
+  });
+
+  it('should allow custom overrides with registry', () => {
+    const result = resolveExpressiveCodeConfig({
+      component: 'CustomCode',
+      module: 'my-module',
+    }, registry);
+
+    expect(result).toEqual({
+      component: 'CustomCode',
+      moduleId: 'my-module',
+    });
+  });
+
+  it('should fall back to constants when registry has no matching components', () => {
+    const emptyRegistry = createRegistry([]);
+    const result = resolveExpressiveCodeConfig(true, emptyRegistry);
+
+    expect(result).toEqual({
+      component: EXPRESSIVE_CODE_COMPONENT,
+      moduleId: EXPRESSIVE_CODE_MODULE,
+    });
+  });
+});
+
+describe('resolveStarlightConfig with registry', () => {
+  const registry = createRegistry([starlightLibrary]);
+
+  it('should return default config from registry for true', () => {
+    const result = resolveStarlightConfig(true, registry);
+
+    expect(result?.moduleId).toBe('@astrojs/starlight/components');
+    expect(result?.components).toContain('Aside');
+    expect(result?.components).toContain('Tabs');
+    expect(result?.components).toContain('TabItem');
+  });
+
+  it('should use registry defaults for empty object', () => {
+    const result = resolveStarlightConfig({}, registry);
+
+    expect(result?.moduleId).toBe('@astrojs/starlight/components');
+    expect((result?.components.length ?? 0) > 0).toBe(true);
+  });
+
+  it('should allow custom overrides with registry', () => {
+    const result = resolveStarlightConfig({
+      components: ['CustomAside'],
+      module: 'my-module',
+    }, registry);
+
+    expect(result).toEqual({
+      components: ['CustomAside'],
+      moduleId: 'my-module',
+    });
+  });
+
+  it('should fall back to constants when registry has no matching components', () => {
+    const emptyRegistry = createRegistry([]);
+    const result = resolveStarlightConfig(true, emptyRegistry);
+
+    expect(result).toEqual({
+      components: STARLIGHT_COMPONENTS,
+      moduleId: STARLIGHT_COMPONENTS_MODULE,
+    });
+  });
+});

package/src/utils/config.ts

@@ -0,0 +1,146 @@
+/**
+ * Configuration resolution utilities
+ * @module utils/config
+ */
+
+import type { Registry } from 'xmdx/registry';
+import { starlightLibrary, expressiveCodeLibrary } from 'xmdx/registry';
+
+/**
+ * Resolved ExpressiveCode configuration.
+ */
+export interface ExpressiveCodeConfig {
+  /** Component name (e.g., "Code" or "ExpressiveCode") */
+  component: string;
+  /** Module to import from */
+  moduleId: string;
+}
+
+/**
+ * ExpressiveCode user configuration input.
+ */
+export interface ExpressiveCodeUserConfig {
+  /** Whether enabled */
+  enabled?: boolean;
+  /** Component name */
+  component?: string;
+  /** Module path */
+  module?: string;
+}
+
+/**
+ * Resolve ExpressiveCode configuration.
+ * Normalizes boolean/object config into consistent object format.
+ *
+ * @example
+ * resolveExpressiveCodeConfig(true)
+ * // => { component: "ExpressiveCode", moduleId: "astro-expressive-code/components" }
+ *
+ * resolveExpressiveCodeConfig({ component: "Code", module: "my-module" })
+ * // => { component: "Code", moduleId: "my-module" }
+ */
+export function resolveExpressiveCodeConfig(
+  config: boolean | ExpressiveCodeUserConfig | null | undefined,
+  registry?: Registry
+): ExpressiveCodeConfig | null {
+  if (!config) return null;
+
+  // Get defaults from registry if available, otherwise use library preset
+  let defaultComponent = expressiveCodeLibrary.components[0]?.name ?? 'Code';
+  let defaultModuleId = expressiveCodeLibrary.defaultModulePath;
+
+  if (registry) {
+    const ecComponents = registry.getComponentsByModule(expressiveCodeLibrary.defaultModulePath);
+    if (ecComponents.length > 0 && ecComponents[0]) {
+      defaultComponent = ecComponents[0].name;
+      defaultModuleId = ecComponents[0].modulePath;
+    }
+  }
+
+  if (config === true) {
+    return {
+      component: defaultComponent,
+      moduleId: defaultModuleId,
+    };
+  }
+  if (typeof config === 'object') {
+    const component =
+      typeof config.component === 'string' && config.component.length > 0
+        ? config.component
+        : defaultComponent;
+    const moduleId =
+      typeof config.module === 'string' && config.module.length > 0
+        ? config.module
+        : defaultModuleId;
+    return { component, moduleId };
+  }
+  return null;
+}
+
+/**
+ * Resolved Starlight configuration.
+ */
+export interface StarlightConfig {
+  /** Component names to inject */
+  components: string[];
+  /** Module to import from */
+  moduleId: string;
+}
+
+/**
+ * Starlight user configuration input.
+ */
+export interface StarlightUserConfig {
+  /** Component names */
+  components?: string[];
+  /** Module path */
+  module?: string;
+}
+
+/**
+ * Resolve Starlight configuration.
+ * Normalizes boolean/object config into consistent object format.
+ *
+ * @example
+ * resolveStarlightConfig(true)
+ * // => { components: ["Aside", "Tabs", ...], moduleId: "@astrojs/starlight/components" }
+ *
+ * resolveStarlightConfig({ components: ["Aside"], module: "my-module" })
+ * // => { components: ["Aside"], moduleId: "my-module" }
+ */
+export function resolveStarlightConfig(
+  config: boolean | StarlightUserConfig | null | undefined,
+  registry?: Registry
+): StarlightConfig | null {
+  if (!config) return null;
+
+  // Get defaults from registry if available, otherwise use library preset
+  let defaultComponents = starlightLibrary.components.map((c) => c.name);
+  let defaultModuleId = starlightLibrary.defaultModulePath;
+
+  if (registry) {
+    const slComponents = registry.getComponentsByModule(starlightLibrary.defaultModulePath);
+    if (slComponents.length > 0 && slComponents[0]) {
+      defaultComponents = slComponents.map((c) => c.name);
+      defaultModuleId = slComponents[0].modulePath;
+    }
+  }
+
+  if (config === true) {
+    return {
+      components: defaultComponents,
+      moduleId: defaultModuleId,
+    };
+  }
+  if (typeof config === 'object') {
+    const components = Array.isArray(config.components)
+      ? config.components
+      : defaultComponents;
+    const moduleId =
+      typeof config.module === 'string' && config.module.length > 0
+        ? config.module
+        : defaultModuleId;
+    return { components, moduleId };
+  }
+  return null;
+}

package/src/utils/frontmatter.ts

@@ -0,0 +1,33 @@
+/**
+ * Frontmatter detection and stripping utilities.
+ * @module utils/frontmatter
+ */
+
+/**
+ * Robust frontmatter regex that handles:
+ * - Optional BOM at file start
+ * - Optional leading blank lines
+ * - Trailing spaces after `---`
+ * - Both `---` and `...` as closing markers (YAML spec)
+ */
+const FRONTMATTER_REGEX =
+  /^\uFEFF?(?:\s*\r?\n)*---[ \t]*\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/;
+
+/**
+ * Strip frontmatter from source, returning content only.
+ * If no frontmatter found, returns the original source.
+ */
+export function stripFrontmatter(source: string): string {
+  const match = source.match(FRONTMATTER_REGEX);
+  if (!match) return source;
+  return source.slice(match[0].length);
+}
+
+/**
+ * Get the byte length of frontmatter (including delimiters).
+ * Returns 0 if no frontmatter found.
+ */
+export function getFrontmatterLength(source: string): number {
+  const match = source.match(FRONTMATTER_REGEX);
+  return match ? match[0].length : 0;
+}