balm-core 5.2.0 → 6.0.0-alpha.0

package/lib/balm.js

@@ -1,49 +0,0 @@
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-import './config/index.js';
-import './utilities/index.js';
-import './plugins/index.js';
-import registerTasks from './tasks/index.js';
-import { setConfig, setTask } from './bootstrap/index.js';
-import loading from './utilities/loading.js';
-var _config = /*#__PURE__*/new WeakMap();
-class Balm {
-  constructor() {
-    _classPrivateFieldInitSpec(this, _config, void 0);
-    BalmJS.loading = false;
-    loading.succeed();
-    _classPrivateFieldSet(_config, this, setConfig({}));
-  }
-  get config() {
-    return _classPrivateFieldGet(_config, this);
-  }
-  set config(value) {
-    _classPrivateFieldSet(_config, this, setConfig(value));
-    BalmJS.config = _classPrivateFieldGet(_config, this);
-  }
-  set beforeTask(name) {
-    BalmJS.beforeTask = setTask(name);
-  }
-  set afterTask(name) {
-    BalmJS.afterTask = setTask(name);
-  }
-  go(recipe = NOOP) {
-    if (BalmJS.utils.isFunction(recipe)) {
-      registerTasks(recipe);
-    } else {
-      BalmJS.logger.error('initialization', 'BalmJS API: `balm.go(mix => {});`');
-    }
-  }
-  reset() {
-    BalmJS.tasks = new Map();
-    BalmJS.recipes = [];
-    BalmJS.recipeIndex = 0;
-    BalmJS.beforeTask = undefined;
-    BalmJS.afterTask = undefined;
-    BalmJS.config.useDefaults = true;
-  }
-}
-export default Balm;

package/lib/bootstrap/check_config.js

@@ -1,43 +0,0 @@
-import { DOMAIN } from '../config/constants.js';
-const docsBaseURL = `${DOMAIN}/docs/config`;
-function upgradeGuide(key, value, message) {
-  const page = key === 'scripts' ? 'scripts-webpack' : key.toLowerCase();
-  return `${message} See ${docsBaseURL}/${page}.html#${key}-${value.toLowerCase()}`;
-}
-function upgradeRenamed(version, configCategory, from, to) {
-  if (BalmJS.config[configCategory][from]) {
-    BalmJS.logger.warn(`balm@${version}+ config`, upgradeGuide(configCategory, to, `'${configCategory}.${from}' was renamed to '${configCategory}.${to}'.`));
-  }
-}
-function upgradeMigrated(version, configName, from, to) {
-  if (BalmJS.config[from][configName]) {
-    BalmJS.logger.warn(`balm@${version}+ config`, upgradeGuide(to, configName, `'${from}.${configName}' was migrated to '${to}.${configName}'.`));
-  }
-}
-function upgradeDeprecated(version, configCategory, configName) {
-  if (BalmJS.config[configCategory][configName]) {
-    BalmJS.logger.warn(`balm@${version}+ config`, `'${configCategory}.${configName}' was deprecated.`);
-  }
-}
-
-// Compatibility for upgrade balm
-function checkConfig() {
-  // For v2
-  upgradeRenamed('2.5.0', 'scripts', 'disableDefaultLoaders', 'defaultLoaders');
-  upgradeMigrated('2.11.0', 'postcssLoaderOptions', 'styles', 'scripts');
-  upgradeRenamed('2.22.0', 'images', 'defaultPlugins', 'plugins');
-
-  // For v3
-  upgradeRenamed('3.0.0', 'styles', 'minified', 'minify');
-  upgradeRenamed('3.9.0', 'scripts', 'options', 'minifyOptions');
-  upgradeRenamed('3.16.0', 'scripts', 'inject', 'useCache');
-  upgradeDeprecated('3.17.0', 'styles', 'darkSass');
-  upgradeDeprecated('3.19.0', 'scripts', 'useCache');
-
-  // For v4
-  upgradeDeprecated('4.0.0', 'scripts', 'libraryTarget');
-  upgradeDeprecated('4.5.0', 'scripts', 'excludeUrlResource');
-  upgradeDeprecated('4.5.0', 'scripts', 'urlLoaderOptions');
-  upgradeRenamed('4.29.0', 'server', 'proxyConfig', 'proxyOptions');
-}
-export default checkConfig;

