@elliemae/pui-cli 9.0.0-next.52 → 9.0.0-next.61

package/dist/cjs/webpack/csp.js

@@ -0,0 +1,158 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csp_exports = {};
+__export(csp_exports, {
+  CSP: () => CSP
+});
+module.exports = __toCommonJS(csp_exports);
+var crypto = __toESM(require("node:crypto"));
+var cheerio = __toESM(require("cheerio"));
+class CSP {
+  static HASH_FUNCTION = "sha256";
+  static INLINE_SCRIPT_SELECTOR = "script:not([src])";
+  static SOURCED_SCRIPT_SELECTOR = "script[src]";
+  $;
+  constructor(html) {
+    this.$ = cheerio.load(html);
+  }
+  serializeDom() {
+    return this.$.root().html() ?? "";
+  }
+  /**
+   * Returns a strict Content Security Policy for mittigating XSS.
+   * For more details read csp.withgoogle.com.
+   * If you modify this CSP, make sure it has not become trivially bypassable by
+   * checking the policy using csp-evaluator.withgoogle.com.
+   * @param hashes A list of sha-256 hashes of trusted inline scripts.
+   * @param cspOptions
+   * @param enableTrustedTypes If Trusted Types should be enabled for scripts.
+   * @param enableBrowserFallbacks If fallbacks for older browsers should be
+   *   added. This is will not weaken the policy as modern browsers will ignore
+   *   the fallbacks.
+   * @param enableUnsafeEval If you cannot remove all uses of eval(), you can
+   *   still set a strict CSP, but you will have to use the 'unsafe-eval'
+   *   keyword which will make your policy slightly less secure.
+   * @param cspOptions.enableBrowserFallbacks
+   * @param cspOptions.enableTrustedTypes
+   * @param cspOptions.enableUnsafeEval
+   * @returns A strict Content Security Policy string.
+   */
+  static getStrictCsp(hashes, cspOptions = {
+    enableUnsafeEval: false
+  }) {
+    const strictCspTemplate = {
+      // 'strict-dynamic' allows hashed scripts to create new scripts.
+      "script-src": [`'strict-dynamic'`, ...hashes ?? []],
+      // Restricts `object-src` to disable dangerous plugins like Flash.
+      "object-src": [`'none'`],
+      // Restricts `base-uri` to block the injection of `<base>` tags. This
+      // prevents attackers from changing the locations of scripts loaded from
+      // relative URLs.
+      "base-uri": [`'self'`]
+    };
+    if (cspOptions.enableUnsafeEval) {
+      strictCspTemplate["script-src"].push(`'unsafe-eval'`);
+    }
+    return Object.entries(strictCspTemplate).map(([directive, values]) => `${directive} ${values.join(" ")};`).join("");
+  }
+  /**
+   * Enables a CSP via a meta tag at the beginning of the document.
+   * Warning: It's recommended to set CSP as HTTP response header instead of
+   * using a meta tag. Injections before the meta tag will not be covered by CSP
+   * and meta tags don't support CSP in report-only mode.
+   * @param csp A Content Security Policy string.
+   */
+  addMetaTag(csp) {
+    let metaTag = this.$('meta[http-equiv="Content-Security-Policy"]');
+    if (!metaTag.length) {
+      metaTag = cheerio.load('<meta http-equiv="Content-Security-Policy">')(
+        "meta"
+      );
+      metaTag.prependTo(this.$("head"));
+    }
+    metaTag.attr("content", csp);
+  }
+  /**
+   * Replaces all sourced scripts with a single inline script that can be hashed
+   */
+  refactorSourcedScriptsForHashBasedCsp() {
+    const scriptInfoList = this.$(CSP.SOURCED_SCRIPT_SELECTOR).map((_i, script) => {
+      const src = this.$(script).attr("src") ?? "";
+      const type = this.$(script).attr("type") ?? "";
+      this.$(script).remove();
+      return { src, type };
+    }).toArray().filter((info) => info.src);
+    const loaderScript = CSP.createLoaderScript(scriptInfoList);
+    if (!loaderScript) {
+      return;
+    }
+    const newScript = cheerio.load("<script>")("script");
+    newScript.text(loaderScript);
+    newScript.appendTo(this.$("body"));
+  }
+  /**
+   * Returns a list of hashes of all inline scripts found in the HTML document.
+   * @returns A list of sha-256 hashes of inline scripts.
+   */
+  hashAllInlineScripts() {
+    return this.$(CSP.INLINE_SCRIPT_SELECTOR).map((_i, elem) => CSP.hashInlineScript(this.$(elem).html() ?? "")).get();
+  }
+  /**
+   * Returns JS code for dynamically loading sourced (external) scripts.
+   * @param scriptInfoList A list of objects containing src and type for scripts that should be loaded
+   * @returns JS code for loading scripts.
+   */
+  static createLoaderScript(scriptInfoList) {
+    if (!scriptInfoList.length) {
+      return void 0;
+    }
+    return `
+    var scripts = ${JSON.stringify(scriptInfoList)};
+    scripts.forEach(function(scriptInfo) {
+      var s = document.createElement('script');
+      s.src = scriptInfo.src;
+      if (scriptInfo.type) {
+        s.type = scriptInfo.type;
+      }
+      s.async = false; // preserve execution order.
+      document.body.appendChild(s);
+    });
+    `;
+  }
+  /**
+   * Calculates a CSP compatible hash of an inline script.
+   * @param scriptText Text between opening and closing script tag. Has to
+   *     include whitespaces and newlines!
+   * @returns A sha-256 hash of the script.
+   */
+  static hashInlineScript(scriptText) {
+    const hash = crypto.createHash(CSP.HASH_FUNCTION).update(scriptText, "utf-8").digest("base64");
+    return `'${CSP.HASH_FUNCTION}-${hash}'`;
+  }
+}

