@catfyrr/vite-plugin-ssi 0.0.3 → 0.1.0

package/dist/dev-server.d.ts

@@ -0,0 +1,25 @@
+import type { ViteDevServer, PreviewServer } from 'vite';
+export interface DevServerOptions {
+    maxDepth: number;
+    includeFileTypes?: string[];
+    fileTypeMap?: import('./file-types').FileTypeMap;
+}
+/**
+ * Sets up preview server middleware to process SSI on-the-fly
+ */
+export declare function setupPreviewServer(previewServer: PreviewServer, options: DevServerOptions): void;
+/**
+ * Handles HMR updates when SSI dependency files change
+ */
+export declare function handleHotUpdate(ctx: {
+    file: string;
+}, server: ViteDevServer, reverseDependencyMap: Map<string, Set<string>>): Array<import('vite').ModuleNode> | void;
+/**
+ * Transforms index HTML with SSI processing
+ */
+export declare function transformIndexHtml(html: string, ctx: {
+    filename?: string;
+    server?: ViteDevServer;
+}, options: DevServerOptions & {
+    root?: string;
+}): Promise<string>;

package/dist/file-types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * File type to extension mappings for intelligent SSI processing
+ */
+export interface FileTypeMap {
+    [key: string]: string[];
+}
+/**
+ * Default file type mappings
+ * Maps file type names to their associated extensions
+ */
+export declare const DEFAULT_FILE_TYPE_MAP: FileTypeMap;
+/**
+ * Checks if a file path matches any of the specified file types
+ */
+export declare function matchesFileType(filePath: string, fileTypes: string[], fileTypeMap: FileTypeMap): boolean;
+/**
+ * Checks if a file path matches HTML file extensions (for top-level processing)
+ */
+export declare function isHtmlFile(filePath: string): boolean;

package/dist/{index.js → index.cjs}

@@ -1,42 +1,62 @@
-// @bun @bun-cjs
-(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
+var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -380,4 +400,3 @@ function vitePluginSsi(options = {}) {
     }
   };
 }
