@zohodesk/client_build_tool 0.0.1

package/lib/schemas/defaultConfigValuesOnly.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _os = require("os");
+
+// NOTE: Don't use 'config_file' as cli option it was reserved
+var _default = {
+  context: 'app',
+  devtool: 'hidden-cheap-source-map',
+  enableChunkHash: false,
+  bundleAnalyze: false,
+  enableMockReplace: false,
+  noPublicPath: false,
+  output: 'build',
+  mode: null,
+  printProgress: false,
+  server: {
+    httpsCerts: '@zohodesk-private/client_dev_cert',
+    host: (0, _os.hostname)(),
+    port: 9090,
+    domain: 'tsi',
+    disableContextURL: false
+  },
+  mockServer: {
+    enable: false,
+    separateSeverPort: 5000,
+    disableNodemon: false,
+    mockEntryFile: 'mockapi/index.js',
+    mockPrefix: '/api/'
+  },
+  css: {
+    classNameOptions: {
+      customizations: [{
+        enable: true,
+        blob: '[local]',
+        patterns: ['*.plain.css']
+      }, {
+        enable: true,
+        blob: '[prefix]-[filename]-[local]',
+        patterns: []
+      }],
+      classNamePrefix: 'zd'
+    },
+    // NOTE: Suggestions
+    // Name Suggestions  `customizations` this will be easier then `plugin` to understand for developers
+    plugins: {
+      rtlSplit: {
+        enableRTLSplit: false,
+        templateLabel: '{{--dir}}',
+        disableMinifySelector: false,
+        dirVarName: 'document.dir'
+      },
+      selectorWeight: {
+        enable: false,
+        patterns: [],
+        configFile: null,
+        defaultSelector: '',
+        customFileDetails: '',
+        excludeStrings: []
+      },
+      selectorReplace: {
+        enable: false,
+        patterns: [],
+        before: [],
+        after: []
+      },
+      hoverActive: {
+        enable: false,
+        patterns: [],
+        hover: '(hover: hover)',
+        active: '(hover: none)'
+      },
+      cssVariableReplacement: {
+        enable: false,
+        patterns: [],
+        configFile: null
+      },
+      rtl: {
+        enable: false,
+        patterns: []
+      } // postcss - plugins end
+
+    },
+    customPlugins: []
+  },
+  i18nChunkSplit: {
+    chunkSplitEnable: false,
+    disableDefault: false,
+    templateLabel: '{{--user-locale}}',
+    localeVarName: 'document.documentElement.lang',
+    jsonpFunc: 'console.log',
+    jsResource: null,
+    propertiesFolder: null
+  },
+  publicFolders: ['...', {
+    source: './deskapp/tp/',
+    target: './tp/'
+  }],
+  app: {
+    entryFile: 'src/index.js',
+    tpFolder: null,
+    moduleResolvePath: 'node_modules'
+  },
+  resolve: {
+    preferLocalFirst: false,
+    defaultAlias: true,
+    moduleResolvePath: 'node_modules',
+    alias: null
+  },
+  // EFC means Embedded Functional Components
+  efc: {
+    hasEFC: false,
+    entryPointName: 'efc',
+    entryFile: 'src/efc.js',
+    version: 'v1',
+    createSDkFile: false,
+    templateFilePath: 'efcTemplate.js',
+    outputFile: 'efc-sdk-[version].js'
+  },
+  createSeparateSMap: false,
+  babelCustomizations: {
+    browserList: null,
+    // NOTE: need to consider
+    // presets: [],
+    plugins: []
+  },
+  webpackPlugins: [],
+  vendorPatterns: [],
+  customChunks: [{
+    name: 'styles',
+    patterns: ['*.css']
+  }],
+  htmlTemplate: {
+    templateFile: 'src/index.html',
+    minify: null,
+    inject: true
+  },
+  // CDN means Content Delivery Network
+  cdnMapping: {
+    isCdnEnabled: false,
+    variableName: '',
+    cssTemplate: '',
+    jsTemplate: '',
+    i18nTemplate: ''
+  },
+  manifestJson: {
+    enable: true
+  },
+  changeRuntimeChunkChar: '~',
+  serviceWorker: {
+    enable: false,
+    templateFilePath: 'sw.js',
+    outputFilePath: '/v1.js',
+    replaceText: '//<!--AssetsFromBuild -->'
+  }
+};
+exports.default = _default;

