@amamo/mdx 0.1.1

package/dist/config.d.ts

@@ -0,0 +1,123 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type ManifestField = string | {
+    default?: JsonValue;
+    from: string;
+    transform?: 'exists' | 'mediaUrl' | 'sha256';
+};
+export interface ILocaleConfig {
+    default: string;
+    names: string[];
+}
+export interface ISlugConfig {
+    indexNames?: string[];
+}
+export interface ICollectionConfig {
+    directory: string;
+    extensions?: string[];
+    locales?: ILocaleConfig;
+    schema: {
+        [key: string]: JsonValue;
+    };
+    sensitive?: string[];
+    slug?: ISlugConfig;
+}
+export interface IMdxConfig {
+    gfm?: boolean;
+    hardBreaks?: boolean;
+    jsxImportSource?: string;
+    providerImportSource?: string;
+}
+export interface IHighlightConfig {
+    colorReplacements?: Record<string, string>;
+    engine?: 'javascript' | 'oniguruma';
+    languages?: 'auto' | string[];
+    provider: 'shiki';
+    themes: {
+        dark: string;
+        light: string;
+    };
+    unknownLanguage?: 'error' | 'plain';
+}
+export interface IMediaConfig {
+    attributes?: Record<string, string[]>;
+    missing?: 'error' | 'warn';
+}
+export interface IDerivedConfig {
+    lastModified?: boolean;
+    readingTime?: boolean;
+}
+export interface IManifestConfig {
+    collections?: string[];
+    fields: Record<string, ManifestField>;
+    key?: string;
+    output: string;
+    sort?: Array<{
+        direction?: 'asc' | 'desc';
+        field: string;
+    }>;
+}
+export interface ICacheConfig {
+    directory?: string;
+}
+export interface IAmamoMdxConfig {
+    cache?: false | ICacheConfig;
+    collections: Record<string, ICollectionConfig>;
+    derived?: IDerivedConfig;
+    generatedDirectory?: string;
+    highlight?: false | IHighlightConfig;
+    manifests?: Record<string, IManifestConfig>;
+    mdx?: IMdxConfig;
+    media?: false | IMediaConfig;
+    root?: string;
+}
+export interface INormalizedCollectionConfig {
+    directory: string;
+    extensions: string[];
+    locales?: ILocaleConfig;
+    schema: {
+        [key: string]: JsonValue;
+    };
+    sensitive: string[];
+    slug: {
+        indexNames: string[];
+    };
+}
+export interface INormalizedHighlightConfig {
+    colorReplacements: Record<string, string>;
+    enabled: boolean;
+    engine: 'javascript' | 'oniguruma';
+    languages: 'auto' | string[];
+    provider: 'shiki';
+    themes: {
+        dark: string;
+        light: string;
+    };
+    unknownLanguage: 'error' | 'plain';
+}
+export interface INormalizedMediaConfig {
+    attributes: Record<string, string[]>;
+    enabled: boolean;
+    missing: 'error' | 'warn';
+}
+export interface INormalizedManifestConfig extends Omit<IManifestConfig, 'collections' | 'output'> {
+    collections: string[];
+    output: string;
+}
+export interface INormalizedConfig {
+    cache: {
+        directory: string;
+        enabled: boolean;
+    };
+    collections: Record<string, INormalizedCollectionConfig>;
+    derived: Required<IDerivedConfig>;
+    generatedDirectory: string;
+    highlight: INormalizedHighlightConfig;
+    manifests: Record<string, INormalizedManifestConfig>;
+    mdx: Required<IMdxConfig>;
+    media: INormalizedMediaConfig;
+    root: string;
+}
+export declare function defineConfig<T extends IAmamoMdxConfig>(config: T): T;
+export declare function normalizeConfig(config: IAmamoMdxConfig): INormalizedConfig;

package/dist/config.js