-})

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import type { Plugin } from 'vite';
+import { type FileTypeMap } from './file-types';
+/**
+ * File type to extension mappings for intelligent SSI processing.
+ * Maps file type names (e.g., 'js', 'css', 'html') to arrays of file extensions.
+ * Used to determine which file types should be processed when included via SSI.
+ *
+ * @example
+ * ```ts
+ * const fileTypeMap: FileTypeMap = {
+ *   js: ['.js', '.ts', '.jsx'],
+ *   css: ['.css', '.scss']
+ * };
+ * ```
+ */
+export type { FileTypeMap } from './file-types';
+/**
+ * Configuration options for the Vite SSI plugin.
+ *
+ * All options are optional and have sensible defaults.
+ */
+export interface VitePluginSsiOptions {
+    /**
+     * Maximum depth for recursive includes
+     * @default 10
+     */
+    maxDepth?: number;
+    /**
+     * When to run this plugin in the pipeline
+     * @default 'pre'
+     */
+    enforce?: 'pre' | 'post';
+    /**
+     * Apply plugin only in specific environments
+     * @default undefined (applies to all environments)
+     */
+    apply?: 'serve' | 'build' | 'preview' | {
+        serve?: boolean;
+        build?: boolean;
+        preview?: boolean;
+    };
+    /**
+     * File types to apply SSI processing to for included files (at any depth)
+     * SSI always applies to top-level HTML files (.html, .htm, .shtml)
+     * When files are included via SSI, they will also be processed if they match these types
+     * Examples: ['js', 'html', 'css'] - will process .js/.ts/.mjs/etc., .html/.htm/.shtml, .css/.scss/etc.
+     * @default [] (only process top-level HTML files)
+     */
+    includeFileTypes?: string[];
+    /**
+     * Custom file type to extension mappings
+     * Allows overriding or extending the default mappings
+     */
+    fileTypeMap?: FileTypeMap;
+}
+/**
+ * Vite plugin for Server-Side Includes (SSI) processing.
+ *
+ * This plugin processes Apache/Nginx-compatible SSI directives in HTML files,
+ * including support for `<!--#include virtual="..." -->` and `<!--#include file="..." -->`.
+ *
+ * Features:
+ * - Supports recursive includes with configurable depth limits
+ * - Hot Module Replacement (HMR) support for included files
+ * - Works in dev, build, and preview modes
+ * - Configurable file type processing
+ * - Custom file type mappings
+ *
+ * @param options - Configuration options for the SSI plugin
+ * @returns A Vite plugin instance
+ *
+ * @example
+ * ```ts
+ * import vitePluginSsi from '@catfyrr/vite-plugin-ssi';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     vitePluginSsi({
+ *       maxDepth: 5,
+ *       includeFileTypes: ['html', 'js']
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+export default function vitePluginSsi(options?: VitePluginSsiOptions): Plugin;

package/dist/index.mjs

@@ -0,0 +1,338 @@
+// src/index.ts
+import * as path3 from "path";
+
+// src/file-types.ts
+var DEFAULT_FILE_TYPE_MAP = {
+  html: [".html", ".htm", ".shtml"],
+  js: [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".mts", ".cts"],
+  css: [".css", ".scss", ".sass", ".less", ".styl"],
+  json: [".json", ".jsonc"],
+  xml: [".xml", ".xhtml"],
+  text: [".txt", ".md", ".markdown"]
+};
+function matchesFileType(filePath, fileTypes, fileTypeMap) {
+  const ext = getFileExtension(filePath);
+  if (!ext)
+    return false;
+  for (const fileType of fileTypes) {
+    const extensions = fileTypeMap[fileType.toLowerCase()] || [];
+    if (extensions.includes(ext)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getFileExtension(filePath) {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1)
+    return null;
+  const ext = filePath.substring(lastDot);
+  return ext && ext.length > 1 ? ext.toLowerCase() : null;
+}
+
+// src/ssi.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+function resolveIncludePath(virtualPath, includingFile, root) {
+  if (virtualPath.startsWith("/")) {
+    return path.join(root, virtualPath.slice(1));
+  }
+  const includingDir = path.dirname(includingFile);
+  return path.resolve(includingDir, virtualPath);
+}
+function normalizePath(filePath) {
+  return path.resolve(filePath).replace(/\\/g, "/");
+}
+async function processSsi(filePath, content, options) {
+  const { root, maxDepth, includeFileTypes = [], fileTypeMap = DEFAULT_FILE_TYPE_MAP } = options;
+  return processSsiRecursive(filePath, content, root, new Set, 0, maxDepth, includeFileTypes, fileTypeMap);
+}
+async function processSsiRecursive(filePath, content, root, seen, depth, maxDepth, includeFileTypes, fileTypeMap) {
+  const normalizedPath = normalizePath(filePath);
+  const deps = new Set;
+  if (seen.has(normalizedPath)) {
+    const seenArray = Array.from(seen);
+    const cycleStart = seenArray.indexOf(normalizedPath);
+    const cycle = seenArray.slice(cycleStart).concat(normalizedPath).join(" -> ");
+    return {
+      code: `<!-- SSI Error: Circular include detected: ${cycle} -->`,
+      deps
+    };
+  }
+  if (depth >= maxDepth) {
+    return {
+      code: `<!-- SSI Error: Maximum include depth (${maxDepth}) exceeded -->`,
+      deps
+    };
+  }
+  seen.add(normalizedPath);
+  const includeRegex = /<!--#include\s+virtual\s*=\s*"([^"]+)"\s*-->/g;
+  let match;
+  let result = content;
+  const replacements = [];
+  const matches = [];
+  while ((match = includeRegex.exec(content)) !== null) {
+    matches.push({
+      index: match.index,
+      length: match[0].length,
+      virtualPath: match[1]
+    });
+  }
+  for (let i = matches.length - 1;i >= 0; i--) {
+    const { index, length, virtualPath } = matches[i];
+    const matchEnd = index + length;
+    const resolvedPath = resolveIncludePath(virtualPath, filePath, root);
+    const normalizedResolvedPath = normalizePath(resolvedPath);
+    deps.add(normalizedResolvedPath);
+    try {
+      await fs.access(resolvedPath);
+      const includedContent = await fs.readFile(resolvedPath, "utf-8");
+      const shouldProcessSsi = includeFileTypes.length === 0 ? false : matchesFileType(resolvedPath, includeFileTypes, fileTypeMap);
+      let processed;
+      if (shouldProcessSsi) {
+        processed = await processSsiRecursive(resolvedPath, includedContent, root, new Set(seen), depth + 1, maxDepth, includeFileTypes, fileTypeMap);
+      } else {
+        processed = {
+          code: includedContent,
+          deps: new Set
+        };
+      }
+      processed.deps.forEach((dep) => deps.add(dep));
+      replacements.push({
+        start: index,
+        end: matchEnd,
+        replacement: processed.code
+      });
+    } catch (error) {
+      replacements.push({
+        start: index,
+        end: matchEnd,
+        replacement: `<!-- SSI Error: File not found: ${normalizedResolvedPath} -->`
+      });
+    }
+  }
+  for (const { start, end, replacement } of replacements) {
+    result = result.slice(0, start) + replacement + result.slice(end);
+  }
+  return { code: result, deps };
+}
+
+// src/dev-server.ts
+import { promises as fs2 } from "fs";
+import * as path2 from "path";
+function setupPreviewServer(previewServer, options) {
+  const outDir = previewServer.config.build.outDir || "dist";
+  const projectRoot = previewServer.config.root;
+  const distRoot = path2.resolve(projectRoot, outDir);
+  const processOptions = {
+    root: projectRoot,
+    maxDepth: options.maxDepth,
+    includeFileTypes: options.includeFileTypes,
+    fileTypeMap: options.fileTypeMap
+  };
+  previewServer.middlewares.use(async (req, res, next) => {
+    try {
+      if (!req.url || req.method !== "GET")
+        return next();
+      let reqPath = req.url.split("?")[0];
+      if (reqPath === "/" || reqPath === "") {
+        reqPath = "/index.html";
+      }
+      if (!reqPath.endsWith(".html"))
+        return next();
+      const filePath = path2.join(distRoot, reqPath.startsWith("/") ? reqPath.slice(1) : reqPath);
+      const exists = await fs2.access(filePath).then(() => true).catch(() => false);
+      if (!exists)
+        return next();
+      const raw = await fs2.readFile(filePath, "utf-8");
+      const relativePath = path2.relative(distRoot, filePath);
+      const sourceFilePath = path2.join(projectRoot, relativePath);
+      const result = await processSsi(sourceFilePath, raw, processOptions);
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(result.code);
+      return;
+    } catch (err) {
+      return next();
+    }
+  });
+}
+function handleHotUpdate(ctx, server, reverseDependencyMap) {
+  const changedFile = normalizePath(ctx.file);
+  const affectedHtmlFiles = reverseDependencyMap.get(changedFile);
+  if (!affectedHtmlFiles || affectedHtmlFiles.size === 0) {
+    return;
+  }
+  const affectedModules = [];
+  for (const htmlFile of affectedHtmlFiles) {
+    const modulesByFile = server.moduleGraph.getModulesByFile(htmlFile);
+    if (modulesByFile && modulesByFile.size > 0) {
+      modulesByFile.forEach((module) => {
+        affectedModules.push(module);
+      });
+    } else {
+      try {
+        const relativePath = path2.relative(server.config.root, htmlFile);
+        const url = `/${relativePath.replace(/\\/g, "/")}`;
+        const urlModule = server.moduleGraph.urlToModuleMap.get(url);
+        if (urlModule) {
+          affectedModules.push(urlModule);
+        }
+      } catch {}
+    }
+  }
+  if (affectedModules.length > 0) {
+    affectedModules.forEach((module) => {
+      try {
+        server.moduleGraph.invalidateModule(module);
+        if ("reloadModule" in server && typeof server.reloadModule === "function") {
+          server.reloadModule(module);
+        }
+      } catch {
+        server.ws.send({ type: "full-reload" });
+      }
+    });
+    return affectedModules;
+  }
+  if (affectedHtmlFiles.size > 0) {
+    server.ws.send({ type: "full-reload" });
+  }
+}
+async function transformIndexHtml(html, ctx, options) {
+  const root = ctx.server?.config.root || options.root || process.cwd();
+  const filename = ctx.filename || "index.html";
+  const filePath = path2.isAbsolute(filename) ? filename : path2.resolve(root, filename);
+  try {
+    const processOptions = {
+      root,
+      maxDepth: options.maxDepth,
+      includeFileTypes: options.includeFileTypes,
+      fileTypeMap: options.fileTypeMap
+    };
+    const result = await processSsi(filePath, html, processOptions);
+    return result.code;
+  } catch (error) {
+    return `<!-- SSI Error: ${error instanceof Error ? error.message : String(error)} -->
+${html}`;
+  }
+}
+
+// src/index.ts
+function normalizeApplyOption(apply) {
+  if (!apply) {
+    return;
+  }
+  if (typeof apply === "string") {
+    if (apply === "preview") {
+      return;
+    }
+    return apply;
+  }
+  if (apply.serve === true && !apply.build) {
+    return "serve";
+  }
+  if (apply.build === true && !apply.serve) {
+    return "build";
+  }
+  return;
+}
+function shouldApplyInEnvironment(apply, command) {
+  if (!apply) {
+    return true;
+  }
+  if (typeof apply === "string") {
+    return apply === command;
+  }
+  if (command === "serve") {
+    return apply.serve !== false;
+  }
+  if (command === "build") {
+    return apply.build !== false;
+  }
+  if (command === "preview") {
+    return apply.preview !== false;
+  }
+  return true;
+}
+function vitePluginSsi(options = {}) {
+  const {
+    maxDepth = 10,
+    enforce = "pre",
+    apply: applyOption,
+    includeFileTypes = [],
+    fileTypeMap
+  } = options;
+  const mergedFileTypeMap = {
+    ...DEFAULT_FILE_TYPE_MAP,
+    ...fileTypeMap
+  };
+  const dependencyGraph = new Map;
+  const reverseDependencyMap = new Map;
+  let server;
+  let command = "serve";
+  let resolvedRoot;
+  return {
+    name: "vite-plugin-ssi",
+    enforce,
+    apply: normalizeApplyOption(applyOption),
+    configResolved(config) {
+      command = config.command || "serve";
+      resolvedRoot = config.root;
+    },
+    configureServer(_server) {
+      server = _server;
+    },
+    configurePreviewServer(previewServer) {
+      if (!shouldApplyInEnvironment(applyOption, "preview")) {
+        return () => {};
+      }
+      setupPreviewServer(previewServer, {
+        maxDepth,
+        includeFileTypes,
+        fileTypeMap: mergedFileTypeMap
+      });
+    },
+    async transformIndexHtml(html, ctx) {
+      const currentCommand = ctx.server ? ctx.server.config.command || "serve" : command;
+      if (!shouldApplyInEnvironment(applyOption, currentCommand)) {
+        return html;
+      }
+      const root = ctx.server?.config.root || resolvedRoot || process.cwd();
+      const result = await transformIndexHtml(html, ctx, {
+        root,
+        maxDepth,
+        includeFileTypes,
+        fileTypeMap: mergedFileTypeMap
+      });
+      const filename = ctx.filename || "index.html";
+      const filePath = path3.isAbsolute(filename) ? filename : path3.resolve(root, filename);
+      const normalizedFilePath = normalizePath(filePath);
+      const processOptions = {
+        root,
+        maxDepth,
+        includeFileTypes,
+        fileTypeMap: mergedFileTypeMap
+      };
+      const depsResult = await processSsi(filePath, html, processOptions);
+      dependencyGraph.set(normalizedFilePath, depsResult.deps);
+      depsResult.deps.forEach((dep) => {
+        if (!reverseDependencyMap.has(dep)) {
+          reverseDependencyMap.set(dep, new Set);
+        }
+        reverseDependencyMap.get(dep).add(normalizedFilePath);
+      });
+      return result;
+    },
+    handleHotUpdate(ctx) {
+      if (!shouldApplyInEnvironment(applyOption, command)) {
+        return;
+      }
+      if (!server) {
+        return;
+      }
+      return handleHotUpdate(ctx, server, reverseDependencyMap);
+    }
+  };
+}
+export {
+  vitePluginSsi as default
+};

package/dist/ssi.d.ts

@@ -0,0 +1,19 @@
+import { type FileTypeMap } from './file-types';
+export interface ProcessResult {
+    code: string;
+    deps: Set<string>;
+}
+export interface ProcessSsiOptions {
+    root: string;
+    maxDepth: number;
+    includeFileTypes?: string[];
+    fileTypeMap?: FileTypeMap;
+}
+/**
+ * Normalizes a file path to absolute path for consistent comparison
+ */
+export declare function normalizePath(filePath: string): string;
+/**
+ * Processes SSI includes recursively
+ */
+export declare function processSsi(filePath: string, content: string, options: ProcessSsiOptions): Promise<ProcessResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@catfyrr/vite-plugin-ssi",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "Fully Apache/Nginx compatible Server-Side Includes (SSI) Vite plugin",
   "type": "module",
   "exports": {
@@ -18,9 +18,10 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "bun run build:esm && bun run build:cjs",
-    "build:esm": "bun build ./src/index.ts --outdir dist --target bun --format esm",
-    "build:cjs": "bun build ./src/index.ts --outdir dist --target bun --format cjs",
+    "build": "bun run build:esm && bun run build:cjs && bun run build:types",
+    "build:esm": "bun build ./src/index.ts --outfile dist/index.mjs --target node --format esm",
+    "build:cjs": "bun build ./src/index.ts --outfile dist/index.cjs --target node --format cjs",
+    "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist",
     "test": "bun test",
     "test:watch": "bun test --watch",
     "lint": "eslint src tests",
@@ -38,14 +39,14 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/catFurr/vite-plugin-ssi.git"
+    "url": "git+https://github.com/catFurr/vite-plugin-ssi.git"
   },
   "bugs": {
     "url": "https://github.com/catFurr/vite-plugin-ssi/issues"
   },
   "homepage": "https://github.com/catFurr/vite-plugin-ssi#readme",
   "peerDependencies": {
-    "vite": "^5.0.0"
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
@@ -58,6 +59,6 @@
     "husky": "^8.0.3",
     "prettier": "^3.1.0",
     "typescript": "^5.3.2",
-    "vite": "^5.0.0"
+    "vite": "^6.0.0"
   }
 }