@ozdao/prometheus-framework 0.2.156 → 0.2.158

package/dist/builder.mjs

@@ -0,0 +1,801 @@
+import require$$0 from "path";
+import require$$1$1 from "webpack";
+import require$$2$1 from "compression";
+import require$$3$1 from "readline";
+import require$$4 from "chalk";
+import require$$5 from "webpack-dev-middleware";
+import require$$6 from "webpack-hot-middleware";
+import require$$1 from "mustache";
+import require$$2 from "chokidar";
+import require$$3 from "fs";
+import require$$9 from "webpack-hot-middleware/client.js";
+import require$$1$2 from "express";
+import require$$7 from "connect-history-api-fallback";
+import require$$2$2 from "vue-loader";
+import require$$3$2 from "mini-css-extract-plugin";
+import require$$4$1 from "clean-webpack-plugin";
+import require$$5$1 from "webpack-bundle-analyzer";
+import require$$6$1 from "dotenv-webpack";
+import require$$1$3 from "glob-all";
+import require$$3$3 from "webpack-merge";
+import require$$4$2 from "webpack-stats-plugin";
+import require$$6$2 from "css-minimizer-webpack-plugin";
+import require$$7$1 from "terser-webpack-plugin";
+import require$$8 from "workbox-webpack-plugin";
+import require$$9$1 from "purgecss-webpack-plugin";
+import require$$2$3 from "webpack-node-externals";
+import require$$6$3 from "copy-webpack-plugin";
+import require$$8$1 from "html-webpack-plugin";
+import require$$4$3 from "webpack-manifest-plugin";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function commonjsRequire(path2) {
+  throw new Error('Could not dynamically require "' + path2 + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+const path$9 = require$$0;
+const Mustache$1 = require$$1;
+const chokidar = require$$2;
+const { promises: { readFile } } = require$$3;
+const templatePath$1 = path$9.resolve(__dirname, "../templates/page.html");
+let template;
+const renderHtml$1 = async (stuff) => {
+  if (!template) {
+    const buffer = await readFile(templatePath$1);
+    template = buffer.toString();
+  }
+  const data = {
+    ...stuff,
+    googleTagId: process.env.GOOGLE_TAG_ID,
+    googleMapApiKey: process.env.GOOGLE_MAPS_API_KEY
+  };
+  return Mustache$1.render(template, data);
+};
+const createHtmlRenderer$1 = (onTemplateUpdate) => {
+  let shouldReload = true;
+  let currentTemplate;
+  chokidar.watch(templatePath$1).on("change", () => {
+    shouldReload = true;
+    onTemplateUpdate();
+  });
+  const loadTemplate = async () => {
+    if (!shouldReload) return;
+    const buffer = await readFile(templatePath$1);
+    currentTemplate = buffer.toString();
+    shouldReload = false;
+  };
+  return async (stuff) => {
+    await loadTemplate();
+    const data = {
+      ...stuff,
+      googleTagId: process.env.GOOGLE_TAG_ID,
+      googleMapApiKey: process.env.GOOGLE_MAPS_API_KEY
+    };
+    return Mustache$1.render(currentTemplate, data);
+  };
+};
+var ssrRenderHtml = {
+  createHtmlRenderer: createHtmlRenderer$1,
+  renderHtml: renderHtml$1
+};
+const normalizeAssets = (assets) => {
+  if (Array.isArray(assets)) return assets;
+  if (typeof assets === "object") return Object.values(assets);
+  return [assets];
+};
+const transformDevStats$1 = (stats, outputFileSystem) => {
+  const {
+    assetsByChunkName: { main },
+    outputPath,
+    publicPath
+  } = stats;
+  const head = `
+      <style>
+      ${normalizeAssets(main).filter((path2) => path2.endsWith(".css")).map(
+    (path2) => outputFileSystem.readFileSync(path2.join(outputPath, path2))
+  ).join("\n")}
+      </style>
+    `;
+  const body = normalizeAssets(main).filter((path2) => path2.endsWith(".js")).map((path2) => `<script src="${publicPath}${path2}"></script>`).join("\n");
+  return { head, body };
+};
+const transformProdStats$1 = ({ stats, publicPath }) => {
+  const {
+    assetsByChunkName: { main }
+  } = stats;
+  const head = normalizeAssets(main).filter((path2) => path2.endsWith(".css")).map((path2) => `<link rel="stylesheet" href="${publicPath}${path2}">`).join("\n");
+  const body = normalizeAssets(main).filter((path2) => path2.endsWith(".js")).map((path2) => `<script src="${publicPath}${path2}"></script>`).join("\n");
+  return { head, body };
+};
+var ssrTransformWebpackStats = {
+  transformDevStats: transformDevStats$1,
+  transformProdStats: transformProdStats$1
+};
+const path$8 = require$$0;
+const webpack$7 = require$$1$1;
+const compression$2 = require$$2$1;
+const readline$1 = require$$3$1;
+const chalk$1 = require$$4;
+const devMiddleware$1 = require$$5;
+const hotMiddleware$1 = require$$6;
+const { createHtmlRenderer } = ssrRenderHtml;
+const { transformDevStats } = ssrTransformWebpackStats;
+var ssr_dev = function createSsrDevServer(projectRoot, { clientConfig: clientConfig2, serverConfig: serverConfig2, ssrConfig: ssrConfig2, createServerPath }) {
+  const clientCompiler = webpack$7(clientConfig2);
+  const serverCompiler = webpack$7(serverConfig2);
+  const ssrCompiler = webpack$7(ssrConfig2);
+  const createDevRenderer = (onUpdate) => {
+    const createHotReloadingServerRenderer = (config) => {
+      const progressPlugin = new webpack$7.ProgressPlugin((percentage, message, ...args) => {
+        readline$1.clearLine(process.stdout, 0);
+        readline$1.cursorTo(process.stdout, 0);
+        process.stdout.write(
+          chalk$1.greenBright.bold(`${(percentage * 100).toFixed(2)}% `) + chalk$1.blueBright(message) + " " + args.map((arg) => chalk$1.yellow(arg)).join(" ")
+        );
+      });
+      config.plugins = config.plugins || [];
+      config.plugins.push(progressPlugin);
+      let renderApp2 = null;
+      let setCompilationDone = null;
+      let ssrCompilation = new Promise((resolve) => {
+        setCompilationDone = resolve;
+      });
+      ssrCompiler.watch(
+        {
+          "info-verbosity": "none"
+        },
+        (error, stats) => {
+          if (error) {
+            console.error(chalk$1.red("Server critical error"));
+            console.error(JSON.stringify(error, null, 2));
+            throw error;
+          }
+          const jsonStats = stats.toJson();
+          if (stats.hasErrors()) {
+            console.error(chalk$1.red("Client compilation error"));
+            jsonStats.errors.forEach((err) => console.error(chalk$1.red(err.details)));
+            return;
+          }
+          const { entrypoints, outputPath } = jsonStats;
+          const { main: { assets: [mainChunkPath] } } = entrypoints;
+          const { render } = commonjsRequire(path$8.resolve(outputPath, mainChunkPath.name));
+          renderApp2 = render;
+          setCompilationDone();
+        }
+      );
+      return async (stuff) => {
+        await ssrCompilation;
+        const result = await renderApp2(stuff);
+        return result;
+      };
+    };
+    const renderApp = createHotReloadingServerRenderer(ssrConfig2);
+    const renderHtml2 = createHtmlRenderer(onUpdate);
+    return async (stuff, { stats, outputFileSystem }) => {
+      const { html, meta, state, statusCode } = await renderApp(stuff);
+      const { head, body } = transformDevStats(stats.toJson(), outputFileSystem);
+      const userState = JSON.stringify(state.user);
+      const completeHtml = await renderHtml2({
+        appHtml: html,
+        meta,
+        head,
+        body,
+        userState
+      });
+      return { html: completeHtml, statusCode };
+    };
+  };
+  let serverInstance;
+  let rendererInstance;
+  const clientDevMiddleware = devMiddleware$1(clientCompiler, {
+    publicPath: clientConfig2.output.publicPath,
+    serverSideRender: true,
+    stats: false
+  });
+  const clientHotMiddleware = hotMiddleware$1(clientCompiler, {
+    heartbeat: 5e3,
+    log: false
+  });
+  const port = process.env.PORT || 8080;
+  const startServer = async () => {
+    if (serverInstance) {
+      serverInstance.close();
+    }
+    Object.keys(require.cache).forEach((id) => {
+      delete require.cache[id];
+    });
+    const { createServer } = commonjsRequire(path$8.resolve(projectRoot, createServerPath));
+    let { app, server, env } = await createServer();
+    app.use(clientDevMiddleware);
+    app.use(clientHotMiddleware);
+    if (!rendererInstance) {
+      rendererInstance = createDevRenderer(() => {
+        clientCompiler.hooks.done.tap("reload", () => {
+          setTimeout(() => {
+            require$$9.reload();
+          }, 500);
+        });
+      });
+    }
+    app.use("/*", async (req, res) => {
+      const result = await rendererInstance({
+        url: req.originalUrl,
+        cookies: req.cookies,
+        languages: req.acceptsLanguages()
+      }, res.locals.webpack.devMiddleware);
+      res.status(result.statusCode).header("Content-Type", "text/html; charset=utf-8").send(result.html);
+    });
+    app.use(compression$2());
+    serverInstance = server;
+    try {
+      await server.listen(port);
+      console.log(`Server started at localhost:${port}
+`);
+    } catch (err) {
+      console.error(err);
+      process.exit(1);
+    }
+  };
+  serverCompiler.watch({}, async (err, stats) => {
+    if (err) {
+      console.error(err);
+      return;
+    }
+    console.log(stats.toString(serverConfig2.stats));
+    console.log("Server.js has changed, updating...");
+    await startServer();
+  });
+  return startServer;
+};
+const path$7 = require$$0;
+const express$1 = require$$1$2;
+const { transformProdStats } = ssrTransformWebpackStats;
+const { renderHtml } = ssrRenderHtml;
+var ssr_prod = function createSsrProdServer(projectRoot, { clientConfig: clientConfig2, serverConfig: serverConfig2, createServerPath }) {
+  const clientStats = commonjsRequire(path$7.join(projectRoot, "builds/web/client/stats.json"));
+  const serverManifest = commonjsRequire(path$7.join(projectRoot, "builds/web/server/manifest.json"));
+  const { createServer } = commonjsRequire(path$7.resolve(projectRoot, createServerPath));
+  const startServer = async () => {
+    const { app, server, env } = await createServer();
+    app.use(
+      clientConfig2.output.publicPath,
+      express$1.static(path$7.resolve(projectRoot, "builds/web/client"), {
+        maxAge: "1d"
+        // Кэширование на 1 день
+      })
+    );
+    const { render } = commonjsRequire(path$7.join(
+      serverConfig2.output.path,
+      serverManifest["main.js"]
+    ));
+    const { head, body } = transformProdStats({
+      stats: clientStats,
+      publicPath: clientConfig2.output.publicPath
+    });
+    app.use("/*", async (req, res) => {
+      const { html, meta, state, statusCode } = await render({
+        url: req.originalUrl,
+        cookies: req.cookies,
+        languages: req.acceptsLanguages()
+      });
+      if (state.NotFound) {
+        res.status(404);
+      }
+      const userState = JSON.stringify(state.user);
+      const completeHtml = await renderHtml({
+        appHtml: html,
+        meta,
+        head,
+        body,
+        userState
+      });
+      res.status(statusCode).header("Content-Type", "text/html; charset=utf-8").send(completeHtml);
+    });
+    return server;
+  };
+  const port = process.env.PORT || 8080;
+  const start = async () => {
+    const server = await startServer();
+    try {
+      server.listen(port, () => console.log(`Server running on port ${port}`));
+    } catch (err) {
+      console.error(err);
+      process.exit(1);
+    }
+  };
+  return start;
+};
+const path$6 = require$$0;
+const webpack$6 = require$$1$1;
+const compression$1 = require$$2$1;
+const readline = require$$3$1;
+const chalk = require$$4;
+const devMiddleware = require$$5;
+const hotMiddleware = require$$6;
+const history$1 = require$$7;
+var spa_dev = function createSpaDevServer(projectRoot, { spaConfig: spaConfig2, serverConfig: serverConfig2, createServerPath }) {
+  const spaCompiler = webpack$6(spaConfig2);
+  const serverCompiler = webpack$6(serverConfig2);
+  const createDevRenderer = () => {
+    const progressPlugin = new webpack$6.ProgressPlugin((percentage, message, ...args) => {
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+      process.stdout.write(
+        chalk.greenBright.bold(`${(percentage * 100).toFixed(2)}% `) + chalk.blueBright(message) + " " + args.map((arg) => chalk.yellow(arg)).join(" ")
+      );
+    });
+    spaConfig2.plugins.push(progressPlugin);
+  };
+  let serverInstance;
+  const clientDevMiddleware = devMiddleware(spaCompiler, {
+    publicPath: spaConfig2.output.publicPath,
+    stats: false
+  });
+  const clientHotMiddleware = hotMiddleware(spaCompiler, {
+    heartbeat: 5e3,
+    log: false
+  });
+  const port = process.env.PORT || 8080;
+  const startServer = async () => {
+    if (serverInstance) {
+      serverInstance.close();
+    }
+    Object.keys(require.cache).forEach((id) => {
+      delete require.cache[id];
+    });
+    const { createServer } = commonjsRequire(path$6.resolve(projectRoot, createServerPath));
+    let { app, server, env } = await createServer();
+    app.use(history$1());
+    app.use(clientDevMiddleware);
+    app.use(clientHotMiddleware);
+    app.use(compression$1());
+    app.get("*", (req, res, next) => {
+      const filename = path$6.join(spaCompiler.outputPath, "index.html");
+      spaCompiler.outputFileSystem.readFile(filename, (err, result) => {
+        if (err) {
+          return next(err);
+        }
+        res.set("content-type", "text/html");
+        res.send(result);
+        res.end();
+      });
+    });
+    serverInstance = server;
+    try {
+      await server.listen(port);
+      console.log(`Server started at http://localhost:${port}
+`);
+    } catch (err) {
+      console.error(err);
+      process.exit(1);
+    }
+  };
+  serverCompiler.watch({}, async (err, stats) => {
+    if (err) {
+      console.error(err);
+      return;
+    }
+    console.log(stats.toString(serverConfig2.stats));
+    console.log("Server.js has changed, updating...");
+    await startServer();
+  });
+  createDevRenderer();
+  return startServer;
+};
+const fs$1 = require$$3;
+const path$5 = require$$0;
+const compression = require$$2$1;
+const express = require$$1$2;
+const history = require$$7;
+var spa_prod = function createSpaProdServer(projectRoot, { createServerPath }) {
+  const port = process.env.PORT || 8080;
+  const startServer = async () => {
+    const { createServer } = commonjsRequire(path$5.resolve(projectRoot, createServerPath));
+    let { app, server } = await createServer();
+    app.use(compression());
+    app.use(express.static(path$5.resolve(projectRoot, "builds/web/spa")));
+    app.use(history({
+      index: "/index.html"
+    }));
+    app.get("*", (req, res) => {
+      fs$1.readFile(path$5.resolve(projectRoot, "builds/web/spa", "index.html"), "utf-8", (err, content) => {
+        if (err) {
+          console.log('We cannot open "index.html" file.');
+          res.writeHead(500, {
+            "Content-Type": "text/plain; charset=utf-8"
+          });
+          res.end("Internal Server Error");
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8"
+        });
+        res.end(content);
+      });
+    });
+    try {
+      await server.listen(port);
+      console.log(`Production server started at http://localhost:${port}
+`);
+    } catch (err) {
+      console.error(err);
+      process.exit(1);
+    }
+  };
+  return startServer;
+};
+const path$4 = require$$0;
+const webpack$5 = require$$1$1;
+const { VueLoaderPlugin } = require$$2$2;
+const MiniCssExtractPlugin = require$$3$2;
+const { CleanWebpackPlugin } = require$$4$1;
+require$$5$1.BundleAnalyzerPlugin;
+const Dotenv = require$$6$1;
+var webpack_config_base = (projectRoot) => {
+  return {
+    resolve: {
+      alias: {
+        "@": path$4.resolve(projectRoot, "src"),
+        "@pf": path$4.resolve(projectRoot, "prometheus-framework"),
+        "vue": path$4.resolve(projectRoot, "node_modules/vue"),
+        "vue-router": path$4.resolve(projectRoot, "node_modules/vue-router"),
+        "vue-i18n": path$4.resolve(projectRoot, "node_modules/vue-i18n")
+      },
+      fallback: {
+        "path": false
+      }
+    },
+    module: {
+      rules: [
+        {
+          test: /\.m?js$/,
+          exclude: /node_modules\/(?!(vue-meta)\/).*/,
+          use: {
+            loader: "babel-loader",
+            options: {
+              configFile: path$4.resolve(projectRoot, "babel.config.js")
+            }
+          }
+        },
+        {
+          test: /\.vue$/,
+          use: [
+            {
+              loader: require.resolve("vue-loader")
+            }
+          ]
+        },
+        {
+          test: /\.(sa|sc|c)ss$/,
+          use: [
+            process.env.NODE_ENV !== "production" ? "vue-style-loader" : MiniCssExtractPlugin.loader,
+            {
+              loader: "css-loader",
+              options: {
+                sourceMap: true,
+                url: {
+                  filter: (url, resourcePath) => {
+                    if (url.indexOf("/fonts/") == 0) {
+                      return false;
+                    }
+                    return true;
+                  }
+                }
+              }
+            },
+            {
+              loader: "sass-loader",
+              options: {
+                sourceMap: true
+              }
+            }
+          ]
+        },
+        {
+          test: /\.(?:ico|gif|png|jpg|jpeg|mp4|webp|webm|svg|woff2?|eot|ttf|otf)$/i,
+          use: {
+            loader: "url-loader",
+            options: {
+              emitFile: false
+            }
+          }
+        }
+      ]
+    },
+    plugins: [
+      // new BundleAnalyzerPlugin(),
+      new MiniCssExtractPlugin({
+        filename: "[name].[contenthash].css",
+        chunkFilename: "[id].[contenthash].css",
+        ignoreOrder: true
+      }),
+      new CleanWebpackPlugin(),
+      new VueLoaderPlugin(),
+      new Dotenv({
+        path: `.env.${process.env.NODE_ENV}`
+      }),
+      new webpack$5.DefinePlugin({
+        __VUE_I18N_LEGACY_API__: false,
+        __VUE_OPTIONS_API__: true,
+        __VUE_PROD_DEVTOOLS_: false,
+        __VUE_PROD_DEVTOOLS__: true,
+        __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: true,
+        __VUE_I18N_FULL_INSTALL__: true,
+        __INTLIFY_PROD_DEVTOOLS__: false,
+        __MOBILE_APP__: false
+      })
+    ],
+    infrastructureLogging: {
+      level: "verbose"
+    },
+    stats: {
+      colors: true,
+      hash: true,
+      version: true,
+      timings: true,
+      assets: true,
+      chunks: true,
+      modules: true,
+      reasons: true,
+      children: true,
+      source: true,
+      errors: true,
+      errorDetails: true,
+      errorStack: true,
+      warnings: true,
+      publicPath: true
+    }
+  };
+};
+const path$3 = require$$0;
+const glob = require$$1$3;
+const webpack$4 = require$$1$1;
+const { merge: merge$2 } = require$$3$3;
+const { StatsWriterPlugin: StatsWriterPlugin$1 } = require$$4$2;
+const CssMinimizerPlugin$1 = require$$6$2;
+const TerserPlugin$1 = require$$7$1;
+const WorkboxPlugin = require$$8;
+const PurgeCSSPlugin = require$$9$1;
+const baseConfig$1 = webpack_config_base;
+var webpack_config_client = (projectRoot) => {
+  const isProd2 = process.env.NODE_ENV === "production";
+  const config = {
+    mode: !isProd2 ? "development" : "production",
+    devtool: !isProd2 ? "inline-source-map" : "source-map",
+    entry: {
+      main: !isProd2 ? [path$3.resolve("../utils/hot-reload.js"), path$3.resolve(projectRoot, "src/entry-client.js")] : path$3.resolve(projectRoot, "src/entry-client.js")
+    },
+    module: {
+      rules: []
+    },
+    output: {
+      filename: "main.[fullhash].js",
+      chunkFilename: "[name].[contenthash].js",
+      path: path$3.resolve(projectRoot, "builds/web/client"),
+      publicPath: "/",
+      clean: true
+    },
+    plugins: [
+      ...!isProd2 ? [new webpack$4.HotModuleReplacementPlugin()] : [],
+      new StatsWriterPlugin$1(),
+      new WorkboxPlugin.GenerateSW({
+        clientsClaim: true,
+        skipWaiting: true
+      }),
+      new PurgeCSSPlugin({
+        paths: glob.sync([
+          path$3.join(projectRoot, "src/**/*.vue"),
+          path$3.join(projectRoot, "prometheus-framework/src/**/*.vue")
+        ]),
+        safelist: { greedy: [/data-v-.*/] }
+      })
+    ],
+    optimization: {
+      usedExports: true,
+      splitChunks: {
+        chunks: "async",
+        minSize: 0,
+        minRemainingSize: 0,
+        minChunks: 1,
+        maxAsyncRequests: 30,
+        maxInitialRequests: 30,
+        enforceSizeThreshold: 5e4,
+        cacheGroups: {
+          vendor: {
+            test: /[\\/]node_modules[\\/]/,
+            name: "vendors",
+            priority: -10,
+            reuseExistingChunk: true
+          }
+        }
+      },
+      minimize: isProd2,
+      minimizer: [
+        new TerserPlugin$1(),
+        new CssMinimizerPlugin$1()
+      ]
+    }
+  };
+  return merge$2(baseConfig$1(projectRoot), config);
+};
+const path$2 = require$$0;
+const webpack$3 = require$$1$1;
+var webpack_config_server = (projectRoot) => {
+  return {
+    target: "node",
+    mode: "development",
+    entry: [
+      "webpack/hot/poll?1000",
+      path$2.resolve(projectRoot, "server/server.js")
+    ],
+    output: {
+      filename: "server.[fullhash].js",
+      path: path$2.resolve(projectRoot, "builds/web/server"),
+      clean: true
+    },
+    resolve: {
+      alias: {
+        "@pf": path$2.resolve(projectRoot, "prometheus-framework")
+      },
+      fallback: {
+        "path": false
+      }
+    },
+    // externals: [nodeExternals()],
+    plugins: [
+      new webpack$3.HotModuleReplacementPlugin()
+    ]
+  };
+};
+const path$1 = require$$0;
+const webpack$2 = require$$1$1;
+const { merge: merge$1 } = require$$3$3;
+const CssMinimizerPlugin = require$$6$2;
+const CopyWebpackPlugin = require$$6$3;
+const TerserPlugin = require$$7$1;
+const HtmlWebpackPlugin = require$$8$1;
+const { StatsWriterPlugin } = require$$4$2;
+const Mustache = require$$1;
+const fs = require$$3.promises;
+const getClientConfig = webpack_config_client;
+const templatePath = path$1.resolve(__dirname, "../templates/page.html");
+const isProd = process.env.NODE_ENV === "production";
+var webpack_config_spa = (projectRoot) => {
+  const spaConfig2 = {
+    mode: !isProd ? "development" : "production",
+    devtool: "source-map",
+    entry: {
+      main: path$1.resolve(projectRoot, "src/app.js")
+    },
+    output: {
+      filename: "main.js",
+      path: path$1.resolve(projectRoot, "builds/web/spa"),
+      clean: true
+    },
+    target: "web",
+    module: {
+      rules: [
+        // Дополнительные правила могут быть добавлены здесь
+      ]
+    },
+    plugins: [
+      ...!isProd ? [new webpack$2.HotModuleReplacementPlugin()] : [],
+      new StatsWriterPlugin(),
+      new webpack$2.optimize.LimitChunkCountPlugin({
+        maxChunks: 1
+      }),
+      new HtmlWebpackPlugin({
+        templateContent: async () => {
+          const template2 = await fs.readFile(templatePath, "utf8");
+          const meta = {
+            htmlAttrs: 'lang="en"',
+            headAttrs: "",
+            bodyAttrs: "",
+            head: '<meta name="description" content="Example">',
+            body: ""
+          };
+          const data = {
+            googleTagId: process.env.GOOGLE_TAG_ID,
+            googleMapApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            meta
+          };
+          return Mustache.render(template2, data);
+        },
+        filename: "index.html",
+        inject: "body"
+      }),
+      new CopyWebpackPlugin({
+        patterns: [
+          { from: path$1.resolve(projectRoot, "../public/logo"), to: "logo" },
+          { from: path$1.resolve(projectRoot, "../public/walkthrough"), to: "walkthrough" }
+        ]
+      })
+      // new ServiceWorkerPlugin()
+    ],
+    optimization: {
+      minimizer: [new TerserPlugin(), new CssMinimizerPlugin()]
+    }
+  };
+  return merge$1(getClientConfig(projectRoot), spaConfig2);
+};
+const path = require$$0;
+const webpack$1 = require$$1$1;
+const nodeExternals = require$$2$3;
+const { merge } = require$$3$3;
+const { WebpackManifestPlugin } = require$$4$3;
+const getBaseConfig = webpack_config_base;
+var webpack_config_ssr = (projectRoot) => {
+  const isProd2 = process.env.NODE_ENV === "production";
+  const ssrConfig2 = {
+    target: "node",
+    mode: !isProd2 ? "development" : "production",
+    entry: {
+      main: path.resolve(projectRoot, "src/entry-server.js")
+    },
+    output: {
+      filename: "main.[fullhash].js",
+      path: path.resolve(projectRoot, "builds/web/server"),
+      libraryTarget: "commonjs2",
+      clean: true
+    },
+    module: {
+      rules: [
+        {
+          test: /\.css$/,
+          // we don't need styles on the server, so we just ignore them
+          use: "null-loader"
+        }
+      ]
+    },
+    optimization: {
+      minimize: false
+    },
+    plugins: [
+      new webpack$1.optimize.LimitChunkCountPlugin({
+        maxChunks: 1
+      }),
+      ...isProd2 ? [new WebpackManifestPlugin({
+        fileName: "manifest.json"
+      })] : []
+    ],
+    externals: [
+      nodeExternals({
+        allowlist: [
+          /^vue-meta*/,
+          /\.(css|sass|scss)$/,
+          /\.(vue)$/,
+          /\.(html)$/
+        ]
+      })
+    ]
+  };
+  return merge(getBaseConfig(projectRoot), ssrConfig2);
+};
+const baseConfig = webpack_config_base;
+const clientConfig = webpack_config_client;
+const serverConfig = webpack_config_server;
+const spaConfig = webpack_config_spa;
+const ssrConfig = webpack_config_ssr;
+var webpack = {
+  baseConfig,
+  clientConfig,
+  serverConfig,
+  spaConfig,
+  ssrConfig
+};
+const createSsrDevServer2 = ssr_dev;
+const createSsrProdServer2 = ssr_prod;
+const createSpaDevServer2 = spa_dev;
+const createSpaProdServer2 = spa_prod;
+const webpackConfigs = webpack;
+var builder = {
+  createSsrDevServer: createSsrDevServer2,
+  createSsrProdServer: createSsrProdServer2,
+  createSpaDevServer: createSpaDevServer2,
+  createSpaProdServer: createSpaProdServer2,
+  webpackConfigs
+};
+const builder$1 = /* @__PURE__ */ getDefaultExportFromCjs(builder);
+export {
+  builder$1 as default
+};