package/lib/bootstrap/index.js

@@ -1,87 +0,0 @@
-import checkConfig from './check_config.js';
-import { ASSETS_TYPES } from '../config/constants.js';
-function createQuickPath(config, rootKey) {
-  const result = {};
-  const rootValue = config.roots[rootKey];
-  for (const pathKey of Object.keys(config.paths[rootKey])) {
-    const pathValue = config.paths[rootKey][pathKey];
-    result[pathKey] = rootKey === 'target' && ASSETS_TYPES.includes(pathKey) ? node.path.join(rootValue, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath, pathValue) : node.path.join(rootValue, pathValue);
-  }
-  return rootKey === 'source' ? result : result;
-}
-function ready(config) {
-  // Create local quick directories
-  config.src = createQuickPath(config, 'source');
-  config.dest = createQuickPath(config, config.env.isProd || !config.inFrontend ? 'target' : 'tmp');
-  config.dest.static = node.path.join(config.dest.base, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath);
-
-  // Create remote quick directories
-  config.assets.static = node.path.join(config.assets.root, config.assets.mainDir, BalmJS.file.assetsSuffixPath);
-  for (const assetType of ASSETS_TYPES) {
-    config.assets[assetType] = node.path.join(config.assets.static, config.paths.target[assetType]);
-  }
-
-  // Set HMR flag
-  const HMR_ENV = config.useDefaults && config.env.isDev && !config.env.inSSR && !config.env.isMP;
-  const HMR_Enabling = config.scripts.bundler === BalmJS.Bundler.webpack && !config.scripts.ie8;
-  config.server.useHMR = HMR_ENV && HMR_Enabling;
-
-  // Set desktop app flag
-  if (/^electron-.*/.test(config.scripts.target)) {
-    config.env.inDesktopApp = true;
-  }
-
-  // Set use cache for webpack
-  config.scripts.useCache = config.env.isProd && config.assets.cache && config.scripts.injectHtml;
-  return config;
-}
-function resetConfig() {
-  BalmJS.config.roots.target = 'dist';
-  BalmJS.config.roots.tmp = '.tmp';
-  return BalmJS.config;
-}
-function setConfig(customConfig) {
-  const defaultConfig = resetConfig();
-
-  // 1. Overwrite config
-  const newConfig = BalmJS.utils.deepMerge(defaultConfig, customConfig);
-  checkConfig();
-
-  // 2. Copy `config.paths.target` to `config.paths.tmp`
-  let config = BalmJS.utils.deepMerge(newConfig, {
-    paths: {
-      tmp: newConfig.paths.target
-    }
-  });
-
-  // 3. For the dynamic project
-  if (!config.inFrontend) {
-    if (config.roots.target === 'dist') {
-      config.roots.target = config.assets.mainDir; // NOTE: `BalmJS.config.roots.target = 'public'` for back-end project
-    }
-    config.roots.tmp = config.roots.target;
-  }
-
-  // 4. Before created
-  config = ready(config);
-  BalmJS.logger.success('balm configuration', config, {
-    pre: true
-  });
-  return config;
-}
-function setTask(name) {
-  let result = undefined;
-  if (BalmJS.utils.isFunction(name)) {
-    result = name;
-  } else if (BalmJS.utils.isString(name)) {
-    if (gulp.tree().nodes.includes(name)) {
-      result = name;
-    } else {
-      BalmJS.logger.error('before/end task', 'Invalid gulp task name');
-    }
-  } else {
-    BalmJS.logger.error('before/end task', 'Task must be a string (gulp task name) or function');
-  }
-  return result;
-}
-export { setConfig, setTask };