@@ -0,0 +1,134 @@
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+const DEFAULT_MEDIA_ATTRIBUTES = {
+    audio: ['src'],
+    embed: ['src'],
+    img: ['src', 'srcset'],
+    object: ['data'],
+    source: ['src', 'srcset'],
+    track: ['src'],
+    video: ['src', 'poster'],
+};
+function notSerializable(location, reason) {
+    throw new TypeError(`AMAMO_CONFIG_NOT_SERIALIZABLE: ${location} ${reason}`);
+}
+function assertPlainData(value, location, active) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            notSerializable(location, 'must be a finite number');
+        return;
+    }
+    if (typeof value !== 'object')
+        notSerializable(location, `contains ${typeof value}`);
+    if (active.has(value))
+        notSerializable(location, 'contains a cycle');
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+        notSerializable(location, 'must be a plain object');
+    }
+    active.add(value);
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key === 'symbol')
+            notSerializable(location, 'contains a symbol key');
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !('value' in descriptor))
+            notSerializable(`${location}.${key}`, 'contains an accessor');
+        assertPlainData(descriptor.value, `${location}.${key}`, active);
+    }
+    active.delete(value);
+}
+function requireNonEmpty(value, location) {
+    if (value.length === 0)
+        throw new TypeError(`AMAMO_CONFIG_INVALID: ${location} must not be empty`);
+    return value;
+}
+function normalizeCollection(root, name, config) {
+    const extensions = config.extensions ?? ['.mdx'];
+    if (extensions.length === 0 || extensions.some((extension) => !extension.startsWith('.'))) {
+        throw new TypeError(`AMAMO_CONFIG_INVALID: collections.${name}.extensions must contain dotted extensions`);
+    }
+    if (config.locales && !config.locales.names.includes(config.locales.default)) {
+        throw new TypeError(`AMAMO_CONFIG_INVALID: collections.${name}.locales.default must be listed in names`);
+    }
+    const directory = path.resolve(root, requireNonEmpty(config.directory, `collections.${name}.directory`));
+    return {
+        directory: existsSync(directory) ? realpathSync.native(directory) : directory,
+        extensions: [...extensions],
+        locales: config.locales
+            ? { default: config.locales.default, names: [...config.locales.names] }
+            : undefined,
+        schema: config.schema,
+        sensitive: [...(config.sensitive ?? [])],
+        slug: { indexNames: [...(config.slug?.indexNames ?? ['index', 'page'])] },
+    };
+}
+export function defineConfig(config) {
+    return config;
+}
+export function normalizeConfig(config) {
+    assertPlainData(config, 'config', new WeakSet());
+    if (!config.collections || Object.keys(config.collections).length === 0) {
+        throw new TypeError('AMAMO_CONFIG_INVALID: collections must not be empty');
+    }
+    const resolvedRoot = path.resolve(config.root ?? process.cwd());
+    const root = existsSync(resolvedRoot) ? realpathSync.native(resolvedRoot) : resolvedRoot;
+    const generatedDirectory = path.resolve(root, config.generatedDirectory ?? '.amamo-mdx');
+    const collectionNames = Object.keys(config.collections);
+    const collections = Object.fromEntries(Object.entries(config.collections).map(([name, collection]) => [
+        requireNonEmpty(name, 'collection name'),
+        normalizeCollection(root, name, collection),
+    ]));
+    const manifests = Object.fromEntries(Object.entries(config.manifests ?? {}).map(([name, manifest]) => [
+        requireNonEmpty(name, 'manifest name'),
+        {
+            ...manifest,
+            collections: [...(manifest.collections ?? collectionNames)],
+            output: path.resolve(root, manifest.output),
+        },
+    ]));
+    const highlight = config.highlight === false ? undefined : config.highlight;
+    const media = config.media === false ? undefined : config.media;
+    return {
+        cache: {
+            directory: path.resolve(root, config.cache === false
+                ? '.amamo-mdx/cache'
+                : (config.cache?.directory ?? '.amamo-mdx/cache')),
+            enabled: config.cache !== false,
+        },
+        collections,
+        derived: {
+            lastModified: config.derived?.lastModified ?? false,
+            readingTime: config.derived?.readingTime ?? false,
+        },
+        generatedDirectory,
+        highlight: {
+            colorReplacements: { ...highlight?.colorReplacements },
+            enabled: config.highlight !== false,
+            engine: highlight?.engine ?? 'oniguruma',
+            languages: highlight?.languages === 'auto' || highlight?.languages === undefined
+                ? 'auto'
+                : [...highlight.languages],
+            provider: 'shiki',
+            themes: highlight?.themes ?? { light: 'vitesse-light', dark: 'vitesse-dark' },
+            unknownLanguage: highlight?.unknownLanguage ?? 'error',
+        },
+        manifests,
+        mdx: {
+            gfm: config.mdx?.gfm ?? true,
+            hardBreaks: config.mdx?.hardBreaks ?? false,
+            jsxImportSource: config.mdx?.jsxImportSource ?? 'react',
+            providerImportSource: config.mdx?.providerImportSource ?? '',
+        },
+        media: {
+            attributes: Object.fromEntries(Object.entries(media?.attributes ?? DEFAULT_MEDIA_ATTRIBUTES).map(([tag, attributes]) => [
+                tag,
+                [...attributes],
+            ])),
+            enabled: config.media !== false,
+            missing: media?.missing ?? 'error',
+        },
+        root,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { IAmamoMdxConfig, ICacheConfig, ICollectionConfig, IDerivedConfig, IHighlightConfig, ILocaleConfig, IManifestConfig, IMdxConfig, IMediaConfig, INormalizedConfig, JsonValue, ManifestField, } from './config.js';
+export { defineConfig, normalizeConfig } from './config.js';
+export type { IBuildResult, ICompiler, ITransformResult } from './compiler.js';
+export { createCompiler } from './compiler.js';
+export type { IDiagnostic } from './native.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { defineConfig, normalizeConfig } from './config.js';
+export { createCompiler } from './compiler.js';

package/dist/native.d.ts

@@ -0,0 +1,71 @@
+import type { INormalizedConfig, JsonValue } from './config.js';
+export interface ISourcePoint {
+    column: number;
+    line: number;
+    offset: number;
+}
+export interface ISourceRange {
+    end: ISourcePoint;
+    start: ISourcePoint;
+}
+export interface IDiagnostic {
+    code: string;
+    file?: string;
+    hint?: string;
+    message: string;
+    range?: ISourceRange;
+    severity: 'error' | 'warning';
+}
+export interface INativeDocumentInput {
+    collection: string;
+    file: string;
+    key: string;
+    locale?: string;
+    modifiedAt?: string;
+    slug?: string;
+    source: string;
+}
+export interface ICodeBlock {
+    blockId: number;
+    code: string;
+    documentId: string;
+    lang: string | null;
+    meta: string | null;
+}
+export interface IHighlightedCodeBlock {
+    blockId: number;
+    documentId: string;
+    hast: JsonValue;
+}
+export interface IDocumentRecord {
+    cacheKey: string;
+    cached: boolean;
+    collection: string;
+    dependencies: string[];
+    derived: Record<string, JsonValue>;
+    diagnostics: IDiagnostic[];
+    file: string;
+    frontmatter: Record<string, JsonValue>;
+    hash: string;
+    key: string;
+    locale?: string;
+    module: string;
+    projections: Record<string, JsonValue>;
+    slug?: string;
+}
+export interface IRenderedManifest {
+    contents: string;
+    path: string;
+}
+export interface IPreparedNativeBatch {
+    codeBlocks: ICodeBlock[];
+    finish(highlights: IHighlightedCodeBlock[]): IDocumentRecord[];
+}
+export declare class AmamoMdxError extends Error {
+    readonly diagnostics: IDiagnostic[];
+    constructor(diagnostics: IDiagnostic[]);
+}
+export declare function configurationFingerprint(config: INormalizedConfig): string;
+export declare function prepareNativeBatch(config: INormalizedConfig, inputs: INativeDocumentInput[]): IPreparedNativeBatch;
+export declare function pruneNativeCache(cacheDirectory: string, keepKeys: string[]): number;
+export declare function renderNativeManifests(config: INormalizedConfig, records: IDocumentRecord[]): IRenderedManifest[];

package/dist/native.js

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+export class AmamoMdxError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        super(diagnostics.map((diagnostic) => diagnostic.message).join('\n'));
+        this.name = 'AmamoMdxError';
+        this.diagnostics = diagnostics;
+    }
+}
+const require = createRequire(import.meta.url);
+const packageVersion = require('../package.json').version;
+const shikiVersion = require('shiki/package.json').version;
+function nativeConfigJson(config) {
+    return JSON.stringify({
+        ...config,
+        _runtime: { packageVersion, shikiVersion },
+    });
+}
+export function configurationFingerprint(config) {
+    return createHash('sha256').update(nativeConfigJson(config)).digest('hex');
+}
+function loadBinding() {
+    return require('../native.cjs');
+}
+function mapNativeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const marker = 'AMAMO_MDX_DIAGNOSTICS:';
+    const index = message.indexOf(marker);
+    if (index === -1)
+        throw error;
+    throw new AmamoMdxError(JSON.parse(message.slice(index + marker.length)));
+}
+export function prepareNativeBatch(config, inputs) {
+    try {
+        const batch = loadBinding().prepareBatch(nativeConfigJson(config), JSON.stringify(inputs));
+        return {
+            codeBlocks: JSON.parse(batch.codeBlocksJson),
+            finish(highlights) {
+                try {
+                    return JSON.parse(batch.finish(JSON.stringify(highlights)));
+                }
+                catch (error) {
+                    return mapNativeError(error);
+                }
+            },
+        };
+    }
+    catch (error) {
+        return mapNativeError(error);
+    }
+}
+export function pruneNativeCache(cacheDirectory, keepKeys) {
+    try {
+        return loadBinding().pruneCache(cacheDirectory, JSON.stringify(keepKeys));
+    }
+    catch (error) {
+        return mapNativeError(error);
+    }
+}
+export function renderNativeManifests(config, records) {
+    try {
+        return JSON.parse(loadBinding().renderManifests(nativeConfigJson(config), JSON.stringify(records)));
+    }
+    catch (error) {
+        return mapNativeError(error);
+    }
+}

