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

package/dist/esm/commands/lint.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import yargs from "yargs";
+import { exec, logError, logSuccess } from "./utils.js";
+import { isTypeScriptEnabled } from "../utils.cjs";
+const { CI = false } = process.env;
+const lintCSS = async (fix = false) => {
+  const fixIssues = fix ? "--fix" : "";
+  await exec(
+    `stylelint ./{lib,app}/**/*.{js,jsx,ts,tsx} ${fixIssues} ${!CI ? "--color" : ""} --allow-empty-input --config ${path.join(
+      process.cwd(),
+      "stylelint.config.cjs"
+    )}`
+  );
+};
+const lintJS = async (fix = false) => {
+  const fixIssues = fix ? "--fix" : "";
+  await exec(`eslint ${!CI ? "--color" : ""} ${fixIssues}  .`);
+};
+const lintCmd = {
+  handler: async (argv) => {
+    if (argv.js) {
+      if (isTypeScriptEnabled())
+        await exec("tsc --noEmit --emitDeclarationOnly false");
+      try {
+        await exec("rimraf ./reports/eslint.json");
+        await lintJS(argv.fix);
+        logSuccess("JS linting completed");
+      } catch (err) {
+        logError("JS linting failed");
+        yargs().exit(-1, err);
+        return -1;
+      }
+    }
+    if (argv.css) {
+      try {
+        await exec("rimraf ./reports/stylelint.json");
+        await lintCSS(argv.fix);
+        logSuccess("CSS linting completed");
+      } catch (err) {
+        logError("CSS linting failed");
+        yargs().exit(-1, err);
+        return -1;
+      }
+    }
+    return 0;
+  },
+  command: "lint [options]",
+  describe: "lints application code",
+  builder: {
+    css: {
+      alias: "css",
+      type: "boolean",
+      default: true
+    },
+    js: {
+      alias: "js",
+      type: "boolean",
+      default: true
+    },
+    fix: {
+      alias: "fix",
+      type: "boolean",
+      default: false
+    }
+  }
+};
+export {
+  lintCmd
+};

package/dist/esm/commands/pack.js

