vite-plugin-html-pages 1.3.7 → 1.4.1

package/src/route-params.ts

@@ -1,38 +0,0 @@
-import type { RouteParamDefinition } from './types';
-
-export function parseRouteParamSegment(
-  segment: string,
-): RouteParamDefinition | null {
-  if (segment.startsWith('[...') && segment.endsWith(']?')) {
-    return {
-      name: segment.slice(4, -2),
-      type: 'optional-catch-all',
-    };
-  }
-
-  if (segment.startsWith('[...') && segment.endsWith(']')) {
-    return {
-      name: segment.slice(4, -1),
-      type: 'catch-all',
-    };
-  }
-
-  if (segment.startsWith('[') && segment.endsWith(']')) {
-    return {
-      name: segment.slice(1, -1),
-      type: 'single',
-    };
-  }
-
-  return null;
-}
-
-export function extractRouteParamDefinitions(
-  routePattern: string,
-): RouteParamDefinition[] {
-  return routePattern
-    .split('/')
-    .filter(Boolean)
-    .map((segment) => parseRouteParamSegment(segment))
-    .filter((value): value is RouteParamDefinition => value != null);
-}

package/src/route-utils.ts

@@ -1,176 +0,0 @@
-import { normalizeRoutePath, stripPageSuffix, toPosix } from './path-utils';
-import type { HtPageInfo, StaticParamRecord } from './types';
-
-const DYNAMIC_SEGMENT_RE = /\[([A-Za-z0-9_]+)\]/g;
-const CATCH_ALL_SEGMENT_RE = /\[\.\.\.([A-Za-z0-9_]+)\]/g;
-const OPTIONAL_CATCH_ALL_SEGMENT_RE = /\[\.\.\.([A-Za-z0-9_]+)\]\?/g;
-const ANY_PARAM_RE = /\[(?:\.\.\.)?([A-Za-z0-9_]+)\]\??/g;
-const ROUTE_GROUP_RE = /(^|\/)\(([^)]+)\)(?=\/|$)/g;
-
-export function getParamNames(relativeFromPagesDir: string): string[] {
-  return [...relativeFromPagesDir.matchAll(ANY_PARAM_RE)].map((m) => m[1]);
-}
-
-export function isDynamicPage(relativeFromPagesDir: string): boolean {
-  return /\[(?:\.\.\.)?[A-Za-z0-9_]+\]\??/.test(relativeFromPagesDir);
-}
-
-export function toRoutePattern(
-  relativeFromPagesDir: string,
-  extensions: string[],
-): string {
-  const noExt = stripPageSuffix(toPosix(relativeFromPagesDir), extensions);
-
-  const withoutGroups = noExt.replace(ROUTE_GROUP_RE, '$1');
-  const withoutIndex = withoutGroups.replace(/\/index$/i, '').replace(/^index$/i, '');
-
-  const raw = withoutIndex
-    .replace(OPTIONAL_CATCH_ALL_SEGMENT_RE, '*?:$1')
-    .replace(CATCH_ALL_SEGMENT_RE, '*:$1')
-    .replace(DYNAMIC_SEGMENT_RE, ':$1');
-
-  return normalizeRoutePath(raw || '/');
-}
-
-export function fillParams(
-  pattern: string,
-  params: Record<string, string>,
-): string {
-  const result = pattern
-    .replace(/\*\?:([A-Za-z0-9_]+)/g, (_, key) => {
-      const value = params[key];
-      if (value == null || value === '') {
-        return '';
-      }
-
-      return String(value)
-        .split('/')
-        .map((part) => encodeURIComponent(part))
-        .join('/');
-    })
-    .replace(/\*:([A-Za-z0-9_]+)/g, (_, key) => {
-      if (!(key in params)) {
-        throw new Error(`Missing catch-all route param "${key}"`);
-      }
-
-      return String(params[key])
-        .split('/')
-        .map((part) => encodeURIComponent(part))
-        .join('/');
-    })
-    .replace(/:([A-Za-z0-9_]+)/g, (_, key) => {
-      if (!(key in params)) {
-        throw new Error(`Missing route param "${key}"`);
-      }
-
-      return encodeURIComponent(params[key]);
-    });
-
-  return normalizeRoutePath(result || '/');
-}
-
-export function fileNameFromRoute(
-  routePath: string,
-  cleanUrls: boolean,
-): string {
-  const normalized = normalizeRoutePath(routePath);
-
-  if (normalized === '/') return 'index.html';
-
-  const base = normalized.slice(1);
-  return cleanUrls ? `${base}/index.html` : `${base}.html`;
-}
-
-export function expandStaticPaths(
-  basePage: Omit<HtPageInfo, 'routePath' | 'fileName' | 'params'>,
-  rows: StaticParamRecord[],
-  cleanUrls: boolean,
-): HtPageInfo[] {
-  return rows.map((row) => {
-    const params = Object.fromEntries(
-      Object.entries(row).map(([k, v]) => [k, String(v)]),
-    );
-
-    const routePath = fillParams(basePage.routePattern, params);
-
-    return {
-      ...basePage,
-      routePath,
-      fileName: fileNameFromRoute(routePath, cleanUrls),
-      params,
-    };
-  });
-}
-
-export function routeMatch(
-  pattern: string,
-  urlPath: string,
-): Record<string, string> | null {
-  const a = normalizeRoutePath(pattern).split('/').filter(Boolean);
-  const b = normalizeRoutePath(urlPath).split('/').filter(Boolean);
-  const params: Record<string, string> = {};
-
-  for (let i = 0; i < a.length; i++) {
-    const patternSeg = a[i];
-    const urlSeg = b[i];
-
-    if (patternSeg.startsWith('*?:')) {
-      params[patternSeg.slice(3)] =
-        i < b.length ? b.slice(i).map(decodeURIComponent).join('/') : '';
-      return params;
-    }
-
-    if (patternSeg.startsWith('*:')) {
-      const rest = b.slice(i);
-      if (rest.length === 0) return null;
-
-      params[patternSeg.slice(2)] = rest.map(decodeURIComponent).join('/');
-      return params;
-    }
-
-    if (!urlSeg) return null;
-
-    if (patternSeg.startsWith(':')) {
-      params[patternSeg.slice(1)] = decodeURIComponent(urlSeg);
-      continue;
-    }
-
-    if (patternSeg !== urlSeg) return null;
-  }
-
-  return a.length === b.length ? params : null;
-}
-
-export function compareRoutePriority(a: string, b: string): number {
-  const aSegs = normalizeRoutePath(a).split('/').filter(Boolean);
-  const bSegs = normalizeRoutePath(b).split('/').filter(Boolean);
-  const len = Math.max(aSegs.length, bSegs.length);
-
-  for (let i = 0; i < len; i++) {
-    const aa = aSegs[i];
-    const bb = bSegs[i];
-
-    if (aa == null) return 1;
-    if (bb == null) return -1;
-
-    const aOptionalCatchAll = aa.startsWith('*?:');
-    const bOptionalCatchAll = bb.startsWith('*?:');
-    if (aOptionalCatchAll !== bOptionalCatchAll) {
-      return aOptionalCatchAll ? 1 : -1;
-    }
-
-    const aCatchAll = aa.startsWith('*:');
-    const bCatchAll = bb.startsWith('*:');
-    if (aCatchAll !== bCatchAll) {
-      return aCatchAll ? 1 : -1;
-    }
-
-    const aDynamic = aa.startsWith(':');
-    const bDynamic = bb.startsWith(':');
-    if (aDynamic !== bDynamic) {
-      return aDynamic ? 1 : -1;
-    }
-  }
-
-  return bSegs.length - aSegs.length;
-}

