@pega/custom-dx-components 0.0.1

package/src/tasks/init/template/src/components/Organization_Library_VideoPlayer/demo.stories.jsx

@@ -0,0 +1,40 @@
+import React, { useState } from 'react';
+import { withKnobs, text, boolean } from '@storybook/addon-knobs';
+
+import VideoPlayer from './index';
+
+export default {
+  title: 'VideoPlayer',
+  decorators: [withKnobs],
+  component: VideoPlayer
+};
+
+export const baseVideoPlayer = () => {
+  const [value, setValue] = useState('test value');
+
+  const props = {
+    getPConnect: () => {
+      return {
+        getActionsApi: () => {
+          return {
+            updateFieldValue: (propName, value) => {
+              setValue(value);
+            }
+          };
+        },
+        getStateProps: () => {
+          return { value: '.name' };
+        }
+      };
+    },
+    value: text('src', 'https://www.youtube.com/watch?v=EtG5IuNGYSk'),
+    placeholder: text('Placeholder', 'Test placeholder'),
+    disabled: boolean('Disabled', false),
+    readOnly: boolean('Disabled', false),
+    required: boolean('Disabled', false),
+    label: text('Label', 'Video player label'),
+    testId: text('Test id', 'video-12344566')
+  };
+
+  return <VideoPlayer {...props} />;
+};

package/src/tasks/init/template/src/components/Organization_Library_VideoPlayer/index.jsx

@@ -0,0 +1,42 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { Label } from '@pega/cosmos-react-core';
+import ReactPlayer from 'react-player';
+
+import StyledVideoPlayerWrapper from './styles';
+
+const VideoPlayer = props => {
+  const { getPConnect, value, placeholder, disabled, readOnly, required, label } = props;
+
+  const pConn = getPConnect();
+  const actions = pConn.getActionsApi();
+  const propName = pConn?.getStateProps()?.value;
+
+  return (
+    <StyledVideoPlayerWrapper>
+      <Label>{label}</Label>
+      <ReactPlayer url={value} />
+    </StyledVideoPlayerWrapper>
+  );
+};
+
+VideoPlayer.defaultProps = {
+  value: '',
+  placeholder: '',
+  disabled: false,
+  readOnly: false,
+  required: false,
+  testId: null
+};
+VideoPlayer.propTypes = {
+  label: PropTypes.string,
+  value: PropTypes.string.isRequired,
+  placeholder: PropTypes.string,
+  getPConnect: PropTypes.func.isRequired,
+  disabled: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  readOnly: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  required: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  testId: PropTypes.string
+};
+
+export default VideoPlayer;

package/src/tasks/init/template/src/components/Organization_Library_VideoPlayer/styles.js

@@ -0,0 +1,5 @@
+import styled, { css } from 'styled-components';
+
+export default styled.div(() => {
+  return css``;
+});

package/src/tasks/init/template/tasks.config.json

@@ -0,0 +1,21 @@
+{
+  "components-directory-path": "src/components",
+  "server-config": {
+    "server": "https://localhost:38764/prweb",
+    "user": "user",
+    "password": "password",
+    "rulesetName": "rulesetName",
+    "rulesetVersion": "rulesetVersion",
+    "sourceOfComponents": "Server",
+    "devBuild": false,
+    "clientId": "",
+    "clientSecret": ""
+  },
+  "component": {
+    "library": "",
+    "type": "",
+    "subtype": "",
+    "description": "",
+    "icon": ""
+  }
+}

package/src/tasks/init/template/tsconfig.build.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["./src/**/*.ts", "./src/**/*.tsx", "./src/**/*.js", "./src/**/*.jsx"],
+  "exclude": [
+    "./src/**/*.stories.ts",
+    "./src/**/*.stories.tsx",
+    "./src/**/*.stories.js",
+    "./src/**/*.stories.jsx"
+  ],
+  "compilerOptions": {
+    "noEmit": false,
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./lib"
+  }
+}

package/src/tasks/init/template/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@pega/tsconfig/index.json",
+  "include": ["./**/*", ".storybook/**/*"],
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true
+  }
+}

package/src/tasks/list/helper.js