package/lib/bundler/esbuild/build.js

@@ -1,26 +0,0 @@
-import { build } from 'esbuild';
-import { minifyOptions } from './options.js';
-const esBuild = (entryPoints, output, customBuildOptions, callback) => {
-  const defaultBuildOptions = {
-    entryPoints: BalmJS.file.absPaths(entryPoints),
-    outdir: BalmJS.file.absPath(output),
-    bundle: BalmJS.config.env.isProd
-  };
-  const buildOptions = BalmJS.config.env.isProd ? Object.assign(defaultBuildOptions, minifyOptions) : defaultBuildOptions;
-  const options = Object.assign(buildOptions, BalmJS.config.scripts.buildOptions, customBuildOptions);
-  BalmJS.logger.debug('esbuild bundler - build', {
-    input: options.entryPoints,
-    output: options.outdir
-  }, {
-    pre: true
-  });
-  BalmJS.logger.success('esbuild options', options, {
-    pre: true
-  });
-  build(options).catch(error => {
-    BalmJS.logger.error('esbuild', error.message);
-  }).finally(() => {
-    callback();
-  });
-};
-export default esBuild;

package/lib/bundler/esbuild/index.js

@@ -1,7 +0,0 @@
-import build from './build.js';
-import transform from './transform.js';
-const esbuild = (input, output, customOptions, callback) => {
-  const entryPoints = BalmJS.utils.isString(input) ? [input] : input;
-  BalmJS.config.scripts.useTransform ? transform(entryPoints, output, customOptions, callback) : build(entryPoints, output, customOptions, callback);
-};
-export default esbuild;

package/lib/bundler/esbuild/options.js

@@ -1,7 +0,0 @@
-const minifyOptions = {
-  minify: true,
-  minifyWhitespace: true,
-  minifyIdentifiers: true,
-  minifySyntax: true
-};
-export { minifyOptions };

package/lib/bundler/esbuild/transform.js

@@ -1,36 +0,0 @@
-import { transform } from 'esbuild';
-import { minifyOptions } from './options.js';
-const esTransform = (entryPoints, output, customTransformOptions, callback) => {
-  const build = {
-    output: BalmJS.file.absPath(output)
-  };
-  const transformOptions = BalmJS.config.env.isProd ? Object.assign({}, minifyOptions) : {};
-  const options = Object.assign(transformOptions, BalmJS.config.scripts.transformOptions, customTransformOptions);
-  (async () => {
-    try {
-      for await (const entryPoint of entryPoints) {
-        build.input = BalmJS.file.absPath(entryPoint);
-        BalmJS.logger.debug('esbuild bundler - transform', {
-          input: build.input,
-          output: build.output
-        }, {
-          pre: true
-        });
-        const filename = entryPoint.split('/').pop();
-        if (filename && node.fs.existsSync(build.input)) {
-          const inputCode = node.fs.readFileSync(build.input, 'utf8');
-          const result = await transform(inputCode, options);
-          node.fs.mkdirSync(build.output, {
-            recursive: true
-          });
-          node.fs.writeFileSync(node.path.join(build.output, filename), result.code);
-        } else {
-          BalmJS.logger.warn('esbuild', `Invalid entry point: ${entryPoint}`);
-        }
-      }
-    } finally {
-      callback();
-    }
-  })();
-};
-export default esTransform;

package/lib/bundler/rollup/build.js