package/src/static-assets.ts

@@ -1,206 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import fg from 'fast-glob';
-import * as esbuild from 'esbuild';
-import fsSync from 'node:fs';
-
-export interface StaticAssetFile {
-  absolutePath: string;
-  relativePathFromSrc: string;
-  outputFileName: string;
-  kind: 'copy' | 'process';
-}
-
-export interface CollectStaticAssetsArgs {
-  root: string;
-  pagesDir: string;
-  pageExtensions: string[];
-}
-
-function normalizeSlashes(value: string): string {
-  return value.replace(/\\/g, '/');
-}
-
-function hasAnySuffix(value: string, suffixes: string[]): boolean {
-  return suffixes.some((suffix) => value.endsWith(suffix));
-}
-
-function shouldIgnoreFile(rel: string): boolean {
-  return (
-    rel.endsWith('.d.ts') ||
-    rel.endsWith('.map') ||
-    rel.endsWith('.tsbuildinfo') ||
-    rel.startsWith('.') ||
-    rel.includes('/.')
-  );
-}
-
-function isProcessableAsset(rel: string): boolean {
-  return (
-    rel.endsWith('.js') ||
-    rel.endsWith('.mjs') ||
-    rel.endsWith('.ts') ||
-    rel.endsWith('.css')
-  );
-}
-
-function toOutputFileName(relativePathFromSrc: string): string {
-  if (relativePathFromSrc.endsWith('.ts')) {
-    return relativePathFromSrc.slice(0, -3) + '.js';
-  }
-  return relativePathFromSrc;
-}
-
-export async function collectStaticAssets(
-  args: CollectStaticAssetsArgs,
-): Promise<StaticAssetFile[]> {
-  const { root, pagesDir, pageExtensions } = args;
-  const srcDir = path.join(root, pagesDir);
-
-  const entries = await fg('**/*', {
-    cwd: srcDir,
-    onlyFiles: true,
-    dot: false,
-    absolute: false,
-  });
-
-  const assets: StaticAssetFile[] = [];
-
-  for (const entry of entries) {
-    const rel = normalizeSlashes(entry);
-
-    if (shouldIgnoreFile(rel)) continue;
-    if (hasAnySuffix(rel, pageExtensions)) continue;
-
-    const absolutePath = path.join(srcDir, rel);
-
-    assets.push({
-      absolutePath,
-      relativePathFromSrc: rel,
-      outputFileName: normalizeSlashes(toOutputFileName(rel)),
-      kind: isProcessableAsset(rel) ? 'process' : 'copy',
-    });
-  }
-
-  return assets;
-}
-
-export async function copyStaticAssetSource(
-  asset: StaticAssetFile,
-): Promise<Uint8Array> {
-  return fs.readFile(asset.absolutePath);
-}
-
-export async function buildProcessedStaticAssets(args: {
-    root: string;
-    pagesDir: string;
-    assets: StaticAssetFile[];
-    minify?: boolean;
-    sourcemap?: boolean;
-  }): Promise<Map<string, string | Uint8Array>> {
-    const { root, pagesDir, assets, minify = true, sourcemap = false } = args;
-  
-    const processable = assets.filter((a) => a.kind === 'process');
-    const out = new Map<string, string | Uint8Array>();
-  
-    if (processable.length === 0) {
-      return out;
-    }
-  
-    const srcDir = path.join(root, pagesDir);
-    const distDir = path.join(root, 'dist');
-    const warnedMissingAssets = new Set<string>();
-    const result = await esbuild.build({
-      entryPoints: processable.map((a) => a.absolutePath),
-      absWorkingDir: root,
-      outbase: srcDir,
-      outdir: distDir,
-      bundle: true,
-      splitting: true,
-      treeShaking: true,
-      minify,
-      sourcemap,
-      format: 'esm',
-      target: 'es2020',
-      platform: 'browser',
-      write: false,
-      entryNames: '[dir]/[name]',
-      assetNames: '[dir]/[name]',
-      loader: {
-        '.css': 'css',
-        '.png': 'file',
-        '.jpg': 'file',
-        '.jpeg': 'file',
-        '.gif': 'file',
-        '.svg': 'file',
-        '.webp': 'file',
-        '.woff': 'file',
-        '.woff2': 'file',
-        '.ttf': 'file',
-        '.otf': 'file',
-      },
-      plugins: [
-        {
-          name: 'html-pages-root-url-resolver',
-          setup(build) {
-            build.onResolve({ filter: /^\// }, (resolveArgs) => {
-              // Leave real filesystem absolute paths alone
-              if (
-                path.isAbsolute(resolveArgs.path) &&
-                fsSync.existsSync(resolveArgs.path)
-              ) {
-                return { path: resolveArgs.path };
-              }
-      
-              const cleanPath = resolveArgs.path.slice(1);
-      
-              const fromSrc = path.join(srcDir, cleanPath);
-              if (fsSync.existsSync(fromSrc)) {
-                return { path: fromSrc };
-              }
-      
-              const fromPublic = path.join(root, 'public', cleanPath);
-              if (fsSync.existsSync(fromPublic)) {
-                return {
-                  path: resolveArgs.path,
-                  external: true,
-                };
-              }
-      
-              const isCssUrlToken = resolveArgs.kind === 'url-token';
-      
-              if (isCssUrlToken) {
-                if (!warnedMissingAssets.has(resolveArgs.path)) {
-                  warnedMissingAssets.add(resolveArgs.path);
-                  console.warn(
-                    `[vite-plugin-html-pages] ⚠️ Missing CSS asset: ${resolveArgs.path}\n` +
-                    `  Looked in:\n` +
-                    `  - ${fromSrc}\n` +
-                    `  - ${fromPublic}`
-                  );
-                }
-      
-                // Keep the original root-relative URL in output CSS
-                return {
-                  path: resolveArgs.path,
-                  external: true,
-                };
-              }
-      
-              // JS/CSS entry imports remain strict
-              return {
-                path: fromSrc,
-              };
-            });
-          },
-        },
-      ],
-    });
-  
-    for (const file of result.outputFiles) {
-      const rel = normalizeSlashes(path.relative(distDir, file.path));
-      out.set(rel, file.text ?? file.contents);
-    }
-  
-    return out;
-  }

