@elliemae/pui-cli 6.16.0 → 7.0.0-alpha.2

package/dist/esm/cli-commands/tsc.js

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import path from "node:path";
+import yargs from "yargs";
+import { spawnSync } from "child_process";
+import fs from "fs";
+import { logInfo, logError } from "./utils.js";
+const randomChars = () => Math.random().toString(36).slice(2);
+const resolveFromRoot = (...paths) => path.join(process.cwd(), ...paths);
+const validateTypescript = async () => {
+  const args = process.argv.slice(2);
+  const argsProjectIndex = args.findIndex((arg) => ["-p", "--project"].includes(arg));
+  const argsProjectValue = argsProjectIndex !== -1 ? args[argsProjectIndex + 1] : void 0;
+  const files = args.filter((file) => /\.(ts|tsx)$/.test(file));
+  if (files.length === 0) {
+    process.exit(0);
+  }
+  const remainingArgsToForward = args.slice().filter((arg) => !files.includes(arg));
+  if (argsProjectIndex !== -1) {
+    remainingArgsToForward.splice(argsProjectIndex, 2);
+  }
+  const tsconfigPath = argsProjectValue || resolveFromRoot("tsconfig.json");
+  const tsconfigContent = fs.readFileSync(tsconfigPath).toString();
+  let tsconfig = {};
+  eval(`tsconfig = ${tsconfigContent}`);
+  const tmpTsconfigPath = resolveFromRoot(`tsconfig.${randomChars()}.json`);
+  const tmpTsconfig = __spreadProps(__spreadValues({}, tsconfig), {
+    compilerOptions: __spreadProps(__spreadValues({}, tsconfig.compilerOptions), {
+      skipLibCheck: true
+    }),
+    files,
+    include: ["shared/typings"]
+  });
+  fs.writeFileSync(tmpTsconfigPath, JSON.stringify(tmpTsconfig, null, 2));
+  const { status } = spawnSync("tsc", ["-p", tmpTsconfigPath, ...remainingArgsToForward], { stdio: "inherit" });
+  fs.unlinkSync(tmpTsconfigPath);
+  process.exit(status);
+};
+const tscCmd = {
+  handler: async (argv) => {
+    try {
+      await validateTypescript(argv.p);
+      logInfo("Typescript validation started");
+    } catch (err) {
+      logError("Typescript validation failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "tsc [options]",
+  describe: "validate typescript code",
+  builder: {
+    project: {
+      alias: "p",
+      type: "boolean",
+      default: false
+    },
+    docs: {
+      type: "boolean",
+      default: false
+    }
+  }
+};
+export {
+  tscCmd,
+  validateTypescript
+};

package/dist/esm/cli-commands/utils.js

@@ -0,0 +1,120 @@
+import path from "node:path";
+import { readFile, writeFile, mkdir, readdir, copyFile } from "fs/promises";
+import { execaCommand } from "execa";
+import chalk from "chalk";
+import {
+  getPaths,
+  isAppLoaderEnabled,
+  getAppVersion,
+  LATEST_VERSION
+} from "../webpack/helpers.js";
+const browsersMapping = {
+  and_chr: "Chrome for Android",
+  chrome: "Google Chrome",
+  edge: "Microsoft Edge",
+  firefox: "Mozilla Firefox",
+  ios_saf: "iOS Safari",
+  safari: "Safari",
+  samsung: "Samsung Internet"
+};
+const exec = async (command, options = { stdio: "inherit" }) => execaCommand(command, options);
+const logInfo = console.log;
+const logSuccess = (...args) => console.log(chalk.green(...args));
+const logError = console.error;
+const readPackageLock = async () => {
+  try {
+    const appPkgLockFile = path.join(process.cwd(), "package-lock.json");
+    const pkgLockJSON = await readFile(appPkgLockFile, "utf8");
+    const { dependencies } = JSON.parse(pkgLockJSON);
+    return (moduleName) => dependencies[moduleName]?.version || "";
+  } catch (err) {
+    console.warn("Package lock file not found");
+    return () => "";
+  }
+};
+const getSupportedBrowsers = async () => {
+  const { stdout } = await exec("npx --no-install browserslist", {
+    stdout: "pipe"
+  });
+  const browserVersions = stdout && stdout.split("\n") || [];
+  return browserVersions.reduce((acc, nameVersion) => {
+    const [name, version] = nameVersion.split(" ");
+    const versionRange = version.split("-");
+    acc[browsersMapping[name]] = versionRange && versionRange[0] || version;
+    return acc;
+  }, {});
+};
+const getModulesInfo = async () => {
+  try {
+    const getModuleVersion = await readPackageLock();
+    return {
+      react: getModuleVersion("react"),
+      "react-dom": getModuleVersion("react-dom"),
+      "app-react-dependencies": getModuleVersion("@elliemae/app-react-dependencies"),
+      "app-sdk": getModuleVersion("@elliemae/pui-app-sdk"),
+      cli: getModuleVersion("@elliemae/pui-cli"),
+      dimsum: getModuleVersion("@elliemae/ds-system")
+    };
+  } catch (err) {
+    console.warn(err);
+    return {};
+  }
+};
+const writeAppInfo = async () => {
+  const appInfo = {
+    timestamp: new Date().toISOString(),
+    modules: await getModulesInfo(),
+    browserSupport: await getSupportedBrowsers(),
+    screenReaderSupport: [
+      "JAWS with Chrome",
+      "NVDA with Chrome",
+      "VoiceOver with Safari",
+      "iOS VoiceOver",
+      "Android Talkback"
+    ]
+  };
+  const infoJSON = JSON.stringify(appInfo, null, 2);
+  const { buildPath: versionedPath } = getPaths();
+  [
+    path.join(versionedPath, "info.json"),
+    path.join(process.cwd(), "build", "public", "info.json")
+  ].forEach(async (infoPath) => writeFile(infoPath, infoJSON));
+};
+const copyDir = async (src, dest) => {
+  const entries = await readdir(src, {
+    withFileTypes: true
+  });
+  await mkdir(dest);
+  return Promise.all(entries.map((entry) => {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      return copyDir(srcPath, destPath);
+    }
+    return copyFile(srcPath, destPath);
+  }));
+};
+const updateManifestWithVersionInfo = async (dest) => {
+  const manifestFile = path.join(dest, "manifest.json");
+  let manifestData = await readFile(manifestFile, "utf8");
+  manifestData = manifestData.replace(/latest\//g, `${getAppVersion()}/`);
+  await writeFile(manifestFile, manifestData);
+};
+const copyBuildAssetsToVersionedFolder = async () => {
+  const appVersion = getAppVersion();
+  const isVersionedApp = isAppLoaderEnabled() && appVersion !== LATEST_VERSION;
+  if (!isVersionedApp)
+    return;
+  const src = path.resolve(process.cwd(), "build/public/latest");
+  const dest = path.resolve(process.cwd(), `build/public/${appVersion}`);
+  await copyDir(src, dest);
+  await updateManifestWithVersionInfo(dest);
+};
+export {
+  copyBuildAssetsToVersionedFolder,
+  exec,
+  logError,
+  logInfo,
+  logSuccess,
+  writeAppInfo
+};

package/dist/esm/cli-commands/version.js

@@ -0,0 +1,49 @@
+import yargs from "yargs";
+import { exec, logError } from "./utils.js";
+import { setWorkspaceVersion } from "../monorepo/set-workspace-version.js";
+import { setRegistryVersion } from "../monorepo/set-registry-version.js";
+import { deleteMergedTags } from "../monorepo/delete-merged-tags.js";
+const version = async (lernaOptions = "") => {
+  await exec(`cross-env NODE_ENV=production lerna version --conventional-commits --exact --create-release github --force-publish --yes ${lernaOptions}`);
+};
+const versionCmd = {
+  handler: async (argv) => {
+    try {
+      if (argv.deleteTags) {
+        await deleteMergedTags();
+      } else if (argv.useRegistry) {
+        await setRegistryVersion();
+      } else if (argv.useWorkspace) {
+        await setWorkspaceVersion();
+      } else {
+        await version(argv.lernaOptions);
+      }
+    } catch (err) {
+      logError("Monorepo versioning failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "version [options]",
+  describe: "version monorepo",
+  builder: {
+    deleteTags: {
+      type: "boolean",
+      default: false
+    },
+    useRegistry: {
+      type: "boolean",
+      default: false
+    },
+    useWorkspace: {
+      type: "boolean",
+      default: false
+    },
+    lernaOptions: {
+      type: "string",
+      default: false
+    }
+  }
+};
+export {
+  versionCmd
+};

package/dist/esm/cli-commands/vitest.js

@@ -0,0 +1,61 @@
+import yargs from "yargs";
+import { exec, logError, logSuccess } from "./utils.js";
+const { CI = false } = process.env;
+const configPath = new URL("../testing/vitest.config.ts", import.meta.url);
+const test = async (commandOptions) => {
+  await exec(`cross-env FORCE_COLOR=true vitest --config ${configPath} ${commandOptions}`);
+};
+const vitestCmd = {
+  handler: async (argv) => {
+    let commandOptions = "--coverage";
+    if (argv.fix)
+      commandOptions = "-u";
+    else if (argv.watch)
+      commandOptions = "--watch";
+    if (argv.p)
+      commandOptions += " --passWithNoTests";
+    if (argv.r)
+      commandOptions += " --related";
+    if (argv.s)
+      commandOptions += " --silent";
+    try {
+      if (CI) {
+        await exec("rimraf ./reports");
+      }
+      await test(commandOptions);
+      logSuccess("Unit test execution completed");
+    } catch (err) {
+      logError("Unit test execution failed", err);
+      yargs().exit(-1, err);
+      return -1;
+    }
+    return 0;
+  },
+  command: "vitest [options]",
+  describe: "unit tests application code using vitest",
+  builder: {
+    fix: {
+      alias: "f",
+      type: "boolean"
+    },
+    watch: {
+      alias: "w",
+      type: "boolean"
+    },
+    passWithNoTests: {
+      alias: "p",
+      type: "boolean"
+    },
+    related: {
+      alias: "r",
+      type: "boolean"
+    },
+    silent: {
+      alias: "s",
+      type: "boolean"
+    }
+  }
+};
+export {
+  vitestCmd
+};

package/dist/esm/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { config as envConfig } from "dotenv";
+import notifyUpdates from "./scripts/update-notifier.js";
+import { buildCmd } from "./cli-commands/build.js";
+import { packCmd } from "./cli-commands/pack.js";
+import { startCmd } from "./cli-commands/start.js";
+import { testCmd } from "./cli-commands/test.js";
+import { lintCmd } from "./cli-commands/lint.js";
+import { gendocCmd } from "./cli-commands/gendoc.js";
+import { codemodCmd } from "./cli-commands/codemod.js";
+import { storybookCmd } from "./cli-commands/storybook.js";
+import { vitestCmd } from "./cli-commands/vitest.js";
+import { versionCmd } from "./cli-commands/version.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+envConfig();
+process.env.PATH += path.delimiter + path.join(__dirname, "..", "node_modules", ".bin");
+yargs(hideBin(process.argv)).command(buildCmd).help().argv;
+yargs(hideBin(process.argv)).command(packCmd).help().argv;
+yargs(hideBin(process.argv)).command(startCmd).help().argv;
+yargs(hideBin(process.argv)).command(testCmd).help().argv;
+yargs(hideBin(process.argv)).command(lintCmd).help().argv;
+yargs(hideBin(process.argv)).command(gendocCmd).help().argv;
+yargs(hideBin(process.argv)).command(codemodCmd).help().argv;
+yargs(hideBin(process.argv)).command(storybookCmd).help().argv;
+yargs(hideBin(process.argv)).command(vitestCmd).help().argv;
+yargs(hideBin(process.argv)).command(versionCmd).help().argv;
+notifyUpdates();

package/dist/esm/docgen/jsdoc.conf.json

@@ -0,0 +1,17 @@
+{
+  "plugins": ["plugins/markdown"],
+  "opts": {
+    "template": "node_modules/docdash"
+  },
+  "docdash": {
+    "sort": true,
+    "search": true,
+    "collapse": true,
+    "wrap": true
+  },
+  "templates": {
+    "default": {
+      "includeDate": false
+    }
+  }
+}

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+import { babelConfig } from "./babel/babel.config.cjs";
+import { esConfig } from "./lint/eslint/non-react.cjs";
+import { esReactConfig } from "./lint/eslint/react.cjs";
+import { stylelintConfig } from "./lint/stylelint.config.cjs";
+import { prettierConfig } from "./lint/prettier.config.cjs";
+import { commitlintConfig } from "./lint/commitlint.config.cjs";
+import { jestConfig } from "./testing/jest.config.cjs";
+import { jestNodeConfig } from "./testing/jest.node.config.cjs";
+import { lintStagedConfig } from "./lint/lint-staged.config.js";
+import { loadRoutes } from "./server/util/index.js";
+export {
+  babelConfig,
+  commitlintConfig,
+  esConfig as eslintBaseConfig,
+  esReactConfig as eslintConfig,
+  jestConfig,
+  jestNodeConfig,
+  lintStagedConfig,
+  loadRoutes,
+  prettierConfig,
+  stylelintConfig
+};

package/dist/esm/lint/lint-staged.config.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const npmClient = fs.existsSync(path.join(process.cwd(), "pnpm-lock.yaml")) ? "pnpm" : "npm";
+const lintStagedConfig = {
+  "*.{js,ts,jsx,tsx,md,mdx,html,css,json}": ["prettier --write"],
+  "*.{ts,tsx}": [
+    `node ${path.resolve(__dirname, "../typescript/tsc-files/index.js")} --noEmit --emitDeclarationOnly false`
+  ],
+  "*.{js,ts,jsx,tsx}": [
+    `${npmClient} run lint:fix`,
+    `${npmClient} run test:staged`,
+    `${npmClient} run gendoc`
+  ]
+};
+export {
+  lintStagedConfig
+};

package/dist/esm/monorepo/delete-merged-tags.js

@@ -0,0 +1,38 @@
+import { execSync } from "child_process";
+const cwd = process.cwd();
+const execaOptions = { cwd, stdio: "inherit" };
+const semVerRegEx = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+const isSemVersion = (tagName) => semVerRegEx.test(tagName);
+const branchName = (process.env.BRANCH_NAME || "master").toLowerCase();
+const branchTags = {
+  master: /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/,
+  next: /^v.*-next\.(0|[1-9]\d*)/,
+  alpha: /^v.*-alpha\.(0|[1-9]\d*)/,
+  beta: /^v.*-beta\.(0|[1-9]\d*)/
+};
+const deleteTags = (cmd, filter) => {
+  const result = execSync(cmd, { cwd });
+  if (!result)
+    return;
+  const tags = result.toString().split("\n").join(" ");
+  execSync(`git tag -d ${filter ? filter(tags) : tags}`, { cwd });
+};
+const tagsFromOtherBranches = (tags = []) => {
+  const regex = branchTags[branchName] || branchTags.master;
+  return tags.split(" ").filter((tagName) => isSemVersion(tagName) && !regex.test(tagName)).join(" ");
+};
+const deleteMergedTags = () => {
+  try {
+    if (branchName) {
+      deleteTags(`git tag -l --no-merged ${branchName}`);
+      deleteTags(`git tag -l --merged ${branchName}`, tagsFromOtherBranches);
+      console.log("Last two tags: ");
+      execSync("git tag --sort=-creatordate | head -n 2", execaOptions);
+    }
+  } catch (error) {
+    console.error(error);
+  }
+};
+export {
+  deleteMergedTags
+};

package/dist/esm/monorepo/set-registry-version.js

@@ -0,0 +1,21 @@
+import { readFile, writeFile } from "node:fs/promises";
+import fg from "fast-glob";
+import normalizePath from "normalize-path";
+import { findMonoRepoRoot } from "./utils.js";
+const monorepoRoot = normalizePath(findMonoRepoRoot() || "");
+const setRegistryVersion = async () => {
+  const files = await fg([
+    `${monorepoRoot}/libs/*/package.json`,
+    `${monorepoRoot}/apps/*/package.json`,
+    `${monorepoRoot}/package.json`
+  ]);
+  Promise.all(files.map(async (file) => {
+    let pkgJSONData = await readFile(file, "utf8");
+    const pkgVersion = JSON.parse(pkgJSONData).version;
+    pkgJSONData = pkgJSONData.replace(/workspace:\*/g, pkgVersion);
+    await writeFile(file, pkgJSONData);
+  }));
+};
+export {
+  setRegistryVersion
+};

package/dist/esm/monorepo/set-workspace-version.js

@@ -0,0 +1,22 @@
+import { readFile, writeFile } from "node:fs/promises";
+import fg from "fast-glob";
+import normalizePath from "normalize-path";
+import { findMonoRepoRoot } from "./utils.js";
+const monorepoRoot = normalizePath(findMonoRepoRoot() || "");
+const setWorkspaceVersion = async () => {
+  const files = await fg([
+    `${monorepoRoot}/libs/*/package.json`,
+    `${monorepoRoot}/apps/*/package.json`,
+    `${monorepoRoot}/package.json`
+  ]);
+  Promise.all(files.map(async (file) => {
+    let pkgJSONData = await readFile(file, "utf8");
+    const pkgVersion = JSON.parse(pkgJSONData).version;
+    pkgJSONData = pkgJSONData.replace(new RegExp(pkgVersion, "g"), "workspace:*");
+    pkgJSONData = pkgJSONData.replace(/"version": "workspace:\*"/g, `"version": "${pkgVersion}"`);
+    await writeFile(file, pkgJSONData);
+  }));
+};
+export {
+  setWorkspaceVersion
+};

package/dist/esm/monorepo/utils.js

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { findUpSync } from "find-up";
+const WORKSPACE_DIR_ENV_VAR = "NPM_CONFIG_WORKSPACE_DIR";
+const WORKSPACE_MANIFEST_FILENAME = "pnpm-workspace.yaml";
+const findMonoRepoRoot = (cwd = process.cwd()) => {
+  const workspaceManifestDirEnvVar = process.env[WORKSPACE_DIR_ENV_VAR] ?? process.env[WORKSPACE_DIR_ENV_VAR.toLowerCase()];
+  const workspaceManifestLocation = workspaceManifestDirEnvVar ? path.join(workspaceManifestDirEnvVar, "pnpm-workspace.yaml") : findUpSync([WORKSPACE_MANIFEST_FILENAME, "pnpm-workspace.yml"], { cwd });
+  return workspaceManifestLocation && path.dirname(workspaceManifestLocation);
+};
+export {
+  findMonoRepoRoot
+};

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}

package/dist/esm/pui-config/index.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import fs from "node:fs";
+import { merge } from "lodash";
+const baseConfig = {
+  esBuild: {
+    target: "es2020"
+  }
+};
+const getPUIConfig = () => {
+  const configPath = path.resolve(process.cwd(), "./pui.config.js");
+  if (!fs.existsSync(configPath))
+    return baseConfig;
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  return merge(baseConfig, config);
+};
+export {
+  getPUIConfig
+};

package/dist/esm/scripts/helpers/checkmark.js

@@ -0,0 +1,10 @@
+import chalk from "chalk";
+function checkmark_default(callback, message = "") {
+  process.stdout.write("\n\n");
+  process.stdout.write(chalk.green(" \u2713"));
+  if (callback)
+    callback(message);
+}
+export {
+  checkmark_default as default
+};

package/dist/esm/scripts/helpers/get-npm-config.js

@@ -0,0 +1,5 @@
+import fs from "node:fs";
+var get_npm_config_default = JSON.parse(fs.readFileSync("package.json", "utf8"));
+export {
+  get_npm_config_default as default
+};

package/dist/esm/scripts/helpers/progress.js

@@ -0,0 +1,13 @@
+import readline from "readline";
+function progress_default(message, amountOfDots = 3) {
+  let i = 0;
+  return setInterval(() => {
+    readline.cursorTo(process.stdout, 0);
+    i = (i + 1) % (amountOfDots + 1);
+    const dots = new Array(i + 1).join(".");
+    process.stdout.write(message + dots);
+  }, 500);
+}
+export {
+  progress_default as default
+};

package/dist/esm/scripts/helpers/xmark.js

@@ -0,0 +1,9 @@
+import chalk from "chalk";
+function xmark_default(callback) {
+  process.stdout.write(chalk.red(" \u2718"));
+  if (callback)
+    callback();
+}
+export {
+  xmark_default as default
+};

package/dist/esm/scripts/npmcheckversion.js

@@ -0,0 +1,8 @@
+import { exec } from "child_process";
+exec("npm -v", (err, stdout) => {
+  if (err)
+    throw err;
+  if (parseFloat(stdout) < 5) {
+    throw new Error(`[ERROR] You need npm version @>=5 but you have ${stdout}`);
+  }
+});

package/dist/esm/scripts/update-notifier.js

@@ -0,0 +1,11 @@
+import updateNotifier from "update-notifier";
+import path from "node:path";
+import fs from "node:fs/promises";
+var update_notifier_default = async () => {
+  const pkgFile = await fs.readFile(path.join(process.cwd(), "./package.json"));
+  const pkg = JSON.parse(pkgFile);
+  updateNotifier({ pkg }).notify();
+};
+export {
+  update_notifier_default as default
+};

package/dist/esm/server/csp.js

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import path from "node:path";
+import cspPolicy from "helmet-csp";
+import crypto from "crypto";
+const sources = [
+  "'self'",
+  "http://localhost:*",
+  "*.elliemae.io",
+  "*.elliemae.com",
+  "*.elliservices.com",
+  "*.ellielabs.com",
+  "http://pdx-col.eum-appdynamics.com",
+  "https://pdx-col.eum-appdynamics.com/",
+  "https://www.google-analytics.com",
+  "https://www.googletagmanager.com"
+];
+const sendFileWithCSPNonce = ({
+  buildPath,
+  page = "index.html",
+  nonceRegex = /__CSP_NONCE__/g,
+  res,
+  fileSystem = fs
+}) => {
+  fileSystem.readFile(path.resolve(buildPath, page), "utf8", (err, html) => {
+    if (err) {
+      res.sendStatus(404);
+    } else {
+      res.set("Content-Type", "text/html");
+      res.send(html.replace(nonceRegex, (res.locals || {}).cspNonce));
+    }
+  });
+};
+const getScriptSrc = () => {
+  const scriptSrc = sources.concat([
+    (req, res) => `'nonce-${res.locals.cspNonce}'`
+  ]);
+  return true ? scriptSrc.concat(["'unsafe-eval'"]) : scriptSrc;
+};
+const csp = (app) => {
+  app.use((req, res, next) => {
+    res.locals.cspNonce = crypto.randomBytes(16).toString("hex");
+    next();
+  });
+  app.use(cspPolicy({
+    directives: {
+      defaultSrc: ["'self'"],
+      baseUri: ["'self'"],
+      blockAllMixedContent: [],
+      connectSrc: sources,
+      fontSrc: sources.concat(["data:"]),
+      frameAncestors: sources,
+      imgSrc: sources.concat(["data:"]),
+      objectSrc: ["'none'"],
+      scriptSrc: getScriptSrc(),
+      scriptSrcAttr: ["'none'"],
+      styleSrc: sources.concat(["'unsafe-inline'"]),
+      upgradeInsecureRequests: [],
+      reportUri: "/v1/csp"
+    },
+    reportOnly: true
+  }));
+};
+export {
+  csp,
+  sendFileWithCSPNonce
+};