@mintlify/astro 0.1.3 → 0.1.4

package/README.md

@@ -39,13 +39,13 @@ import { components } from '@mintlify/astro/components';
 - `./docs/docs.json`
 - `./docs/**/*.mdx`
 - `./docs/snippets/*` (optional)
-- assets like `./docs/images`, `./docs/logo`, `./docs/favicon.*` (optional)
+- supported static assets anywhere in `./docs/**` (`.png`, `.jpg`, `.jpeg`, `.gif`, `.webp`, `.svg`, `.ico`, `.mp4`, `.webm`, `.mp3`, `.wav`, `.css`, `.woff`, `.woff2`, `.ttf`, `.eot`)
 
 At build setup time, the integration generates:
 
-- `.mintlify/docs/**/*`
-- `.mintlify/components/**/*`
+- `.mintlify/docs/**/*` (synced page content)
+- `.mintlify/components/**/*` (extracted React components)
+- `.mintlify/static/**/*` (static assets from docs)
 - `.mintlify/generated/favicons.json` (when favicon is configured)
 
 These directories are generated build artifacts and should not be edited manually.
-

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { AstroIntegration } from 'astro';
-export type { DocsConfig, NavigationConfig, Favicons } from './types.js';
+export type { DocsConfig, NavigationConfig } from './types.js';
 export interface MintlifyOptions {
     docsDir?: string;
 }

package/dist/index.js

@@ -1,3 +1,4 @@
+import { cp } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getAllPathsInDocsNav } from '@mintlify/common';
@@ -8,43 +9,33 @@ import { loadAllSnippets } from './utils/load-all-snippets.js';
 import { initLogger } from './utils/logger.js';
 import { readDocsConfig } from './utils/read-docs-config.js';
 import { readPageContent } from './utils/read-page-content.js';
+import { createStaticAssetMiddleware } from './utils/serve-docs-assets.js';
 import { writePageContent } from './utils/write-page-content.js';
