@elliemae/pui-cli 7.0.0-beta.9 → 7.2.0

package/dist/cjs/transpile/esbuild.js

@@ -0,0 +1,134 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var esbuild_exports = {};
+__export(esbuild_exports, {
+  TARGETS: () => TARGETS,
+  esBuild: () => esBuild
+});
+module.exports = __toCommonJS(esbuild_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_esbuild = require("esbuild");
+var import_promises = require("node:fs/promises");
+var import_browserslist_to_esbuild = __toESM(require("browserslist-to-esbuild"), 1);
+const import_meta = {};
+const __dirname = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+const TARGETS = {
+  browserslist: (0, import_browserslist_to_esbuild.default)(),
+  web: "es2020",
+  node: "node14"
+};
+const ESBUILD_FORMAT = {
+  CJS: "cjs",
+  ESM: "esm"
+};
+const NODE_MODULE_TYPES = {
+  CJS: "commonjs",
+  ESM: "module"
+};
+const getCommonConfig = ({ injectReactShim }) => ({
+  bundle: false,
+  loader: { ".js": "jsx" },
+  mainFields: ["module", "browser", "main"],
+  inject: [
+    injectReactShim ? import_node_path.default.resolve(__dirname, "./react-shim.js") : ""
+  ].filter(Boolean)
+});
+const copyFiles = async ({ srcdir, outdir }) => {
+  const files = await (0, import_fast_glob.default)([
+    `${srcdir}/**/*.*`,
+    `${srcdir}/**/.swcrc`,
+    `!${srcdir}/**/*.{js,jsx,ts,tsx,mjs}`
+  ]);
+  await Promise.all(
+    files.map(async (srcFilePath) => {
+      const destFilePath = srcFilePath.replace(srcdir, outdir);
+      const fileDir = import_node_path.default.dirname(destFilePath);
+      await (0, import_promises.mkdir)(fileDir, { recursive: true });
+      await (0, import_promises.copyFile)(srcFilePath, destFilePath);
+    })
+  );
+};
+const getSideEffects = async () => {
+  const data = await (0, import_promises.readFile)(import_node_path.default.join(process.cwd(), "./package.json"));
+  const packageJSON = JSON.parse(data);
+  return packageJSON?.sideEffects || false;
+};
+const createPackageJson = async ({ outdir, type = NODE_MODULE_TYPES.ESM }) => {
+  const filePath = import_node_path.default.join(process.cwd(), outdir, "package.json");
+  const packageJSON = JSON.stringify(
+    {
+      type,
+      sideEffects: await getSideEffects()
+    },
+    null,
+    2
+  );
+  await (0, import_promises.writeFile)(filePath, packageJSON);
+};
+const esBuild = async ({
+  srcdir,
+  outdir = "dist",
+  esmOnly = false,
+  target = TARGETS.browserslist,
+  injectReactShim = true,
+  skipNestedPackageJSON = false
+}) => {
+  const inputFiles = [
+    `${srcdir}/**/*.{js,jsx,ts,tsx}`,
+    `!${srcdir}/**/*.d.ts`,
+    `!${srcdir}/**/*.test.{js,jsx,ts,tsx}`,
+    `!${srcdir}/**/*.stories.{js,jsx,ts,tsx}`,
+    `!${srcdir}/**/*.endpoint.{js,jsx,ts,tsx}`
+  ];
+  if (!esmOnly) {
+    const cjsOutdir = `${outdir}/cjs`;
+    const commonJSEntryPoints = await (0, import_fast_glob.default)(inputFiles);
+    await (0, import_esbuild.build)({
+      entryPoints: commonJSEntryPoints,
+      ...getCommonConfig({ injectReactShim }),
+      outdir: cjsOutdir,
+      format: ESBUILD_FORMAT.CJS,
+      target
+    });
+    await copyFiles({ srcdir, outdir: cjsOutdir });
+    await createPackageJson({ outdir: cjsOutdir, type: NODE_MODULE_TYPES.CJS });
+  }
+  const esmOutdir = esmOnly ? outdir : `${outdir}/esm`;
+  const entryPoints = await (0, import_fast_glob.default)(
+    inputFiles.concat([`!${srcdir}/**/cjs/**/*.{js,jsx,ts,tsx}`])
+  );
+  await (0, import_esbuild.build)({
+    entryPoints,
+    ...getCommonConfig({ injectReactShim }),
+    outdir: esmOutdir,
+    format: ESBUILD_FORMAT.ESM,
+    target
+  });
+  await copyFiles({ srcdir, outdir: esmOutdir });
+  if (!skipNestedPackageJSON)
+    await createPackageJson({ outdir: esmOutdir, type: NODE_MODULE_TYPES.ESM });
+};

package/dist/cjs/transpile/react-shim.js

@@ -0,0 +1,30 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_shim_exports = {};
+__export(react_shim_exports, {
+  React: () => React
+});
+module.exports = __toCommonJS(react_shim_exports);
+var React = __toESM(require("react"), 1);

package/{lib/transpile/swcrc.config.js → dist/cjs/transpile/swcrc.config.cjs}

@@ -10,4 +10,4 @@ if (fs.existsSync(projectPath)) {
 const localConfig = JSON.parse(
   fs.readFileSync(path.join(__dirname, '.swcrc'), 'utf-8'),
 );
-module.exports = merge(localConfig, projectConfig);
+exports.swcrcConfig = merge(localConfig, projectConfig);

package/dist/cjs/typedoc.cjs

@@ -0,0 +1,12 @@
+const path = require('path');
+const fs = require('fs');
+
+const isApp = () => fs.existsSync(path.join(process.cwd(), 'app'));
+
+const srcPath = path.join(process.cwd(), isApp() ? 'app' : 'lib');
+
+module.exports = {
+  entryPoints: [srcPath],
+  exclude: ['**/*+(.spec|.e2e|.test).ts'],
+  out: path.join(process.cwd(), 'docs'),
+};

package/dist/cjs/update-notifier.js

@@ -0,0 +1,37 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_notifier_exports = {};
+__export(update_notifier_exports, {
+  notifyUpdates: () => notifyUpdates
+});
+module.exports = __toCommonJS(update_notifier_exports);
+var import_update_notifier = __toESM(require("update-notifier"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+const notifyUpdates = async () => {
+  const pkgFile = await import_promises.default.readFile(import_node_path.default.join(process.cwd(), "./package.json"));
+  const pkg = JSON.parse(pkgFile);
+  (0, import_update_notifier.default)({ pkg }).notify();
+};

package/dist/cjs/utils.cjs

@@ -0,0 +1,23 @@
+const path = require('path');
+const fs = require('fs');
+
+exports.basePath = (process.env.BASE_PATH || '/').replace(/\/?$/, '/');
+
+const isApp = () => fs.existsSync(path.join(process.cwd(), 'app'));
+
+exports.getAppConfig = () => {
+  const appConfigPath = path.join(
+    process.cwd(),
+    isApp() ? 'app' : 'lib',
+    'app.config.json',
+  );
+
+  if (!fs.existsSync(appConfigPath)) return '{}';
+  const appConfig = fs.readFileSync(appConfigPath);
+  return appConfig || '{}';
+};
+
+exports.isApp = isApp;
+
+exports.isTypeScriptEnabled = () =>
+  fs.existsSync(path.join(process.cwd(), 'tsconfig.json'));

package/dist/cjs/webpack/helpers.js

@@ -0,0 +1,237 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+__export(helpers_exports, {
+  LATEST_VERSION: () => LATEST_VERSION,
+  excludeNodeModulesExcept: () => excludeNodeModulesExcept,
+  filterByFilePresence: () => filterByFilePresence,
+  getAlias: () => getAlias,
+  getAppVersion: () => getAppVersion,
+  getCompressionPlugins: () => getCompressionPlugins,
+  getLibraryName: () => getLibraryName,
+  getMediaPath: () => getMediaPath,
+  getPaths: () => getPaths,
+  isAppLoaderEnabled: () => isAppLoaderEnabled,
+  isGoogleTagManagerEnabled: () => isGoogleTagManagerEnabled,
+  mainFields: () => mainFields,
+  mapToFolder: () => mapToFolder,
+  modulesToTranspile: () => modulesToTranspile,
+  resolveExtensions: () => resolveExtensions
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_lodash = __toESM(require("lodash"), 1);
+var import_compression_webpack_plugin = __toESM(require("compression-webpack-plugin"), 1);
+var import_zlib = __toESM(require("zlib"), 1);
+var import_utils = require("../monorepo/utils.cjs");
+var import_utils2 = require("../utils.cjs");
+let pathSep = import_node_path.default.sep;
+if (pathSep === "\\")
+  pathSep = "\\\\";
+const LATEST_VERSION = "latest";
+const getNodeModulesRegEx = (modules) => modules.map(
+  (modName) => new RegExp(`node_modules${pathSep}${modName.replace("/", pathSep)}`)
+);
+const excludeNodeModulesExcept = (modules) => {
+  const moduleRegExps = getNodeModulesRegEx(modules);
+  return function(modulePath) {
+    if (/node_modules/.test(modulePath)) {
+      for (let i = 0; i < moduleRegExps.length; i += 1)
+        if (moduleRegExps[i].test(modulePath))
+          return false;
+      return true;
+    }
+    return false;
+  };
+};
+const getLibraryName = () => {
+  const packageJson = JSON.parse(
+    import_node_fs.default.readFileSync(import_node_path.default.join(process.cwd(), "package.json"))
+  );
+  const libraryName = packageJson ? packageJson.name : process.env.LIBRARY_NAME || "mylibrary";
+  const modifiedLibName = `emui-${libraryName.replace("@elliemae/", "").replace("pui-", "")}`;
+  return import_lodash.default.camelCase(modifiedLibName);
+};
+const mapToFolder = (dependencies, folder) => dependencies.reduce(
+  (acc, dependency) => ({
+    [dependency]: import_node_path.default.resolve(`${folder}/${dependency.replace("$", "")}`),
+    ...acc
+  }),
+  {}
+);
+const getAlias = () => {
+  const monorepoRoot = (0, import_utils.findMonoRepoRoot)(process.cwd()) || "";
+  return mapToFolder(
+    [
+      "@babel/runtime",
+      "react",
+      "react-dom",
+      "react-redux",
+      "redux",
+      "redux-saga",
+      "moment",
+      "lodash",
+      "styled-components",
+      "immer",
+      "react-dates",
+      "react-transition-group",
+      "@elliemae/pui-cli",
+      "@elliemae/pui-app-sdk$",
+      "@elliemae/pui-theme$"
+    ],
+    import_node_path.default.join(monorepoRoot, "./node_modules")
+  );
+};
+const modulesToTranspile = [
+  "@elliemae/pui-*",
+  "@elliemae/ds-*",
+  "@dnd-kit/*",
+  "@elliemae/em-platform-document-viewer"
+];
+const getUserMonitoringFileName = () => {
+  const libName = "emuiUserMonitoring";
+  const userMonLibPath = import_node_path.default.join(
+    process.cwd(),
+    "node_modules/@elliemae/pui-user-monitoring/dist/public/js"
+  );
+  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];
+};
+const getAppLoaderFileName = () => {
+  const libName = "emuiAppLoader";
+  const appLoaderLibPath = import_node_path.default.join(
+    process.cwd(),
+    "node_modules/@elliemae/pui-app-loader/dist/public/js"
+  );
+  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];
+};
+const getDiagnosticsFileName = () => {
+  const libName = "emuiDiagnostics";
+  const libPath = import_node_path.default.join(
+    process.cwd(),
+    "node_modules/@elliemae/pui-diagnostics/dist/public/js"
+  );
+  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];
+};
+const getENCWLoaderFileName = () => {
+  const libName = "emuiEncwLoader";
+  const appLoaderLibPath = import_node_path.default.join(
+    process.cwd(),
+    "node_modules/@elliemae/encw-loader/dist/public/js"
+  );
+  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];
+};
+const getAppVersion = () => {
+  if (!process.env.APP_VERSION)
+    return LATEST_VERSION;
+  const match = process.env.APP_VERSION.match(/^v?(\d+\.\d+)\..*$/);
+  return match && match[1] || LATEST_VERSION;
+};
+const getPaths = (latestVersion = true) => {
+  const version = latestVersion ? LATEST_VERSION : getAppVersion();
+  const publicPath = `${version}/`;
+  const timeStampQuery = process.env.PUI_PIPELINE !== "true" ? `?timeStamp=${Date.now()}` : "";
+  return {
+    appVersion: version,
+    buildPath: import_node_path.default.resolve(process.cwd(), `build/public/`),
+    basePath: import_utils2.basePath,
+    publicPath,
+    userMonScriptPath: `latest/js/${getUserMonitoringFileName()}`,
+    appLoaderScriptPath: `latest/js/${getAppLoaderFileName()}`,
+    diagnosticsScriptPath: `latest/js/${getDiagnosticsFileName()}`,
+    globalScriptPath: `latest/js/global.js${timeStampQuery}`,
+    encwLoaderScriptPath: `latest/js/${getENCWLoaderFileName()}`
+  };
+};
+const isAppLoaderEnabled = () => process.env.APP_LOADER === "true";
+const getMediaPath = () => `assets/[name].[contenthash].[ext]`;
+const isGoogleTagManagerEnabled = () => {
+  const appConfig = JSON.parse((0, import_utils2.getAppConfig)());
+  return !!appConfig?.googleTagManager;
+};
+const getCompressionPlugins = (isLibrary = false) => {
+  const excludeList = [
+    /\/adrum-ext/,
+    /\/emuiUserMonitoring/,
+    /\/emuiDiagnostics/,
+    /\/emuiAppLoader/,
+    /\/encwLoader/
+  ];
+  const commonConfig = {
+    test: /\.(js|css)$/,
+    exclude: !isLibrary ? excludeList : [],
+    minRatio: Infinity
+  };
+  return [
+    new import_compression_webpack_plugin.default({
+      filename: "[path][base].gz",
+      algorithm: "gzip",
+      ...commonConfig
+    }),
+    new import_compression_webpack_plugin.default({
+      filename: "[path][base].br",
+      algorithm: "brotliCompress",
+      ...commonConfig,
+      compressionOptions: {
+        params: {
+          [import_zlib.default.constants.BROTLI_PARAM_QUALITY]: 11
+        }
+      }
+    })
+  ];
+};
+const filterByFilePresence = (patterns) => patterns.filter(
+  ({ from, noErrorOnMissing }) => !noErrorOnMissing || import_node_fs.default.existsSync(import_node_path.default.resolve(process.cwd(), from))
+);
+const resolveExtensions = [
+  ".wasm",
+  ".mjs",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json"
+];
+const mainFields = ["browser", "module", "main"];