@@ -1,52 +0,0 @@
-const build = async (bundle, outputOptions) => {
-  const {
-    output
-  } = await bundle.generate(outputOptions);
-  for (const chunkOrAsset of output) {
-    if (chunkOrAsset.type === 'asset') {
-      // For assets, this contains
-      // {
-      //   fileName: string,              // the asset file name
-      //   source: string | Uint8Array    // the asset source
-      //   type: 'asset'                  // signifies that this is an asset
-      // }
-      BalmJS.logger.debug('rollup bundler - Asset', chunkOrAsset, {
-        pre: true
-      });
-    } else {
-      // For chunks, this contains
-      // {
-      //   code: string,                  // the generated JS code
-      //   dynamicImports: string[],      // external modules imported dynamically by the chunk
-      //   exports: string[],             // exported variable names
-      //   facadeModuleId: string | null, // the id of a module that this chunk corresponds to
-      //   fileName: string,              // the chunk file name
-      //   implicitlyLoadedBefore: string[]; // entries that should only be loaded after this chunk
-      //   imports: string[],             // external modules imported statically by the chunk
-      //   importedBindings: {[imported: string]: string[]} // imported bindings per dependency
-      //   isDynamicEntry: boolean,       // is this chunk a dynamic entry point
-      //   isEntry: boolean,              // is this chunk a static entry point
-      //   isImplicitEntry: boolean,      // should this chunk only be loaded after other chunks
-      //   map: string | null,            // sourcemaps if present
-      //   modules: {                     // information about the modules in this chunk
-      //     [id: string]: {
-      //       renderedExports: string[]; // exported variable names that were included
-      //       removedExports: string[];  // exported variable names that were removed
-      //       renderedLength: number;    // the length of the remaining code in this module
-      //       originalLength: number;    // the original length of the code in this module
-      //     };
-      //   },
-      //   name: string                   // the name of this chunk as used in naming patterns
-      //   referencedFiles: string[]      // files referenced via import.meta.ROLLUP_FILE_URL_<id>
-      //   type: 'chunk',                 // signifies that this is a chunk
-      // }
-      BalmJS.logger.debug('rollup bundler - Chunk', chunkOrAsset.modules, {
-        pre: true
-      });
-    }
-  }
-
-  // or write the bundle to disk
-  return await bundle.write(outputOptions);
-};
-export default build;

package/lib/bundler/rollup/entry.js

@@ -1,28 +0,0 @@
-import { getInputPlugins } from './plugins.js';
-function getEntry(inputOptions) {
-  // Set plugins
-  const inputPlugins = getInputPlugins(inputOptions);
-  const options = Object.assign({}, BalmJS.config.scripts.inputOptions, inputOptions);
-  options.plugins = inputPlugins;
-
-  // Set entry points
-  const {
-    input
-  } = options;
-  let rollupEntries = input;
-  if (BalmJS.utils.isObject(input)) {
-    const entries = input;
-    Object.keys(entries).forEach(entryAlias => {
-      entries[entryAlias] = BalmJS.file.absPath(entries[entryAlias]);
-    });
-    rollupEntries = entries;
-  } else {
-    rollupEntries = BalmJS.file.absPaths(input);
-  }
-  options.input = rollupEntries;
-  BalmJS.logger.debug('rollup input options', options, {
-    pre: true
-  });
-  return options;
-}
-export default getEntry;

package/lib/bundler/rollup/index.js

@@ -1,20 +0,0 @@
-import { rollup } from 'rollup';
-import getEntry from './entry.js';
-import getOutput from './output.js';
-import build from './build.js';
-const buildLibrary = async (inputOptions, outputOptions) => {
-  inputOptions = getEntry(inputOptions);
-  outputOptions = getOutput(outputOptions);
-  const rollupOptions = Object.assign({}, inputOptions, {
-    output: outputOptions
-  });
-  const bundle = await rollup(rollupOptions);
-  if (Array.isArray(outputOptions)) {
-    for await (const outputOption of outputOptions) {
-      await build(bundle, outputOption);
-    }
-  } else {
-    await build(bundle, outputOptions);
-  }
-};
-export default buildLibrary;

package/lib/bundler/rollup/output.js

