@elliemae/pui-cli 7.0.0-alpha.1 → 7.0.0-alpha.4

package/dist/esm/server/index.js

@@ -0,0 +1,17 @@
+import express from "express";
+import { logger } from "./logger.js";
+import {
+  setupDefaultMiddlewares,
+  setupAdditionalMiddlewars
+} from "./middlewares/index.js";
+import { loadRoutes, port, host } from "./util/index.js";
+const app = express();
+setupDefaultMiddlewares(app);
+loadRoutes(app);
+setupAdditionalMiddlewars(app);
+app.listen(port, host, async (err) => {
+  if (err) {
+    return logger.error(err.message);
+  }
+  logger.appStarted(port, host || "localhost");
+});

package/dist/esm/server/logger.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+import ip from "ip";
+const divider = chalk.gray("\n-----------------------------------");
+const logger = {
+  error: (err) => {
+    console.error(chalk.red(err));
+  },
+  appStarted: (port, host, tunnelStarted) => {
+    console.log(`Server started ! ${chalk.green("\u2713")}`);
+    if (tunnelStarted) {
+      console.log(`Tunnel initialised ${chalk.green("\u2713")}`);
+    }
+    const accessUrls = `${chalk.bold("Access URLs:")}${divider}
+`;
+    const localHostUrl = `Localhost: ${chalk.magenta(`http://${host}:${port}`)}
+`;
+    const lanUrl = `LAN: ${chalk.magenta(`http://${ip.address()}:${port}`)}
+`;
+    const proxy = tunnelStarted ? `
+    Proxy: ${chalk.magenta(tunnelStarted)}` : "";
+    console.log(`${accessUrls}${localHostUrl}${lanUrl}${proxy}${divider}${chalk.blue(`
+Press ${chalk.italic("CTRL-C")} to stop`)}
+    `);
+  }
+};
+export {
+  logger
+};

package/dist/esm/server/middlewares/addProdMiddlewares.js

@@ -0,0 +1,22 @@
+import compression from "compression";
+import expressStaticGzip from "express-static-gzip";
+import { sendFileWithCSPNonce } from "../csp.js";
+import { getPaths } from "../../webpack/helpers.js";
+const paths = getPaths();
+const addProdMiddlewares = (app, options = {}) => {
+  const { buildPath = paths.buildPath, basePath = paths.basePath } = options;
+  app.use(compression());
+  app.get(basePath, (req, res) => {
+    sendFileWithCSPNonce({ buildPath, res });
+  });
+  app.use(basePath, expressStaticGzip(buildPath, {
+    index: false,
+    enableBrotli: true,
+    orderPreference: ["br"]
+  }));
+  app.use(expressStaticGzip("cdn"));
+  app.get("*", (req, res) => sendFileWithCSPNonce({ buildPath, res }));
+};
+export {
+  addProdMiddlewares
+};

package/dist/esm/server/middlewares/index.js

@@ -0,0 +1,35 @@
+import express from "express";
+import cors from "cors";
+import expressPinoLogger from "express-pino-logger";
+import { csp } from "../csp.js";
+import { addProdMiddlewares } from "./addProdMiddlewares.js";
+const setupDefaultMiddlewares = (app) => {
+  const pino = expressPinoLogger({
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true
+      }
+    }
+  });
+  pino.logger.level = "warn";
+  app.use(pino);
+  app.use(cors());
+  app.options("*", cors());
+  csp(app);
+  app.use(express.urlencoded({ extended: false }));
+  app.use(express.text({ type: "text/plain" }));
+  app.use(express.json({ type: "application/json" }));
+  app.use(express.json({ type: "application/csp-report" }));
+};
+const setupAdditionalMiddlewars = (app, options) => {
+  const isProd = false;
+  if (isProd) {
+    addProdMiddlewares(app, options);
+  }
+  return app;
+};
+export {
+  setupAdditionalMiddlewars,
+  setupDefaultMiddlewares
+};

package/dist/esm/server/util/index.js

@@ -0,0 +1,46 @@
+import fs from "fs";
+import path from "path";
+import minimist from "minimist";
+const argv = minimist(process.argv.slice(2));
+const getCWD = () => process.cwd();
+const allJS = /\.js$/;
+const serviceEndpoints = /\.endpoint\.js$/;
+const getFilesMatching = (filePattern) => {
+  const getFiles = (dir) => {
+    let routeFiles = [];
+    if (!fs.existsSync(dir))
+      return routeFiles;
+    fs.readdirSync(dir).forEach((file) => {
+      const fullPath = path.join(dir, file);
+      if (fs.lstatSync(fullPath).isDirectory()) {
+        routeFiles = routeFiles.concat(getFiles(fullPath));
+      } else if (filePattern.test(fullPath))
+        routeFiles.push(fullPath);
+    });
+    return routeFiles;
+  };
+  return getFiles;
+};
+const getServerRouteFiles = getFilesMatching(allJS);
+const getServiceEndpoints = getFilesMatching(serviceEndpoints);
+const loadRoutes = (app) => {
+  const routeFiles = getServerRouteFiles(path.join(getCWD(), "server/routes"));
+  routeFiles.push(...getServiceEndpoints(path.join(getCWD(), "app")));
+  routeFiles.push(...getServiceEndpoints(path.join(getCWD(), "lib")));
+  routeFiles.forEach(async (routeFile) => {
+    const init = await import(routeFile);
+    try {
+      init(app);
+    } catch (err) {
+      console.error(`unable to load routes from ${routeFile}. ${err.message}`);
+    }
+  });
+};
+const port = parseInt(argv.port || process.env.port || process.env.PORT || "3000", 10);
+const host = argv.host || process.env.HOST;
+export {
+  getCWD,
+  host,
+  loadRoutes,
+  port
+};

package/dist/esm/testing/jest.config.cjs

@@ -0,0 +1,105 @@
+const path = require('path');
+const normalizePath = require('normalize-path');
+const { getAppConfig, basePath } = require('../utils.cjs');
+const { swcrcConfig } = require('../transpile/swcrc.config.cjs');
+
+let monorepoRoot = null;
+import('../monorepo/utils.js').then(({ findMonoRepoRoot }) => {
+  monorepoRoot = findMonoRepoRoot(process.cwd());
+}).catch((ex) => console.error('Error loading monorepo utils:', ex));
+
+let isReactModule = true;
+try {
+  /* eslint-disable global-require, import/no-unresolved */
+  require('react');
+  require('styled-components');
+  /* eslint-enable global-require, import/no-unresolved */
+} catch (err) {
+  isReactModule = false;
+}
+
+const getMockFilePath = (fileName) =>
+  normalizePath(path.resolve(__dirname, './mocks', fileName));
+
+const getNodeModulesPath = (fileName) => {
+  return normalizePath(
+    monorepoRoot
+      ? path.join(monorepoRoot, 'node_modules', fileName)
+      : `<rootDir>/node_modules/${fileName}`,
+  );
+};
+
+const jestConfig = {
+  collectCoverageFrom: [
+    'app/**/*.{js,ts,jsx,tsx}',
+    'lib/**/*.{js,ts,jsx,tsx}',
+    '!app/**/*.d.ts',
+    '!lib/**/*.d.ts',
+    '!app/**/*.test.{js,ts,jsx,tsx}',
+    '!lib/**/*.test.{js,ts,jsx,tsx}',
+    '!app/**/*.stories.{js,ts,jsx,tsx}',
+    '!lib/**/*.stories.{js,ts,jsx,tsx}',
+    '!app/**/*.endpoint.{js,ts,jsx,tsx}',
+    '!lib/**/*.endpoint.{js,ts,jsx,tsx}',
+    '!app/*/RbGenerated*/*.{js,ts,jsx,tsx}',
+    '!app/index.{js,ts,jsx,tsx}',
+    '!app/global-styles.{js,ts,jsx,tsx}',
+    '!app/**/loadable.{js,ts,jsx,tsx}',
+    '!lib/**/loadable.{js,ts,jsx,tsx}',
+  ],
+  coverageThreshold: {
+    // Todo: enable the coverage threshold later
+    // global: {
+    //   statements: 95,
+    //   branches: 90,
+    //   functions: 95,
+    //   lines: 95,
+    // },
+  },
+  coverageDirectory: 'reports',
+  coverageReporters: ['lcov', 'html', 'text-summary'],
+  moduleDirectories: ['node_modules', 'app', 'lib'],
+  moduleNameMapper: {
+    '.*\\webpack-hmr(.[t|j]s)?$': getMockFilePath('webpack-hmr.cjs'),
+    '.*\\.(css|scss)$': getMockFilePath('cssModule.cjs'),
+    '.*\\.(jpg|jpeg|png|gif|eot|otf|webp|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga|ico)$':
+      getMockFilePath('image.cjs'),
+    '.*\\.svg(?:\\?[a-zA-Z]+)?$': getMockFilePath('svg.cjs'),
+    '.*\\.html$(?:\\?[a-zA-Z]+)?$': getMockFilePath('html.cjs'),
+    '@elliemae/pui-user-monitoring': getMockFilePath('pui-user-monitoring.cjs'),
+    '@elliemae/pui-app-loader': getMockFilePath('pui-app-loader.cjs'),
+    '@elliemae/pui-diagnostics': getMockFilePath('pui-diagnostics.cjs'),
+    'react-spring/web': getNodeModulesPath('react-spring/web.cjs.js'),
+    'react-spring/renderprops': getNodeModulesPath(
+      'react-spring/renderprops.cjs.js',
+    ),
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  setupFilesAfterEnv: [path.resolve(__dirname, './setup-tests.js')],
+  setupFiles: ['raf/polyfill', 'whatwg-fetch'],
+  testRegex: '(app|lib).*/tests/.*\\.test\\.[jt]sx?$',
+  snapshotSerializers: [],
+  testResultsProcessor: 'jest-sonar-reporter',
+  resolver: path.resolve(__dirname, './resolver.cjs'),
+  transform: {
+    '^.+\\.[jt]sx?$': ['@swc/jest', swcrcConfig],
+  },
+  transformIgnorePatterns: [
+    'node_modules/(?!(.*@elliemae/pui-cli|lodash-es|react-select|react-dates)/)',
+  ],
+  globals: {
+    APP_CONFIG: getAppConfig(),
+    __webpack_public_path__: '/',
+  },
+  testEnvironmentOptions: {
+    url: `http://localhost:3111${basePath}`,
+  },
+  testEnvironment: 'jsdom',
+};
+
+if (isReactModule && jestConfig.setupFilesAfterEnv)
+  jestConfig.setupFilesAfterEnv.push(
+    path.resolve(__dirname, './setup-react-env.js'),
+  );
+
+exports.jestConfig = jestConfig;

