blogger-plugin 0.0.2 → 0.0.4

package/dist/vite.cjs

@@ -1,15 +1,78 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/vite.ts
-var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }// src/vite.ts
+var _fs = require('fs'); var fs2 = _interopRequireWildcard(_fs); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path2 = _interopRequireWildcard(_path); var path = _interopRequireWildcard(_path);
 var _stream = require('stream');
 
-// src/schema.ts
-var _zod = require('zod');
-var BloggerPluginOptionsSchema = _zod.z.object({
-  entry: _zod.z.string().optional(),
-  template: _zod.z.string().optional(),
-  proxyBlog: _zod.z.url()
-}).strict();
+
+var _vite = require('vite');
+
+// src/cache.ts
+
+
+var _tailwindcssiso = require('tailwindcss-iso');
+var TAILWIND_CACHE_FILE = ".tailwind-classes.json";
+function readFileContent(file) {
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  return fs.readFileSync(file, "utf-8");
+}
+function writeFileContent(file, content) {
+  const dirname2 = path.dirname(file);
+  if (!fs.existsSync(dirname2)) {
+    fs.mkdirSync(dirname2, { recursive: true });
+  }
+  const current = readFileContent(file);
+  if (current === null || content !== current) {
+    fs.writeFileSync(file, content, "utf8");
+    return true;
+  }
+  return false;
+}
+function removeFile(file) {
+  if (!fs.existsSync(file)) {
+    return false;
+  }
+  fs.rmSync(file);
+  return true;
+}
+function getTailwindCacheFile(root) {
+  return path.resolve(root, TAILWIND_CACHE_FILE);
+}
+function readTailwindCache(root) {
+  const content = readFileContent(getTailwindCacheFile(root));
+  if (!content) {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (e) {
+    return null;
+  }
+}
+function writeTailwindCache(root, classes) {
+  const file = getTailwindCacheFile(root);
+  const content = JSON.stringify(classes, null, 2);
+  const updated = writeFileContent(file, content);
+  return { updated, content };
+}
+function clearTailwindCache(root) {
+  writeTailwindCache(root, []);
+}
+function removeTailwindCache(root) {
+  removeFile(getTailwindCacheFile(root));
+}
+async function updateTailwindCache(root, content) {
+  var _a;
+  const classes = await _tailwindcssiso.getTailwindClasses.call(void 0, {
+    content
+  });
+  writeTailwindCache(root, [.../* @__PURE__ */ new Set([...(_a = readTailwindCache(root)) != null ? _a : [], ...classes])]);
+}
+
+// src/constants.ts
+var DEFAULT_ENTRIES = ["index.tsx", "index.ts", "index.jsx", "index.js", "main.tsx", "main.ts", "main.jsx", "main.js"];
+var DEFAULT_TEMPLATES = ["template.xml", "theme.xml"];
 
 // src/utils.ts
 function escapeHtml(str) {
@@ -49,24 +112,20 @@ function toWebHeaders(httpHeaders) {
   }
   return headers;
 }
+var BLOGGER_PLUGIN_HEAD_COMMENT_REGEX = /(<!--blogger-plugin:head:begin-->)([\s\S]*?)(<!--blogger-plugin:head:end-->)/;
+var BLOGGER_PLUGIN_HEAD_BCOMMENT_REGEX = /(<b:comment><!--blogger-plugin:head:begin--><\/b:comment>)([\s\S]*?)(<b:comment><!--blogger-plugin:head:end--><\/b:comment>)/;
 function replaceBloggerPluginHeadComment(input, replacement, bcomment = false) {
   if (bcomment) {
-    return input.replace(
-      /<b:comment><!--blogger-plugin:head:begin--><\/b:comment>[\s\S]*?<b:comment><!--blogger-plugin:head:end--><\/b:comment>/,
-      `<b:comment><!--blogger-plugin:head:begin--></b:comment>${replacement}<b:comment><!--blogger-plugin:head:end--></b:comment>`
-    );
+    return input.replace(BLOGGER_PLUGIN_HEAD_BCOMMENT_REGEX, (_, start, _content, end) => `${start}${replacement}${end}`);
   }
-  return input.replace(
-    /<!--blogger-plugin:head:begin-->[\s\S]*?<!--blogger-plugin:head:end-->/,
-    `<!--blogger-plugin:head:begin-->${replacement}<!--blogger-plugin:head:end-->`
-  );
+  return input.replace(BLOGGER_PLUGIN_HEAD_COMMENT_REGEX, (_, start, _content, end) => `${start}${replacement}${end}`);
 }
 function getBloggerPluginHeadComment(input, bcomment = false) {
   var _a, _b, _c, _d;
   if (bcomment) {
-    return (_b = (_a = input.match(/<b:comment><!--blogger-plugin:head:begin--><\/b:comment>([\s\S]*?)<b:comment><!--blogger-plugin:head:end--><\/b:comment>/)) == null ? void 0 : _a[1]) != null ? _b : null;
+    return (_b = (_a = input.match(BLOGGER_PLUGIN_HEAD_BCOMMENT_REGEX)) == null ? void 0 : _a[2]) != null ? _b : null;
   }
-  return (_d = (_c = input.match(/<!--blogger-plugin:head:begin-->([\s\S]*?)<!--blogger-plugin:head:end-->/)) == null ? void 0 : _c[1]) != null ? _d : null;
+  return (_d = (_c = input.match(BLOGGER_PLUGIN_HEAD_COMMENT_REGEX)) == null ? void 0 : _c[2]) != null ? _d : null;
 }
 function replaceHost(input, oldHost, newHost, newProtocol) {
   return input.replace(
@@ -74,6 +133,21 @@ function replaceHost(input, oldHost, newHost, newProtocol) {
     (_, protocol, slash) => `${protocol ? newProtocol != null ? newProtocol : protocol : ""}${slash != null ? slash : ""}${newHost}`
   );
 }
+function getRequestUrl(req) {
+  const xForwardedProtoHeader = req.headers["x-forwarded-proto"];
+  const xForwardedHostHeader = req.headers["x-forwarded-host"];
+  const hostHeader = req.headers.host;
+  const protocol = Array.isArray(xForwardedProtoHeader) ? xForwardedProtoHeader[0] : xForwardedProtoHeader != null ? xForwardedProtoHeader : req.socket && "encrypted" in req.socket && req.socket.encrypted ? "https" : "http";
+  const host = Array.isArray(xForwardedHostHeader) ? xForwardedHostHeader[0] : xForwardedHostHeader != null ? xForwardedHostHeader : hostHeader;
+  if (host && req.url) {
+    return new URL(`${protocol}://${host}${req.url}`);
+  }
+  return null;
+}
+var TAILWIND_PLUGIN_NAMES = /* @__PURE__ */ new Set(["@tailwindcss/vite:scan"]);
+function isTailwindPlugin(plugin) {
+  return TAILWIND_PLUGIN_NAMES.has(plugin.name);
+}
 function errorHtml(reqUrl) {
   return `<!DOCTYPE html>
 <html>
@@ -179,14 +253,94 @@ function errorHtml(reqUrl) {
 }
 
 // src/vite.ts
-var DEFAULT_ENTRIES = ["index.tsx", "index.ts", "index.jsx", "index.js", "main.tsx", "main.ts", "main.jsx", "main.js"];
-var DEFAULT_TEMPLATES = ["template.xml", "theme.xml"];
-function createPluginContext(userOptions) {
+function createBloggerPluginContext(userOptions) {
+  if (typeof userOptions.entry !== "undefined" && typeof userOptions.entry !== "string") {
+    throw new Error("Option 'entry' must be a string");
+  }
+  if (typeof userOptions.template !== "undefined" && typeof userOptions.template !== "string") {
+    throw new Error("Option 'template' must be a string");
+  }
+  if (typeof userOptions.proxyBlog !== "string") {
+    throw new Error("Option 'proxyBlog' must be a string");
+  }
+  let proxyBlog;
+  try {
+    proxyBlog = new URL(userOptions.proxyBlog);
+  } catch (e) {
+    throw new Error("Option 'proxyBlog' must be a valid url");
+  }
   return {
-    viteConfig: void 0,
+    root: process.cwd(),
     entry: void 0,
     template: void 0,
-    options: BloggerPluginOptionsSchema.parse(userOptions)
+    proxyBlog,
+    viteConfig: void 0,
+    tailwind: false,
+    input: void 0,
+    html: void 0,
+    resolve(config) {
+      this.root = config.root ? path2.resolve(config.root) : this.root;
+      if (userOptions.entry) {
+        const providedPath = path2.resolve(this.root, userOptions.entry);
+        if (fs2.existsSync(providedPath)) {
+          this.entry = providedPath;
+        } else {
+          throw new Error(`Provided entry file does not exist: ${providedPath}`);
+        }
+      } else {
+        for (const file of DEFAULT_ENTRIES) {
+          const fullPath = path2.resolve(this.root, "src", file);
+          if (fs2.existsSync(fullPath)) {
+            this.entry = fullPath;
+            break;
+          }
+        }
+        if (!this.entry) {
+          throw new Error(
+            `No entry file found in "src".
+Tried: ${DEFAULT_ENTRIES.map((c) => path2.join("src", c)).join(", ")}
+\u{1F449} Tip: You can pass a custom entry like:
+   blogger({ entry: "src/my-entry.ts" })`
+          );
+        }
+      }
+      if (userOptions.template) {
+        const providedPath = path2.resolve(this.root, userOptions.template);
+        if (fs2.existsSync(providedPath)) {
+          this.template = providedPath;
+        } else {
+          throw new Error(`Provided template file does not exist: ${providedPath}`);
+        }
+      } else {
+        for (const file of DEFAULT_TEMPLATES) {
+          const fullPath = path2.resolve(this.root, "src", file);
+          if (fs2.existsSync(fullPath)) {
+            this.template = fullPath;
+            break;
+          }
+        }
+        if (!this.template) {
+          throw new Error(
+            `No template file found in "src".
+Tried: ${DEFAULT_TEMPLATES.map((c) => path2.join("src", c)).join(", ")}
+\u{1F449} Tip: You can pass a custom template like:
+   blogger({ template: "src/my-template.xml" })`
+          );
+        }
+      }
+      const name = path2.basename(this.entry, path2.extname(this.entry));
+      this.input = `virtual:blogger-plugin/${name}.html`;
+      this.html = `<!DOCTYPE html>
+<html>
+<head>
+  <!--head-->
+  <script type="module" src="/${path2.relative(this.root, this.entry).replace("\\", "/")}"></script>
+</head>
+<body>
+  <!--body-->
+</body>
+</html>`;
+    }
   };
 }
 function isViteDevServer(server) {
@@ -197,17 +351,18 @@ function useServerMiddleware(server, ctx, _this) {
     var _a;
     (_a = server.httpServer) == null ? void 0 : _a.once("listening", () => {
       setTimeout(() => {
-        _this.info(`Unhandled requests will be proxied to ${ctx.options.proxyBlog}`);
+        _this.info(`Unhandled requests will be proxied to ${ctx.proxyBlog.origin}`);
       }, 0);
     });
     server.middlewares.use(async (req, res, next) => {
       var _a2;
-      if (!req.url || !req.originalUrl) {
+      const url = getRequestUrl(req);
+      if (!req.url || !req.originalUrl || !url) {
         next();
         return;
       }
       const start = Date.now();
-      const proxyUrl = new URL(req.originalUrl, ctx.options.proxyBlog);
+      const proxyUrl = new URL(`${ctx.proxyBlog.origin}${req.originalUrl}`);
       const viewParam = proxyUrl.searchParams.get("view");
       proxyUrl.searchParams.set("view", `${isViteDevServer(server) ? "-DevServer" : "-PreviewServer"}${(viewParam == null ? void 0 : viewParam.startsWith("-")) ? viewParam : ""}`);
       const proxyRequest = new Request(proxyUrl, {
@@ -229,28 +384,24 @@ function useServerMiddleware(server, ctx, _this) {
         return null;
       });
       if (proxyResponse) {
-        const requestProtocol = `${req.headers["x-forwarded-proto"] || (req.socket && "encrypted" in req.socket && req.socket.encrypted ? "https" : "http")}:`;
-        const requestHost = req.headers["x-forwarded-host"] || req.headers.host;
         res.statusCode = proxyResponse.status;
         res.statusMessage = proxyResponse.statusText;
         proxyResponse.headers.forEach((value, key) => {
           var _a3;
           if (key === "location") {
-            const redirectUrl = new URL(value, requestHost ? `${requestProtocol}//${requestHost}${req.originalUrl}` : proxyUrl.href);
-            if (requestHost && redirectUrl.host === requestHost || redirectUrl.host === proxyUrl.host) {
-              if (requestHost && requestProtocol) {
-                redirectUrl.host = requestHost;
-                redirectUrl.protocol = requestProtocol;
-              }
+            const redirectUrl = new URL(value, proxyUrl);
+            if (redirectUrl.host === url.host || redirectUrl.host === proxyUrl.host) {
+              redirectUrl.host = url.host;
+              redirectUrl.protocol = url.protocol;
               const viewParam2 = (_a3 = redirectUrl.searchParams.get("view")) == null ? void 0 : _a3.replaceAll("-DevServer", "").replaceAll("-PreviewServer", "");
               if (viewParam2) {
                 redirectUrl.searchParams.set("view", viewParam2);
               } else {
                 redirectUrl.searchParams.delete("view");
               }
-              res.setHeader(key, redirectUrl.pathname + redirectUrl.search + redirectUrl.hash);
+              res.setHeader("location", redirectUrl.pathname + redirectUrl.search + redirectUrl.hash);
             } else {
-              res.setHeader(key, redirectUrl.href);
+              res.setHeader("location", redirectUrl.href);
             }
           } else if (["content-type", "x-robots-tag", "date", "location"].includes(key)) {
             res.setHeader(key, value);
@@ -259,12 +410,13 @@ function useServerMiddleware(server, ctx, _this) {
         const contentType = proxyResponse.headers.get("content-type");
         if (contentType == null ? void 0 : contentType.startsWith("text/html")) {
           let htmlTemplateContent = await proxyResponse.text();
-          if (requestHost && requestProtocol) {
-            htmlTemplateContent = replaceHost(htmlTemplateContent, proxyUrl.host, requestHost, requestProtocol);
+          if (ctx.tailwind && isViteDevServer(server)) {
+            await updateTailwindCache(ctx.root, htmlTemplateContent);
           }
+          htmlTemplateContent = replaceHost(htmlTemplateContent, proxyUrl.host, url.host, url.protocol);
           if (isViteDevServer(server)) {
             const htmlTags = [];
-            htmlTags.push(`<script src='/${escapeHtml(_path2.default.relative(ctx.viteConfig.root, ctx.entry))}' type='module'></script>`);
+            htmlTags.push(`<script type='module' src='/${escapeHtml(path2.relative(ctx.root, ctx.entry).replace("\\", "/"))}'></script>`);
             const template = await server.transformIndexHtml(
               req.url,
               replaceBloggerPluginHeadComment(htmlTemplateContent, htmlTags.join("")),
@@ -272,14 +424,14 @@ function useServerMiddleware(server, ctx, _this) {
             );
             res.end(template);
           } else {
-            const xmlTemplateContent = _fs2.default.readFileSync(_path2.default.resolve(ctx.viteConfig.build.outDir, "template.xml"), "utf8");
+            const xmlTemplateContent = fs2.readFileSync(path2.resolve(ctx.viteConfig.build.outDir, "template.xml"), "utf8");
             const htmlTagsStr = getBloggerPluginHeadComment(xmlTemplateContent, true);
             const template = replaceBloggerPluginHeadComment(htmlTemplateContent, htmlTagsStr != null ? htmlTagsStr : "");
             res.end(template);
           }
-        } else if (requestHost && requestProtocol && contentType && /^(text\/)|(application\/(.*\+)?(xml|json))/.test(contentType)) {
+        } else if (contentType && /^(text\/)|(application\/(.*\+)?(xml|json))/.test(contentType)) {
           const content = await proxyResponse.text();
-          res.end(replaceHost(content, proxyUrl.host, requestHost, requestProtocol));
+          res.end(replaceHost(content, proxyUrl.host, url.host, url.protocol));
         } else {
           res.end(new Uint8Array(await proxyResponse.arrayBuffer()));
         }
@@ -295,94 +447,103 @@ function useServerMiddleware(server, ctx, _this) {
   };
 }
 function blogger(userOptions) {
-  const ctx = createPluginContext(userOptions);
+  const ctx = createBloggerPluginContext(userOptions);
   return {
     name: "vite-plugin-blogger",
     config(config) {
-      var _a, _b, _c;
-      const root = config.root || process.cwd();
-      let entry;
-      let template;
-      if (ctx.options.entry) {
-        const providedPath = _path2.default.resolve(root, ctx.options.entry);
-        if (_fs2.default.existsSync(providedPath)) {
-          entry = providedPath;
-        } else {
-          this.error(`Provided entry file does not exist: ${providedPath}`);
-        }
+      var _a;
+      ctx.resolve(config);
+      config.build || (config.build = {});
+      const major = Number(_vite.version.split(".")[0]);
+      const bundlerKey = major >= 8 ? "rolldownOptions" : "rollupOptions";
+      (_a = config.build)[bundlerKey] || (_a[bundlerKey] = {});
+      const bundlerOptions = config.build[bundlerKey];
+      if (Array.isArray(bundlerOptions.input)) {
+        bundlerOptions.input = [...bundlerOptions.input, ctx.input];
+      } else if (typeof bundlerOptions.input === "object" && bundlerOptions.input !== null) {
+        bundlerOptions.input[ctx.input] = ctx.input;
       } else {
-        for (const file of DEFAULT_ENTRIES) {
-          const fullPath = _path2.default.resolve(root, "src", file);
-          if (_fs2.default.existsSync(fullPath)) {
-            entry = fullPath;
-            break;
-          }
-        }
-        if (!entry) {
-          this.error(
-            `No entry file found in "src".
-Tried: ${DEFAULT_ENTRIES.map((c) => _path2.default.join("src", c)).join(", ")}
-\u{1F449} Tip: You can pass a custom entry like:
-   blogger({ entry: "src/my-entry.ts" })`
-          );
-        }
+        bundlerOptions.input = ctx.input;
       }
-      if (ctx.options.template) {
-        const providedPath = _path2.default.resolve(root, ctx.options.template);
-        if (_fs2.default.existsSync(providedPath)) {
-          template = providedPath;
-        } else {
-          this.error(`Provided template file does not exist: ${providedPath}`);
+      const originalTemplateXmlContent = fs2.readFileSync(ctx.template, "utf8");
+      const modifiedTemplateXmlContent = replaceBloggerPluginHeadComment(replaceBloggerPluginHeadComment(originalTemplateXmlContent, ""), "", true);
+      fs2.writeFileSync(ctx.template, modifiedTemplateXmlContent, "utf-8");
+    },
+    configResolved(config) {
+      ctx.viteConfig = config;
+      ctx.tailwind = config.plugins.flat(Number.POSITIVE_INFINITY).some((plugin) => isTailwindPlugin(plugin));
+      if (ctx.tailwind) {
+        clearTailwindCache(ctx.root);
+        if (config.command === "build") {
+          updateTailwindCache(ctx.root, fs2.readFileSync(ctx.template, "utf-8"));
         }
       } else {
-        for (const file of DEFAULT_TEMPLATES) {
-          const fullPath = _path2.default.resolve(root, "src", file);
-          if (_fs2.default.existsSync(fullPath)) {
-            template = fullPath;
-            break;
-          }
-        }
-        if (!template) {
-          this.error(
-            `No template file found in "src".
-Tried: ${DEFAULT_TEMPLATES.map((c) => _path2.default.join("src", c)).join(", ")}
-\u{1F449} Tip: You can pass a custom template like:
-   blogger({ template: "src/my-template.xml" })`
-          );
-        }
+        removeTailwindCache(ctx.root);
       }
-      ctx.entry = entry;
-      ctx.template = template;
-      (_a = config.build) != null ? _a : config.build = {};
-      (_c = (_b = config.build).rollupOptions) != null ? _c : _b.rollupOptions = {};
-      config.build.rollupOptions.input = entry;
-      const xmlTemplateContent = _fs2.default.readFileSync(ctx.template, "utf8");
-      _fs2.default.writeFileSync(ctx.template, replaceBloggerPluginHeadComment(replaceBloggerPluginHeadComment(xmlTemplateContent, ""), "", true), {
-        encoding: "utf8"
-      });
     },
-    configResolved(config) {
-      ctx.viteConfig = config;
+    resolveId(source) {
+      if (source === ctx.input) {
+        return ctx.input;
+      }
     },
-    generateBundle(_options, bundle) {
-      var _a;
-      for (const output of Object.values(bundle)) {
-        if (output.type !== "chunk" || !output.isEntry) {
-          continue;
-        }
-        const xmlTemplateContent = _fs2.default.readFileSync(ctx.template, "utf8");
-        const htmlTags = [];
-        (_a = output.viteMetadata) == null ? void 0 : _a.importedCss.forEach((value) => {
-          htmlTags.push(`<link crossorigin='anonymous' href='${escapeHtml(ctx.viteConfig.base + value)}' rel='stylesheet'/>`);
-        });
-        htmlTags.push(`<script crossorigin='anonymous' src='${escapeHtml(ctx.viteConfig.base + output.fileName)}' type='module'></script>`);
-        const template = replaceBloggerPluginHeadComment(xmlTemplateContent, htmlTags.join(""), true);
-        this.emitFile({
-          type: "asset",
-          fileName: "template.xml",
-          source: template
-        });
-        break;
+    load(id) {
+      if (id === ctx.input) {
+        return ctx.html;
+      }
+    },
+    writeBundle(_, bundle) {
+      if (!(ctx.input in bundle)) {
+        return;
+      }
+      const asset = bundle[ctx.input];
+      delete bundle[ctx.input];
+      if (asset.type !== "asset" || typeof asset.source !== "string") {
+        return;
+      }
+      const regex = /<!DOCTYPE html>\s*<html[^>]*>\s*<head>([\s\S]*?)<!--head-->([\s\S]*?)<\/head>\s*<body>([\s\S]*?)<!--body-->([\s\S]*?)<\/body>\s*<\/html>/i;
+      const match = asset.source.match(regex);
+      if (!match) {
+        return;
+      }
+      const afterHeadBegin = match[1];
+      const beforeHeadEnd = match[2];
+      const afterBodyBegin = match[3];
+      const beforeBodyEnd = match[4];
+      const headContent = (afterHeadBegin + beforeHeadEnd).replace(/\b(crossorigin|defer|async|disabled|checked)\b(?!=)/g, (_2, $1) => `${$1}=""`).replace(/(\w+)=(".*?"|'.*?')/g, (_2, $1, $2) => {
+        const v = $2.slice(1, -1).replace(/&/g, "&amp;").replace(/'/g, "&apos;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        return `${$1}='${v}'`;
+      }).replace(/<(link|meta|img|br|hr|input)([^>]*?)>/gi, (_2, $1, $2) => `<${$1}${$2} />`).replace(/>\s+</g, "><").trim();
+      const originalTemplateXmlContent = fs2.readFileSync(ctx.template, "utf8");
+      const modifiedTemplateXmlContent = replaceBloggerPluginHeadComment(originalTemplateXmlContent, headContent, true);
+      const templateTagsXmlContent = `<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html>
+<html>
+<head>
+  <!--head:afterbegin:begin-->
+
+  <!--head:afterbegin:end-->
+
+  <!--head:beforeend:begin-->
+  ${headContent}
+  <!--head:beforeend:end-->
+</head>
+<body>
+  <!--body:afterbegin:begin-->
+  ${afterBodyBegin.trim()}
+  <!--body:afterbegin:end-->
+
+  <!--body:beforeend:begin-->
+  ${beforeBodyEnd.trim()}
+  <!--body:beforeend:end-->
+</body>
+</html>`;
+      fs2.writeFileSync(path2.resolve(ctx.viteConfig.build.outDir, "template.xml"), modifiedTemplateXmlContent);
+      fs2.writeFileSync(path2.resolve(ctx.viteConfig.build.outDir, "template-tags.xml"), templateTagsXmlContent);
+    },
+    closeBundle() {
+      const htmlDir = path2.resolve(ctx.viteConfig.build.outDir, "virtual:blogger-plugin");
+      if (fs2.existsSync(htmlDir)) {
+        fs2.rmSync(htmlDir, { recursive: true });
       }
     },
     configureServer(server) {