@pega/dx-component-builder-sdk 0.1.47 → 0.1.49

package/src/tasks/bundle/builderAssociated/paths.js

@@ -0,0 +1,51 @@
+import path from 'path';
+import fs from 'fs';
+
+// Make sure any symlinks in the project folder are resolved:
+// https://github.com/facebook/create-react-app/issues/637
+const appDirectory = fs.realpathSync(process.cwd());
+const resolveApp = relativePath => path.resolve(appDirectory, relativePath);
+
+const buildPath = 'dist/components';
+
+export const moduleFileExtensions = [
+  'web.mjs',
+  'mjs',
+  'web.js',
+  'js',
+  'web.ts',
+  'ts',
+  'web.tsx',
+  'tsx',
+  'json',
+  'web.jsx',
+  'jsx'
+];
+
+// Resolve file paths in the same order as webpack
+const resolveModule = (resolveFn, filePath) => {
+  const extension = moduleFileExtensions.find(ext =>
+    fs.existsSync(resolveFn(`${filePath}.${ext}`))
+  );
+
+  if (extension) {
+    return resolveFn(`${filePath}.${extension}`);
+  }
+
+  return resolveFn(`${filePath}.js`);
+};
+
+// config after eject: we're in ./config/
+// associated (constellation) components get their tsconfig from the constellation-comp-config directory
+export default {
+  dotenv: resolveApp('.env'),
+  appPath: resolveApp('.'),
+  appBuild: resolveApp(buildPath),
+  appPublic: resolveApp('public'),
+  appIndexJs: resolveModule(resolveApp, 'src/index'),
+  appPackageJson: resolveApp('package.json'),
+  appSrc: [resolveApp('src/components'), resolveApp('src/app/_components')],
+  appTsConfig: resolveApp('constellation-comp-config/tsconfig.build.json'),
+  appJsConfig: resolveApp('jsconfig.json'),
+  appNodeModules: resolveApp('node_modules')
+};

package/src/tasks/bundle/{builder → builderAssociated}/webpack.config.js