package/dist/cjs/webpack/helpers.js

@@ -64,7 +64,7 @@ const getNodeModulesRegEx = (modules) => modules.map(
 const excludeNodeModulesExcept = (modules) => {
   const moduleRegExps = getNodeModulesRegEx(modules);
   return function(modulePath) {
-    if (/node_modules/.test(modulePath)) {
+    if (modulePath.includes("node_modules")) {
       for (const moduleRegExp of moduleRegExps)
         if (moduleRegExp.test(modulePath)) return false;
       return true;
@@ -136,9 +136,9 @@ const getUserMonitoringFileName = () => {
   );
   if (!import_node_fs.default.existsSync(userMonLibPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(userMonLibPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiUserMonitoring+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiUserMonitoring+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getAppLoaderFileName = () => {
   const libName = "emuiAppLoader";
@@ -148,9 +148,9 @@ const getAppLoaderFileName = () => {
   );
   if (!import_node_fs.default.existsSync(appLoaderLibPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(appLoaderLibPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiAppLoader+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiAppLoader+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getDiagnosticsFileName = () => {
   const libName = "emuiDiagnostics";
@@ -160,9 +160,9 @@ const getDiagnosticsFileName = () => {
   );
   if (!import_node_fs.default.existsSync(libPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(libPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiDiagnostics+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiDiagnostics+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getENCWLoaderFileName = () => {
   const libName = "emuiEncwLoader";
@@ -172,13 +172,13 @@ const getENCWLoaderFileName = () => {
   );
   if (!import_node_fs.default.existsSync(appLoaderLibPath)) return `${libName}.js`;
   const distJSFiles = import_node_fs.default.readdirSync(appLoaderLibPath);
-  return distJSFiles.filter(
-    (fName) => fName.match(/emuiEncwLoader+((?!chunk).)*\.js$/)
-  )[0];
+  return distJSFiles.find(
+    (fName) => /emuiEncwLoader+((?!chunk).)*\.js$/.exec(fName)
+  );
 };
 const getAppVersion = () => {
   if (!process.env.APP_VERSION) return LATEST_VERSION;
-  const match = process.env.APP_VERSION.match(/^v?(\d+\.\d+)\..*$/);
+  const match = /^v?(\d+\.\d+)\..*$/.exec(process.env.APP_VERSION);
   return match?.[1] ?? LATEST_VERSION;
 };
 const getPaths = (latestVersion = true) => {

package/dist/cjs/webpack/interceptor-middleware.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interceptor_middleware_exports = {};
+__export(interceptor_middleware_exports, {
+  addCSPNonceMiddleware: () => addCSPNonceMiddleware,
+  interceptorMiddleware: () => interceptorMiddleware
+});
+module.exports = __toCommonJS(interceptor_middleware_exports);
+const VALID_PARAMS = ["isInterceptable", "intercept", "afterSend"];
+const validateParams = (methods) => {
+  Object.keys(methods).forEach((k) => {
+    if (!VALID_PARAMS.includes(k)) {
+      throw new Error(`${k} isn't a valid param (${VALID_PARAMS.join(", ")})`);
+    }
+  });
+  if (!("isInterceptable" in methods)) {
+    throw new Error("isInterceptable is a required param (function)");
+  }
+};
+const interceptorMiddleware = (fn) => (req, res, next) => {
+  const methods = fn(req, res);
+  validateParams(methods);
+  const originalEnd = res.end;
+  const originalWrite = res.write;
+  const chunks = [];
+  let isIntercepting;
+  let isFirstWrite = true;
+  function intercept(rawChunk, encoding) {
+    if (isFirstWrite) {
+      isFirstWrite = false;
+      isIntercepting = methods.isInterceptable();
+    }
+    if (isIntercepting) {
+      if (rawChunk) {
+        let tempChunk = rawChunk;
+        if (rawChunk !== null && !Buffer.isBuffer(tempChunk)) {
+          if (!encoding) {
+            tempChunk = Buffer.from(rawChunk);
+          } else {
+            tempChunk = Buffer.from(
+              rawChunk,
+              encoding
+            );
+          }
+        }
+        chunks.push(tempChunk);
+      }
+    }
+    return isIntercepting;
+  }
+  const newResWrite = (...args) => {
+    if (!intercept(args[0], args[1])) {
+      return originalWrite.apply(res, args);
+    }
+    return true;
+  };
+  res.write = newResWrite;
+  const afterSend = (oldBody, newBody) => {
+    if (typeof methods.afterSend === "function") {
+      process.nextTick(() => {
+        methods.afterSend?.(oldBody, newBody);
+      });
+    }
+  };
+  const newResEnd = (...args) => {
+    if (intercept(args[0], args[1])) {
+      isIntercepting = false;
+      const oldBody = Buffer.concat(chunks).toString("utf-8");
+      if (methods.intercept) {
+        if (typeof methods.intercept !== "function") {
+          throw new Error(
+            "`send` must be a function with the body to be sent as the only param"
+          );
+        }
+        res.removeHeader("Content-Length");
+        methods.intercept(oldBody, (newBody) => {
+          args[0] = newBody;
+          originalEnd.apply(res, args);
+          afterSend(oldBody, newBody);
+        });
+      } else {
+        afterSend(oldBody, oldBody);
+        originalEnd.apply(res, args);
+      }
+    } else {
+      originalEnd.apply(res, args);
+    }
+  };
+  res.end = newResEnd;
+  next();
+};
+const addCSPNonceMiddleware = (middlewares) => {
+  const index = middlewares.findIndex(
+    (middleware) => middleware.name === "webpack-dev-middleware"
+  );
+  middlewares.splice(index, 0, {
+    name: "csp-nonce-middleware",
+    middleware: interceptorMiddleware((_req, res) => ({
+      // Only HTML responses will be intercepted
+      isInterceptable() {
+        return (res.get("Content-Type") ?? "").includes("text/html");
+      },
+      // Appends a paragraph at the end of the response body
+      intercept(body, send) {
+        send(body.replace(/__CSP_NONCE__/g, res.locals.cspNonce));
+      }
+    }))
+  });
+};

package/dist/cjs/webpack/webpack.dev.babel.js

@@ -39,12 +39,15 @@ var import_circular_dependency_plugin = __toESM(require("circular-dependency-plu
 var import_mini_css_extract_plugin = __toESM(require("mini-css-extract-plugin"));
 var import_react_refresh_webpack_plugin = __toESM(require("@pmmmwh/react-refresh-webpack-plugin"));
 var import_express_static_gzip = __toESM(require("express-static-gzip"));
+var import_interceptor_middleware = require("./interceptor-middleware.js");
 var import_middlewares = require("../server/middlewares.js");
 var import_appRoutes = require("../server/appRoutes.js");
 var import_helpers = require("./helpers.js");
 var import_webpack_base_babel = require("./webpack.base.babel.js");
 var import_utils = require("../server/utils.js");
 var import_wsServer = require("../server/wsServer.js");
+var import_cert = require("../server/cert.js");
+var import_utils2 = require("../utils.js");
 const import_meta = {};
 const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
 const {
@@ -57,6 +60,10 @@ const {
   diagnosticsScriptPath,
   encwLoaderScriptPath
 } = (0, import_helpers.getPaths)();
+const serverOptions = {
+  type: "https",
+  options: (0, import_cert.getCertOptions)()
+};
 const devConfig = {
   mode: "development",
   cache: {
@@ -100,7 +107,7 @@ const devConfig = {
   // Add development plugins
   plugins: [
     new import_html_webpack_plugin.default({
-      inject: !(0, import_helpers.isAppLoaderEnabled)() ? "head" : false,
+      inject: !(0, import_helpers.isAppLoaderEnabled)() && process.env.CSP !== "true",
       // Inject all files that are generated by webpack, e.g. bundle.js
       template: !(0, import_helpers.isAppLoaderEnabled)() ? "app/index.html" : "app/index-app-loader.html",
       emui: {
@@ -111,10 +118,14 @@ const devConfig = {
         appLoaderScriptPath,
         diagnosticsScriptPath,
         encwLoaderScriptPath,
-        googleTagManager: (0, import_helpers.isGoogleTagManagerEnabled)()
+        googleTagManager: (0, import_helpers.isGoogleTagManagerEnabled)(),
+        csp: process.env.CSP === "true"
       },
       scriptLoading: "defer"
     }),
+    // new CspPlugin(HtmlWebpackPlugin, {
+    //   enableUnsafeEval: true,
+    // }),
     new import_circular_dependency_plugin.default({
       exclude: /a\.(js|ts|jsx|tsx)|node_modules/,
       // exclude node_modules
@@ -147,11 +158,12 @@ const devConfig = {
     hot: true,
     open: [basePath],
     port: process.env.PORT ?? "auto",
+    server: (0, import_utils2.isHttps)() ? serverOptions : {},
     setupMiddlewares: (middlewares, devServer) => {
+      (0, import_interceptor_middleware.addCSPNonceMiddleware)(middlewares);
       if (devServer.app) {
         (0, import_middlewares.setupDefaultMiddlewares)(devServer.app);
-        (0, import_appRoutes.loadRoutes)(devServer.app).then(() => {
-        }).catch((err) => {
+        (0, import_appRoutes.loadRoutes)(devServer.app).catch((err) => {
           console.error(err);
         });
         const cdnRouter = (0, import_express_static_gzip.default)("cdn", {});

package/dist/cjs/webpack/webpack.lib.base.babel.js

@@ -66,13 +66,11 @@ const plugins = [
   new import_webpack.default.DefinePlugin({
     APP_CONFIG: (0, import_utils.getAppConfig)()
   }),
-  /* eslint-disable indent */
   ...copyPluginPatterns.length > 0 ? [
     new import_copy_webpack_plugin.default({
       patterns: copyPluginPatterns
     })
   ] : [],
-  /* eslint-enable indent */
   new import_webpack.default.optimize.LimitChunkCountPlugin({
     maxChunks: 1
   }),

package/dist/cjs/webpack/webpack.lib.prod.babel.js

@@ -74,7 +74,9 @@ const prodConfig = {
     minimizer: [
       new import_esbuild_loader.EsbuildPlugin({
         target: (0, import_browserslist_to_esbuild.default)(),
-        css: true
+        css: true,
+        pure: ["console.log", "console.warn"],
+        drop: ["debugger"]
       })
     ],
     nodeEnv: "production",

package/dist/cjs/webpack/webpack.prod.babel.js

@@ -57,10 +57,13 @@ const getProdConfig = ({ latestVersion = true } = {}) => {
     },
     optimization: {
       moduleIds: "deterministic",
+      // realContentHash: false,
       minimizer: [
         new import_esbuild_loader.EsbuildPlugin({
           target: (0, import_browserslist_to_esbuild.default)(),
-          css: true
+          css: true,
+          pure: ["console.log", "console.warn"],
+          drop: ["debugger"]
         })
       ],
       runtimeChunk: true,
@@ -74,7 +77,8 @@ const getProdConfig = ({ latestVersion = true } = {}) => {
           },
           vendors: {
             name: "vendors",
-            test: /[\\/]node_modules[\\/]/
+            test: /[\\/]node_modules[\\/]/,
+            enforce: true
           }
         }
       }
@@ -111,7 +115,7 @@ const {
   basePath
 } = (0, import_helpers.getPaths)();
 const htmlWebpackPlugin = new import_html_webpack_plugin.default({
-  inject: !(0, import_helpers.isAppLoaderEnabled)() ? "head" : false,
+  inject: !(0, import_helpers.isAppLoaderEnabled)() && process.env.CSP !== "true",
   template: !(0, import_helpers.isAppLoaderEnabled)() ? "app/index.html" : "app/index-app-loader.html",
   minify: {
     removeComments: true,
@@ -133,10 +137,13 @@ const htmlWebpackPlugin = new import_html_webpack_plugin.default({
     appLoaderScriptPath,
     diagnosticsScriptPath,
     encwLoaderScriptPath,
-    googleTagManager: (0, import_helpers.isGoogleTagManagerEnabled)()
+    googleTagManager: (0, import_helpers.isGoogleTagManagerEnabled)(),
+    csp: process.env.CSP === "true"
   },
   scriptLoading: "defer"
 });
 const config = (0, import_webpack_base_babel.baseConfig)(getProdConfig());
-if (config.plugins) config.plugins.push(htmlWebpackPlugin);
+if (config.plugins) {
+  config.plugins.push(htmlWebpackPlugin);
+}
 var webpack_prod_babel_default = config;

package/dist/cjs/webpack/webpack.storybook.js

@@ -41,7 +41,7 @@ const IS_APP = (0, import_utils.isApp)();
 const CWD = process.cwd();
 const getAdditionalPlugins = () => [
   new import_webpack.default.EnvironmentPlugin({
-    IS_APP,
+    IS_APP: IS_APP ? "true" : "false",
     CWD
   }),
   new import_mini_css_extract_plugin.default({

package/dist/esm/babel.config.cjs

@@ -1,4 +1,4 @@
-const { isApp } =  require('./utils.cjs');
+const { isApp } = require('./utils.cjs');
 
 const nodeEnvPreset = {
   modules: process.env.ES_MODULES === 'false' ? 'commonjs' : false,

package/dist/esm/build/vite.config.js

@@ -0,0 +1,25 @@
+import { defineConfig } from "vite";
+const noncePlugin = () => ({
+  name: "add-nonce-attr",
+  enforce: "post",
+  transformIndexHtml(html) {
+    return html.replace(new RegExp("<script", "g"), `<script nonce="__CSP_NONCE__"`).replace(new RegExp("<link", "g"), `<link nonce="__CSP_NONCE__"`);
+  }
+});
+var vite_config_default = defineConfig({
+  plugins: [noncePlugin()],
+  build: {
+    emptyOutDir: true,
+    sourcemap: true,
+    rollupOptions: {
+      output: {
+        chunkFileNames: "assets/[name].[hash].js",
+        entryFileNames: "assets/[name].[hash].js",
+        assetFileNames: "assets/[name].[hash][extname]"
+      }
+    }
+  }
+});
+export {
+  vite_config_default as default
+};

package/dist/esm/cli.js

@@ -16,10 +16,11 @@ import { storybookCmd } from "./commands/storybook.js";
 import { vitestCmd } from "./commands/vitest.js";
 import { versionCmd } from "./commands/version.js";
 import { tscheckCmd } from "./commands/tscheck.js";
+import { buildCDNCmd } from "./commands/buildcdn.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 envConfig();
 process.env.PATH += path.delimiter + path.join(__dirname, "..", "node_modules", ".bin");
-(async () => {
+void (async () => {
   await yargs(hideBin(process.argv)).command(buildCmd).help().argv;
   await yargs(hideBin(process.argv)).command(packCmd).help().argv;
   await yargs(hideBin(process.argv)).command(startCmd).help().argv;
@@ -31,5 +32,6 @@ process.env.PATH += path.delimiter + path.join(__dirname, "..", "node_modules",
   await yargs(hideBin(process.argv)).command(vitestCmd).help().argv;
   await yargs(hideBin(process.argv)).command(versionCmd).help().argv;
   await yargs(hideBin(process.argv)).command(tscheckCmd).help().argv;
+  await yargs(hideBin(process.argv)).command(buildCDNCmd).help().argv;
   await notifyUpdates();
 })();

package/dist/esm/commands/buildcdn.js

@@ -0,0 +1,43 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fg from "fast-glob";
+import yargs from "yargs";
+import { exec, logInfo, logError, logSuccess } from "./utils.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const buildCDN = async () => {
+  const files = await fg(["src/**/*.html"]);
+  await Promise.all(
+    files.map(async (file) => {
+      const srcDir = path.dirname(file);
+      const sitePath = srcDir.replace("src/", "");
+      const outDir = path.join(process.cwd(), "public", sitePath);
+      await exec(
+        `vite build -c ${path.resolve(
+          __dirname,
+          "../build/vite.config.js"
+        )} ${srcDir} --outDir ${outDir} --base ${path.join(
+          process.env.BASE_PATH ?? "",
+          sitePath
+        )}`
+      );
+    })
+  );
+};
+const buildCDNCmd = {
+  handler: async () => {
+    try {
+      logInfo("CDN Build in progress...");
+      await buildCDN();
+      logSuccess("CDN Build completed");
+    } catch (err) {
+      logError("Build failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "buildCDN",
+  describe: "builds web application for CDN",
+  builder: (yargsRef) => yargsRef.options({}).help()
+};
+export {
+  buildCDNCmd
+};

package/dist/esm/commands/lint.js

@@ -30,7 +30,7 @@ const lintJS = async (args) => {
   const fixIssues = args.fix ? "--fix" : "";
   const debugFlags = args.debug ? "--env-info --debug" : "";
   await exec(
-    `eslint ${!getCIEnv() ? "--color" : "--no-color"} ${fixIssues} ${debugFlags} .`
+    `eslint --flag unstable_ts_config ${!getCIEnv() ? "--color" : "--no-color"} ${fixIssues} ${debugFlags} .`
   );
 };
 const cmdArgs = {

package/dist/esm/commands/test.js

@@ -77,7 +77,6 @@ const debugTest = async () => {
   );
 };
 const testCmd = {
-  // eslint-disable-next-line max-statements
   handler: async (argv) => {
     try {
       if (getCIEnv()) {

package/dist/esm/commands/tscheck.js

@@ -17,7 +17,14 @@ const validateTypescript = async (files = []) => {
       skipLibCheck: true
     },
     files,
-    include: ["app", "lib"]
+    include: [
+      "app",
+      "lib",
+      "lib/**/*.json",
+      "lib/**/*.d.ts",
+      "app/**/*.json",
+      "app/**/*.d.ts"
+    ]
   };
   fs.writeFileSync(tmpTsconfigPath, JSON.stringify(tmpTsconfig, null, 2));
   const tscPath = path.resolve(