-import { writeFaviconsManifest } from './utils/write-favicons-manifest.js';
 export function mintlify(options) {
+    let docsDir;
+    let staticDir;
     return {
         name: '@mintlify/astro',
         hooks: {
             'astro:config:setup': async ({ config: astroConfig, logger }) => {
                 initLogger(logger);
                 const rootDir = fileURLToPath(astroConfig.root);
-                const publicDir = fileURLToPath(astroConfig.publicDir);
                 const contentDir = join(rootDir, '.mintlify', 'docs');
                 const componentsDir = join(rootDir, '.mintlify', 'components');
-                const docsDir = resolve(rootDir, options?.docsDir ?? './docs');
+                staticDir = join(rootDir, '.mintlify', 'static');
+                docsDir = resolve(rootDir, options?.docsDir ?? './docs');
                 await Promise.all([
                     clearContentDirectory(contentDir),
                     clearContentDirectory(componentsDir),
+                    clearContentDirectory(staticDir),
                 ]);
-                await copyAssets(docsDir, publicDir);
+                const assetCount = await copyAssets(docsDir, staticDir);
+                logger.info(`Copied ${assetCount} static assets`);
                 const snippets = await loadAllSnippets(docsDir);
                 logger.info(`Loaded ${snippets.length} snippet files`);
                 const userComponents = await findUserComponents(docsDir);
                 const docsConfig = await readDocsConfig(docsDir);
                 const pagePaths = getAllPathsInDocsNav(docsConfig.navigation);
-                if (docsConfig.favicon) {
-                    const faviconHref = typeof docsConfig.favicon === 'string'
-                        ? docsConfig.favicon
-                        : docsConfig.favicon.light;
-                    await writeFaviconsManifest(rootDir, {
-                        icons: [
-                            {
-                                rel: 'icon',
-                                type: 'image/svg+xml',
-                                href: faviconHref,
-                            },
-                        ],
-                    });
-                }
                 logger.info(`Found ${pagePaths.length} pages to sync`);
                 await Promise.all(pagePaths.map(async (pagePath) => {
                     try {
@@ -64,6 +55,13 @@ export function mintlify(options) {
                 }));
                 logger.info(`Synced ${pagePaths.length} pages`);
             },
+            'astro:server:setup': ({ server }) => {
+                server.middlewares.use(createStaticAssetMiddleware(staticDir));
+            },
+            'astro:build:done': async ({ dir }) => {
+                const outputDir = fileURLToPath(dir);
+                await cp(staticDir, outputDir, { recursive: true });
+            },
         },
     };
 }

package/dist/types.d.ts

@@ -1,12 +1 @@
 export type { DocsConfig, NavigationConfig } from '@mintlify/validation';
-export interface FaviconIcon {
-    rel: string;
-    sizes?: string;
-    type: string;
-    href: string;
-    media?: string;
-}
-export interface Favicons {
-    icons: FaviconIcon[];
-    browserconfig?: string;
-}

package/dist/utils/copy-assets.d.ts

@@ -1 +1 @@
-export declare function copyAssets(docsDir: string, publicDir: string): Promise<void>;
+export declare function copyAssets(docsDir: string, outputDir: string): Promise<number>;

package/dist/utils/copy-assets.js

@@ -1,14 +1,6 @@
-import { cp, stat } from 'node:fs/promises';
+import { cp, mkdir, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-async function exists(path) {
-    try {
-        await stat(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+import { isSupportedStaticAsset } from './static-assets.js';
 async function isDirectory(path) {
     try {
         const stats = await stat(path);
@@ -18,19 +10,21 @@ async function isDirectory(path) {
         return false;
     }
 }
-async function copyDirectoryIfExists(source, dest) {
-    if (!(await isDirectory(source)))
-        return;
-    await cp(source, dest, { recursive: true });
-}
-async function copyFileIfExists(source, dest) {
-    if (!(await exists(source)))
-        return;
-    await cp(source, dest);
-}
-export async function copyAssets(docsDir, publicDir) {
-    await copyDirectoryIfExists(join(docsDir, 'images'), join(publicDir, 'images'));
-    await copyDirectoryIfExists(join(docsDir, 'logo'), join(publicDir, 'logo'));
-    await copyFileIfExists(join(docsDir, 'favicon.svg'), join(publicDir, 'favicon.svg'));
-    await copyFileIfExists(join(docsDir, 'favicon.ico'), join(publicDir, 'favicon.ico'));
+export async function copyAssets(docsDir, outputDir) {
+    if (!(await isDirectory(docsDir)))
+        return 0;
+    let count = 0;
+    const copyDirectory = async (sourceDir, targetDir) => {
+        const entries = await readdir(sourceDir, { withFileTypes: true });
+        const files = entries.filter((e) => e.isFile() && isSupportedStaticAsset(e.name));
+        const subdirs = entries.filter((e) => e.isDirectory());
+        if (files.length > 0) {
+            await mkdir(targetDir, { recursive: true });
+            await Promise.all(files.map((entry) => cp(join(sourceDir, entry.name), join(targetDir, entry.name))));
+            count += files.length;
+        }
+        await Promise.all(subdirs.map((entry) => copyDirectory(join(sourceDir, entry.name), join(targetDir, entry.name))));
+    };
+    await copyDirectory(docsDir, outputDir);
+    return count;
 }

package/dist/utils/rewrite-asset-paths.d.ts

@@ -0,0 +1 @@
+export declare function rewriteAssetPaths(content: string, filename: string): string;

package/dist/utils/rewrite-asset-paths.js

@@ -0,0 +1,76 @@
+import { getAST, stringifyTree } from '@mintlify/common';
+import { posix } from 'node:path';
+import { visit } from 'unist-util-visit';
+import { hasSupportedStaticAssetExtension } from './static-asset-utils.js';
+const MINTLIFY_ASSET_PREFIX = '/_mintlify';
+function isMdxJsxAttribute(attr) {
+    return (typeof attr === 'object' &&
+        attr !== null &&
+        'type' in attr &&
+        attr.type === 'mdxJsxAttribute');
+}
+function splitPathAndSuffix(url) {
+    const queryIndex = url.indexOf('?');
+    const hashIndex = url.indexOf('#');
+    let splitIndex = -1;
+    if (queryIndex === -1) {
+        splitIndex = hashIndex;
+    }
+    else if (hashIndex === -1) {
+        splitIndex = queryIndex;
+    }
+    else {
+        splitIndex = Math.min(queryIndex, hashIndex);
+    }
+    if (splitIndex === -1) {
+        return { pathname: url, suffix: '' };
+    }
+    return {
+        pathname: url.slice(0, splitIndex),
+        suffix: url.slice(splitIndex),
+    };
+}
+function rewriteRootAssetUrl(url) {
+    if (!url.startsWith('/') ||
+        url.startsWith('//') ||
+        url === MINTLIFY_ASSET_PREFIX ||
+        url.startsWith(`${MINTLIFY_ASSET_PREFIX}/`)) {
+        return url;
+    }
+    const { pathname, suffix } = splitPathAndSuffix(url);
+    if (hasSupportedStaticAssetExtension(pathname)) {
+        return `${posix.join(MINTLIFY_ASSET_PREFIX, pathname)}${suffix}`;
+    }
+    return url;
+}
+function rewriteJsxAttributes(node) {
+    if (!node.attributes)
+        return;
+    for (const attr of node.attributes) {
+        if (!isMdxJsxAttribute(attr))
+            continue;
+        if (typeof attr.value !== 'string')
+            continue;
+        if (attr.name !== 'src' && attr.name !== 'href')
+            continue;
+        attr.value = rewriteRootAssetUrl(attr.value);
+    }
+}
+export function rewriteAssetPaths(content, filename) {
+    const tree = getAST(content, filename);
+    visit(tree, 'image', (node) => {
+        node.url = rewriteRootAssetUrl(node.url);
+    });
+    visit(tree, 'link', (node) => {
+        node.url = rewriteRootAssetUrl(node.url);
+    });
+    visit(tree, 'definition', (node) => {
+        node.url = rewriteRootAssetUrl(node.url);
+    });
+    visit(tree, (node) => {
+        if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+            rewriteJsxAttributes(node);
+        }
+    });
+    return stringifyTree(tree);
+}

package/dist/utils/serve-docs-assets.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function createStaticAssetMiddleware(staticDir: string): (req: IncomingMessage, res: ServerResponse, next: () => void) => void;

package/dist/utils/serve-docs-assets.js

@@ -0,0 +1,41 @@
+import { readFile, stat } from 'node:fs/promises';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { getMimeType, isSupportedStaticAsset } from './static-assets.js';
+export function createStaticAssetMiddleware(staticDir) {
+    const normalizedDir = resolve(staticDir);
+    return async (req, res, next) => {
+        const url = req.url;
+        if (!url)
+            return next();
+        let pathname;
+        try {
+            pathname = decodeURIComponent(new URL(url, 'http://localhost').pathname);
+        }
+        catch {
+            return next();
+        }
+        const relativePath = pathname.startsWith('/') ? pathname.slice(1) : pathname;
+        if (!relativePath)
+            return next();
+        if (!isSupportedStaticAsset(relativePath))
+            return next();
+        const filePath = resolve(normalizedDir, relativePath);
+        const relativeToRoot = relative(normalizedDir, filePath);
+        if (relativeToRoot.startsWith('..') || isAbsolute(relativeToRoot))
+            return next();
+        try {
+            const stats = await stat(filePath);
+            if (!stats.isFile())
+                return next();
+            const content = await readFile(filePath);
+            const mimeType = getMimeType(pathname);
+            if (mimeType) {
+                res.setHeader('Content-Type', mimeType);
+            }
+            res.end(content);
+        }
+        catch {
+            next();
+        }
+    };
+}

package/dist/utils/static-asset-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function hasSupportedStaticAssetExtension(pathname: string): boolean;
+export declare function getMimeType(pathname: string): string | undefined;

package/dist/utils/static-asset-utils.js

@@ -0,0 +1,47 @@
+import { posix } from 'node:path';
+const SUPPORTED_STATIC_ASSET_EXTENSIONS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.svg',
+    '.ico',
+    '.mp4',
+    '.webm',
+    '.mp3',
+    '.wav',
+    '.css',
+    '.js',
+    '.woff',
+    '.woff2',
+    '.ttf',
+    '.eot',
+]);
+const MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+};
+export function hasSupportedStaticAssetExtension(pathname) {
+    const extension = posix.extname(pathname).toLowerCase();
+    return SUPPORTED_STATIC_ASSET_EXTENSIONS.has(extension);
+}
+export function getMimeType(pathname) {
+    const extension = posix.extname(pathname).toLowerCase();
+    return MIME_TYPES[extension];
+}

package/dist/utils/static-assets.d.ts

@@ -0,0 +1,2 @@
+export declare function isSupportedStaticAsset(pathname: string): boolean;
+export declare function getMimeType(pathname: string): string | undefined;

package/dist/utils/static-assets.js

@@ -0,0 +1,27 @@
+import { posix } from 'node:path';
+const SUPPORTED_STATIC_ASSETS = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.css': 'text/css',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+};
+export function isSupportedStaticAsset(pathname) {
+    const extension = posix.extname(pathname).toLowerCase();
+    return extension in SUPPORTED_STATIC_ASSETS;
+}
+export function getMimeType(pathname) {
+    const extension = posix.extname(pathname).toLowerCase();
+    return SUPPORTED_STATIC_ASSETS[extension];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/astro",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Mintlify integration for Astro",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",