package/dist/next-loader.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+function nextLoader(_source) {
+    return readCompiledModule(this);
+}
+async function readCompiledModule(context) {
+    const options = context.getOptions();
+    try {
+        const index = JSON.parse(await (0, promises_1.readFile)(options.indexFile, 'utf8'));
+        const resource = await (0, promises_1.realpath)(node_path_1.default.resolve(context.resourcePath));
+        const cacheKey = index.documents?.[resource]?.cacheKey;
+        if (index.configFingerprint !== options.configFingerprint ||
+            typeof index.cacheDirectory !== 'string' ||
+            typeof cacheKey !== 'string' ||
+            !/^[a-f0-9]{64}$/.test(cacheKey)) {
+            throw new Error('index entry does not match this build');
+        }
+        const cacheFile = node_path_1.default.join(index.cacheDirectory, cacheKey.slice(0, 2), `${cacheKey}.json`);
+        const record = JSON.parse(await (0, promises_1.readFile)(cacheFile, 'utf8'));
+        if (record.cacheKey !== cacheKey || typeof record.module !== 'string') {
+            throw new Error('cache record does not match its index entry');
+        }
+        return record.module;
+    }
+    catch (error) {
+        throw new Error(`AMAMO_NEXT_CACHE_MISS: ${context.resourcePath}; rerun the coordinated amamo-mdx build`, { cause: error });
+    }
+}
+module.exports = nextLoader;