package/lib/schemas/deprecatedOptionsHandler.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deprecatedOptionsHandler = deprecatedOptionsHandler;
+
+var _logger = require("../logger");
+
+function nestedSelect(obj, key) {
+  let temp = obj;
+  const keys = key.split('.');
+
+  for (let i = 0; i < keys.length && temp; i++) {
+    const element = keys[i];
+    temp = temp[element];
+  }
+
+  return temp;
+}
+
+function nestedUpdate(obj, key, value) {
+  let temp = obj;
+  const keys = key.split('.');
+  let i = 0;
+
+  for (; i < keys.length - 1 && temp; i++) {
+    const element = keys[i];
+    temp = temp[element];
+  }
+
+  if (temp) {
+    temp[keys[i]] = value;
+  }
+}
+
+function deprecatedOptionsHandler(options) {
+  function checkAndUpdateAndPrintWaring(oldKey, newkey) {
+    const oldVal = nestedSelect(options, oldKey);
+    const newVal = nestedSelect(options, newkey); // console.log({ oldVal, newVal });
+
+    if (oldVal !== undefined && newVal === undefined) {
+      nestedUpdate(options, newkey, newVal);
+      (0, _logger.warnLogger)(`"${oldKey}" deprecated use "${newkey}" instead`);
+    }
+  } // return;
+
+
+  checkAndUpdateAndPrintWaring('app.context', 'context'); // TODO handle deprecations  here
+  // we will finish this logic later when options are confirmed
+
+  if (nestedSelect(options, 'app.hasRTL') === true) {
+    nestedUpdate(options, 'app.plugins.hasRTL', true);
+  }
+
+  if (nestedSelect(options, 'docs.hasRTL') === true) {
+    nestedUpdate(options, 'docs.plugins.hasRTL', true);
+  }
+
+  if (nestedSelect(options, 'app.rtlExclude.length') > 0) {
+    nestedUpdate(options, 'app.exclude.rtl', nestedSelect(options, 'app.rtlExclude'));
+  }
+
+  if (nestedSelect(options, 'docs.rtlExclude.length') > 0) {
+    nestedUpdate(options, 'docs.exclude.rtl', nestedSelect(options, 'docs.rtlExclude'));
+  }
+}

package/lib/schemas/getNpmVersion.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNpmVersion = getNpmVersion;
+
+var _child_process = require("child_process");
+
+var _logger = require("../logger");
+
+function getNpmVersion() {
+  let vers = '6';
+
+  try {
+    [vers] = (0, _child_process.execSync)('npm -v').toString().trim().split('.');
+  } catch (error) {
+    (0, _logger.messageLogger)(error);
+  }
+
+  return vers;
+}

package/lib/schemas/giveDefaultValue.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.giveDefaultValue = giveDefaultValue;
+
+function giveDefaultValue(value) {
+  if (value === true || value === 'true') {
+    return true;
+  }
+
+  if (value === false || value === 'false' || value === '') {
+    return false;
+  }
+
+  return value;
+}

