vite-plugin-php 1.0.71 → 2.0.0

package/dist/index.mjs

@@ -1,17 +1,45 @@
-import require$$0$4, { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
-import require$$0$1, { relative, dirname, resolve } from 'path';
-import { normalizePath } from 'vite';
-import http from 'node:http';
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'url';
+import { resolve, dirname, relative } from 'node:path';
 import require$$0 from 'os';
+import require$$0$1 from 'path';
 import require$$0$2 from 'util';
 import require$$0$3 from 'stream';
 import require$$0$5 from 'events';
+import require$$0$4 from 'fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import http from 'node:http';
+import { normalizePath } from 'vite';
 
-function makeID() {
-  return Date.now().toString(36) + Math.random() * 100;
-}
+const EPHPError = {
+  ERROR: 1,
+  WARNING: 2,
+  PARSE: 4,
+  NOTICE: 8,
+  CORE_ERROR: 16,
+  CORE_WARNING: 32,
+  COMPILE_ERROR: 64,
+  COMPILE_WARNING: 128,
+  USER_ERROR: 256,
+  USER_WARNING: 512,
+  USER_NOTICE: 1024,
+  STRICT: 2048,
+  RECOVERABLE_ERROR: 4096,
+  DEPRECATED: 8192,
+  USER_DEPRECATED: 16384,
+  ALL: 32767
+};
+
+const internalParam = "__314159265359__";
+const shared = {
+  viteConfig: void 0,
+  devConfig: {
+    cleanup: true,
+    errorLevels: EPHPError.ALL | EPHPError.STRICT
+  },
+  entries: [],
+  tempDir: ".php-tmp"
+};
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -100,136 +128,130 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 const colors = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
-function resolveEnvPrefix({ envPrefix = "VITE_" }) {
-  envPrefix = Array.isArray(envPrefix) ? envPrefix : [envPrefix];
-  if (envPrefix.includes("")) {
-    throw new Error(
-      `envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
-    );
+function hasViteConfig(input) {
+  if (!input) {
+    throw new Error("Vite config not initialized!");
   }
-  return envPrefix;
-}
-const envPattern = /%(\S+?)%/g;
-function initReplaceEnv(config) {
-  const envPrefix = resolveEnvPrefix({ envPrefix: config.envPrefix });
-  const env = { ...config.env };
-  for (const key in config.define) {
-    if (key.startsWith(`import.meta.env.`)) {
-      const val = config.define[key];
-      if (typeof val === "string") {
-        try {
-          const parsed = JSON.parse(val);
-          env[key.slice(16)] = typeof parsed === "string" ? parsed : val;
-        } catch {
-          env[key.slice(16)] = val;
-        }
-      } else {
-        env[key.slice(16)] = JSON.stringify(val);
-      }
-    }
-  }
-  return function replaceEnv(content, filename) {
-    return content.replace(envPattern, (text, key) => {
-      if (key in env) {
-        return env[key];
-      } else {
-        if (envPrefix.some((prefix) => key.startsWith(prefix))) {
-          const relativeHtml = normalizePath(
-            relative(config.root, filename)
-          );
-          config.logger.warn(
-            colors.yellow(
-              colors.bold(
-                `(!) ${text} is not defined in env variables found in /${relativeHtml}. Is the variable mistyped?`
-              )
-            )
-          );
-        }
-        return text;
-      }
-    });
-  };
 }
 
-function writeFile(file, data) {
-  mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, data);
+function log(message, { type = "info", prefix = true, ...options } = {}) {
+  hasViteConfig(shared.viteConfig);
+  let output = "";
+  if (prefix) {
+    output += colors.bgMagenta(colors.white("\u2009php\u2009")) + " ";
+  }
+  output += message;
+  shared.viteConfig.logger[type](output, options);
 }
-
-const phpTagPattern = /<\?(?:php|).+?(\?>|$)/gis;
-function escapePHP({ inputFile, config }) {
-  const replaceEnv = initReplaceEnv(config);
-  const input = readFileSync(inputFile, "utf-8").toString();
-  const phpCodes = {};
-  const isJS = inputFile.includes(".js") || inputFile.includes(".ts");
-  const isML = inputFile.includes(".php") || inputFile.includes(".htm");
-  const escapedCode = input.replace(phpTagPattern, (match) => {
-    let token = makeID();
-    if (isJS) {
-      token = `/*${token}*/`;
-    } else if (isML) {
-      token = `\u2400\u2400${token}\u2400\u2400`;
-    }
-    phpCodes[token] = replaceEnv(match, inputFile);
-    return token;
-  });
-  return {
-    escapedCode,
-    phpCodes,
-    write(outputFile) {
-      writeFile(outputFile, escapedCode);
-      writeFile(outputFile + ".json", JSON.stringify(phpCodes));
+log.error = function(json, options = {}) {
+  let output = json;
+  let type = "info";
+  try {
+    const data = JSON.parse(json);
+    output = "";
+    switch (data.code) {
+      case EPHPError.PARSE:
+      case EPHPError.ERROR:
+      case EPHPError.CORE_ERROR:
+      case EPHPError.COMPILE_ERROR:
+      case EPHPError.USER_ERROR:
+        type = "error";
+        output += colors.bgRedBright(colors.white("Fatal Error"));
+        break;
+      case EPHPError.WARNING:
+      case EPHPError.USER_WARNING:
+      case EPHPError.COMPILE_WARNING:
+      case EPHPError.RECOVERABLE_ERROR:
+        type = "warn";
+        output += colors.yellowBright("Warning");
+        break;
+      case EPHPError.NOTICE:
+      case EPHPError.USER_NOTICE:
+        type = "info";
+        output += colors.bgWhite(colors.black("Notice"));
+        break;
+      case EPHPError.STRICT:
+        type = "info";
+        output += colors.yellow("Strict");
+        break;
+      case EPHPError.DEPRECATED:
+      case EPHPError.USER_DEPRECATED:
+        type = "info";
+        output += colors.cyan("Deprecated");
+        break;
+      default:
+        break;
     }
-  };
-}
-function unescapePHP({ escapedCode, phpCodes }) {
-  let out = escapedCode;
-  Object.entries(phpCodes).forEach(([token, code]) => {
-    out = out.replace(token, (match) => {
-      return `${code}`;
-    });
-  });
-  return out;
-}
+    output += " " + data.message + "\r\n";
+    output += "	In: " + data.file.replace(
+      resolve(shared.tempDir),
+      shared.viteConfig?.root
+    ) + "\r\n";
+    output += "	On line: " + data.line;
+  } catch (error) {
+  }
+  log(output, { ...options, type });
+};
 
+const PHP_Server = {
+  binary: "php",
+  port: 65535,
+  process: void 0,
+  start,
+  stop
+};
 function start(root) {
-  if (!globalThis.php?.pid) {
+  if (!PHP_Server.process?.pid) {
     const routerFileUrl = new URL("./router.php", import.meta.url);
-    globalThis.php = spawn(phpServer.binary, [
+    PHP_Server.process = spawn(PHP_Server.binary, [
       "-S",
-      "localhost:" + phpServer.port,
+      "localhost:" + PHP_Server.port,
       "-t",
       root,
       fileURLToPath(routerFileUrl)
     ]).once("spawn", () => {
-      console.log(
-        `PHP development server started (PID: ${globalThis.php?.pid})`
-      );
+      log(`Server started (PID: ${PHP_Server.process?.pid})`);
     }).on("error", (error) => {
-      console.error("PHP dev-server error: " + error.message);
-    }).on("close", (code) => {
-      console.log(`PHP development server stopped (Code: ${code})`);
+      log(`Server error: ${error.message})`, {
+        type: "error"
+      });
+    });
+    PHP_Server.process.stdout?.on("data", (data) => {
+      log("", { timestamp: true });
+      `${data}`.trim().split("\r\n").forEach((line) => {
+        if (line.startsWith(internalParam + ":")) {
+          log.error(
+            line.substring((internalParam + ":").length),
+            { prefix: false }
+          );
+        } else {
+          log(line);
+        }
+      });
     });
   }
 }
-function stop() {
-  if (globalThis.php) {
-    globalThis.php.stdin?.destroy();
-    globalThis.php.stdout?.destroy();
-    globalThis.php.stderr?.destroy();
-    if (globalThis.php.kill()) {
-      console.log("PHP development server killed");
+function stop(callBack) {
+  if (PHP_Server.process) {
+    PHP_Server.process.on("close", (code) => {
+      log("Ended with: " + code);
+      PHP_Server.process = void 0;
+      callBack();
+    });
+    PHP_Server.process.stdin?.destroy();
+    PHP_Server.process.stdout?.destroy();
+    PHP_Server.process.stderr?.destroy();
+    if (PHP_Server.process.kill()) {
+      log("Shutting down");
     } else {
-      console.error("Attention! Failed to kill PHP development server!");
+      log("Failed to send SIGTERM", {
+        type: "error"
+      });
     }
+  } else {
+    callBack();
   }
 }
-const phpServer = {
-  binary: "php",
-  port: 65535,
-  start,
-  stop
-};
 
 var tasks = {};
 
@@ -6948,7 +6970,8 @@ var out = FastGlob;
 
 const fastGlob = /*@__PURE__*/getDefaultExportFromCjs(out);
 
-function consoleHijack(entries) {
+function consoleHijack() {
+  const entries = shared.entries;
   ["log", "info", "warn", "error"].forEach((command) => {
     const cx = console[command];
     console[command] = function(...args) {
@@ -6964,307 +6987,457 @@ function consoleHijack(entries) {
   });
 }
 
-const namespacePattern = new RegExp(
-  /(.+?)(<\?(?:php|)\s+namespace\s\S+?(?:\s*;|\s*{).+)(<\/.+?>|<.+?\/>)(.+|$)/,
+function readFile(file) {
+  return readFileSync(file, "utf-8").toString();
+}
+function writeFile(file, data) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, data);
+}
+
+function makeID() {
+  return Date.now().toString(36) + Math.random() * 100;
+}
+
+function resolveEnvPrefix({ envPrefix = "VITE_" }) {
+  envPrefix = Array.isArray(envPrefix) ? envPrefix : [envPrefix];
+  if (envPrefix.includes("")) {
+    throw new Error(
+      `envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
+    );
+  }
+  return envPrefix;
+}
+const envPattern = /%(\S+?)%/g;
+function initReplaceEnv() {
+  hasViteConfig(shared.viteConfig);
+  const { env, define, root, logger } = shared.viteConfig;
+  const envPrefix = resolveEnvPrefix({
+    envPrefix: shared.viteConfig.envPrefix
+  });
+  for (const key in define) {
+    if (key.startsWith(`import.meta.env.`)) {
+      const val = define[key];
+      if (typeof val === "string") {
+        try {
+          const parsed = JSON.parse(val);
+          env[key.slice(16)] = typeof parsed === "string" ? parsed : val;
+        } catch {
+          env[key.slice(16)] = val;
+        }
+      } else {
+        env[key.slice(16)] = JSON.stringify(val);
+      }
+    }
+  }
+  return function replaceEnv(content, filename) {
+    const relativeHtml = normalizePath(relative(root, filename));
+    return content.replace(envPattern, (text, key) => {
+      if (key in env) {
+        return env[key];
+      } else {
+        if (envPrefix.some((prefix) => key.startsWith(prefix))) {
+          logger.warn(
+            colors.yellow(
+              colors.bold(
+                `(!) ${text} is not defined in env variables found in /${relativeHtml}. Is the variable mistyped?`
+              )
+            )
+          );
+        }
+        return text;
+      }
+    });
+  };
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const phpStartPattern = `<\\?(?:php|)`;
+const phpEndPattern = `\\?>`;
+const phpTagRegex = new RegExp(
+  `${phpStartPattern}.+?(${phpEndPattern}|$)`,
+  "gis"
+);
+class PHP_Code {
+  constructor(code) {
+    __publicField(this, "file", "!!__VIRTUAL__!!.php");
+    __publicField(this, "code");
+    __publicField(this, "mapping", {});
+    this.code = code;
+    return this;
+  }
+  static fromFile(file) {
+    const inst = new this(readFile(file));
+    inst.file = file;
+    return inst;
+  }
+  applyEnv() {
+    const replaceEnv = initReplaceEnv();
+    this.code = replaceEnv(this.code, this.file || "");
+    return this;
+  }
+  escape() {
+    const isJS = this.file.includes(".js") || this.file.includes(".ts");
+    const isML = this.file.includes(".php") || this.file.includes(".htm");
+    this.code = this.code.replace(phpTagRegex, (match) => {
+      let token = makeID();
+      if (isJS) {
+        token = `/*${token}*/`;
+      } else if (isML) {
+        token = `\u2400\u2400${token}\u2400\u2400`;
+      }
+      this.mapping[token] = match;
+      return token;
+    });
+    return this;
+  }
+  write(file, mapping = false) {
+    writeFile(file, this.code);
+    mapping && writeFile(file + ".json", JSON.stringify(this.mapping));
+  }
+  static unescape(code, mapping) {
+    let out = code;
+    Object.entries(mapping).forEach(([token, code2]) => {
+      out = out.replace(token, code2);
+    });
+    return out;
+  }
+}
+
+const serve = {
+  rewriteUrl: (url) => url
+};
+function tempName(entry) {
+  return `${shared.tempDir}/${entry}`;
+}
+const servePlugin = {
+  name: "serve-php",
+  apply: "serve",
+  enforce: "post",
+  configResolved() {
+    function handleExit(signal) {
+      if (signal === "SIGINT") {
+        console.log();
+      }
+      const tempDir = resolve(shared.tempDir);
+      if (shared.devConfig.cleanup && existsSync(tempDir)) {
+        log("Removing temporary files");
+        rmSync(tempDir, {
+          recursive: true,
+          force: true
+        });
+      }
+      if (PHP_Server.process && shared.viteConfig?.command === "serve") {
+        PHP_Server.stop(() => {
+          process.exit();
+        });
+      } else {
+        process.exit();
+      }
+    }
+    [
+      "exit",
+      "SIGINT",
+      "SIGUSR1",
+      "SIGUSR2",
+      "uncaughtException",
+      "SIGTERM"
+    ].forEach((eventType) => {
+      new Promise((resolve2) => process.on(eventType, resolve2)).then(
+        handleExit
+      );
+    });
+    const gitIgnoreFile = resolve(`${shared.tempDir}/.gitignore`);
+    if (!existsSync(gitIgnoreFile)) {
+      writeFile(gitIgnoreFile, "*\r\n**/*");
+    }
+    shared.entries.forEach((entry) => {
+      PHP_Code.fromFile(entry).applyEnv().write(tempName(entry));
+    });
+  },
+  configureServer(server) {
+    if (!PHP_Server.process) {
+      PHP_Server.start(server?.config.root);
+    }
+    server.middlewares.use(async (req, res, next) => {
+      try {
+        if (req.url && !["/@vite", "/@fs", "/@id/__x00__", "/node_modules"].some(
+          (path) => req.url.startsWith(path)
+        )) {
+          req.on("error", (error) => {
+            throw error;
+          });
+          const url = new URL(req.url, "http://localhost");
+          if (shared.viteConfig?.server.port) {
+            url.port = shared.viteConfig.server.port.toString();
+          }
+          const requestUrl = url.pathname;
+          if (url.pathname.endsWith("/")) {
+            url.pathname += "index.php";
+          }
+          const routedUrl = serve.rewriteUrl(url);
+          if (routedUrl) {
+            url.pathname = routedUrl.pathname;
+            url.search = routedUrl.search;
+            url.hash = routedUrl.hash;
+          }
+          const entryPathname = url.pathname.substring(1);
+          const entry = shared.entries.find((file) => {
+            return file === entryPathname || file.substring(0, file.lastIndexOf(".")) === entryPathname;
+          });
+          if (entry) {
+            const tempFile = tempName(entry);
+            if (existsSync(resolve(tempFile))) {
+              url.pathname = tempFile;
+              url.port = PHP_Server.port.toString();
+              url.searchParams.set(
+                internalParam,
+                new URLSearchParams({
+                  $REQUEST_URI: requestUrl,
+                  $PHP_SELF: "/" + entry,
+                  temp_dir: shared.tempDir,
+                  error_levels: shared.devConfig.errorLevels.toString()
+                }).toString()
+              );
+              const body = await new Promise(
+                (resolve2, reject) => {
+                  let data = [];
+                  req.on("data", (chunk) => {
+                    data.push(chunk);
+                  }).on("end", () => {
+                    resolve2(Buffer.concat(data));
+                  });
+                }
+              );
+              const phpResult = await new Promise(async (resolve2, reject) => {
+                const chunks = [];
+                let statusCode;
+                let incomingHeaders = {};
+                const request = http.request(
+                  url.toString(),
+                  {
+                    method: req.method,
+                    headers: {
+                      ...req.headers,
+                      "content-length": Buffer.byteLength(body)
+                    }
+                  },
+                  (msg) => {
+                    statusCode = msg.statusCode;
+                    incomingHeaders = msg.headers;
+                    msg.on("data", (data) => {
+                      chunks.push(data);
+                    });
+                  }
+                ).on("error", (error) => {
+                  reject(error);
+                }).on("close", () => {
+                  const content = Buffer.concat(chunks).toString(
+                    "utf8"
+                  );
+                  resolve2({
+                    statusCode,
+                    headers: incomingHeaders,
+                    content
+                  });
+                });
+                request.write(body, (error) => {
+                  if (error) {
+                    reject(error);
+                  }
+                });
+                request.end();
+              });
+              let out = phpResult.content;
+              if (phpResult.headers["content-type"]?.includes(
+                "html"
+              )) {
+                out = await server.transformIndexHtml(
+                  `/${entry}.html`,
+                  out,
+                  requestUrl
+                );
+              }
+              res.writeHead(
+                phpResult.statusCode || 200,
+                phpResult.headers
+              ).end(out);
+              return;
+            }
+          }
+        }
+      } catch (error) {
+        console.error("Vite-PHP Error: " + error);
+      }
+      next();
+    });
+  },
+  handleHotUpdate({ server, file }) {
+    const entry = shared.entries.find(
+      (entryFile) => resolve(entryFile) === resolve(file)
+    );
+    if (entry) {
+      PHP_Code.fromFile(entry).applyEnv().write(tempName(entry));
+      server.moduleGraph.invalidateAll();
+    }
+    if (entry || !file.startsWith(resolve(shared.tempDir)) && file.includes(".php")) {
+      server.ws.send({
+        type: "full-reload"
+      });
+    }
+  }
+};
+
+const assetsPattern = new RegExp(
+  `^(.+?)(${phpStartPattern}\\s+namespace\\s\\S+?(?:\\s*;|\\s*{).+)$`,
   "si"
 );
-function processOutput(input) {
+const lastTagPattern = new RegExp(`^(.+(?:</.+?>|<.+?/>))(.+|)$`, "si");
+const closingPattern = new RegExp(`^(.+)(${phpStartPattern}.+)$`, "si");
+function fixAssetsInjection(input) {
   let out = input;
-  out = out.replace(
-    namespacePattern,
-    (match, assets, contents, lastTag, trailingContent) => contents + lastTag + "\r\n" + assets.trim() + trailingContent
-  );
+  let assets = "";
+  out = out.replace(assetsPattern, (match, p1, p2) => {
+    assets = p1.trim();
+    return p2;
+  });
+  const injectAssets = (_, part1, part2) => {
+    let a = assets;
+    if (!(part1.endsWith("\n") || part1.endsWith("\r"))) {
+      a = "\r\n" + a;
+    }
+    if (!(part2.startsWith("\n") || part2.startsWith("\r"))) {
+      a += "\r\n";
+    }
+    assets = "";
+    return `${part1}${a}${part2}`;
+  };
+  if (assets) {
+    out = out.replace(lastTagPattern, injectAssets);
+  }
+  if (assets) {
+    out = out.replace(closingPattern, injectAssets);
+  }
+  if (assets) {
+    out += assets;
+  }
   return out;
 }
 
-const internalParam = "__314159265359__";
+const buildPlugin = {
+  name: "build-php",
+  apply: "build",
+  enforce: "pre",
+  resolveId(source, importer, options) {
+    if (shared.entries.includes(source)) {
+      return {
+        // Rename ids because Vite transforms only .html files: https://github.com/vitejs/vite/blob/0cde495ebeb48bcfb5961784a30bfaed997790a0/packages/vite/src/node/plugins/html.ts#L330
+        id: `${source}.html`,
+        resolvedBy: "vite-plugin-php",
+        meta: {
+          originalId: source
+        }
+      };
+    }
+  },
+  load(id, options) {
+    const moduleInfo = this.getModuleInfo(id);
+    const entry = moduleInfo?.meta.originalId;
+    if (entry) {
+      const php = PHP_Code.fromFile(entry).applyEnv().escape();
+      return {
+        code: php.code,
+        meta: { phpMapping: php.mapping }
+      };
+    }
+  },
+  generateBundle: {
+    order: "post",
+    handler(options, bundle, isWrite) {
+      Object.entries(bundle).forEach(([key, item]) => {
+        if (item.type === "asset") {
+          const moduleInfo = this.getModuleInfo(item.fileName);
+          if (moduleInfo?.meta.originalId) {
+            const meta = moduleInfo.meta;
+            item.fileName = meta.originalId;
+            if (meta.phpMapping) {
+              item.source = PHP_Code.unescape(
+                item.source.toString(),
+                meta.phpMapping
+              );
+            }
+            item.source = fixAssetsInjection(
+              item.source.toString()
+            );
+          }
+        } else if (item.type === "chunk" && item.facadeModuleId) {
+          const moduleInfo = this.getModuleInfo(item.facadeModuleId);
+          if (moduleInfo) {
+            const meta = moduleInfo.meta;
+            if (meta.phpMapping) {
+              item.code = PHP_Code.unescape(
+                item.code,
+                meta.phpMapping
+              );
+            }
+            item.code = fixAssetsInjection(item.code);
+          }
+        }
+      });
+    }
+  }
+};
+
 function usePHP(cfg = {}) {
-  const {
-    binary = "php",
-    entry = "index.php",
-    rewriteUrl = (requestUrl) => requestUrl,
-    tempDir = ".php-tmp",
-    cleanup = {}
-  } = cfg;
-  const { dev: devCleanup = true } = cleanup;
-  phpServer.binary = binary;
-  let config = void 0;
-  let viteServer = void 0;
-  let entries = Array.isArray(entry) ? entry : [entry];
-  function getTempFileName(file) {
-    return `${tempDir}/${file}.html`;
-  }
-  function cleanupTemp() {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-  function onExit() {
-    if (config?.command === "serve") {
-      phpServer.stop();
-      devCleanup && cleanupTemp();
-    }
-    process.exit();
-  }
-  [
-    "exit",
-    "SIGINT",
-    "SIGUSR1",
-    "SIGUSR2",
-    "uncaughtException",
-    "SIGTERM"
-  ].forEach((eventType) => {
-    process.on(eventType, onExit.bind(null));
-  });
+  const { entry = "index.php" } = cfg;
+  PHP_Server.binary = cfg.binary ?? PHP_Server.binary;
+  serve.rewriteUrl = cfg.rewriteUrl ?? serve.rewriteUrl;
+  shared.entries = Array.isArray(entry) ? entry : [entry];
+  shared.tempDir = cfg.tempDir ?? shared.tempDir;
+  shared.devConfig = {
+    cleanup: cfg.dev?.cleanup || shared.devConfig.cleanup,
+    errorLevels: cfg.dev?.errorLevels || shared.devConfig.errorLevels
+  };
   return [
     {
-      name: "prepare-php",
+      name: "init-php",
       enforce: "post",
-      config(config2, env) {
-        const gitIgnoreFile = `${tempDir}/.gitignore`;
-        if (!existsSync(gitIgnoreFile)) {
-          writeFile(gitIgnoreFile, "*\n**/*.php.html");
-        }
-        entries = [
+      config(config, env) {
+        shared.entries = [
           ...new Set(
-            entries.flatMap(
+            shared.entries.flatMap(
               (entry2) => fastGlob.globSync(entry2, {
                 dot: true,
                 onlyFiles: true,
                 unique: true,
                 ignore: [
-                  tempDir,
-                  config2.build?.outDir || "dist"
+                  shared.tempDir,
+                  config.build?.outDir || "dist"
                 ]
               })
             )
           )
         ];
-        consoleHijack(entries);
+        consoleHijack();
         return {
           build: {
-            rollupOptions: { input: entries }
+            rollupOptions: { input: shared.entries }
           },
-          optimizeDeps: { entries }
+          optimizeDeps: { entries: shared.entries }
         };
       },
       configResolved(_config) {
-        config = _config;
+        shared.viteConfig = _config;
       }
     },
-    {
-      name: "serve-php",
-      apply: "serve",
-      enforce: "pre",
-      configResolved(_config) {
-        config = _config;
-        entries.forEach((entry2) => {
-          const outputFile = getTempFileName(entry2);
-          escapePHP({
-            inputFile: entry2,
-            config
-          }).write(outputFile);
-        });
-      },
-      configureServer(server) {
-        viteServer = server;
-        phpServer.start(viteServer?.config.root);
-        server.middlewares.use(async (req, res, next) => {
-          try {
-            if (req.url && ![
-              "/@vite",
-              "/@fs",
-              "/@id/__x00__",
-              "/node_modules"
-            ].some((path) => req.url.startsWith(path))) {
-              req.on("error", (error) => {
-                throw error;
-              });
-              res.on("error", (error) => {
-                throw error;
-              });
-              const url = new URL(req.url, "http://localhost");
-              if (config?.server.port) {
-                url.port = config.server.port.toString();
-              }
-              const requestUrl = url.pathname;
-              if (url.pathname.endsWith("/")) {
-                url.pathname += "index.php";
-              }
-              const routedUrl = rewriteUrl(url);
-              if (routedUrl) {
-                url.pathname = routedUrl.pathname;
-                url.search = routedUrl.search;
-                url.hash = routedUrl.hash;
-              }
-              const entryPathname = url.pathname.substring(1);
-              const entry2 = entries.find((file) => {
-                return file === entryPathname || file.substring(0, file.lastIndexOf(".")) === entryPathname;
-              });
-              if (entry2) {
-                const tempFile = getTempFileName(entry2);
-                if (existsSync(resolve(tempFile))) {
-                  url.pathname = tempFile;
-                  url.port = phpServer.port.toString();
-                  url.searchParams.set(
-                    internalParam,
-                    new URLSearchParams({
-                      REQUEST_URI: requestUrl,
-                      PHP_SELF: "/" + entry2
-                    }).toString()
-                  );
-                  const body = await new Promise(
-                    (resolve2, reject) => {
-                      let data = [];
-                      req.on("data", (chunk) => {
-                        data.push(chunk);
-                      }).on("end", () => {
-                        resolve2(Buffer.concat(data));
-                      });
-                    }
-                  );
-                  const phpResult = await new Promise(async (resolve2, reject) => {
-                    const chunks = [];
-                    let statusCode;
-                    let incomingHeaders = {};
-                    const request = http.request(
-                      url.toString(),
-                      {
-                        method: req.method,
-                        headers: {
-                          ...req.headers,
-                          "content-length": Buffer.byteLength(
-                            body
-                          )
-                        }
-                      },
-                      (msg) => {
-                        statusCode = msg.statusCode;
-                        incomingHeaders = msg.headers;
-                        msg.on("data", (data) => {
-                          chunks.push(data);
-                        });
-                      }
-                    ).on("error", (error) => {
-                      reject(error);
-                    }).on("close", () => {
-                      const content = Buffer.concat(
-                        chunks
-                      ).toString("utf8");
-                      resolve2({
-                        statusCode,
-                        headers: incomingHeaders,
-                        content
-                      });
-                    });
-                    request.write(body, (error) => {
-                      if (error) {
-                        reject(error);
-                      }
-                    });
-                    request.end();
-                  });
-                  let out = phpResult.content;
-                  if (phpResult.headers["content-type"]?.includes("html")) {
-                    out = await server.transformIndexHtml(
-                      requestUrl,
-                      out,
-                      "/" + entryPathname
-                    );
-                  }
-                  res.writeHead(
-                    phpResult.statusCode || 200,
-                    phpResult.headers
-                  ).end(out);
-                  return;
-                }
-              }
-            }
-          } catch (error) {
-            console.error("Vite-PHP Error: " + error);
-          }
-          next();
-        });
-      },
-      async handleHotUpdate({ server, file }) {
-        const entry2 = entries.find(
-          (entryFile) => resolve(entryFile) === resolve(file)
-        );
-        if (entry2) {
-          const outputFile = getTempFileName(entry2);
-          escapePHP({
-            inputFile: entry2,
-            config
-          }).write(outputFile);
-          server.moduleGraph.invalidateAll();
-        }
-        if (entry2 || !file.startsWith(resolve(tempDir)) && file.includes(".php")) {
-          server.ws.send({
-            type: "full-reload"
-          });
-        }
-      }
-    },
-    {
-      name: "build-php",
-      apply: "build",
-      enforce: "pre",
-      resolveId(source, importer, options) {
-        if (entries.includes(source)) {
-          return {
-            // Rename ids because Vite transforms only .html files: https://github.com/vitejs/vite/blob/0cde495ebeb48bcfb5961784a30bfaed997790a0/packages/vite/src/node/plugins/html.ts#L330
-            id: `${source}.html`,
-            resolvedBy: "vite-plugin-php",
-            meta: {
-              originalId: source
-            }
-          };
-        }
-      },
-      load(id, options) {
-        const entry2 = this.getModuleInfo(id)?.meta.originalId;
-        if (entry2) {
-          const { escapedCode, phpCodes } = escapePHP({
-            inputFile: entry2,
-            config
-          });
-          return {
-            code: escapedCode,
-            meta: { phpCodes }
-          };
-        }
-      },
-      generateBundle: {
-        order: "post",
-        handler(options, bundle, isWrite) {
-          Object.entries(bundle).forEach(([key, item]) => {
-            if (item.type === "asset") {
-              const meta = this.getModuleInfo(
-                item.fileName
-              )?.meta;
-              if (meta?.originalId && meta?.phpCodes) {
-                item.fileName = meta.originalId;
-                item.source = unescapePHP({
-                  escapedCode: item.source.toString(),
-                  phpCodes: meta.phpCodes
-                });
-                item.source = processOutput(item.source);
-              }
-            } else if (item.type === "chunk" && item.facadeModuleId) {
-              const meta = this.getModuleInfo(
-                item.facadeModuleId
-              )?.meta;
-              if (meta?.phpCodes) {
-                item.code = unescapePHP({
-                  escapedCode: item.code,
-                  phpCodes: meta.phpCodes
-                });
-                item.code = processOutput(item.code);
-              }
-            }
-          });
-        }
-      }
-    }
+    servePlugin,
+    buildPlugin
   ];
 }
 
-export { usePHP as default };
+export { EPHPError, usePHP as default };