@@ -125,7 +125,8 @@ export default (
         name: componentKey,
         type: 'umd',
         export: 'default'
-      }
+      },
+      publicPath: ''
     },
     optimization: {
       minimize: isEnvProduction,
@@ -175,7 +176,7 @@ export default (
               include: paths.appSrc,
               loader: 'ts-loader',
               options: {
-                configFile: 'tsconfig.build.json'
+                configFile: paths.appTsConfig
               },
               exclude: /node_modules/
             },
@@ -184,7 +185,7 @@ export default (
               test: /\.(ts|tsx)$/,
               loader: 'ts-loader',
               options: {
-                configFile: 'tsconfig.build.json'
+                configFile: paths.appTsConfig
               },
               exclude: /node_modules/
             },
@@ -318,7 +319,7 @@ export default (
       }),
 
       new webpack.optimize.LimitChunkCountPlugin({
-        maxChunks: 5
+        maxChunks: 1
       }),
       new webpack.optimize.MinChunkSizePlugin({
         minChunkSize: 100000 // Minimum number of characters

package/src/tasks/bundle/builderReact/index.js

@@ -0,0 +1,218 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import webpack from 'webpack';
+import FileSizeReporter from 'react-dev-utils/FileSizeReporter.js';
+import printBuildError from 'react-dev-utils/printBuildError.js';
+
+import configFactory from './webpack.config.js';
+import paths from './paths.js';
+
+// Do this as the first thing so that any code reading it knows the right env.
+let Env = 'production';
+if (process.argv.includes('development')) {
+  Env = 'development';
+}
+
+if (process.argv.includes('source-map')) {
+  process.env.SOURCE_MAP = true;
+}
+
+// Do this as the first thing so that any code reading it knows the right env.
+process.env.BABEL_ENV = Env;
+process.env.NODE_ENV = Env;
+
+// Makes the script crash on unhandled rejections instead of silently
+// ignoring them. In the future, promise rejections that are not handled will
+// terminate the Node.js process with a non-zero exit code.
+process.on('unhandledRejection', err => {
+  console.log(err);
+  process.exit(1);
+});
+
+const measureFileSizesBeforeBuild = FileSizeReporter.measureFileSizesBeforeBuild;
+const printFileSizesAfterBuild = FileSizeReporter.printFileSizesAfterBuild;
+
+// These sizes are pretty large. We'll warn for bundles exceeding them.
+const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
+const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
+
+let compilationErrors = null;
+
+// Create the build and print the deployment instructions.
+function build(config, previousFileSizes) {
+  console.log(`Creating a ${Env} build...`);
+
+
+
+  const compiler = webpack(config);
+  return new Promise((resolve, reject) => {
+    compiler.run((err, stats) => {
+
+       if (err != null && typeof (err) == "object") {
+          if (err.error != undefined) {
+            //store and print elsewhere
+            compilationErrors = err.error;
+            //console.log("err:" + err);
+          }
+       }
+       if (stats != null & typeof(stats) == "object") {
+        if (stats.errors != undefined) {
+          console.log("stats:" + stats);
+        }
+        else if (stats.compilation != undefined && stats.compilation.errors != undefined) {
+
+          //store and print elsewhere
+          compilationErrors = stats.compilation.errors;
+
+          console.log("stats:" + stats);
+        }
+
+       }
+
+
+      let messages;
+      if (err) {
+        if (!err.message) {
+          return reject(err);
+        }
+
+        let errMessage = err.message;
+
+        // Add additional information for postcss errors
+        if (Object.prototype.hasOwnProperty.call(err, 'postcssNode')) {
+          errMessage += `\nCompileError: Begins at CSS selector ${err.postcssNode.selector}`;
+        }
+
+        messages = {
+          errors: [errMessage],
+          warnings: []
+        };
+      } else {
+        messages = stats.toJson({ all: false, warnings: true, errors: true });
+      }
+      if (messages.errors.length) {
+        // Only keep the first error. Others are often indicative
+        // of the same problem, but confuse the reader with noise.
+        if (messages.errors.length > 1) {
+          messages.errors.length = 1;
+        }
+        return reject(new Error(messages.errors));
+      }
+      if (
+        process.env.CI &&
+        (typeof process.env.CI !== 'string' || process.env.CI.toLowerCase() !== 'false') &&
+        messages.warnings.length
+      ) {
+        console.log(
+          chalk.yellow(
+            '\nTreating warnings as errors because process.env.CI = true.\n' +
+              'Most CI servers set it automatically.\n'
+          )
+        );
+        return reject(new Error(messages.warnings.join('\n\n')));
+      }
+
+      const resolveArgs = {
+        stats,
+        previousFileSizes,
+        warnings: messages.warnings
+      };
+      return resolve(resolveArgs);
+    });
+  });
+}
+
+export default ({
+  inputFile,
+  outputFile,
+  componentKey,
+  externals,
+  globals,
+  sourceMap,
+  devBuild
+}) => {
+  // Generate configuration
+  const config = configFactory(Env, {
+    inputFile,
+    outputFile,
+    componentKey,
+    externals,
+    globals,
+    sourceMap,
+    devBuild
+  });
+
+  if (devBuild) {
+    Env = 'development';
+  }
+
+  return new Promise((resolve, reject) => {
+    measureFileSizesBeforeBuild(paths.appBuild)
+      .then(previousFileSizes => {
+        // Remove all content but keep the directory so that
+        // if you're in it, you don't end up in Trash
+        fs.emptyDirSync(paths.appBuild);
+        // Start the webpack build
+        return build(config, previousFileSizes);
+      })
+      .then(
+        ({ stats, previousFileSizes, warnings }) => {
+          if (warnings.length) {
+            //console.log(chalk.yellow('Compiled with warnings.\n'), warnings[0].message);
+            console.log(chalk.yellow('Compiled with warnings.\n'));
+            for (let warning in warnings) {
+              console.log(chalk.yellow("Warning.."), warnings[warning].message);
+            }
+          } else {
+            console.log(chalk.green('Compiled successfully.\n'));
+          }
+
+          console.log('File sizes after gzip:\n');
+          printFileSizesAfterBuild(
+            stats,
+            previousFileSizes,
+            paths.appBuild,
+            WARN_AFTER_BUNDLE_GZIP_SIZE,
+            WARN_AFTER_CHUNK_GZIP_SIZE
+          );
+          resolve('done emitting');
+        },
+        err  => {
+          reject();
+          const tscCompileOnError = process.env.TSC_COMPILE_ON_ERROR === 'true';
+          if (tscCompileOnError) {
+            console.log(
+              chalk.yellow(
+                'Compiled with the following type errors (you may want to check these before deploying your app):\n'
+              )
+            );
+            printBuildError(err);
+          }
+          else if (compilationErrors != null) {
+            if (compilationErrors.length == undefined) {
+              console.log(chalk.red("Error..."), compilationErrors.message);
+            }
+            else {
+              for (let error in compilationErrors) {
+                console.log(chalk.red("Error..."), compilationErrors[error].message);
+              }
+            }
+
+            process.exit(1);
+          }
+          else {
+            console.log(chalk.red('Failed to compile.\n'));
+            printBuildError(JSON.stringify(err));
+
+          }
+        }
+      )
+      .catch(err => {
+        reject();
+        if (err && err.message) {
+          console.log(err.message);
+        }
+        process.exit(1);
+      });
+  });
+};

package/src/tasks/bundle/builderReact/modules.js

@@ -0,0 +1,139 @@
+/* eslint-disable import/no-dynamic-require */
+
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+
+import chalk from 'chalk';
+import resolve from 'resolve';
+
+import paths from './paths.js';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Get additional module paths based on the baseUrl of a compilerOptions object.
+ *
+ * @param {Object} options
+ */
+function getAdditionalModulePaths(options = {}) {
+  const baseUrl = options.baseUrl;
+
+  if (!baseUrl) {
+    return '';
+  }
+
+  const baseUrlResolved = path.resolve(paths.appPath, baseUrl);
+
+  // We don't need to do anything if `baseUrl` is set to `node_modules`. This is
+  // the default behavior.
+  if (path.relative(paths.appNodeModules, baseUrlResolved) === '') {
+    return null;
+  }
+
+  // Allow the user set the `baseUrl` to `appSrc`.
+  if (path.relative(paths.appSrc, baseUrlResolved) === '') {
+    return [paths.appSrc];
+  }
+
+  // If the path is equal to the root directory we ignore it here.
+  // We don't want to allow importing from the root directly as source files are
+  // not transpiled outside of `src`. We do allow importing them with the
+  // absolute path (e.g. `src/Components/Button.js`) but we set that up with
+  // an alias.
+  if (path.relative(paths.appPath, baseUrlResolved) === '') {
+    return null;
+  }
+
+  // Otherwise, throw an error.
+  throw new Error(
+    chalk.red.bold(
+      "Your project's `baseUrl` can only be set to `src` or `node_modules`." +
+        ' Create React App does not support other values at this time.'
+    )
+  );
+}
+
+/**
+ * Get webpack aliases based on the baseUrl of a compilerOptions object.
+ *
+ * @param {*} options
+ */
+function getWebpackAliases(options = {}) {
+  const baseUrl = options.baseUrl;
+
+  if (!baseUrl) {
+    return {};
+  }
+
+  const baseUrlResolved = path.resolve(paths.appPath, baseUrl);
+
+  if (path.relative(paths.appPath, baseUrlResolved) === '') {
+    return {
+      src: paths.appSrc
+    };
+  }
+}
+
+/**
+ * Get jest aliases based on the baseUrl of a compilerOptions object.
+ *
+ * @param {*} options
+ */
+function getJestAliases(options = {}) {
+  const baseUrl = options.baseUrl;
+
+  if (!baseUrl) {
+    return {};
+  }
+
+  const baseUrlResolved = path.resolve(paths.appPath, baseUrl);
+
+  if (path.relative(paths.appPath, baseUrlResolved) === '') {
+    return {
+      '^src/(.*)$': '<rootDir>/src/$1'
+    };
+  }
+}
+
+function getModules() {
+  // Check if TypeScript is setup
+  const hasTsConfig = fs.existsSync(paths.appTsConfig);
+  const hasJsConfig = fs.existsSync(paths.appJsConfig);
+
+  if (hasTsConfig && hasJsConfig) {
+    throw new Error(
+      'You have both a tsconfig.json and a jsconfig.json. If you are using TypeScript please remove your jsconfig.json file.'
+    );
+  }
+
+  let config;
+
+  // If there's a tsconfig.json we assume it's a
+  // TypeScript project and set up the config
+  // based on tsconfig.json
+  if (hasTsConfig) {
+    const ts = require(resolve.sync('typescript', {
+      basedir: paths.appNodeModules
+    }));
+    config = ts.readConfigFile(paths.appTsConfig, ts.sys.readFile).config;
+    // Otherwise we'll check if there is jsconfig.json
+    // for non TS projects.
+  } else if (hasJsConfig) {
+    config = require(paths.appJsConfig);
+  }
+
+  config = config || {};
+  const options = config.compilerOptions || {};
+
+  const additionalModulePaths = getAdditionalModulePaths(options);
+
+  return {
+    additionalModulePaths,
+    webpackAliases: getWebpackAliases(options),
+    jestAliases: getJestAliases(options),
+    hasTsConfig
+  };
+}
+
+module.exports = getModules();

package/src/tasks/bundle/builderReact/paths.js

@@ -0,0 +1,51 @@
+import path from 'path';
+import fs from 'fs';
+
+// Make sure any symlinks in the project folder are resolved:
+// https://github.com/facebook/create-react-app/issues/637
+const appDirectory = fs.realpathSync(process.cwd());
+const resolveApp = relativePath => path.resolve(appDirectory, relativePath);
+
+const buildPath = 'dist/components';
+
+export const moduleFileExtensions = [
+  'web.mjs',
+  'mjs',
+  'web.js',
+  'js',
+  'web.ts',
+  'ts',
+  'web.tsx',
+  'tsx',
+  'json',
+  'web.jsx',
+  'jsx'
+];
+
+// Resolve file paths in the same order as webpack
+const resolveModule = (resolveFn, filePath) => {
+  const extension = moduleFileExtensions.find(ext =>
+    fs.existsSync(resolveFn(`${filePath}.${ext}`))
+  );
+
+  if (extension) {
+    return resolveFn(`${filePath}.${extension}`);
+  }
+
+  return resolveFn(`${filePath}.js`);
+};
+
+// config after eject: we're in ./config/
+// building a standard React component for react SDK, use same ts config as buid:dev
+export default {
+  dotenv: resolveApp('.env'),
+  appPath: resolveApp('.'),
+  appBuild: resolveApp(buildPath),
+  appPublic: resolveApp('public'),
+  appIndexJs: resolveModule(resolveApp, 'src/index'),
+  appPackageJson: resolveApp('package.json'),
+  appSrc: [resolveApp('src/components'), resolveApp('src/app/_components')],
+  appTsConfig: resolveApp('./tsconfig.build.json'),
+  appJsConfig: resolveApp('jsconfig.json'),
+  appNodeModules: resolveApp('node_modules')
+};