@@ -0,0 +1,71 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import yargs from "yargs";
+import { exec, logInfo, logError, logSuccess } from "./utils.js";
+import { isTypeScriptEnabled } from "../utils.cjs";
+import { esBuild } from "../transpile/esbuild.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const compileTypeScript = async () => {
+  logInfo("Generating types...");
+  await exec("tsc --emitDeclarationOnly");
+  logInfo("Types generation completed...");
+};
+const webBuild = async (productionBuild) => {
+  logInfo("Building source files for browser environment...");
+  const devCmd = `${path.resolve(
+    __dirname,
+    "../webpack/webpack.lib.dev.babel.js"
+  )} --color`;
+  const prodCmd = `${path.resolve(
+    __dirname,
+    "../webpack/webpack.lib.prod.babel.js"
+  )} --color`;
+  await exec(`webpack --config ${productionBuild ? prodCmd : devCmd}`);
+  logInfo("Building source files for browser environment completed...");
+};
+const pack = async ({ production, target, srcPath }) => {
+  logInfo("Build in-progress...");
+  await exec("rimraf ./dist");
+  if (isTypeScriptEnabled()) {
+    await compileTypeScript();
+  }
+  if (target !== "node")
+    await webBuild(production);
+  if (target !== "web") {
+    logInfo("Building source files for nodejs environment...");
+    await esBuild({ srcdir: srcPath });
+    logInfo("Building source files for nodejs environment completed.");
+  }
+};
+const packCmd = {
+  handler: async (argv) => {
+    try {
+      await pack(argv);
+      logSuccess("Build completed");
+    } catch (err) {
+      logError("Build failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "pack",
+  describe: "builds library",
+  builder: {
+    production: {
+      alias: "p",
+      type: "boolean",
+      default: false
+    },
+    target: {
+      alias: "t",
+      type: "string",
+      description: "target environment where this library will be used. allowed values are web, node. by default libraries will be compiled for both web and nodejs environments"
+    },
+    srcPath: {
+      type: "string",
+      default: "./lib"
+    }
+  }
+};
+export {
+  packCmd
+};

package/dist/esm/commands/start.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import yargs from "yargs";
+import { exec, logError, logSuccess, isApp } from "./utils.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const startProdServer = async () => {
+  await exec(
+    `cross-env NODE_ENV=production ts-node ${path.resolve(
+      __dirname,
+      "../server"
+    )} --color always`
+  );
+};
+const startDevServer = async () => {
+  const configFile = `../webpack/${await isApp() ? "webpack.dev.babel.js" : "webpack.lib.dev.babel.js"}`;
+  await exec(
+    `cross-env NODE_ENV=development webpack serve --config ${path.resolve(
+      __dirname,
+      configFile
+    )}`
+  );
+};
+const startCmd = {
+  handler: async (argv) => {
+    try {
+      if (argv.prod) {
+        await startProdServer();
+      } else {
+        await startDevServer();
+      }
+      logSuccess("Server started");
+    } catch (err) {
+      logError("Server start failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "start [options]",
+  describe: "starts local web server to test the application",
+  builder: {
+    prod: {
+      alias: "p",
+      default: false,
+      type: "boolean"
+    }
+  }
+};
+export {
+  startCmd
+};

package/dist/esm/commands/storybook.js

@@ -0,0 +1,45 @@
+import yargs from "yargs";
+import { exec, logInfo, logError, logSuccess } from "./utils.js";
+const buildStoryBook = async (isDoc = false) => {
+  const additionalParams = isDoc ? "--docs -o demo/docs" : "-o demo";
+  await exec(
+    `cross-env NODE_ENV=production FORCE_COLOR=true build-storybook --quiet ${additionalParams}`
+  );
+};
+const startStoryBook = async (isDoc = false) => {
+  await exec(
+    `cross-env NODE_ENV=development STORYBOOK_BUILD=true FORCE_COLOR=true start-storybook ${isDoc && "--docs"} -p 11000 --quiet`
+  );
+};
+const storybookCmd = {
+  handler: async (argv) => {
+    try {
+      if (!argv.build) {
+        await startStoryBook(argv.docs);
+        logInfo("Storybook started");
+      } else {
+        await buildStoryBook(argv.docs);
+        logSuccess("Storybook build completed");
+      }
+    } catch (err) {
+      logError("Storybook execution failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "storybook [options]",
+  describe: "story book application code",
+  builder: {
+    build: {
+      alias: "b",
+      type: "boolean",
+      default: false
+    },
+    docs: {
+      type: "boolean",
+      default: false
+    }
+  }
+};
+export {
+  storybookCmd
+};

package/dist/esm/commands/test.js

@@ -0,0 +1,74 @@
+import yargs from "yargs";
+import { exec, logError, logSuccess } from "./utils.js";
+const { CI = false } = process.env;
+const test = async (commandOptions) => {
+  await exec(`cross-env NODE_ENV=test jest ${commandOptions}`);
+};
+const debugTest = async () => {
+  await exec(
+    `node --inspect-brk ./node_modules/jest-cli/bin/jest.js --runInBand --watch`
+  );
+};
+const testCmd = {
+  handler: async (argv) => {
+    let commandOptions = "--coverage --maxWorkers=50%";
+    if (argv.fix)
+      commandOptions = "-u";
+    else if (argv.watch)
+      commandOptions = "--watchAll";
+    if (CI)
+      commandOptions += " --ci --no-colors";
+    if (argv.p)
+      commandOptions += " --passWithNoTests";
+    if (argv.r)
+      commandOptions += " --bail --findRelatedTests";
+    if (argv.s)
+      commandOptions += " --silent";
+    try {
+      if (CI) {
+        await exec("rimraf ./reports");
+      }
+      if (argv.debug) {
+        await debugTest();
+      } else {
+        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: "test [options]",
+  describe: "unit tests application code",
+  builder: {
+    fix: {
+      alias: "f",
+      type: "boolean"
+    },
+    watch: {
+      alias: "w",
+      type: "boolean"
+    },
+    debug: {
+      type: "boolean"
+    },
+    passWithNoTests: {
+      alias: "p",
+      type: "boolean"
+    },
+    findReleatedTests: {
+      alias: "r",
+      type: "boolean"
+    },
+    silent: {
+      alias: "s",
+      type: "boolean"
+    }
+  }
+};
+export {
+  testCmd
+};

package/dist/esm/commands/tscheck.js

@@ -0,0 +1,56 @@
+import path from "node:path";
+import fs from "node:fs";
+import yargs from "yargs";
+import { exec, logInfo, logError } from "./utils.js";
+const randomChars = () => Math.random().toString(36).slice(2);
+const validateTypescript = async (files = []) => {
+  const tsconfigPath = path.join(process.cwd(), "tsconfig.json");
+  const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath));
+  const tmpTsconfigPath = path.join(
+    process.cwd(),
+    `tsconfig.${randomChars()}.json`
+  );
+  const tmpTsconfig = {
+    ...tsconfig,
+    compilerOptions: {
+      ...tsconfig.compilerOptions,
+      skipLibCheck: true
+    },
+    files,
+    include: ["app", "lib"]
+  };
+  fs.writeFileSync(tmpTsconfigPath, JSON.stringify(tmpTsconfig, null, 2));
+  const tscPath = path.resolve(
+    process.cwd(),
+    `./node_modules/.bin/tsc${process.platform === "win32" ? ".cmd" : ""}`
+  );
+  try {
+    await exec(
+      `${tscPath} -p ${tmpTsconfigPath} --noEmit --emitDeclarationOnly false`
+    );
+  } finally {
+    fs.unlinkSync(tmpTsconfigPath);
+  }
+};
+const tscheckCmd = {
+  handler: async ({ files }) => {
+    try {
+      await validateTypescript(files);
+      logInfo("Typescript validation completed");
+    } catch (err) {
+      logError("Typescript validation failed", err);
+      yargs().exit(-1, err);
+    }
+  },
+  command: "tscheck [options]",
+  describe: "validate typescript file(s)",
+  builder: {
+    files: {
+      type: "array",
+      default: []
+    }
+  }
+};
+export {
+  tscheckCmd
+};

package/dist/esm/commands/utils.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+import { constants } from "fs";
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  readdir,
+  copyFile,
+  access
+} 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);
+};
+const isPathExist = async (pathToCheck) => {
+  try {
+    await access(pathToCheck, constants.F_OK);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+const isApp = async () => isPathExist(path.join(process.cwd(), "app"));
+export {
+  copyBuildAssetsToVersionedFolder,
+  exec,
+  isApp,
+  isPathExist,
+  logError,
+  logInfo,
+  logSuccess,
+  writeAppInfo
+};

package/dist/esm/commands/version.js

@@ -0,0 +1,51 @@
+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/commands/vitest.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import yargs from "yargs";
+import { exec, logError, logSuccess } from "./utils.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const { CI = false } = process.env;
+const configPath = path.resolve(__dirname, "../testing/vitest.config.js");
+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/index.cjs

@@ -0,0 +1,25 @@
+const { babelConfig } = require('./babel.config.cjs');
+const {
+  esConfig: eslintBaseConfig,
+} = require('./lint-config/eslint/non-react.cjs');
+const {
+  esReactConfig: eslintConfig,
+} = require('./lint-config/eslint/react.cjs');
+const { stylelintConfig } = require('./lint-config/stylelint.config.cjs');
+const { prettierConfig } = require('./lint-config/prettier.config.cjs');
+const { commitlintConfig } = require('./lint-config/commitlint.config.cjs');
+const { jestConfig } = require('./testing/jest.config.cjs');
+const { jestNodeConfig } = require('./testing/jest.node.config.cjs');
+const { loadRoutes } = require('./server/app-routes.cjs');
+
+module.exports = {
+  babelConfig,
+  eslintBaseConfig,
+  eslintConfig,
+  stylelintConfig,
+  prettierConfig,
+  commitlintConfig,
+  jestConfig,
+  jestNodeConfig,
+  loadRoutes,
+};

package/dist/esm/index.js

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

package/dist/esm/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
+    }
+  }
+}