@@ -1,20 +0,0 @@
-import { getOutputPlugins } from './plugins.js';
-function setOutput(outputOptions) {
-  const outputPlugins = getOutputPlugins(outputOptions);
-  outputOptions = Object.assign({}, BalmJS.config.scripts.outputOptions, outputOptions);
-  outputOptions.plugins = outputPlugins;
-  if (outputOptions.dir) {
-    outputOptions.dir = BalmJS.file.absPath(outputOptions.dir);
-  } else {
-    outputOptions.file = BalmJS.file.absPath(outputOptions.file);
-  }
-  return outputOptions;
-}
-function getOutput(outputOptions) {
-  const options = Array.isArray(outputOptions) ? outputOptions.map(outputOption => setOutput(outputOption)) : setOutput(outputOptions);
-  BalmJS.logger.debug('rollup output options', options, {
-    pre: true
-  });
-  return options;
-}
-export default getOutput;

package/lib/bundler/rollup/plugins.js

@@ -1,31 +0,0 @@
-import terser from '@rollup/plugin-terser';
-function getInputPlugins(customInputOptions) {
-  const {
-    inputOptions
-  } = BalmJS.config.scripts;
-  const inputPlugins = [];
-  if (inputOptions.plugins) {
-    inputPlugins.push(...inputOptions.plugins);
-  }
-  if (customInputOptions.plugins) {
-    inputPlugins.push(...customInputOptions.plugins);
-  }
-  return inputPlugins;
-}
-function getOutputPlugins(customOutputOptions) {
-  const {
-    outputOptions
-  } = BalmJS.config.scripts;
-  const outputPlugins = [];
-  if (outputOptions.plugins) {
-    outputPlugins.push(...outputOptions.plugins);
-  }
-  if (BalmJS.config.env.isProd) {
-    outputPlugins.push(terser(BalmJS.config.scripts.minifyOptions));
-  }
-  if (customOutputOptions.plugins) {
-    outputPlugins.push(...customOutputOptions.plugins);
-  }
-  return outputPlugins;
-}
-export { getInputPlugins, getOutputPlugins };

package/lib/bundler/webpack/config/common.js