package/dist/esm/testing/jest.node.config.cjs

@@ -0,0 +1,8 @@
+const { jestConfig } = require('./jest.config.cjs');
+exports.jestNodeConfig = {
+  ...jestConfig,
+  testEnvironment: 'node',
+  transformIgnorePatterns: [],
+  setupFiles: [],
+  setupFilesAfterEnv: [],
+};

package/dist/esm/testing/mocks/axios.cjs

@@ -0,0 +1,15 @@
+module.exports = {
+  defaults: {},
+  interceptors: {
+    request: {
+      use: jest.fn(),
+    },
+    response: {
+      use: jest.fn(),
+    },
+  },
+  create: jest.fn().mockReturnThis(),
+  get: jest.fn().mockResolvedValue({ data: {} }),
+  post: jest.fn().mockResolvedValue({ data: {} }),
+  put: jest.fn().mockResolvedValue({ data: {} }),
+};

package/dist/esm/testing/mocks/cssModule.cjs

@@ -0,0 +1 @@
+module.exports = 'CSS_MODULE';

package/dist/esm/testing/mocks/html.cjs

@@ -0,0 +1 @@
+module.exports = 'HTML_MODULE';

package/dist/esm/testing/mocks/image.cjs

@@ -0,0 +1 @@
+module.exports = 'IMAGE_MOCK';