package/dist/next.d.ts

@@ -0,0 +1,8 @@
+import type { NextConfig } from 'next';
+import type { IAmamoMdxConfig } from './config.js';
+export interface IAmamoNextConfigContext {
+    defaultConfig: NextConfig;
+}
+export type AmamoNextConfigInput = NextConfig | Promise<NextConfig> | ((phase: string, context: IAmamoNextConfigContext) => NextConfig | Promise<NextConfig>);
+export type AmamoNextConfig = (phase: string, context: IAmamoNextConfigContext) => Promise<NextConfig>;
+export declare function withAmamoMdx(config: IAmamoMdxConfig): (nextConfig?: AmamoNextConfigInput) => AmamoNextConfig;

package/dist/next.js

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from 'next/constants.js';
+import { normalizeConfig } from './config.js';
+import { createAdapterCompiler } from './compiler.js';
+import { configurationFingerprint } from './native.js';
+export function withAmamoMdx(config) {
+    const normalized = normalizeConfig(config);
+    const loader = fileURLToPath(new URL('./next-loader.cjs', import.meta.url));
+    const loaderOptions = {
+        configFingerprint: configurationFingerprint(normalized),
+        indexFile: path.join(normalized.generatedDirectory, 'index.json'),
+    };
+    let compilerPromise;
+    let buildPromise;
+    let watching = false;
+    function compiler() {
+        compilerPromise ??= createAdapterCompiler(config);
+        return compilerPromise;
+    }
+    async function prepare(phase) {
+        if (phase !== PHASE_DEVELOPMENT_SERVER && phase !== PHASE_PRODUCTION_BUILD)
+            return;
+        buildPromise ??= compiler().then((instance) => instance.build());
+        await buildPromise;
+        if (phase === PHASE_DEVELOPMENT_SERVER && !watching) {
+            const instance = await compiler();
+            instance.startWatch();
+            watching = true;
+        }
+    }
+    return function applyAmamoMdx(nextConfig = {}) {
+        return async (phase, context) => {
+            const resolved = typeof nextConfig === 'function' ? await nextConfig(phase, context) : await nextConfig;
+            await prepare(phase);
+            const existingWebpack = resolved.webpack;
+            return {
+                ...resolved,
+                turbopack: {
+                    ...resolved.turbopack,
+                    rules: {
+                        ...resolved.turbopack?.rules,
+                        '*.mdx': {
+                            as: '*.js',
+                            loaders: [{ loader, options: loaderOptions }],
+                        },
+                    },
+                },
+                webpack(webpackConfig, webpackContext) {
+                    const configured = existingWebpack
+                        ? existingWebpack(webpackConfig, webpackContext)
+                        : webpackConfig;
+                    configured.module ??= {};
+                    configured.module.rules ??= [];
+                    configured.module.rules.push({
+                        test: /\.mdx$/,
+                        use: [{ loader, options: loaderOptions }],
+                    });
+                    return configured;
+                },
+            };
+        };
+    };
+}