package/lib/schemas/npmConfigToObject.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.npmConfigToObject = npmConfigToObject;
+
+var _logger = require("../logger");
+
+const NPM_CONFIG_PREFIX = 'npm_config_'; // TODO: we have to do option parse logic little better
+// if user use react-cli strictly without using npm scripts options won't work,
+//  So  we have to write our own option parse logic or some other library
+// console.log('type', process.argv,  process.env.npm_config_check,  process.env.npm_config_clone_type, process.env.npm_config_clone_url);
+// console.log('Object.keys(process.env).filter(s => s.startsWith(\'npm_config_\') && s.includes(\'clone\')', Object.keys(process.env).filter(s => s.startsWith('npm_config_') && s.includes('clone')));
+
+function npmConfigToObject() {
+  // // clone:type
+  const processEnv = {};
+  const keysWithColon = [];
+  Object.keys(process.env).filter(key => key.startsWith(NPM_CONFIG_PREFIX)).forEach(key => {
+    const nKey = key.slice(NPM_CONFIG_PREFIX.length);
+    processEnv[nKey] = process.env[key];
+    nKey.includes(':') && keysWithColon.push(nKey);
+  });
+  keysWithColon.forEach(key => {
+    const nKey = key.replace(/:/g, '_');
+
+    if (processEnv[nKey]) {
+      (0, _logger.warnLogger)('there is some options conflict', key, nKey);
+    }
+
+    processEnv[nKey] = processEnv[key];
+  });
+  return processEnv;
+}

package/lib/schemas/readOptions.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOptions = exports.args = void 0;
+
+var _applyValuesToSchema = require("./applyValuesToSchema");
+
+var _cliArgsToObject = require("./cliArgsToObject");
+
+var _defaultConfigValues = _interopRequireDefault(require("./defaultConfigValues"));
+
+var _deprecatedOptionsHandler = require("./deprecatedOptionsHandler");
+
+var _getNpmVersion = require("./getNpmVersion");
+
+var _npmConfigToObject = require("./npmConfigToObject");
+
+var _readOptionsForConfigFile = require("./readOptionsForConfigFile");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const args = process.argv.slice(2);
+exports.args = args;
+const processEnv = (0, _npmConfigToObject.npmConfigToObject)();
+const cliArgsObject = (0, _cliArgsToObject.cliArgsToObject)(args);
+Object.assign(processEnv, cliArgsObject);
+let reactCLIOptions = null;
+
+const getOptions = () => {
+  if (reactCLIOptions) {
+    return reactCLIOptions;
+  }
+
+  const appPath = process.cwd();
+  const userSchemas = (0, _readOptionsForConfigFile.readOptionsForPackageJson)(appPath); // NOTE: Only config File option will with cli option  config_file
+
+  const configFileSchemas = (0, _readOptionsForConfigFile.readOptionsForConfigFile)(appPath, cliArgsObject.config_file || 'cbt.config.js');
+  const options = (0, _applyValuesToSchema.applyValuesToSchema)(_defaultConfigValues.default, configFileSchemas || userSchemas || {}, processEnv);
+  (0, _deprecatedOptionsHandler.deprecatedOptionsHandler)(options); // for future may be for npm 8 edge cases
+
+  options.npmVersion = (0, _getNpmVersion.getNpmVersion)();
+  options.cwd = appPath;
+  options.packageVersion = process.env.npm_package_version;
+  options.extraArgs = process.argv.slice(3); // eslint-disable-next-line prefer-destructuring
+
+  options.commandOption = process.argv[2];
+  reactCLIOptions = options; // console.log({ options });
+
+  return options;
+};
+
+exports.getOptions = getOptions;

