vite-plugin-html-pages 1.3.7 → 1.4.1

package/src/page-helper-generator.ts

@@ -1,43 +0,0 @@
-import type { HtPageInfo, RouteParamDefinition } from './types';
-
-function paramsTypeFromDefinitions(
-  paramDefinitions: RouteParamDefinition[],
-): string {
-  if (paramDefinitions.length === 0) {
-    return '{}';
-  }
-
-  const fields = paramDefinitions.map((param) => {
-    if (param.type === 'single') {
-      return `${JSON.stringify(param.name)}: string`;
-    }
-
-    if (param.type === 'catch-all') {
-      return `${JSON.stringify(param.name)}: string[]`;
-    }
-
-    return `${JSON.stringify(param.name)}?: string[]`;
-  });
-
-  return `{ ${fields.join('; ')} }`;
-}
-
-export function generateTypedPageHelper(page: HtPageInfo | undefined): string {
-  const paramsType = page
-    ? paramsTypeFromDefinitions(page.paramDefinitions ?? [])
-    : '{}';
-
-  return `
-export type PageParams = ${paramsType};
-
-export type PageContext = {
-  params: PageParams;
-  data?: unknown;
-  dev: boolean;
-};
-
-export function definePage<T extends (ctx: PageContext) => any>(fn: T): T {
-  return fn;
-}
-`;
-}

package/src/page-index.ts

@@ -1,67 +0,0 @@
-import {
-  compareRoutePriority,
-  expandStaticPaths,
-  fileNameFromRoute,
-} from './route-utils';
-import type { HtPageInfo, HtPageModule, StaticParamRecord } from './types';
-import { PLUGIN_NAME } from './constants';
-export async function buildPageIndex(args: {
-  entries: HtPageInfo[];
-  modulesByEntry: Map<string, HtPageModule>;
-  cleanUrls: boolean;
-}): Promise<HtPageInfo[]> {
-  const { entries, modulesByEntry, cleanUrls } = args;
-  const pages: HtPageInfo[] = [];
-
-  for (const entry of entries) {
-    const mod = modulesByEntry.get(entry.entryPath) ?? {};
-
-    if (entry.dynamic) {
-      const rows =
-        (mod.generateStaticParams
-          ? await mod.generateStaticParams()
-          : []) ?? [];
-
-      pages.push(
-        ...expandStaticPaths(
-          {
-            id: entry.id,
-            entryPath: entry.entryPath,
-            absolutePath: entry.absolutePath,
-            relativePath: entry.relativePath,
-            routePattern: entry.routePattern,
-            dynamic: entry.dynamic,
-            paramNames: entry.paramNames,
-          } as Omit<HtPageInfo, 'routePath' | 'fileName' | 'params'>,
-          Array.isArray(rows) ? rows : [],
-          cleanUrls,
-        ),
-      );
-    } else {
-      pages.push({
-        ...entry,
-        routePath: entry.routePattern,
-        fileName: fileNameFromRoute(entry.routePattern, cleanUrls),
-        params: {},
-      });
-    }
-  }
-
-  pages.sort((a, b) => compareRoutePriority(a.routePattern, b.routePattern));
-
-  const seenRoutes = new Map<string, HtPageInfo>();
-
-  for (const page of pages) {
-    const existing = seenRoutes.get(page.routePath);
-
-    if (existing) {
-      throw new Error(
-        `[${PLUGIN_NAME}] Duplicate route generated: "${page.routePath}" from "${existing.relativePath}" and "${page.relativePath}"`,
-      );
-    }
-
-    seenRoutes.set(page.routePath, page);
-  }
-
-  return pages;
-}

package/src/path-utils.ts