package/dist/shiki.d.ts

@@ -0,0 +1,7 @@
+import type { INormalizedHighlightConfig } from './config.js';
+import type { ICodeBlock, IHighlightedCodeBlock } from './native.js';
+export interface IShikiRenderer {
+    dispose(): void;
+    highlight(blocks: ICodeBlock[]): Promise<IHighlightedCodeBlock[]>;
+}
+export declare function createShikiRenderer(config: INormalizedHighlightConfig): Promise<IShikiRenderer>;

package/dist/shiki.js

@@ -0,0 +1,82 @@
+import { createHighlighterCore } from 'shiki/core';
+import { createJavaScriptRegexEngine } from 'shiki/engine/javascript';
+import { createOnigurumaEngine } from 'shiki/engine/oniguruma';
+import { bundledLanguages, bundledLanguagesAlias } from 'shiki/langs';
+import { bundledThemes } from 'shiki/themes';
+function themeLoader(name) {
+    if (!Object.hasOwn(bundledThemes, name)) {
+        throw new Error(`AMAMO_SHIKI_UNKNOWN_THEME: Unknown bundled Shiki theme \`${name}\``);
+    }
+    return bundledThemes[name];
+}
+function languageLoader(name) {
+    if (Object.hasOwn(bundledLanguages, name)) {
+        return bundledLanguages[name];
+    }
+    if (Object.hasOwn(bundledLanguagesAlias, name)) {
+        return bundledLanguagesAlias[name];
+    }
+    return undefined;
+}
+export async function createShikiRenderer(config) {
+    const engine = config.engine === 'javascript'
+        ? createJavaScriptRegexEngine()
+        : createOnigurumaEngine(import('shiki/wasm'));
+    const highlighter = await createHighlighterCore({
+        engine,
+        langs: [],
+        themes: [themeLoader(config.themes.light), themeLoader(config.themes.dark)],
+    });
+    const loading = new Map();
+    let disposed = false;
+    async function loadLanguage(requested) {
+        if (!requested || requested === 'text' || requested === 'plain' || requested === 'plaintext') {
+            return 'text';
+        }
+        const existing = loading.get(requested);
+        if (existing)
+            return existing;
+        const loader = languageLoader(requested);
+        if (!loader) {
+            if (config.unknownLanguage === 'plain')
+                return 'text';
+            throw new Error(`AMAMO_SHIKI_UNKNOWN_LANGUAGE: Unknown bundled Shiki language \`${requested}\``);
+        }
+        const promise = highlighter.loadLanguage(loader).then(() => requested);
+        loading.set(requested, promise);
+        return promise;
+    }
+    if (config.languages !== 'auto') {
+        await Promise.all(config.languages.map((language) => loadLanguage(language)));
+    }
+    return {
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            highlighter.dispose();
+        },
+        async highlight(blocks) {
+            if (disposed)
+                throw new Error('AMAMO_SHIKI_DISPOSED: Shiki renderer is disposed');
+            const languages = await Promise.all(blocks.map((block) => loadLanguage(block.lang)));
+            return blocks.map((block, index) => {
+                const hast = highlighter.codeToHast(block.code, {
+                    colorReplacements: config.colorReplacements,
+                    defaultColor: false,
+                    lang: languages[index] ?? 'text',
+                    meta: block.meta ? { __raw: block.meta } : undefined,
+                    themes: {
+                        dark: config.themes.dark,
+                        light: config.themes.light,
+                    },
+                });
+                return {
+                    blockId: block.blockId,
+                    documentId: block.documentId,
+                    hast: JSON.parse(JSON.stringify(hast)),
+                };
+            });
+        },
+    };
+}

package/dist/vite.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { IAmamoMdxConfig } from './config.js';
+export declare function amamoMdx(config: IAmamoMdxConfig): Plugin;