package/dist/esm/testing/mocks/matchMedia.cjs

@@ -0,0 +1,24 @@
+/**
+ *
+ */
+export default () => {
+  Object.defineProperty(window, 'matchMedia', {
+    writable: true,
+    value: jest.fn().mockImplementation((query) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: jest.fn(), // Deprecated
+      removeListener: jest.fn(), // Deprecated
+      addEventListener: jest.fn(),
+      removeEventListener: jest.fn(),
+      dispatchEvent: jest.fn(),
+    })),
+  });
+
+  Object.defineProperty(window, 'getComputedStyle', {
+    value: () => ({
+      getPropertyValue: () => {},
+    }),
+  });
+};

package/dist/esm/testing/mocks/pui-app-loader.cjs

@@ -0,0 +1 @@
+export const load = () => {};

package/dist/esm/testing/mocks/pui-diagnostics.cjs

@@ -0,0 +1,28 @@
+export const logger = () => ({
+  setLogLevel() {},
+  setOptions() {},
+  info() {},
+  warn() {},
+  error() {},
+  trace() {},
+  debug() {},
+  audit() {},
+  fatal() {},
+});
+export const LogLevel = {
+  info: 'info',
+  debug: 'debug',
+  trace: 'trace',
+  warn: 'warn',
+  error: 'error',
+  audit: 'audit',
+  fatal: 'fatal',
+};
+export const Console = () => ({
+  log: () => {},
+});
+export const http = () => ({
+  log() {},
+});
+export const webvitals = () => {};
+export const logUnhandledErrors = () => {};

