mokup 2.0.2 → 2.1.0

package/dist/webpack.cjs

@@ -1,16 +1,15 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const node_module = require('node:module');
 const process = require('node:process');
-const chokidar = require('@mokup/shared/chokidar');
+const scanner = require('./shared/mokup.i875Kuim.cjs');
+const logger = require('@mokup/shared/logger');
 const esbuild = require('@mokup/shared/esbuild');
+const node_module = require('node:module');
 const pathe = require('@mokup/shared/pathe');
-const sw = require('./shared/mokup.B-yfMz5B.cjs');
+const chokidar = require('@mokup/shared/chokidar');
+require('node:fs');
 require('node:buffer');
 require('@mokup/shared/hono');
-require('node:fs');
 require('node:url');
 require('@mokup/shared/jsonc-parser');
 require('@mokup/runtime');
@@ -20,8 +19,141 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
 
-const pluginName = "mokup:webpack";
-const lifecycleBaseName = "mokup-sw-lifecycle.js";
+async function bundleScript(params) {
+  const result = await esbuild.build({
+    stdin: {
+      contents: params.code,
+      resolveDir: params.root,
+      sourcefile: params.sourceName,
+      loader: "js"
+    },
+    absWorkingDir: params.root,
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    target: "es2020",
+    write: false
+  });
+  return result.outputFiles[0]?.text ?? "";
+}
+
+function buildSwLifecycleScript(params) {
+  const {
+    importPath,
+    swConfig,
+    unregisterConfig,
+    hasSwEntries,
+    hasSwRoutes,
+    resolveRequestPath,
+    resolveRegisterScope
+  } = params;
+  const shouldUnregister = unregisterConfig.unregister === true || !hasSwEntries;
+  if (shouldUnregister) {
+    const path2 = resolveRequestPath(unregisterConfig.path);
+    const scope2 = resolveRegisterScope(unregisterConfig.scope);
+    return [
+      `import { unregisterMokupServiceWorker } from ${JSON.stringify(importPath)}`,
+      "(async () => {",
+      `  await unregisterMokupServiceWorker({ path: ${JSON.stringify(path2)}, scope: ${JSON.stringify(scope2)} })`,
+      "})()"
+    ].join("\n");
+  }
+  if (!swConfig || swConfig.register === false) {
+    return null;
+  }
+  if (!hasSwRoutes) {
+    return null;
+  }
+  const path = resolveRequestPath(swConfig.path);
+  const scope = resolveRegisterScope(swConfig.scope);
+  return [
+    `import { registerMokupServiceWorker } from ${JSON.stringify(importPath)}`,
+    "(async () => {",
+    `  const registration = await registerMokupServiceWorker({ path: ${JSON.stringify(path)}, scope: ${JSON.stringify(scope)} })`,
+    "  if (import.meta.hot && registration) {",
+    "    import.meta.hot.on('mokup:routes-changed', () => {",
+    "      registration.update()",
+    "    })",
+    "  }",
+    "})()"
+  ].join("\n");
+}
+
+function createBundleBuilder(params) {
+  const {
+    bundleState,
+    state,
+    root,
+    swConfig,
+    unregisterConfig,
+    hasSwEntries,
+    hasSwRoutes,
+    resolveRequestPath,
+    resolveRegisterScope,
+    resolveModulePath,
+    refreshRoutes,
+    logger
+  } = params;
+  let buildPromise = null;
+  const rebuildBundles = async () => {
+    const lifecycle = buildSwLifecycleScript({
+      importPath: "mokup/sw",
+      swConfig,
+      unregisterConfig,
+      hasSwEntries,
+      hasSwRoutes: hasSwRoutes(),
+      resolveRequestPath,
+      resolveRegisterScope
+    });
+    bundleState.swLifecycleBundle = lifecycle ? await bundleScript({
+      code: lifecycle,
+      root: root(),
+      sourceName: "mokup-sw-lifecycle.js"
+    }) : null;
+    if (swConfig && hasSwRoutes()) {
+      const swScript = scanner.buildSwScript({
+        routes: state.swRoutes,
+        root: root(),
+        runtimeImportPath: "mokup/runtime",
+        basePaths: swConfig.basePaths ?? [],
+        resolveModulePath
+      });
+      bundleState.swBundle = await bundleScript({
+        code: swScript,
+        root: root(),
+        sourceName: "mokup-sw.js"
+      });
+    } else {
+      bundleState.swBundle = null;
+    }
+  };
+  const ensureBuilt = async () => {
+    if (!buildPromise) {
+      buildPromise = (async () => {
+        await refreshRoutes();
+        await rebuildBundles();
+      })().catch((error) => {
+        logger.error("Failed to build mokup bundles:", error);
+      }).finally(() => {
+        buildPromise = null;
+      });
+    }
+    await buildPromise;
+  };
+  return { rebuildBundles, ensureBuilt };
+}
+
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('webpack.cjs', document.baseURI).href)));
+function resolveHtmlWebpackPlugin() {
+  try {
+    const mod = require$1("html-webpack-plugin");
+    const plugin = mod.default ?? mod;
+    return plugin;
+  } catch {
+    return null;
+  }
+}
+
 const legacyEntryKeys = [
   "dir",
   "prefix",
@@ -58,6 +190,7 @@ function normalizeOptions(options) {
   const list = Array.isArray(entries) ? entries : entries ? [entries] : [{}];
   return list.length > 0 ? list : [{}];
 }
+
 function normalizeBase(base) {
   if (!base) {
     return "/";
@@ -120,118 +253,18 @@ function joinPublicPath(publicPath, fileName) {
   const normalized = publicPath.endsWith("/") ? publicPath : `${publicPath}/`;
   return `${normalized}${fileName}`;
 }
-function buildSwLifecycleScript(params) {
-  const { base, importPath, swConfig, unregisterConfig, hasSwEntries, hasSwRoutes } = params;
-  const shouldUnregister = unregisterConfig.unregister === true || !hasSwEntries;
-  if (shouldUnregister) {
-    const path2 = resolveRegisterPath(base, unregisterConfig.path);
-    const scope2 = resolveRegisterScope(base, unregisterConfig.scope);
-    return [
-      `import { unregisterMokupServiceWorker } from ${JSON.stringify(importPath)}`,
-      "(async () => {",
-      `  await unregisterMokupServiceWorker({ path: ${JSON.stringify(path2)}, scope: ${JSON.stringify(scope2)} })`,
-      "})()"
-    ].join("\n");
-  }
-  if (!swConfig || swConfig.register === false) {
-    return null;
-  }
-  if (!hasSwRoutes) {
-    return null;
-  }
-  const path = resolveRegisterPath(base, swConfig.path);
-  const scope = resolveRegisterScope(base, swConfig.scope);
-  return [
-    `import { registerMokupServiceWorker } from ${JSON.stringify(importPath)}`,
-    "(async () => {",
-    `  const registration = await registerMokupServiceWorker({ path: ${JSON.stringify(path)}, scope: ${JSON.stringify(scope)} })`,
-    "  if (import.meta.hot && registration) {",
-    "    import.meta.hot.on('mokup:routes-changed', () => {",
-    "      registration.update()",
-    "    })",
-    "  }",
-    "})()"
-  ].join("\n");
-}
 function resolveModuleFilePath(file, root) {
   const absolute = pathe.isAbsolute(file) ? file : pathe.resolve(root, file);
-  const normalized = sw.toPosix(absolute);
+  const normalized = scanner.toPosix(absolute);
   if (/^[a-z]:\//i.test(normalized)) {
     return `file:///${normalized}`;
   }
   return normalized;
 }
-async function bundleScript(params) {
-  const result = await esbuild.build({
-    stdin: {
-      contents: params.code,
-      resolveDir: params.root,
-      sourcefile: params.sourceName,
-      loader: "js"
-    },
-    absWorkingDir: params.root,
-    bundle: true,
-    platform: "browser",
-    format: "esm",
-    target: "es2020",
-    write: false
-  });
-  return result.outputFiles[0]?.text ?? "";
-}
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('webpack.cjs', document.baseURI).href)));
-function resolveHtmlWebpackPlugin() {
-  try {
-    const mod = require$1("html-webpack-plugin");
-    const plugin = mod.default ?? mod;
-    return plugin;
-  } catch {
-    return null;
-  }
-}
-function createMokupWebpackPlugin(options = {}) {
-  const normalizedOptions = normalizeMokupOptions(options);
-  const optionList = normalizeOptions(normalizedOptions);
-  const logEnabled = optionList.every((entry) => entry.log !== false);
-  const watchEnabled = optionList.every((entry) => entry.watch !== false);
-  const playgroundConfig = sw.resolvePlaygroundOptions(normalizedOptions.playground);
-  const logger = sw.createLogger(logEnabled);
-  const hasSwEntries = optionList.some((entry) => entry.mode === "sw");
-  const swConfig = sw.resolveSwConfig(optionList, logger);
-  const unregisterConfig = sw.resolveSwUnregisterConfig(optionList, logger);
-  let root = process.cwd();
-  let base = "/";
-  let assetsDir = "assets";
-  let routes = [];
-  let serverRoutes = [];
-  let swRoutes = [];
-  let disabledRoutes = [];
-  let ignoredRoutes = [];
-  let configFiles = [];
-  let disabledConfigFiles = [];
-  let app = null;
-  let watcher = null;
-  let watchingCompiler = null;
-  let swLifecycleBundle = null;
-  let swBundle = null;
-  let swLifecycleFileName = `${assetsDir}/${lifecycleBaseName}`;
-  let warnedHtml = false;
-  let buildPromise = null;
-  const resolveAllDirs = () => {
-    const dirs = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const entry of optionList) {
-      for (const dir of sw.resolveDirs(entry.dir, root)) {
-        if (seen.has(dir)) {
-          continue;
-        }
-        seen.add(dir);
-        dirs.push(dir);
-      }
-    }
-    return dirs;
-  };
-  const hasSwRoutes = () => !!swConfig && swRoutes.length > 0;
-  const refreshRoutes = async () => {
+
+function createRouteRefresher(params) {
+  const { state, optionList, root, logger } = params;
+  return async () => {
     const collected = [];
     const collectedServer = [];
     const collectedSw = [];
@@ -239,9 +272,8 @@ function createMokupWebpackPlugin(options = {}) {
     const collectedIgnored = [];
     const collectedConfigs = [];
     for (const entry of optionList) {
-      const dirs = sw.resolveDirs(entry.dir, root);
       const scanParams = {
-        dirs,
+        dirs: scanner.resolveDirs(entry.dir, root()),
         prefix: entry.prefix ?? "",
         logger,
         onSkip: (info) => collectedDisabled.push(info),
@@ -257,7 +289,7 @@ function createMokupWebpackPlugin(options = {}) {
       if (typeof entry.ignorePrefix !== "undefined") {
         scanParams.ignorePrefix = entry.ignorePrefix;
       }
-      const scanned = await sw.scanRoutes(scanParams);
+      const scanned = await scanner.scanRoutes(scanParams);
       collected.push(...scanned);
       if (entry.mode === "sw") {
         collectedSw.push(...scanned);
@@ -268,69 +300,121 @@ function createMokupWebpackPlugin(options = {}) {
         collectedServer.push(...scanned);
       }
     }
-    routes = sw.sortRoutes(collected);
-    serverRoutes = sw.sortRoutes(collectedServer);
-    swRoutes = sw.sortRoutes(collectedSw);
-    disabledRoutes = collectedDisabled;
-    ignoredRoutes = collectedIgnored;
+    state.routes = scanner.sortRoutes(collected);
+    state.serverRoutes = scanner.sortRoutes(collectedServer);
+    state.swRoutes = scanner.sortRoutes(collectedSw);
+    state.disabledRoutes = collectedDisabled;
+    state.ignoredRoutes = collectedIgnored;
     const configMap = new Map(collectedConfigs.map((entry) => [entry.file, entry]));
     const resolvedConfigs = Array.from(configMap.values());
-    configFiles = resolvedConfigs.filter((entry) => entry.enabled);
-    disabledConfigFiles = resolvedConfigs.filter((entry) => !entry.enabled);
-    app = serverRoutes.length > 0 ? sw.createHonoApp(serverRoutes) : null;
+    state.configFiles = resolvedConfigs.filter((entry) => entry.enabled);
+    state.disabledConfigFiles = resolvedConfigs.filter((entry) => !entry.enabled);
+    state.app = state.serverRoutes.length > 0 ? scanner.createHonoApp(state.serverRoutes) : null;
   };
-  const rebuildBundles = async () => {
-    const lifecycle = buildSwLifecycleScript({
-      base,
-      importPath: "mokup/sw",
-      swConfig,
-      unregisterConfig,
-      hasSwEntries,
-      hasSwRoutes: hasSwRoutes()
-    });
-    swLifecycleBundle = lifecycle ? await bundleScript({
-      code: lifecycle,
-      root,
-      sourceName: lifecycleBaseName
-    }) : null;
-    if (swConfig && hasSwRoutes()) {
-      const swScript = sw.buildSwScript({
-        routes: swRoutes,
-        root,
-        runtimeImportPath: "mokup/runtime",
-        basePaths: swConfig.basePaths ?? [],
-        resolveModulePath: resolveModuleFilePath
-      });
-      swBundle = await bundleScript({
-        code: swScript,
-        root,
-        sourceName: "mokup-sw.js"
-      });
-    } else {
-      swBundle = null;
+}
+
+function createWebpackWatcher(params) {
+  if (!params.enabled || params.dirs.length === 0) {
+    return null;
+  }
+  const watcher = chokidar__default.watch(params.dirs, { ignoreInitial: true });
+  const scheduleRefresh = scanner.createDebouncer(80, () => {
+    void params.onRefresh();
+  });
+  watcher.on("add", (file) => {
+    if (scanner.isInDirs(file, params.dirs)) {
+      scheduleRefresh();
+    }
+  });
+  watcher.on("change", (file) => {
+    if (scanner.isInDirs(file, params.dirs)) {
+      scheduleRefresh();
     }
+  });
+  watcher.on("unlink", (file) => {
+    if (scanner.isInDirs(file, params.dirs)) {
+      scheduleRefresh();
+    }
+  });
+  return watcher;
+}
+
+const pluginName = "mokup:webpack";
+const lifecycleBaseName = "mokup-sw-lifecycle.js";
+function createMokupWebpackPlugin(options = {}) {
+  const normalizedOptions = normalizeMokupOptions(options);
+  const optionList = normalizeOptions(normalizedOptions);
+  const logEnabled = optionList.every((entry) => entry.log !== false);
+  const watchEnabled = optionList.every((entry) => entry.watch !== false);
+  const playgroundConfig = scanner.resolvePlaygroundOptions(normalizedOptions.playground);
+  const logger$1 = logger.createLogger(logEnabled);
+  const hasSwEntries = optionList.some((entry) => entry.mode === "sw");
+  const swConfig = scanner.resolveSwConfig(optionList, logger$1);
+  const unregisterConfig = scanner.resolveSwUnregisterConfig(optionList, logger$1);
+  let root = process.cwd();
+  let base = "/";
+  let assetsDir = "assets";
+  const state = {
+    routes: [],
+    serverRoutes: [],
+    swRoutes: [],
+    disabledRoutes: [],
+    ignoredRoutes: [],
+    configFiles: [],
+    disabledConfigFiles: [],
+    app: null
   };
-  const ensureBuilt = async () => {
-    if (!buildPromise) {
-      buildPromise = (async () => {
-        await refreshRoutes();
-        await rebuildBundles();
-      })().catch((error) => {
-        logger.error("Failed to build mokup bundles:", error);
-      }).finally(() => {
-        buildPromise = null;
-      });
+  let watcher = null;
+  let watchingCompiler = null;
+  const bundleState = {
+    swLifecycleBundle: null,
+    swBundle: null
+  };
+  let swLifecycleFileName = `${assetsDir}/${lifecycleBaseName}`;
+  let warnedHtml = false;
+  const resolveAllDirs = () => {
+    const dirs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of optionList) {
+      for (const dir of scanner.resolveDirs(entry.dir, root)) {
+        if (seen.has(dir)) {
+          continue;
+        }
+        seen.add(dir);
+        dirs.push(dir);
+      }
     }
-    await buildPromise;
+    return dirs;
   };
-  const playgroundMiddleware = sw.createPlaygroundMiddleware({
-    getRoutes: () => routes,
-    getDisabledRoutes: () => disabledRoutes,
-    getIgnoredRoutes: () => ignoredRoutes,
-    getConfigFiles: () => configFiles,
-    getDisabledConfigFiles: () => disabledConfigFiles,
+  const hasSwRoutes = () => !!swConfig && state.swRoutes.length > 0;
+  const refreshRoutes = createRouteRefresher({
+    state,
+    optionList,
+    root: () => root,
+    logger: logger$1
+  });
+  const { rebuildBundles, ensureBuilt } = createBundleBuilder({
+    bundleState,
+    state,
+    root: () => root,
+    swConfig,
+    unregisterConfig,
+    hasSwEntries,
+    hasSwRoutes,
+    resolveRequestPath: (path) => resolveRegisterPath(base, path),
+    resolveRegisterScope: (scope) => resolveRegisterScope(base, scope),
+    resolveModulePath: resolveModuleFilePath,
+    refreshRoutes,
+    logger: logger$1
+  });
+  const playgroundMiddleware = scanner.createPlaygroundMiddleware({
+    getRoutes: () => state.routes,
+    getDisabledRoutes: () => state.disabledRoutes,
+    getIgnoredRoutes: () => state.ignoredRoutes,
+    getConfigFiles: () => state.configFiles,
+    getDisabledConfigFiles: () => state.disabledConfigFiles,
     config: playgroundConfig,
-    logger,
+    logger: logger$1,
     getDirs: () => resolveAllDirs(),
     getServer: () => ({ config: { base, root } })
   });
@@ -345,7 +429,7 @@ function createMokupWebpackPlugin(options = {}) {
       return next();
     }
     await ensureBuilt();
-    if (!swBundle) {
+    if (!bundleState.swBundle) {
       res.statusCode = 500;
       res.setHeader("Content-Type", "text/plain; charset=utf-8");
       res.end("Failed to generate mokup service worker.");
@@ -354,9 +438,9 @@ function createMokupWebpackPlugin(options = {}) {
     res.statusCode = 200;
     res.setHeader("Content-Type", "application/javascript; charset=utf-8");
     res.setHeader("Cache-Control", "no-cache");
-    res.end(swBundle);
+    res.end(bundleState.swBundle);
   };
-  const mockMiddleware = sw.createMiddleware(() => app, logger);
+  const mockMiddleware = scanner.createMiddleware(() => state.app, logger$1);
   return {
     apply(compiler) {
       root = compiler.context ?? process.cwd();
@@ -376,7 +460,7 @@ function createMokupWebpackPlugin(options = {}) {
         if (HtmlWebpackPlugin) {
           const hooks = HtmlWebpackPlugin.getHooks(compilation);
           const injectTag = () => {
-            if (!swLifecycleBundle) {
+            if (!bundleState.swLifecycleBundle) {
               return;
             }
             const tagBase = {
@@ -416,25 +500,25 @@ function createMokupWebpackPlugin(options = {}) {
           injectTag();
         } else if (!warnedHtml) {
           warnedHtml = true;
-          logger.warn("html-webpack-plugin not found; skip SW lifecycle injection.");
+          logger$1.warn("html-webpack-plugin not found; skip SW lifecycle injection.");
         }
         compilation.hooks.processAssets.tapPromise(
           { name: pluginName, stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS },
           async () => {
             await ensureBuilt();
-            if (swLifecycleBundle) {
+            if (bundleState.swLifecycleBundle) {
               const RawSource = compiler.webpack.sources.RawSource;
-              const source = new RawSource(swLifecycleBundle);
+              const source = new RawSource(bundleState.swLifecycleBundle);
               if (compilation.getAsset(swLifecycleFileName)) {
                 compilation.updateAsset(swLifecycleFileName, source);
               } else {
                 compilation.emitAsset(swLifecycleFileName, source);
               }
             }
-            if (swBundle && swConfig) {
+            if (bundleState.swBundle && swConfig) {
               const fileName = swConfig.path.startsWith("/") ? swConfig.path.slice(1) : swConfig.path;
               const RawSource = compiler.webpack.sources.RawSource;
-              const source = new RawSource(swBundle);
+              const source = new RawSource(bundleState.swBundle);
               if (compilation.getAsset(fileName)) {
                 compilation.updateAsset(fileName, source);
               } else {
@@ -459,30 +543,19 @@ function createMokupWebpackPlugin(options = {}) {
           );
           if (!watcher && watchEnabled) {
             const dirs = resolveAllDirs();
-            const fsWatcher = chokidar__default.watch(dirs, { ignoreInitial: true });
-            watcher = fsWatcher;
-            const scheduleRefresh = sw.createDebouncer(80, () => {
-              void refreshRoutes().then(rebuildBundles).then(() => {
-                if (watchingCompiler?.watching) {
-                  watchingCompiler.watching.invalidate();
+            watcher = createWebpackWatcher({
+              enabled: watchEnabled,
+              dirs,
+              onRefresh: async () => {
+                try {
+                  await refreshRoutes();
+                  await rebuildBundles();
+                  if (watchingCompiler?.watching) {
+                    watchingCompiler.watching.invalidate();
+                  }
+                } catch (error) {
+                  logger$1.error("Failed to refresh mokup routes:", error);
                 }
-              }).catch((error) => {
-                logger.error("Failed to refresh mokup routes:", error);
-              });
-            });
-            fsWatcher.on("add", (file) => {
-              if (sw.isInDirs(file, dirs)) {
-                scheduleRefresh();
-              }
-            });
-            fsWatcher.on("change", (file) => {
-              if (sw.isInDirs(file, dirs)) {
-                scheduleRefresh();
-              }
-            });
-            fsWatcher.on("unlink", (file) => {
-              if (sw.isInDirs(file, dirs)) {
-                scheduleRefresh();
               }
             });
           }
@@ -498,4 +571,3 @@ function createMokupWebpackPlugin(options = {}) {
 }
 
 exports.createMokupWebpackPlugin = createMokupWebpackPlugin;
-exports.default = createMokupWebpackPlugin;

package/dist/webpack.d.cts

@@ -1,5 +1,5 @@
-import { MokupPluginOptions } from './index.cjs';
-export { HttpMethod, RequestHandler, RouteDirectoryConfig, RouteResponse, RouteRule, RuntimeMode, ServiceWorkerOptions, VitePluginOptions, VitePluginOptionsInput } from './index.cjs';
+import { M as MokupPluginOptions } from './shared/mokup.CWQ8woZc.cjs';
+export { H as HttpMethod, a as MiddlewarePosition, b as MiddlewareRegistry, R as RequestHandler, c as RouteDirectoryConfig, d as RouteResponse, e as RouteRule, f as RuntimeMode, S as ServiceWorkerOptions, V as VitePluginOptions, g as VitePluginOptionsInput } from './shared/mokup.CWQ8woZc.cjs';
 import { IncomingMessage, ServerResponse } from 'node:http';
 export { Context, MiddlewareHandler } from '@mokup/shared/hono';
 export { PlaygroundOptionsInput } from '@mokup/shared';
@@ -82,8 +82,40 @@ interface WebpackCompiler {
         };
     };
 }
+
+/**
+ * Create the mokup webpack plugin for webpack-dev-server.
+ *
+ * @param options - Plugin options.
+ * @returns Webpack plugin instance.
+ *
+ * @example
+ * import { createMokupWebpackPlugin } from 'mokup/webpack'
+ *
+ * export default {
+ *   plugins: [createMokupWebpackPlugin({ entries: { dir: 'mock' } })],
+ * }
+ */
 declare function createMokupWebpackPlugin(options?: MokupPluginOptions): WebpackPluginInstance;
 
-// @ts-ignore
-export = createMokupWebpackPlugin;
+/**
+ * Webpack plugin options (alias of MokupPluginOptions).
+ *
+ * @example
+ * import type { WebpackPluginOptions } from 'mokup/webpack'
+ *
+ * const options: WebpackPluginOptions = { entries: { dir: 'mock' } }
+ */
+type WebpackPluginOptions = MokupPluginOptions;
+/**
+ * Webpack plugin options input (alias of MokupPluginOptions).
+ *
+ * @example
+ * import type { WebpackPluginOptionsInput } from 'mokup/webpack'
+ *
+ * const options: WebpackPluginOptionsInput = { entries: { dir: 'mock' } }
+ */
+type WebpackPluginOptionsInput = MokupPluginOptions;
+
 export { MokupPluginOptions, createMokupWebpackPlugin };
+export type { WebpackPluginOptions, WebpackPluginOptionsInput };