@@ -1,30 +0,0 @@
-import path from 'node:path';
-
-export function toPosix(value: string): string {
-  return value.replace(/\\/g, '/');
-}
-
-export function normalizeFsPath(value: string): string {
-  return path.normalize(value);
-}
-
-export function normalizeRoutePath(value: string): string {
-  const normalized = toPosix(value).replace(/\/+/g, '/');
-  if (!normalized || normalized === '/') return '/';
-  return normalized.startsWith('/') ? normalized : `/${normalized}`;
-}
-
-export function stripPageSuffix(
-  filePath: string,
-  extensions: string[],
-): string {
-  const normalized = toPosix(filePath);
-
-  const match = [...extensions]
-    .sort((a, b) => b.length - a.length)
-    .find((ext) => normalized.endsWith(ext));
-
-  if (!match) return normalized;
-
-  return normalized.slice(0, -match.length);
-}

package/src/plugin.ts

@@ -1,513 +0,0 @@
-import pLimit from 'p-limit';
-import type { Plugin, ViteDevServer } from 'vite';
-
-import { discoverEntryPages } from './discover';
-import { installDevServer } from './dev-server';
-import { createPageModuleLoader, closePageModuleLoader } from './module-loader';
-import { buildPageIndex } from './page-index';
-import { renderPage } from './render-runtime';
-import {
-  buildProcessedStaticAssets,
-  collectStaticAssets,
-  copyStaticAssetSource,
-} from './static-assets';
-import { validateHtmlAssetReferences } from './html-asset-validator';
-import type { HtPageInfo, HtPageModule, HtPagesPluginOptions } from './types';
-import {
-  PLUGIN_NAME,
-  VIRTUAL_BUILD_ENTRY_ID,
-  VIRTUAL_PAGE_HELPER_ID,
-  RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX,
-} from './constants';
-import { generateTypedPageHelper } from './page-helper-generator';
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-let hasWarnedESM = false;
-
-function warnIfNotESM(root: string) {
-  try {
-    const pkgPath = path.join(root, 'package.json');
-
-    if (!fs.existsSync(pkgPath)) return;
-
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-
-    if (pkg.type !== 'module') {
-      console.warn(
-        `[${PLUGIN_NAME}] ⚠️ It is recommended to add "type": "module" to your package.json for optimal performance and to avoid Node ESM warnings.`,
-      );
-    }
-  } catch {
-    // silent — never break build
-  }
-}
-
-function chunkArray<T>(items: T[], size: number): T[][] {
-  const out: T[][] = [];
-  for (let i = 0; i < items.length; i += size) {
-    out.push(items.slice(i, i + size));
-  }
-  return out;
-}
-
-export function htPages(options: HtPagesPluginOptions = {}): Plugin {
-  let root = process.cwd();
-  let server: ViteDevServer | null = null;
-  let devPages: HtPageInfo[] = [];
-  let watcherAttached = false;
-
-  const cleanUrls = options.cleanUrls ?? true;
-  const pagesDir = options.pagesDir ?? 'src';
-  const pageExtensions = options.pageExtensions?.length
-    ? options.pageExtensions
-    : ['.ht.js', '.html.js', '.ht.ts', '.html.ts'];
-
-  function logDebug(enabled: boolean | undefined, ...args: unknown[]) {
-    if (!enabled) return;
-    console.log(`[${PLUGIN_NAME}]`, ...args);
-  }
-
-  async function loadDevPages(): Promise<HtPageInfo[]> {
-    const entries = await discoverEntryPages(root, options);
-    const modulesByEntry = new Map<string, HtPageModule>();
-
-    logDebug(
-      options.debug,
-      'discovered entries',
-      entries.map((e) => e.relativePath),
-    );
-
-    if (!server) return [];
-
-    const loadModule = await createPageModuleLoader({
-      mode: 'dev',
-      root,
-      server,
-    });
-
-    for (const entry of entries) {
-      const mod = await loadModule(entry.entryPath, entry.relativePath);
-      modulesByEntry.set(entry.entryPath, mod);
-    }
-
-    devPages = await buildPageIndex({
-      entries,
-      modulesByEntry,
-      cleanUrls,
-    });
-
-    logDebug(
-      options.debug,
-      'dev pages',
-      devPages.map((p) => `${p.routePath} -> ${p.relativePath}`),
-    );
-
-    return devPages;
-  }
-
-  async function buildPagesPipeline() {
-    const entries = await discoverEntryPages(root, options);
-    const modulesByEntry = new Map<string, HtPageModule>();
-
-    const loadModule = await createPageModuleLoader({
-      mode: 'build',
-      root,
-    });
-
-    for (const entry of entries) {
-      const mod = await loadModule(entry.entryPath, entry.relativePath);
-      modulesByEntry.set(entry.entryPath, mod);
-    }
-
-    const pages = await buildPageIndex({
-      entries,
-      modulesByEntry,
-      cleanUrls,
-    });
-
-    return { entries, modulesByEntry, pages };
-  }
-
-  return {
-    name: PLUGIN_NAME,
-
-    config(userConfig, env) {
-      if (env.command !== 'build') return;
-
-      const hasExplicitInput = userConfig.build?.rollupOptions?.input != null;
-      if (hasExplicitInput) return;
-
-      return {
-        build: {
-          rollupOptions: {
-            input: VIRTUAL_BUILD_ENTRY_ID,
-          },
-        },
-      };
-    },
-
-    resolveId(id, importer) {
-      if (id === VIRTUAL_BUILD_ENTRY_ID) return id;
-    
-      if (id === VIRTUAL_PAGE_HELPER_ID && importer) {
-        return `${RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX}${importer}`;
-      }
-    
-      return null;
-    },
-
-    async load(id) {
-      if (id === VIRTUAL_BUILD_ENTRY_ID) {
-        return 'export default {};';
-      }
-    
-      if (id.startsWith(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX)) {
-        const importer = id.slice(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX.length);
-        const { pages } = await buildPagesPipeline();
-    
-        const normalizedImporter = path.resolve(importer);
-    
-        const page = pages.find(
-          (candidate) => path.resolve(candidate.absolutePath) === normalizedImporter,
-        );
-    
-        return generateTypedPageHelper(page);
-      }
-    
-      return null;
-    },
-
-    configResolved(resolved) {
-      root = options.root ? path.resolve(resolved.root, options.root) : resolved.root;
-    
-      if (!hasWarnedESM) {
-        warnIfNotESM(root);
-        hasWarnedESM = true;
-      }
-    },
-
-    async buildStart() {
-      const entries = await discoverEntryPages(root, options);
-
-      for (const entry of entries) {
-        this.addWatchFile(entry.entryPath);
-      }
-
-      const staticAssets = await collectStaticAssets({
-        root,
-        pagesDir,
-        pageExtensions,
-      });
-
-      for (const asset of staticAssets) {
-        this.addWatchFile(asset.absolutePath);
-      }
-
-      logDebug(
-        options.debug,
-        'static assets',
-        staticAssets.map((asset) => ({
-          kind: asset.kind,
-          input: asset.relativePathFromSrc,
-          output: asset.outputFileName,
-        })),
-      );
-    },
-
-    configureServer(_server) {
-      server = _server;
-    
-      installDevServer({
-        server,
-        root,
-        pagesDir,
-        getPages: async () => {
-          if (devPages.length > 0) return devPages;
-          return loadDevPages();
-        },
-        getEntries: async () => discoverEntryPages(root, options),
-      });
-    
-      if (!watcherAttached) {
-        watcherAttached = true;
-    
-        const reload = async (file: string) => {
-          if (!file.includes(`${path.sep}src${path.sep}`) && !file.includes('/src/')) {
-            return;
-          }
-    
-          logDebug(options.debug, 'file changed', file);
-    
-          await loadDevPages();
-    
-          server?.ws.send({ type: 'full-reload' });
-
-        };
-    
-        server.watcher.on('add', reload);
-        server.watcher.on('change', reload);
-        server.watcher.on('unlink', reload);
-      }
-    
-      loadDevPages().catch((error) => {
-        server?.config.logger.error(
-          `[${PLUGIN_NAME}] loadDevPages failed: ${
-            error instanceof Error ? error.stack ?? error.message : String(error)
-          }`,
-        );
-      });
-    },
-
-    // async handleHotUpdate(ctx) {
-    //   if (!server) return;
-    
-    //   logDebug(options.debug, 'file changed', ctx.file);
-    
-    //   await loadDevPages();
-    
-    //   server.ws.send({
-    //     type: 'full-reload',
-    //   });
-    
-    //   return [];
-    // },
-
-    async generateBundle(_, bundle) {
-      try {
-        const { modulesByEntry, pages } = await buildPagesPipeline();
-
-        const staticAssets = await collectStaticAssets({
-          root,
-          pagesDir,
-          pageExtensions,
-        });
-
-        logDebug(
-          options.debug,
-          'emitting pages',
-          pages.map((p) => p.fileName),
-        );
-
-        logDebug(
-          options.debug,
-          'emitting static assets',
-          staticAssets.map((asset) => ({
-            kind: asset.kind,
-            input: asset.relativePathFromSrc,
-            output: asset.outputFileName,
-          })),
-        );
-
-        const limit = pLimit(options.renderConcurrency ?? 8);
-        const batchSize =
-          options.renderBatchSize ??
-          Math.max(options.renderConcurrency ?? 8, 32);
-
-        const processedOutputs = await buildProcessedStaticAssets({
-          root,
-          pagesDir,
-          assets: staticAssets,
-          minify: true,
-          sourcemap: false,
-        });
-
-        for (const [fileName, source] of processedOutputs) {
-          this.emitFile({
-            type: 'asset',
-            fileName,
-            source,
-          });
-        }
-
-        for (const asset of staticAssets) {
-          if (asset.kind !== 'copy') continue;
-
-          const source = await copyStaticAssetSource(asset);
-
-          this.emitFile({
-            type: 'asset',
-            fileName: asset.outputFileName,
-            source,
-          });
-        }
-
-        for (const batch of chunkArray(pages, batchSize)) {
-          await Promise.all(
-            batch.map((page) =>
-              limit(async () => {
-                const mod = modulesByEntry.get(page.entryPath);
-
-                if (!mod) {
-                  throw new Error(
-                    `[${PLUGIN_NAME}] Missing module for page entry: ${page.entryPath}`,
-                  );
-                }
-
-                const html = await renderPage(page, mod, false);
-
-                validateHtmlAssetReferences({
-                  root,
-                  pagesDir,
-                  html,
-                  pluginName: PLUGIN_NAME,
-                  pageLabel: page.relativePath,
-                  missingAssets: options.missingAssets ?? 'error',
-                });
-                
-                this.emitFile({
-                  type: 'asset',
-                  fileName: options.mapOutputPath?.(page) ?? page.fileName,
-                  source: html,
-                });
-              }),
-            ),
-          );
-        }
-
-        const notFoundPage = pages.find((p) => p.routePath === '/404');
-
-        if (notFoundPage) {
-          const mod = modulesByEntry.get(notFoundPage.entryPath);
-
-          if (!mod) {
-            throw new Error(
-              `[${PLUGIN_NAME}] Missing module for 404 page entry: ${notFoundPage.entryPath}`,
-            );
-          }
-
-          const html = await renderPage(notFoundPage, mod, false);
-
-          validateHtmlAssetReferences({
-            root,
-            pagesDir,
-            html,
-            pluginName: PLUGIN_NAME,
-            pageLabel: notFoundPage.relativePath,
-            missingAssets: options.missingAssets ?? 'error',
-          });
-          
-          this.emitFile({
-            type: 'asset',
-            fileName: '404.html',
-            source: html,
-          });
-
-          logDebug(options.debug, 'generated 404.html from user page');
-        } else {
-          const default404 = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>404 - Page Not Found</title>
-    <style>
-      :root {
-        color-scheme: light dark;
-      }
-      body {
-        margin: 0;
-        font-family: system-ui, sans-serif;
-        min-height: 100vh;
-        display: grid;
-        place-items: center;
-        padding: 2rem;
-      }
-      main {
-        max-width: 40rem;
-        text-align: center;
-      }
-      h1 {
-        font-size: 3rem;
-        margin: 0 0 1rem;
-      }
-      p {
-        margin: 0.5rem 0;
-        line-height: 1.5;
-      }
-      a {
-        color: inherit;
-      }
-    </style>
-  </head>
-  <body>
-    <main>
-      <h1>404</h1>
-      <p>Page not found.</p>
-      <p><a href="/">Go back home</a></p>
-    </main>
-  </body>
-</html>
-`;
-
-          this.emitFile({
-            type: 'asset',
-            fileName: '404.html',
-            source: default404,
-          });
-
-          logDebug(options.debug, 'generated default 404.html');
-        }
-
-        const sitemapBase = options.site ?? '';
-
-        const sitemapRoutes = [...new Set(pages.map((p) => p.routePath))].filter(
-          (route) => !route.includes(':') && !route.includes('*'),
-        );
-
-        if (sitemapBase && sitemapRoutes.length > 0) {
-          const sitemap = `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${sitemapRoutes
-            .map((route) => `  <url><loc>${sitemapBase}${route}</loc></url>`)
-            .join('\n')}\n</urlset>\n`;
-
-          this.emitFile({
-            type: 'asset',
-            fileName: 'sitemap.xml',
-            source: sitemap,
-          });
-
-          logDebug(options.debug, 'generated sitemap.xml');
-        }
-
-        const rss = options.rss;
-
-        if (rss?.site) {
-          const routePrefix = rss.routePrefix ?? '/blog';
-        
-          const rssItems = pages
-            .filter((page) => page.routePath.startsWith(routePrefix))
-            .map((page) => {
-              const url = `${rss.site}${page.routePath}`;
-        
-              return `  <item>\n    <title>${page.routePath}</title>\n    <link>${url}</link>\n    <guid>${url}</guid>\n  </item>`;
-            })
-            .join('\n');
-        
-          const rssXml = `<?xml version="1.0" encoding="UTF-8"?>\n<rss version="2.0">\n<channel>\n  <title>${rss.title ?? PLUGIN_NAME}</title>\n  <link>${rss.site}</link>\n  <description>${rss.description ?? 'RSS feed'}</description>\n${rssItems}\n</channel>\n</rss>\n`;
-        
-          this.emitFile({
-            type: 'asset',
-            fileName: 'rss.xml',
-            source: rssXml,
-          });
-        
-          logDebug(options.debug, 'generated rss.xml');
-        }
-
-        for (const [fileName, output] of Object.entries(bundle)) {
-          if (
-            output.type === 'chunk' &&
-            output.facadeModuleId === VIRTUAL_BUILD_ENTRY_ID
-          ) {
-            delete bundle[fileName];
-          }
-        }
-      } finally {
-        await closePageModuleLoader();
-      }
-    }
-  };
-}
-
-export default htPages;

package/src/render-runtime.ts

@@ -1,36 +0,0 @@
-import { invalidHtmlReturn, pageError, missingDefaultExport } from './errors';
-import type { HtPageInfo, HtPageModule, HtPageRenderContext } from './types';
-
-export async function renderPage(
-  page: HtPageInfo,
-  mod: HtPageModule,
-  dev = false,
-): Promise<string> {
-  const ctx: HtPageRenderContext = {
-    page,
-    params: page.params,
-    dev,
-  };
-
-  try {
-    if (typeof mod.data === 'function') {
-      ctx.data = await mod.data(ctx);
-    }
-
-    const entry = mod.default;
-
-    if (entry == null) {
-      throw missingDefaultExport(page);
-    }
-
-    const html = typeof entry === 'function' ? await entry(ctx) : entry;
-
-    if (typeof html !== 'string') {
-      throw invalidHtmlReturn(page, html);
-    }
-
-    return html;
-  } catch (error) {
-    throw pageError(page, error);
-  }
-}