@@ -1,135 +0,0 @@
-import HtmlWebpackPlugin from 'html-webpack-plugin';
-import getLoaders from '../loaders.js';
-import { CHUNK } from '../../../config/constants.js';
-import getClientEnvironment from './env.js';
-function getDefaultPlugins(webpack, scripts) {
-  // We will provide `BalmJS.file.publicUrlOrPath` to our app
-  // as %PUBLIC_URL% in `index.html` and `process.env.PUBLIC_URL` in JavaScript.
-  // Omit trailing slash as %PUBLIC_URL%/xyz looks better than %PUBLIC_URL%xyz.
-  // Get environment variables to inject into our app.
-  const env = getClientEnvironment(BalmJS.file.publicUrlOrPath.slice(0, -1));
-  const plugins = [
-  // Makes some environment variables available to the JS code, for example:
-  // if (process.env.NODE_ENV === 'production') { ... }. See `./env.js`.
-  // It is absolutely essential that NODE_ENV is set to production
-  // during a production build.
-  // Otherwise webapp will be compiled in the very slow development mode.
-  new webpack.DefinePlugin(env.stringified),
-  // Moment.js is an extremely popular library that bundles large locale files
-  // by default due to how webpack interprets its code. This is a practical
-  // solution that requires the user to opt into importing specific locales.
-  // https://github.com/jmblog/how-to-optimize-momentjs-with-webpack
-  // You can remove this if you don't use Moment.js:
-  new webpack.IgnorePlugin({
-    resourceRegExp: /^\.\/locale$/,
-    contextRegExp: /moment$/
-  })];
-  if (scripts.injectHtml) {
-    const isSPA = BalmJS.entries.length < 2;
-    const titles = scripts.htmlPluginOptions.title || ['BalmJS App'];
-    if (!BalmJS.entries.length) {
-      BalmJS.entries.push({
-        key: 'main',
-        value: `./${BalmJS.file.defaultEntry}`
-      });
-    }
-    BalmJS.entries.forEach((entry, index) => {
-      const entryName = isSPA ? 'index' : entry.key;
-      const chunks = isSPA ? 'all' : [entryName];
-      const title = titles[index];
-      const options = Object.assign({
-        filename: BalmJS.file.absPath(`${BalmJS.config.src.base}/${entryName}.html`),
-        chunks
-      }, scripts.htmlPluginOptions, {
-        title
-      });
-      plugins.push(new HtmlWebpackPlugin(options));
-    });
-  }
-  return plugins;
-}
-function getSplitChunks() {
-  const scripts = BalmJS.config.scripts;
-  const jsFolder = BalmJS.config.paths.target.js;
-  let cacheGroups = {};
-  if (scripts.extractAllVendors) {
-    // All vendors
-    const vendorsFilename = scripts.useCache ? `${scripts.vendorName}.${CHUNK.hash}.js` : `${scripts.vendorName}.js`;
-    cacheGroups = {
-      allVendors: {
-        name: 'vendors',
-        chunks: 'initial',
-        test: /[\\/](node_modules|bower_components)[\\/]/,
-        filename: BalmJS.file.assetsPath(`${jsFolder}/${vendorsFilename}`) // Output: `js/vendors.js`
-      }
-    };
-  } else if (BalmJS.vendors.length) {
-    // Custom vendors
-    cacheGroups = {};
-    for (const vendor of BalmJS.vendors) {
-      const name = vendor.key;
-      const cacheGroupModules = vendor.value.join('|');
-      const vendorFilename = scripts.useCache ? `${name}.${CHUNK.hash}.js` : `${name}.js`;
-      cacheGroups[`${name}Scripts`] = {
-        name,
-        chunks: 'initial',
-        test: new RegExp(`[\\\\/](${cacheGroupModules})[\\\\/].*(?<!\\.css)$`),
-        filename: BalmJS.file.assetsPath(`${jsFolder}/${scripts.vendorName}/${vendorFilename}`),
-        // Output: `js/vendor/customVendorName.js`
-        enforce: true
-      };
-    }
-  }
-  if (BalmJS.config.env.isProd && BalmJS.config.scripts.extractCss) {
-    // Custom styles in scripts
-    for (const entry of BalmJS.entries) {
-      const name = entry.key;
-      cacheGroups[`${name}Styles`] = {
-        type: 'css/mini-extract',
-        name,
-        chunks: chunk => chunk.name === name,
-        enforce: true
-      };
-    }
-  }
-  return Object.keys(cacheGroups).length ? {
-    cacheGroups
-  } : false;
-}
-function getCommonConfig(webpack, scripts) {
-  const splitChunks = getSplitChunks();
-  const optimization = splitChunks ? BalmJS.utils.deepMerge({
-    splitChunks: splitChunks
-  }, scripts.optimization) : scripts.optimization;
-  return {
-    context: BalmJS.config.workspace,
-    mode: 'none',
-    // Stop compilation early in production
-    bail: BalmJS.config.env.isProd,
-    module: {
-      strictExportPresence: true,
-      rules: getLoaders(scripts.loaders)
-    },
-    resolve: {
-      // (was split into `root`, `modulesDirectories` and `fallback` in the old options)
-      // In which folders the resolver look for modules
-      // relative paths are looked up in every parent folder (like node_modules)
-      // absolute paths are looked up directly
-      // the order is respected
-      modules: ['node_modules', 'bower_components', BalmJS.file.absPath(BalmJS.config.src.base)],
-      // These extensions are tried when resolving a file
-      extensions: ['.wasm', '.mjs', '.js', '.json', '.jsx', '.ts', '.tsx', '.vue', ...scripts.extensions],
-      // These aliasing is used when trying to resolve a module
-      alias: scripts.alias,
-      // These JSON files are read in directories
-      descriptionFiles: ['package.json', 'bower.json'],
-      // These fields in the description files are looked up when trying to resolve the package directory
-      mainFields: ['browser', 'module', 'main']
-    },
-    optimization,
-    plugins: [...getDefaultPlugins(webpack, scripts), ...scripts.plugins],
-    target: scripts.target,
-    stats: scripts.stats
-  };
-}
-export default getCommonConfig;