package/src/types.ts

@@ -1,73 +0,0 @@
-import type { Plugin as RollupPlugin } from 'rollup';
-
-export interface StaticParamRecord {
-  [key: string]: string | number | boolean;
-}
-
-export type HtPageParams = Record<string, string | string[] | undefined>;
-
-export interface HtPageInfo {
-  id: string;
-  entryPath: string;
-  absolutePath: string;
-  relativePath: string;
-  routePattern: string;
-  routePath: string;
-  fileName: string;
-  dynamic: boolean;
-  paramNames: string[];
-  paramDefinitions: RouteParamDefinition[];
-  params: HtPageParams;
-}
-
-export type HtPageRenderContext = {
-  page: HtPageInfo;
-  params: HtPageParams;
-  data?: unknown;
-  dev: boolean;
-};
-
-export interface HtPageModule {
-  default?: ((ctx: {
-    page: HtPageInfo;
-    params: Record<string, string | string[] | undefined>;
-    data?: unknown;
-    dev: boolean;
-  }) => string | Promise<string>) | string;
-  data?: (ctx: {
-    page: HtPageInfo;
-    params: Record<string, string | string[] | undefined>;
-    dev: boolean;
-  }) => unknown | Promise<unknown>;
-  generateStaticParams?: () =>
-    | Array<Record<string, string | number | boolean>>
-    | Promise<Array<Record<string, string | number | boolean>>>;
-  dynamic?: boolean;
-  prerender?: boolean;
-}
-
-export interface HtPagesPluginOptions {
-  root?: string;
-  include?: string | string[];
-  exclude?: string | string[];  
-  pagesDir?: string;
-  pageExtensions?: string[];
-  cleanUrls?: boolean;
-  debug?: boolean;
-  renderConcurrency?: number;
-  renderBatchSize?: number;
-  site?: string;
-  missingAssets?: 'error' | 'warn';
-  rss?: {
-    site: string;
-    title?: string;
-    description?: string;
-    routePrefix?: string;
-  };
-  mapOutputPath?: (page: HtPageInfo) => string;
-}
-
-export type RouteParamDefinition = {
-  name: string;
-  type: 'single' | 'catch-all' | 'optional-catch-all';
-};

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "compilerOptions": {
-      "target": "ES2020",
-      "module": "ESNext",
-      "moduleResolution": "Bundler",
-      "strict": true,
-      "declaration": true,
-      "outDir": "dist",
-      "skipLibCheck": true,
-      "esModuleInterop": true,
-      "types": ["node"]
-    },
-    "include": ["src"]
-}

package/tsup.config.ts

@@ -1,18 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm'],
-  dts: true,
-  sourcemap: true,
-  clean: true,
-  target: 'node18',
-  platform: 'node',
-  splitting: false,
-  external: [
-    'vite',
-    'fast-glob',
-    'p-limit',
-    'esbuild'
-  ],
-});