package/dist/esm/testing/mocks/pui-user-monitoring.cjs

@@ -0,0 +1,3 @@
+export const setCustomUserData = () => {};
+export const setCustomVirtualPageName = () => {};
+export const startVirtualPageMonitoringWithAutoEnd = () => {};

package/dist/esm/testing/mocks/retry-axios.cjs

@@ -0,0 +1,3 @@
+export const attach = jest.fn();
+export const detach = jest.fn();
+export const getConfig = jest.fn();

package/dist/esm/testing/mocks/svg.cjs

@@ -0,0 +1,5 @@
+// eslint-disable-next-line no-unused-vars
+import * as React from 'react';
+
+export default 'SvgrURL';
+export const ReactComponent = 'div';

package/dist/esm/testing/mocks/webpack-hmr.cjs

@@ -0,0 +1 @@
+exports.enableHotReloading = () => {};

package/dist/esm/testing/resolver.cjs

@@ -0,0 +1,47 @@
+const resolutions = [
+  {
+    matcher: /\.jsx?$/i,
+    extensions: ['.tsx', '.ts'],
+  },
+  {
+    matcher: /\.mjs$/i,
+    extensions: ['.mts'],
+  },
+  {
+    matcher: /\.cjs$/i,
+    extensions: ['.cts'],
+  },
+];
+
+const resolveConfig = {
+  conditionNames: ['import', 'node', 'default'],
+  extensions: ['.ts', '.tsx', '.js', '.jsx', '.json', '.node'],
+  modules: ['node_modules', 'app', 'lib'],
+};
+
+const importResolver = require('enhanced-resolve').create.sync(resolveConfig);
+const requireResolver = require('enhanced-resolve').create.sync({
+  ...resolveConfig,
+  conditionNames: ['require', 'node', 'default'],
+});
+
+module.exports = (request, options) => {
+  let resolver = requireResolver;
+  if (options.conditions?.includes('import')) {
+    resolver = importResolver;
+  }
+  const resolution = resolutions.find(({ matcher }) => matcher.test(request));
+  if (resolution) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const extension of resolution.extensions) {
+      try {
+        return resolver(
+          options.basedir,
+          request.replace(resolution.matcher, extension),
+        );
+        // eslint-disable-next-line no-empty
+      } catch {}
+    }
+  }
+  return resolver(options.basedir, request);
+};

package/dist/esm/testing/setup-react-env.js

@@ -0,0 +1,3 @@
+import * as React from "react";
+import "jest-styled-components";
+global.React = React;

package/dist/esm/testing/setup-tests.js

