mokup 0.0.0

package/dist/vite.cjs

@@ -0,0 +1,783 @@
+'use strict';
+
+const node_process = require('node:process');
+const chokidar = require('chokidar');
+const node_buffer = require('node:buffer');
+const runtime = require('@mokup/runtime');
+const pathe = require('pathe');
+const node_fs = require('node:fs');
+const node_module = require('node:module');
+const node_url = require('node:url');
+const esbuild = require('esbuild');
+const jsoncParser = require('jsonc-parser');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
+
+function createLogger(enabled) {
+  return {
+    info: (...args) => {
+      if (enabled) {
+        console.info("[mokup]", ...args);
+      }
+    },
+    warn: (...args) => {
+      if (enabled) {
+        console.warn("[mokup]", ...args);
+      }
+    },
+    error: (...args) => {
+      if (enabled) {
+        console.error("[mokup]", ...args);
+      }
+    }
+  };
+}
+
+const methodSet = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+const methodSuffixSet = new Set(
+  Array.from(methodSet, (method) => method.toLowerCase())
+);
+const supportedExtensions = /* @__PURE__ */ new Set([
+  ".json",
+  ".jsonc",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs"
+]);
+
+function normalizeMethod(method) {
+  if (!method) {
+    return void 0;
+  }
+  const normalized = method.toUpperCase();
+  if (methodSet.has(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizePrefix(prefix) {
+  if (!prefix) {
+    return "";
+  }
+  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function resolveDirs(dir, root) {
+  const raw = typeof dir === "function" ? dir(root) : dir;
+  const resolved = Array.isArray(raw) ? raw : raw ? [raw] : ["mock"];
+  const normalized = resolved.map(
+    (entry) => pathe.isAbsolute(entry) ? entry : pathe.resolve(root, entry)
+  );
+  return Array.from(new Set(normalized));
+}
+function createDebouncer(delayMs, fn) {
+  let timer = null;
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn();
+    }, delayMs);
+  };
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function isInDirs(file, dirs) {
+  const normalized = toPosix(file);
+  return dirs.some((dir) => {
+    const normalizedDir = toPosix(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = toPosix(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+function extractQuery(parsedUrl) {
+  const query = {};
+  for (const [key, value] of parsedUrl.searchParams.entries()) {
+    const current = query[key];
+    if (typeof current === "undefined") {
+      query[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      query[key] = [current, value];
+    }
+  }
+  return query;
+}
+async function readRawBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(node_buffer.Buffer.isBuffer(chunk) ? chunk : node_buffer.Buffer.from(chunk));
+    });
+    req.on("end", () => {
+      if (chunks.length === 0) {
+        resolve(null);
+        return;
+      }
+      resolve(node_buffer.Buffer.concat(chunks));
+    });
+    req.on("error", reject);
+  });
+}
+async function readRequestBody(req, parsedUrl) {
+  const query = extractQuery(parsedUrl);
+  const rawBody = await readRawBody(req);
+  if (!rawBody) {
+    return { query, body: void 0, rawBody: void 0 };
+  }
+  const rawText = rawBody.toString("utf8");
+  const contentTypeHeader = req.headers["content-type"];
+  const contentTypeValue = Array.isArray(contentTypeHeader) ? contentTypeHeader[0] ?? "" : contentTypeHeader ?? "";
+  const contentType = contentTypeValue.split(";")[0]?.trim() ?? "";
+  if (contentType === "application/json" || contentType.endsWith("+json")) {
+    try {
+      return { query, body: JSON.parse(rawText), rawBody: rawText };
+    } catch {
+      return { query, body: rawText, rawBody: rawText };
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    const params = new URLSearchParams(rawText);
+    const body = Object.fromEntries(params.entries());
+    return { query, body, rawBody: rawText };
+  }
+  return { query, body: rawText, rawBody: rawText };
+}
+function applyHeaders(res, headers) {
+  if (!headers) {
+    return;
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    res.setHeader(key, value);
+  }
+}
+function writeResponse(res, body) {
+  if (typeof body === "undefined") {
+    if (!res.headersSent && res.statusCode === 200) {
+      res.statusCode = 204;
+    }
+    res.end();
+    return;
+  }
+  if (node_buffer.Buffer.isBuffer(body)) {
+    if (!res.getHeader("Content-Type")) {
+      res.setHeader("Content-Type", "application/octet-stream");
+    }
+    res.end(body);
+    return;
+  }
+  if (typeof body === "string") {
+    if (!res.getHeader("Content-Type")) {
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    }
+    res.end(body);
+    return;
+  }
+  if (!res.getHeader("Content-Type")) {
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+  }
+  res.end(JSON.stringify(body));
+}
+function findMatchingRoute(routes, method, pathname) {
+  for (const route of routes) {
+    if (route.method !== method) {
+      continue;
+    }
+    const matched = runtime.matchRouteTokens(route.tokens, pathname);
+    if (matched) {
+      return { route, params: matched.params };
+    }
+  }
+  return null;
+}
+function createMiddleware(getRoutes, logger) {
+  return async (req, res, next) => {
+    const url = req.url ?? "/";
+    const parsedUrl = new URL(url, "http://mokup.local");
+    const pathname = parsedUrl.pathname;
+    const method = normalizeMethod(req.method) ?? "GET";
+    const matched = findMatchingRoute(getRoutes(), method, pathname);
+    if (!matched) {
+      return next();
+    }
+    try {
+      const { query, body, rawBody } = await readRequestBody(req, parsedUrl);
+      const mockReq = {
+        url: pathname,
+        method,
+        headers: req.headers,
+        query,
+        body,
+        params: matched.params
+      };
+      if (rawBody) {
+        mockReq.rawBody = rawBody;
+      }
+      const ctx = {
+        delay: (ms) => delay(ms),
+        json: (data) => data
+      };
+      const startedAt = Date.now();
+      const responseValue = typeof matched.route.response === "function" ? await matched.route.response(mockReq, res, ctx) : matched.route.response;
+      if (res.writableEnded) {
+        return;
+      }
+      if (matched.route.delay && matched.route.delay > 0) {
+        await delay(matched.route.delay);
+      }
+      applyHeaders(res, matched.route.headers);
+      if (matched.route.status) {
+        res.statusCode = matched.route.status;
+      }
+      writeResponse(res, responseValue);
+      logger.info(`${method} ${pathname} ${Date.now() - startedAt}ms`);
+    } catch (error) {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.end("Mock handler error");
+      logger.error("Mock handler failed:", error);
+    }
+  };
+}
+
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vite.cjs', document.baseURI).href)));
+const mimeTypes = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".ico": "image/x-icon"
+};
+function normalizePlaygroundPath(value) {
+  if (!value) {
+    return "/_mokup";
+  }
+  const normalized = value.startsWith("/") ? value : `/${value}`;
+  return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function resolvePlaygroundOptions(playground) {
+  if (playground === false) {
+    return { enabled: false, path: "/_mokup" };
+  }
+  if (playground && typeof playground === "object") {
+    return {
+      enabled: playground.enabled !== false,
+      path: normalizePlaygroundPath(playground.path)
+    };
+  }
+  return { enabled: true, path: "/_mokup" };
+}
+function resolvePlaygroundDist() {
+  const pkgPath = require$1.resolve("@mokup/playground/package.json");
+  return pathe.join(pkgPath, "..", "dist");
+}
+function sendJson(res, data, statusCode = 200) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(data, null, 2));
+}
+function sendFile(res, content, contentType) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", contentType);
+  res.end(content);
+}
+function toPlaygroundRoute(route) {
+  return {
+    method: route.method,
+    url: route.template,
+    file: route.file,
+    type: typeof route.response === "function" ? "handler" : "static",
+    status: route.status,
+    delay: route.delay
+  };
+}
+function createPlaygroundMiddleware(params) {
+  const distDir = resolvePlaygroundDist();
+  const playgroundPath = params.config.path;
+  const indexPath = pathe.join(distDir, "index.html");
+  return async (req, res, next) => {
+    if (!params.config.enabled) {
+      return next();
+    }
+    const requestUrl = req.url ?? "/";
+    const url = new URL(requestUrl, "http://mokup.local");
+    const pathname = url.pathname;
+    if (!pathname.startsWith(playgroundPath)) {
+      return next();
+    }
+    const subPath = pathname.slice(playgroundPath.length);
+    if (subPath === "" || subPath === "/" || subPath === "/index.html") {
+      try {
+        const html = await node_fs.promises.readFile(indexPath, "utf8");
+        const contentType = mimeTypes[".html"] ?? "text/html; charset=utf-8";
+        sendFile(res, html, contentType);
+      } catch (error) {
+        params.logger.error("Failed to load playground index:", error);
+        res.statusCode = 500;
+        res.end("Playground is not available.");
+      }
+      return;
+    }
+    if (subPath === "/routes") {
+      const routes = params.getRoutes();
+      sendJson(res, {
+        basePath: playgroundPath,
+        count: routes.length,
+        routes: routes.map(toPlaygroundRoute)
+      });
+      return;
+    }
+    const relPath = subPath.replace(/^\/+/, "");
+    if (relPath.includes("..")) {
+      res.statusCode = 400;
+      res.end("Invalid path.");
+      return;
+    }
+    const normalizedPath = pathe.normalize(relPath);
+    const filePath = pathe.join(distDir, normalizedPath);
+    try {
+      const content = await node_fs.promises.readFile(filePath);
+      const ext = pathe.extname(filePath);
+      const contentType = mimeTypes[ext] ?? "application/octet-stream";
+      sendFile(res, content, contentType);
+    } catch {
+      return next();
+    }
+  };
+}
+
+async function walkDir(dir, rootDir, files) {
+  const entries = await node_fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") {
+      continue;
+    }
+    const fullPath = pathe.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(fullPath, rootDir, files);
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push({ file: fullPath, rootDir });
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await node_fs.promises.stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectFiles(dirs) {
+  const files = [];
+  for (const dir of dirs) {
+    if (!await exists(dir)) {
+      continue;
+    }
+    await walkDir(dir, dir, files);
+  }
+  return files;
+}
+function isSupportedFile(file) {
+  if (file.endsWith(".d.ts")) {
+    return false;
+  }
+  const ext = pathe.extname(file).toLowerCase();
+  return supportedExtensions.has(ext);
+}
+
+async function loadModule(file) {
+  const ext = pathe.extname(file).toLowerCase();
+  if (ext === ".cjs") {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vite.cjs', document.baseURI).href)));
+    delete require$1.cache[file];
+    return require$1(file);
+  }
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  if (ext === ".ts") {
+    const result = await esbuild.build({
+      entryPoints: [file],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      sourcemap: "inline",
+      target: "es2020",
+      write: false
+    });
+    const output = result.outputFiles[0];
+    const code = output?.text ?? "";
+    const dataUrl = `data:text/javascript;base64,${node_buffer.Buffer.from(code).toString(
+      "base64"
+    )}`;
+    return import(`${dataUrl}#${Date.now()}`);
+  }
+  return null;
+}
+async function loadModuleWithVite(server, file) {
+  const asDevServer = server;
+  if ("ssrLoadModule" in asDevServer) {
+    const moduleNode = asDevServer.moduleGraph.getModuleById(file);
+    if (moduleNode) {
+      asDevServer.moduleGraph.invalidateModule(moduleNode);
+    }
+    return asDevServer.ssrLoadModule(file);
+  }
+  return loadModule(file);
+}
+async function readJsonFile(file, logger) {
+  try {
+    const content = await node_fs.promises.readFile(file, "utf8");
+    const errors = [];
+    const data = jsoncParser.parse(content, errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    if (errors.length > 0) {
+      logger.warn(`Invalid JSONC in ${file}`);
+      return void 0;
+    }
+    return data;
+  } catch (error) {
+    logger.warn(`Failed to read ${file}: ${String(error)}`);
+    return void 0;
+  }
+}
+async function loadRules(file, server, logger) {
+  const ext = pathe.extname(file).toLowerCase();
+  if (ext === ".json" || ext === ".jsonc") {
+    const json = await readJsonFile(file, logger);
+    if (typeof json === "undefined") {
+      return [];
+    }
+    return [
+      {
+        response: json
+      }
+    ];
+  }
+  const mod = server ? await loadModuleWithVite(server, file) : await loadModule(file);
+  const value = mod?.default ?? mod;
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "function") {
+    return [
+      {
+        response: value
+      }
+    ];
+  }
+  return [value];
+}
+
+function resolveMethod(fileMethod, ruleMethod, logger) {
+  if (ruleMethod) {
+    const normalized = normalizeMethod(ruleMethod);
+    if (normalized) {
+      return normalized;
+    }
+    logger.warn(`Unknown method "${ruleMethod}", falling back to file method`);
+  }
+  if (fileMethod) {
+    return fileMethod;
+  }
+  return "GET";
+}
+function resolveTemplate(template, prefix) {
+  const normalized = template.startsWith("/") ? template : `/${template}`;
+  if (!prefix) {
+    return normalized;
+  }
+  const normalizedPrefix = normalizePrefix(prefix);
+  if (!normalizedPrefix) {
+    return normalized;
+  }
+  if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
+    return normalized;
+  }
+  if (normalized === "/") {
+    return `${normalizedPrefix}/`;
+  }
+  return `${normalizedPrefix}${normalized}`;
+}
+function stripMethodSuffix(base) {
+  const segments = base.split(".");
+  const last = segments.at(-1);
+  if (last && methodSuffixSet.has(last.toLowerCase())) {
+    segments.pop();
+    return {
+      name: segments.join("."),
+      method: last.toUpperCase()
+    };
+  }
+  return {
+    name: base,
+    method: void 0
+  };
+}
+function deriveRouteFromFile(file, rootDir, logger) {
+  const rel = toPosix(pathe.relative(rootDir, file));
+  const ext = pathe.extname(rel);
+  const withoutExt = rel.slice(0, rel.length - ext.length);
+  const dir = pathe.dirname(withoutExt);
+  const base = pathe.basename(withoutExt);
+  const { name, method } = stripMethodSuffix(base);
+  if (!method) {
+    logger.warn(`Skip mock without method suffix: ${file}`);
+    return null;
+  }
+  if (!name) {
+    logger.warn(`Skip mock with empty route name: ${file}`);
+    return null;
+  }
+  const joined = dir === "." ? name : pathe.join(dir, name);
+  const segments = toPosix(joined).split("/");
+  if (segments.at(-1) === "index") {
+    segments.pop();
+  }
+  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+  const parsed = runtime.parseRouteTemplate(template);
+  if (parsed.errors.length > 0) {
+    for (const error of parsed.errors) {
+      logger.warn(`${error} in ${file}`);
+    }
+    return null;
+  }
+  for (const warning of parsed.warnings) {
+    logger.warn(`${warning} in ${file}`);
+  }
+  return {
+    template: parsed.template,
+    method,
+    tokens: parsed.tokens,
+    score: parsed.score
+  };
+}
+function resolveRule(params) {
+  const method = resolveMethod(params.derivedMethod, params.rule.method, params.logger);
+  if (!method) {
+    params.logger.warn(`Invalid mock method in ${params.file}`);
+    return null;
+  }
+  const template = resolveTemplate(params.rule.url ?? params.derivedTemplate, params.prefix);
+  const parsed = runtime.parseRouteTemplate(template);
+  if (parsed.errors.length > 0) {
+    for (const error of parsed.errors) {
+      params.logger.warn(`${error} in ${params.file}`);
+    }
+    return null;
+  }
+  for (const warning of parsed.warnings) {
+    params.logger.warn(`${warning} in ${params.file}`);
+  }
+  const route = {
+    file: params.file,
+    template: parsed.template,
+    method,
+    tokens: parsed.tokens,
+    score: parsed.score,
+    response: params.rule.response
+  };
+  if (typeof params.rule.status === "number") {
+    route.status = params.rule.status;
+  }
+  if (params.rule.headers) {
+    route.headers = params.rule.headers;
+  }
+  if (typeof params.rule.delay === "number") {
+    route.delay = params.rule.delay;
+  }
+  return route;
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.method !== b.method) {
+      return a.method.localeCompare(b.method);
+    }
+    const scoreCompare = runtime.compareRouteScore(a.score, b.score);
+    if (scoreCompare !== 0) {
+      return scoreCompare;
+    }
+    return a.template.localeCompare(b.template);
+  });
+}
+
+async function scanRoutes(params) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const files = await collectFiles(params.dirs);
+  for (const fileInfo of files) {
+    if (!isSupportedFile(fileInfo.file)) {
+      continue;
+    }
+    if (!matchesFilter(fileInfo.file, params.include, params.exclude)) {
+      continue;
+    }
+    const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, params.logger);
+    if (!derived) {
+      continue;
+    }
+    const rules = await loadRules(fileInfo.file, params.server, params.logger);
+    for (const rule of rules) {
+      if (!rule || typeof rule !== "object") {
+        continue;
+      }
+      if (typeof rule.response === "undefined") {
+        params.logger.warn(`Skip mock without response: ${fileInfo.file}`);
+        continue;
+      }
+      const resolved = resolveRule({
+        rule,
+        derivedTemplate: derived.template,
+        derivedMethod: derived.method,
+        prefix: params.prefix,
+        file: fileInfo.file,
+        logger: params.logger
+      });
+      if (!resolved) {
+        continue;
+      }
+      const key = `${resolved.method} ${resolved.template}`;
+      if (seen.has(key)) {
+        params.logger.warn(`Duplicate mock route ${key} from ${fileInfo.file}`);
+      }
+      seen.add(key);
+      routes.push(resolved);
+    }
+  }
+  return sortRoutes(routes);
+}
+
+function createMokupPlugin(options = {}) {
+  let root = node_process.cwd();
+  let routes = [];
+  let previewWatcher = null;
+  const logger = createLogger(options.log !== false);
+  const watchEnabled = options.watch !== false;
+  const playgroundConfig = resolvePlaygroundOptions(options.playground);
+  const playgroundMiddleware = createPlaygroundMiddleware({
+    getRoutes: () => routes,
+    config: playgroundConfig,
+    logger
+  });
+  const refreshRoutes = async (server) => {
+    const dirs = resolveDirs(options.dir, root);
+    const scanParams = {
+      dirs,
+      prefix: options.prefix ?? "",
+      logger
+    };
+    if (options.include) {
+      scanParams.include = options.include;
+    }
+    if (options.exclude) {
+      scanParams.exclude = options.exclude;
+    }
+    if (server) {
+      scanParams.server = server;
+    }
+    routes = await scanRoutes(scanParams);
+  };
+  return {
+    name: "mokup:vite",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root;
+    },
+    async configureServer(server) {
+      await refreshRoutes(server);
+      server.middlewares.use(playgroundMiddleware);
+      server.middlewares.use(createMiddleware(() => routes, logger));
+      if (!watchEnabled) {
+        return;
+      }
+      const dirs = resolveDirs(options.dir, root);
+      server.watcher.add(dirs);
+      const scheduleRefresh = createDebouncer(80, () => refreshRoutes(server));
+      server.watcher.on("add", (file) => {
+        if (isInDirs(file, dirs)) {
+          scheduleRefresh();
+        }
+      });
+      server.watcher.on("change", (file) => {
+        if (isInDirs(file, dirs)) {
+          scheduleRefresh();
+        }
+      });
+      server.watcher.on("unlink", (file) => {
+        if (isInDirs(file, dirs)) {
+          scheduleRefresh();
+        }
+      });
+    },
+    async configurePreviewServer(server) {
+      await refreshRoutes(server);
+      server.middlewares.use(playgroundMiddleware);
+      server.middlewares.use(createMiddleware(() => routes, logger));
+      if (!watchEnabled) {
+        return;
+      }
+      const dirs = resolveDirs(options.dir, root);
+      previewWatcher = chokidar__default.watch(dirs, { ignoreInitial: true });
+      const scheduleRefresh = createDebouncer(80, () => refreshRoutes(server));
+      previewWatcher.on("add", scheduleRefresh);
+      previewWatcher.on("change", scheduleRefresh);
+      previewWatcher.on("unlink", scheduleRefresh);
+      server.httpServer?.once("close", () => {
+        previewWatcher?.close();
+        previewWatcher = null;
+      });
+    },
+    closeBundle() {
+      previewWatcher?.close();
+      previewWatcher = null;
+    }
+  };
+}
+
+module.exports = createMokupPlugin;