package/lib/bundler/webpack/config/dev.js

@@ -1,12 +0,0 @@
-import { merge } from 'webpack-merge';
-import getCommonConfig from './common.js';
-function getDevConfig(webpack, scripts) {
-  return merge(getCommonConfig(webpack, scripts), {
-    mode: 'development',
-    plugins: [
-    // This is necessary to emit hot updates
-    new webpack.HotModuleReplacementPlugin()],
-    devtool: scripts.sourceMap ? scripts.sourceMap : 'eval-cheap-module-source-map'
-  });
-}
-export default getDevConfig;

package/lib/bundler/webpack/config/env.js

@@ -1,67 +0,0 @@
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import dotenv from 'dotenv';
-import dotenvExpand from 'dotenv-expand';
-const NODE_ENV = process.env.NODE_ENV;
-if (!NODE_ENV) {
-  throw new Error('The NODE_ENV environment variable is required but was not specified.');
-}
-const dotenvFile = BalmJS.file.resolveApp('.env');
-
-// https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use
-const dotenvFiles = [`${dotenvFile}.${NODE_ENV}.local`,
-// Don't include `.env.local` for `test` environment
-// since normally you expect tests to produce the same
-// results for everyone
-NODE_ENV !== 'test' && `${dotenvFile}.local`, `${dotenvFile}.${NODE_ENV}`, dotenvFile].filter(Boolean);
-
-// Load environment variables from .env* files. Suppress warnings using silent
-// if this file is missing. dotenv will never modify any environment variables
-// that have already been set.  Variable expansion is supported in .env files.
-// https://github.com/motdotla/dotenv
-// https://github.com/motdotla/dotenv-expand
-dotenvFiles.forEach(dotenvFile => {
-  if (node.fs.existsSync(dotenvFile)) {
-    dotenvExpand.expand(dotenv.config({
-      path: dotenvFile
-    }));
-  }
-});
-
-// Grab NODE_ENV and BALM_APP_* environment variables and prepare them to be
-// injected into the application via DefinePlugin in webpack configuration.
-const BALM_APP = /^BALM_APP_/i;
-function getClientEnvironment(publicUrl) {
-  const raw = Object.keys(process.env).filter(key => BALM_APP.test(key)).reduce((env, key) => {
-    env[key] = process.env[key];
-    return env;
-  }, _objectSpread({
-    // Useful for determining whether we’re running in production mode.
-    // Most importantly, it switches webapp into the correct mode.
-    NODE_ENV: process.env.NODE_ENV || 'development',
-    // Useful for resolving the correct path to static assets in `public`.
-    // For example, <img src={process.env.PUBLIC_URL + '/img/logo.png'} />.
-    // This should only be used as an escape hatch. Normally you would put
-    // images into the `src` and `import` them in code to get their paths.
-    PUBLIC_URL: publicUrl
-  }, BalmJS.config.scripts.nodeEnv));
-
-  // Stringify all values so we can feed into webpack DefinePlugin
-  const stringified = {
-    'process.env': Object.keys(raw).reduce((env, key) => {
-      env[key] = JSON.stringify(raw[key]);
-      return env;
-    }, {})
-  };
-  BalmJS.logger.debug('webpack .env', stringified, {
-    pre: true
-  });
-  return {
-    raw,
-    stringified
-  };
-}
-export default getClientEnvironment;

package/lib/bundler/webpack/config/index.js

@@ -1,6 +0,0 @@
-import getDevConfig from './dev.js';
-import getProdConfig from './prod.js';
-function getDefaultConfig(webpack, scripts) {
-  return BalmJS.config.env.isProd || scripts.minify || scripts.ie8 ? getProdConfig(webpack, scripts) : getDevConfig(webpack, scripts);
-}
-export default getDefaultConfig;