package/lib/schemas/readOptionsForConfigFile.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readOptionsForConfigFile = readOptionsForConfigFile;
+exports.readOptionsForPackageJson = readOptionsForPackageJson;
+
+var _fs = require("fs");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _constants = require("../shared/constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import { CONFIG_ROOT } from "../constants";
+function readOptionsForPackageJson(appPath) {
+  const packagePath = _path.default.join(appPath, 'package.json');
+
+  if ((0, _fs.existsSync)(packagePath)) {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(packagePath)[_constants.BASE_CONFIG_KEY] || {};
+  }
+
+  return {};
+}
+
+function readOptionsForConfigFile(appPath, configFile) {
+  if (!configFile) {
+    return null;
+  }
+
+  const packagePath = _path.default.join(appPath, configFile);
+
+  if ((0, _fs.existsSync)(packagePath)) {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(packagePath).config;
+  }
+
+  return null;
+}

package/lib/shared/babel/babelWebConfig.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.babelWebConfig = babelWebConfig;
+
+var _helperCompilationTargets = _interopRequireDefault(require("@babel/helper-compilation-targets"));
+
+var _logger = require("../../logger");
+
+var _defaultBabelPlugins = require("./defaultBabelPlugins");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-use-before-define */
+const supportedBrowserVersions = ['last 3 Chrome versions', 'last 3 Firefox versions', 'last 3 Edge versions', 'last 3 Safari versions'];
+
+function customBabelPlugins(babelPlugins) {
+  return babelPlugins.map(p => p).filter(Boolean);
+}
+
+function babelWebConfig(options, mode) {
+  const {
+    plugins: babelPlugins,
+    browserList
+  } = options.babelCustomizations;
+  return {
+    presets: [getBabelPresetEnvConfig(browserList, mode), require.resolve('@babel/preset-react')],
+    plugins: customBabelPlugins(babelPlugins).concat((0, _defaultBabelPlugins.defaultBabelPlugins)(options)).filter(Boolean)
+  };
+}
+
+function getBabelPresetEnvConfig(browserList, mode) {
+  if (mode === 'lib') {
+    return require.resolve('@babel/preset-env');
+  }
+
+  const browsers = browserList || supportedBrowserVersions;
+  (0, _logger.verboseLogger)('getTargets', (0, _helperCompilationTargets.default)({
+    browsers
+  }));
+  return [require.resolve('@babel/preset-env'), {
+    modules: false,
+    useBuiltIns: 'usage',
+    corejs: 3,
+    targets: {
+      browsers
+    }
+  }];
+}

package/lib/shared/babel/babel_plugins/removeAttributesPlugin.js

@@ -0,0 +1,23 @@
+"use strict";
+
+module.exports = () => ({
+  visitor: {
+    Program(path, state) {
+      let properties = state.opts.properties || [];
+
+      if (properties.length === 0) {
+        properties = properties.concat(state.opts.attributeNames);
+      }
+
+      path.traverse({
+        JSXIdentifier(path2) {
+          if (properties.indexOf(path2.node.name.toLowerCase()) > -1) {
+            path2.parentPath.remove();
+          }
+        }
+
+      });
+    }
+
+  }
+});

package/lib/shared/babel/defaultBabelPlugins.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultBabelPlugins = defaultBabelPlugins;
+
+var _modeUtils = require("../bundler/webpack/common/modeUtils");
+
+function defaultBabelPlugins(options) {
+  const {
+    mode
+  } = options;
+  const customPlugins = [];
+  const {
+    enable
+  } = options.removeAttribute;
+
+  if (enable && (0, _modeUtils.isProductionMode)(mode)) {
+    customPlugins.push([require.resolve('./babel_plugins/removeAttributesPlugin'), {
+      attributeNames: options.removeAttribute.attributeNames
+    }]);
+  }
+
+  return customPlugins;
+}

package/lib/shared/babel/runBabelForJSFile.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runBabelForJSFile = runBabelForJSFile;
+
+var _core = require("@babel/core");
+
+var _babelWebConfig = require("./babelWebConfig");
+
+var _copyFile = require("../fileUtils/copyFile");
+
+function runBabelForJSFile({
+  filename,
+  outputFile,
+  options,
+  mode = 'es'
+}) {
+  // const jsSourceCode = readFileSync(filename).toString();
+  const babelConfig = (0, _babelWebConfig.babelWebConfig)(options, mode);
+  const result = (0, _core.transformFileSync)(filename, babelConfig);
+  (0, _copyFile.writeFile)(outputFile, result.code);
+}

package/lib/shared/bundler/webpack/common/decidePublicPath.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decidePublicPath = decidePublicPath;
+exports.modifiedServerOptions = modifiedServerOptions;
+
+var _getServerURL = require("../../../server/getServerURL");
+
+var _httpsOptions = require("../../../server/httpsOptions");
+
+var _urlConcat = require("../../../server/urlConcat");
+
+function decidePublicPath(serverExtras) {
+  return serverExtras.isHttps ? serverExtras.httpsUrl : serverExtras.httpUrl;
+}
+
+function modifiedServerOptions(options) {
+  const {
+    server,
+    context
+  } = options;
+  const {
+    disableContextURL
+  } = server;
+  const port = Number(server.port);
+  const httpsOptions = (0, _httpsOptions.httpsOptionsWithUserFriendlyError)(options);
+  const machineDomain = (0, _getServerURL.getServerDomain)(server);
+  const httpPort = port + 1;
+  const httpsUrl = (0, _getServerURL.getServerUrl)({
+    domain: machineDomain,
+    port,
+    protocol: 'https'
+  });
+  const httpUrl = (0, _getServerURL.getServerUrl)({
+    domain: machineDomain,
+    port: httpPort,
+    protocol: 'http'
+  });
+  const contextURL = disableContextURL ? '' : `/${context}`;
+  return {
+    httpsOptions,
+    machineDomain,
+    contextURL,
+    httpsPort: port,
+    httpPort,
+    httpsUrl: (0, _urlConcat.urlConcat)(httpsUrl, contextURL),
+    httpUrl: (0, _urlConcat.urlConcat)(httpUrl, contextURL),
+    isHttps: !!httpsOptions
+  };
+}

package/lib/shared/bundler/webpack/common/libAlias.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.libAlias = void 0;
+// the reason for alias at the time was code tree shaking
+// tree shaking was most compactable with ES module system
+// FIXME: But there is a posiblity when these  package  does not have lib,
+//  app will work because of alias, But may be jest won't work because of not alais
+//  So need to think about use alais in jest 
+const libAlias = {
+  '@zohodesk/components/lib': '@zohodesk/components/es',
+  // '@zohodesk/zc-custom/lib': '@zohodesk/zc-custom/es',
+  '@zohodesk/dot/lib': '@zohodesk/dot/es',
+  '@zohodesk/i18n/lib': '@zohodesk/i18n/es',
+  '@zohodesk/icons/lib': '@zohodesk/icons/es',
+  '@zohodesk/normalizer/lib': '@zohodesk/normalizer/es',
+  '@zohodesk/perf-components/lib': '@zohodesk/perf-components/es',
+  '@zohodesk/perf-middleware/lib': '@zohodesk/perf-middleware/es',
+  '@zohodesk/permissions/lib': '@zohodesk/permissions/es',
+  '@zohodesk/platform-middleware/lib': '@zohodesk/platform-middleware/es',
+  '@zohodesk/react-dnd/lib': '@zohodesk/react-dnd/es',
+  '@zohodesk/router-middleware/lib': '@zohodesk/router-middleware/es',
+  '@zohodesk/storage/lib': '@zohodesk/storage/es',
+  '@zohodesk/svg/lib': '@zohodesk/svg/es',
+  '@zohodesk/timetracker/lib': '@zohodesk/timetracker/es',
+  '@zohodesk/variables/lib': '@zohodesk/variables/es',
+  '@zohodesk/virtualizer/lib': '@zohodesk/virtualizer/es'
+};
+exports.libAlias = libAlias;

package/lib/shared/bundler/webpack/common/modeUtils.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getWebpackMode = getWebpackMode;
+exports.isDevelopmentMode = isDevelopmentMode;
+exports.isNotProduction = isNotProduction;
+exports.isProductionMode = isProductionMode;
+
+function isProductionMode(mode) {
+  return mode === 'prod' || mode === 'production';
+}
+
+function isDevelopmentMode(mode) {
+  return mode === 'dev' || mode === 'development';
+}
+
+function getWebpackMode(options) {
+  const {
+    mode
+  } = options;
+  return isProductionMode(mode) ? 'production' : 'development';
+}
+
+function isNotProduction(options) {
+  const {
+    mode
+  } = options;
+  return isProductionMode(mode) === false;
+}