@@ -0,0 +1,118 @@
+import fs from 'fs';
+import https from 'https';
+
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+
+import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
+import { constructCompleteUrl, getComponents, getPegaServerConfig } from '../../util.js';
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+export const getListComponentsQuestions = async (options, sourceOfComponentsOption) => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+
+  return [
+    {
+      name: 'sourceOfComponents',
+      type: 'rawlist',
+      message: 'List components from Server or Local ?',
+      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
+      default: defaultPegaServerConfig.sourceOfComponents,
+      when() {
+        return !options.params[3];
+      }
+    }
+  ];
+};
+
+export const listLocalComponents = async sourceOfComponents => {
+  let localComponents = await getComponents();
+  localComponents = localComponents.map(name => ({ 'Rule name': name }));
+  if (localComponents.length > 0) {
+    console.log(chalk.bold.blueBright(`List of custom components in ${sourceOfComponents}`));
+    console.table(localComponents, ['Rule name']);
+  } else {
+    console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
+  }
+};
+
+export const getComponentsFromServer = async data => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const url = constructCompleteUrl(
+    defaultPegaServerConfig.server,
+    LIST_COMPONENT_SERVICE_REST_ENDPOINT
+  );
+  return new Promise((resolve, reject) => {
+    try {
+      fs.readFile(TOKEN_PATH, 'utf8', (err, data) => {
+        if (err) {
+          reject(
+            `\n${chalk.bold.red(
+              'Error occured in authentication. Please regenerate using authenticate'
+            )}`
+          );
+        }
+        if (data) {
+          const {
+            access_token: accessToken,
+            token_type: tokenType,
+            refresh_token: refreshToken
+          } = JSON.parse(data);
+          let status = 500;
+          fetch(url, {
+            method: 'GET',
+            agent: new https.Agent({ rejectUnauthorized: false }),
+            headers: {
+              Authorization: `${tokenType} ${accessToken}`
+            }
+          })
+            .then(response => {
+              status = response.status;
+              return response.text();
+            })
+            .then(resp => {
+              const respData = JSON.parse(resp);
+              if (status === 401) {
+                throw new Error(
+                  'Error occured in authentication. Please regenerate using authenticate'
+                );
+                // console.log(accessTokenUri, refreshToken);
+                /* TODO - Handle refresh_token */
+              } else if (status == 200) {
+                resolve(resp);
+              } else {
+                throw new Error(`${respData.message}`);
+              }
+            })
+            .catch(e => reject(`${chalk.bold.red(e)}`));
+        }
+      });
+    } catch (error) {
+      console.log(`\n${chalk.bold.red(error)}`);
+      reject(`${chalk.bold.red(error)}`);
+    }
+  });
+};
+
+export const displayServerComponents = async data => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const parsedData = JSON.parse(data);
+  const componentList = parsedData.pxResults?.map(({ label, pyRuleSet, pyRuleSetVersion }) => ({
+    'Rule name': label,
+    'Ruleset name': pyRuleSet,
+    'Ruleset version': pyRuleSetVersion
+  }));
+
+  if (componentList && componentList.length > 0) {
+    console.log(
+      chalk.bold.blueBright(`List of custom components in ${defaultPegaServerConfig.server}`)
+    );
+    console.table(componentList, ['Rule name', 'Ruleset name', 'Ruleset version']);
+  } else {
+    console.log(chalk.bold.redBright(`No custom components in ${defaultPegaServerConfig.server}`));
+  }
+};

package/src/tasks/list/index.js

@@ -0,0 +1,51 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+
+import {
+  listLocalComponents,
+  SOURCE_OF_COMPONENT_TYPES,
+  getComponentsFromServer,
+  displayServerComponents,
+  getListComponentsQuestions
+} from './helper.js';
+
+const getList = async (sourceOfComponents, answers) => {
+  switch (sourceOfComponents) {
+    case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
+      await listLocalComponents(sourceOfComponents);
+      break;
+    }
+    case SOURCE_OF_COMPONENT_TYPES.SERVER: {
+      const spinner = ora('Fetching components from server\n').start();
+      const data = await getComponentsFromServer(answers);
+      spinner.stop();
+      await displayServerComponents(data, answers);
+
+      break;
+    }
+    default: {
+      console.log('Source of components needs to be either Local or Server');
+      break;
+    }
+  }
+};
+
+export default async options => {
+  let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
+
+  if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
+    sourceOfComponentsOption = options.params[3];
+    await getList(sourceOfComponentsOption);
+  } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
+    sourceOfComponentsOption = options.params[3];
+    const questions = await getListComponentsQuestions(options, sourceOfComponentsOption);
+    const answers = await inquirer.prompt(questions);
+    await getList(sourceOfComponentsOption, answers);
+  } else {
+    const questions = await getListComponentsQuestions(options);
+    const answers = await inquirer.prompt(questions);
+    const { sourceOfComponents } = answers;
+    await getList(sourceOfComponents, answers);
+  }
+};

package/src/tasks/publish/bundle/builder/index.js

@@ -0,0 +1,174 @@
+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;
+
+// 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) => {
+      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);
+          } 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 {
+            console.log(chalk.red('Failed to compile.\n'));
+            printBuildError(err);
+            process.exit(1);
+          }
+        }
+      )
+      .catch(err => {
+        reject();
+        if (err && err.message) {
+          console.log(err.message);
+        }
+        process.exit(1);
+      });
+  });
+};

package/src/tasks/publish/bundle/builder/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/publish/bundle/builder/paths.js

@@ -0,0 +1,50 @@
+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/
+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'),
+  appTsConfig: resolveApp('tsconfig.json'),
+  appJsConfig: resolveApp('jsconfig.json'),
+  appNodeModules: resolveApp('node_modules')
+};