@@ -0,0 +1,48 @@
+import "core-js/stable";
+import "regenerator-runtime/runtime";
+import "@testing-library/jest-dom/extend-expect";
+import jestAxe from "jest-axe";
+import ResizeObserver from "resize-observer-polyfill";
+import addMatchMedia from "./mocks/matchMedia.cjs";
+import { logger } from "./mocks/pui-diagnostics.cjs";
+const originalError = console.error;
+console.error = (...args) => {
+  const ignoreList = [
+    `Warning: Can't perform a React state update on an unmounted component`,
+    `Warning: Function components cannot be given refs`,
+    `Warning: Failed %s type:`,
+    `Warning: Invalid DOM property`,
+    `Warning: Each child in a list should have a unique`,
+    "Warning: Received `%s` for a non-boolean attribute",
+    "Warning: <%s /> is using incorrect casing.",
+    "Warning: The tag <%s> is unrecognized in this browser",
+    "Warning: Invalid arguments supplied to oneOf"
+  ];
+  if (ignoreList.find((ignoreMsg) => !!args.find((arg) => arg?.includes?.(ignoreMsg))))
+    return false;
+  return originalError(...args);
+};
+if (expect)
+  expect.extend(jestAxe.toHaveNoViolations);
+jest.setTimeout(6e4);
+const addElementToBody = (element) => {
+  const documentEle = (window || {}).document;
+  if (!documentEle)
+    return null;
+  const bodyEle = documentEle.body;
+  const newEle = documentEle.createElement(...element);
+  if (!newEle)
+    return null;
+  bodyEle.appendChild(newEle);
+  return newEle;
+};
+const addRootElement = (id) => {
+  const rootEle = addElementToBody("div");
+  if (rootEle)
+    rootEle.id = id;
+};
+addRootElement("root");
+addMatchMedia();
+window.ResizeObserver = ResizeObserver;
+window.emui = {};
+window.emui.logger = logger();

package/dist/esm/testing/vitest.config.js

@@ -0,0 +1,17 @@
+import { defineConfig } from "vite";
+import path from "path";
+var vitest_config_default = defineConfig({
+  test: {
+    globals: true,
+    root: process.cwd(),
+    exclude: ["node_modules", "dist", ".idea", ".git", ".cache", "e2e"],
+    setupFiles: [path.resolve(__dirname, "./vitest.setup.ts")],
+    coverage: {
+      reportsDirectory: "./reports/coverage"
+    },
+    environment: "happy-dom"
+  }
+});
+export {
+  vitest_config_default as default
+};

package/dist/esm/transpile/esbuild.js

@@ -0,0 +1,117 @@
+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 { fileURLToPath } from "node:url";
+import fg from "fast-glob";
+import { build } from "esbuild";
+import { writeFile, copyFile, readFile, mkdir } from "node:fs/promises";
+import browserslistToEsbuild from "browserslist-to-esbuild";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TARGETS = {
+  browserslist: browserslistToEsbuild(),
+  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 ? path.resolve(__dirname, "./react-shim.js") : ""
+  ].filter(Boolean)
+});
+const copyFiles = async ({ srcdir, outdir }) => {
+  const files = await fg([
+    `${srcdir}/**/*.*`,
+    `!${srcdir}/**/*.{js,jsx,ts,tsx,mjs}`
+  ]);
+  await Promise.all(files.map(async (srcFilePath) => {
+    const destFilePath = srcFilePath.replace(srcdir, outdir);
+    const fileDir = path.dirname(destFilePath);
+    await mkdir(fileDir, { recursive: true });
+    await copyFile(srcFilePath, destFilePath);
+  }));
+};
+const getSideEffects = async () => {
+  const data = await readFile(path.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 = path.join(process.cwd(), outdir, "package.json");
+  const packageJSON = JSON.stringify({
+    type,
+    sideEffects: await getSideEffects()
+  }, null, 2);
+  await 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 fg(inputFiles);
+    await build(__spreadProps(__spreadValues({
+      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 fg(inputFiles.concat([`!${srcdir}/**/cjs/**/*.{js,jsx,ts,tsx}`]));
+  await build(__spreadProps(__spreadValues({
+    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 });
+};
+export {
+  TARGETS,
+  esBuild
+};

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

@@ -0,0 +1,4 @@
+import * as React from "react";
+export {
+  React
+};

package/dist/esm/transpile/swcrc.config.cjs

@@ -0,0 +1,13 @@
+const fs = require('fs');
+const path = require('path');
+const { merge } = require('lodash');
+
+let projectConfig = {};
+const projectPath = path.join(process.cwd(), '.swcrc');
+if (fs.existsSync(projectPath)) {
+  projectConfig = JSON.parse(fs.readFileSync(projectPath, 'utf-8'));
+}
+const localConfig = JSON.parse(
+  fs.readFileSync(path.join(__dirname, '.swcrc'), 'utf-8'),
+);
+exports.swcrcConfig = merge(localConfig, projectConfig);

package/dist/esm/typescript/app.tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "module": "ES2020",
+    "target": "ES2015",
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "moduleResolution": "node",
+    "noEmit": true,
+    "noFallthroughCasesInSwitch": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "preserveConstEnums": true,
+    "sourceMap": true
+  },
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "pui-cli app"
+}