NPM RUN EJECT [WORK COPY]

dynselect/config/env.js

+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const paths = require('./paths');
+
+// Make sure that including paths.js after env.js will read .env variables.
+delete require.cache[require.resolve('./paths')];
+
+const NODE_ENV = process.env.NODE_ENV;
+if (!NODE_ENV) {
+    throw new Error(
+        'The NODE_ENV environment variable is required but was not specified.'
+    );
+}
+
+// https://github.com/bkeepers/dotenv#what-other-env-files-can-i-use
+var dotenvFiles = [
+    `${paths.dotenv}.${NODE_ENV}.local`,
+    `${paths.dotenv}.${NODE_ENV}`,
+    // Don't include `.env.local` for `test` environment
+    // since normally you expect tests to produce the same
+    // results for everyone
+    NODE_ENV !== 'test' && `${paths.dotenv}.local`,
+    paths.dotenv,
+].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 (fs.existsSync(dotenvFile)) {
+        require('dotenv-expand')(
+            require('dotenv').config({
+                path: dotenvFile,
+            })
+        );
+    }
+});
+
+// We support resolving modules according to `NODE_PATH`.
+// This lets you use absolute paths in imports inside large monorepos:
+// https://github.com/facebook/create-react-app/issues/253.
+// It works similar to `NODE_PATH` in Node itself:
+// https://nodejs.org/api/modules.html#modules_loading_from_the_global_folders
+// Note that unlike in Node, only *relative* paths from `NODE_PATH` are honored.
+// Otherwise, we risk importing Node.js core modules into an app instead of Webpack shims.
+// https://github.com/facebook/create-react-app/issues/1023#issuecomment-265344421
+// We also resolve them to make sure all tools using them work consistently.
+const appDirectory = fs.realpathSync(process.cwd());
+process.env.NODE_PATH = (process.env.NODE_PATH || '')
+    .split(path.delimiter)
+    .filter(folder => folder && !path.isAbsolute(folder))
+    .map(folder => path.resolve(appDirectory, folder))
+    .join(path.delimiter);
+
+// Grab NODE_ENV and REACT_APP_* environment variables and prepare them to be
+// injected into the application via DefinePlugin in Webpack configuration.
+const REACT_APP = /^REACT_APP_/i;
+
+function getClientEnvironment(publicUrl) {
+    const raw = Object.keys(process.env)
+        .filter(key => REACT_APP.test(key))
+        .reduce(
+            (env, key) => {
+                env[key] = process.env[key];
+                return env;
+            },
+            {
+                // Useful for determining whether we’re running in production mode.
+                // Most importantly, it switches React 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,
+            }
+        );
+    // 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;
+        }, {}),
+    };
+
+    return {raw, stringified};
+}
+
+module.exports = getClientEnvironment;

dynselect/config/jest/cssTransform.js

+'use strict';
+
+// This is a custom Jest transformer turning style imports into empty objects.
+// http://facebook.github.io/jest/docs/en/webpack.html
+
+module.exports = {
+    process() {
+        return 'module.exports = {};';
+    },
+    getCacheKey() {
+        // The output is always the same.
+        return 'cssTransform';
+    },
+};

dynselect/config/jest/fileTransform.js

+'use strict';
+
+const path = require('path');
+
+// This is a custom Jest transformer turning file imports into filenames.
+// http://facebook.github.io/jest/docs/en/webpack.html
+
+module.exports = {
+    process(src, filename) {
+        const assetFilename = JSON.stringify(path.basename(filename));
+
+        if (filename.match(/\.svg$/)) {
+            return `module.exports = {
+        __esModule: true,
+        default: ${assetFilename},
+        ReactComponent: (props) => ({
+          $$typeof: Symbol.for('react.element'),
+          type: 'svg',
+          ref: null,
+          key: null,
+          props: Object.assign({}, props, {
+            children: ${assetFilename}
+          })
+        }),
+      };`;
+        }
+
+        return `module.exports = ${assetFilename};`;
+    },
+};

dynselect/config/paths.js

+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const url = require('url');
+
+// 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 envPublicUrl = process.env.PUBLIC_URL;
+
+function ensureSlash(inputPath, needsSlash) {
+    const hasSlash = inputPath.endsWith('/');
+    if (hasSlash && !needsSlash) {
+        return inputPath.substr(0, inputPath.length - 1);
+    } else if (!hasSlash && needsSlash) {
+        return `${inputPath}/`;
+    } else {
+        return inputPath;
+    }
+}
+
+const getPublicUrl = appPackageJson =>
+    envPublicUrl || require(appPackageJson).homepage;
+
+// We use `PUBLIC_URL` environment variable or "homepage" field to infer
+// "public path" at which the app is served.
+// Webpack needs to know it to put the right <script> hrefs into HTML even in
+// single-page apps that may serve index.html for nested URLs like /todos/42.
+// We can't use a relative path in HTML because we don't want to load something
+// like /todos/42/static/js/bundle.7289d.js. We have to know the root.
+function getServedPath(appPackageJson) {
+    const publicUrl = getPublicUrl(appPackageJson);
+    const servedUrl =
+        envPublicUrl || (publicUrl ? url.parse(publicUrl).pathname : '/');
+    return ensureSlash(servedUrl, true);
+}
+
+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(extension =>
+        fs.existsSync(resolveFn(`${filePath}.${extension}`))
+    );
+
+    if (extension) {
+        return resolveFn(`${filePath}.${extension}`);
+    }
+
+    return resolveFn(`${filePath}.js`);
+};
+
+// config after eject: we're in ./config/
+module.exports = {
+    dotenv: resolveApp('.env'),
+    appPath: resolveApp('.'),
+    appBuild: resolveApp('build'),
+    appPublic: resolveApp('public'),
+    appHtml: resolveApp('public/index.html'),
+    appIndexJs: resolveModule(resolveApp, 'src/index'),
+    appPackageJson: resolveApp('package.json'),
+    appSrc: resolveApp('src'),
+    appTsConfig: resolveApp('tsconfig.json'),
+    yarnLockFile: resolveApp('yarn.lock'),
+    testsSetup: resolveModule(resolveApp, 'src/setupTests'),
+    proxySetup: resolveApp('src/setupProxy.js'),
+    appNodeModules: resolveApp('node_modules'),
+    publicUrl: getPublicUrl(resolveApp('package.json')),
+    servedPath: getServedPath(resolveApp('package.json')),
+};
+
+
+module.exports.moduleFileExtensions = moduleFileExtensions;

dynselect/config/webpackDevServer.config.js

+'use strict';
+
+const errorOverlayMiddleware = require('react-dev-utils/errorOverlayMiddleware');
+const evalSourceMapMiddleware = require('react-dev-utils/evalSourceMapMiddleware');
+const noopServiceWorkerMiddleware = require('react-dev-utils/noopServiceWorkerMiddleware');
+const ignoredFiles = require('react-dev-utils/ignoredFiles');
+const paths = require('./paths');
+const fs = require('fs');
+
+const protocol = process.env.HTTPS === 'true' ? 'https' : 'http';
+const host = process.env.HOST || '0.0.0.0';
+
+module.exports = function (proxy, allowedHost) {
+    return {
+        // WebpackDevServer 2.4.3 introduced a security fix that prevents remote
+        // websites from potentially accessing local content through DNS rebinding:
+        // https://github.com/webpack/webpack-dev-server/issues/887
+        // https://medium.com/webpack/webpack-dev-server-middleware-security-issues-1489d950874a
+        // However, it made several existing use cases such as development in cloud
+        // environment or subdomains in development significantly more complicated:
+        // https://github.com/facebook/create-react-app/issues/2271
+        // https://github.com/facebook/create-react-app/issues/2233
+        // While we're investigating better solutions, for now we will take a
+        // compromise. Since our WDS configuration only serves files in the `public`
+        // folder we won't consider accessing them a vulnerability. However, if you
+        // use the `proxy` feature, it gets more dangerous because it can expose
+        // remote code execution vulnerabilities in backends like Django and Rails.
+        // So we will disable the host check normally, but enable it if you have
+        // specified the `proxy` setting. Finally, we let you override it if you
+        // really know what you're doing with a special environment variable.
+        disableHostCheck:
+        !proxy || process.env.DANGEROUSLY_DISABLE_HOST_CHECK === 'true',
+        // Enable gzip compression of generated files.
+        compress: true,
+        // Silence WebpackDevServer's own logs since they're generally not useful.
+        // It will still show compile warnings and errors with this setting.
+        clientLogLevel: 'none',
+        // By default WebpackDevServer serves physical files from current directory
+        // in addition to all the virtual build products that it serves from memory.
+        // This is confusing because those files won’t automatically be available in
+        // production build folder unless we copy them. However, copying the whole
+        // project directory is dangerous because we may expose sensitive files.
+        // Instead, we establish a convention that only files in `public` directory
+        // get served. Our build script will copy `public` into the `build` folder.
+        // In `index.html`, you can get URL of `public` folder with %PUBLIC_URL%:
+        // <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico">
+        // In JavaScript code, you can access it with `process.env.PUBLIC_URL`.
+        // Note that we only recommend to use `public` folder as an escape hatch
+        // for files like `favicon.ico`, `manifest.json`, and libraries that are
+        // for some reason broken when imported through Webpack. If you just want to
+        // use an image, put it in `src` and `import` it from JavaScript instead.
+        contentBase: paths.appPublic,
+        // By default files from `contentBase` will not trigger a page reload.
+        watchContentBase: true,
+        // Enable hot reloading server. It will provide /sockjs-node/ endpoint
+        // for the WebpackDevServer client so it can learn when the files were
+        // updated. The WebpackDevServer client is included as an entry point
+        // in the Webpack development configuration. Note that only changes
+        // to CSS are currently hot reloaded. JS changes will refresh the browser.
+        hot: true,
+        // It is important to tell WebpackDevServer to use the same "root" path
+        // as we specified in the config. In development, we always serve from /.
+        publicPath: '/',
+        // WebpackDevServer is noisy by default so we emit custom message instead
+        // by listening to the compiler events with `compiler.hooks[...].tap` calls above.
+        quiet: true,
+        // Reportedly, this avoids CPU overload on some systems.
+        // https://github.com/facebook/create-react-app/issues/293
+        // src/node_modules is not ignored to support absolute imports
+        // https://github.com/facebook/create-react-app/issues/1065
+        watchOptions: {
+            ignored: ignoredFiles(paths.appSrc),
+        },
+        // Enable HTTPS if the HTTPS environment variable is set to 'true'
+        https: protocol === 'https',
+        host,
+        overlay: false,
+        historyApiFallback: {
+            // Paths with dots should still use the history fallback.
+            // See https://github.com/facebook/create-react-app/issues/387.
+            disableDotRule: true,
+        },
+        public: allowedHost,
+        proxy,
+        before(app, server) {
+            if (fs.existsSync(paths.proxySetup)) {
+                // This registers user provided middleware for proxy reasons
+                require(paths.proxySetup)(app);
+            }
+
+            // This lets us fetch source contents from webpack for the error overlay
+            app.use(evalSourceMapMiddleware(server));
+            // This lets us open files from the runtime error overlay.
+            app.use(errorOverlayMiddleware());
+
+            // This service worker file is effectively a 'no-op' that will reset any
+            // previous service worker registered for the same host:port combination.
+            // We do this in development to avoid hitting the production cache if
+            // it used the same host and port.
+            // https://github.com/facebook/create-react-app/issues/2272#issuecomment-302832432
+            app.use(noopServiceWorkerMiddleware());
+        },
+    };
+};

dynselect/package-lock.json

@@ -13263,61 +13263,6 @@
       "resolved": "https://registry.npmjs.org/react-error-overlay/-/react-error-overlay-5.1.2.tgz",
       "integrity": "sha512-7kEBKwU9R8fKnZJBRa5RSIfay4KJwnYvKB6gODGicUmDSAhQJ7Tdnll5S0RLtYrzRfMVXlqYw61rzrSpP4ThLQ=="
     },
-    "react-scripts": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/react-scripts/-/react-scripts-2.1.3.tgz",
-      "integrity": "sha512-JASD0QVVgSVleVhA9TeA+UBx+shq887hm/L+09qjZLrqIUvJZHZU+oOnhMFGot02Yop+LKfkvf9KSsTNlu/Rwg==",
-      "requires": {
-        "@babel/core": "7.1.6",
-        "@svgr/webpack": "2.4.1",
-        "babel-core": "7.0.0-bridge.0",
-        "babel-eslint": "9.0.0",
-        "babel-jest": "23.6.0",
-        "babel-loader": "8.0.4",
-        "babel-plugin-named-asset-import": "^0.3.0",
-        "babel-preset-react-app": "^7.0.0",
-        "bfj": "6.1.1",
-        "case-sensitive-paths-webpack-plugin": "2.1.2",
-        "chalk": "2.4.1",
-        "css-loader": "1.0.0",
-        "dotenv": "6.0.0",
-        "dotenv-expand": "4.2.0",
-        "eslint": "5.6.0",
-        "eslint-config-react-app": "^3.0.6",
-        "eslint-loader": "2.1.1",
-        "eslint-plugin-flowtype": "2.50.1",
-        "eslint-plugin-import": "2.14.0",
-        "eslint-plugin-jsx-a11y": "6.1.2",
-        "eslint-plugin-react": "7.11.1",
-        "file-loader": "2.0.0",
-        "fork-ts-checker-webpack-plugin-alt": "0.4.14",
-        "fs-extra": "7.0.0",
-        "fsevents": "1.2.4",
-        "html-webpack-plugin": "4.0.0-alpha.2",
-        "identity-obj-proxy": "3.0.0",
-        "jest": "23.6.0",
-        "jest-pnp-resolver": "1.0.1",
-        "jest-resolve": "23.6.0",
-        "mini-css-extract-plugin": "0.4.3",
-        "optimize-css-assets-webpack-plugin": "5.0.1",
-        "pnp-webpack-plugin": "1.1.0",
-        "postcss-flexbugs-fixes": "4.1.0",
-        "postcss-loader": "3.0.0",
-        "postcss-preset-env": "6.3.1",
-        "postcss-safe-parser": "4.0.1",
-        "react-app-polyfill": "^0.2.0",
-        "react-dev-utils": "^7.0.1",
-        "resolve": "1.8.1",
-        "sass-loader": "7.1.0",
-        "style-loader": "0.23.0",
-        "terser-webpack-plugin": "1.1.0",
-        "url-loader": "1.1.1",
-        "webpack": "4.19.1",
-        "webpack-dev-server": "3.1.14",
-        "webpack-manifest-plugin": "2.0.4",
-        "workbox-webpack-plugin": "3.6.3"
-      }
-    },
     "read-pkg": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz",

dynselect/package.json

@@ -3,18 +3,63 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
+    "@babel/core": "7.1.6",
+    "@svgr/webpack": "2.4.1",
+    "babel-core": "7.0.0-bridge.0",
+    "babel-eslint": "9.0.0",
+    "babel-jest": "23.6.0",
+    "babel-loader": "8.0.4",
+    "babel-plugin-named-asset-import": "^0.3.0",
+    "babel-preset-react-app": "^7.0.0",
+    "bfj": "6.1.1",
+    "case-sensitive-paths-webpack-plugin": "2.1.2",
+    "chalk": "2.4.1",
+    "css-loader": "1.0.0",
+    "dotenv": "6.0.0",
+    "dotenv-expand": "4.2.0",
+    "eslint": "5.6.0",
+    "eslint-config-react-app": "^3.0.6",
+    "eslint-loader": "2.1.1",
+    "eslint-plugin-flowtype": "2.50.1",
+    "eslint-plugin-import": "2.14.0",
+    "eslint-plugin-jsx-a11y": "6.1.2",
+    "eslint-plugin-react": "7.11.1",
+    "file-loader": "2.0.0",
+    "fork-ts-checker-webpack-plugin-alt": "0.4.14",
+    "fs-extra": "7.0.0",
+    "html-webpack-plugin": "4.0.0-alpha.2",
+    "identity-obj-proxy": "3.0.0",
+    "jest": "23.6.0",
+    "jest-pnp-resolver": "1.0.1",
+    "jest-resolve": "23.6.0",
     "jquery": "^3.3.1",
     "materialize-css": "^1.0.0-rc.2",
+    "mini-css-extract-plugin": "0.4.3",
+    "optimize-css-assets-webpack-plugin": "5.0.1",
+    "pnp-webpack-plugin": "1.1.0",
+    "postcss-flexbugs-fixes": "4.1.0",
+    "postcss-loader": "3.0.0",
+    "postcss-preset-env": "6.3.1",
+    "postcss-safe-parser": "4.0.1",
+    "prop-types": "latest",
     "react": "^16.7.0",
+    "react-app-polyfill": "^0.2.0",
+    "react-dev-utils": "^7.0.1",
     "react-dom": "^16.7.0",
-    "react-scripts": "2.1.3",
-    "prop-types": "latest"
+    "resolve": "1.8.1",
+    "sass-loader": "7.1.0",
+    "style-loader": "0.23.0",
+    "terser-webpack-plugin": "1.1.0",
+    "url-loader": "1.1.1",
+    "webpack": "4.19.1",
+    "webpack-dev-server": "3.1.14",
+    "webpack-manifest-plugin": "2.0.4",
+    "workbox-webpack-plugin": "3.6.3"
   },
   "scripts": {
-    "start": "react-scripts start",
-    "build": "react-scripts build",
-    "test": "react-scripts test",
-    "eject": "react-scripts eject"
+    "start": "node scripts/start.js",
+    "build": "node scripts/build.js",
+    "test": "node scripts/test.js"
   },
   "eslintConfig": {
     "extends": "react-app"
@@ -24,5 +69,51 @@
     "not dead",
     "not ie <= 11",
     "not op_mini all"
-  ]
+  ],
+  "jest": {
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "!src/**/*.d.ts"
+    ],
+    "resolver": "jest-pnp-resolver",
+    "setupFiles": [
+      "react-app-polyfill/jsdom"
+    ],
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.{js,jsx,ts,tsx}",
+      "<rootDir>/src/**/?(*.)(spec|test).{js,jsx,ts,tsx}"
+    ],
+    "testEnvironment": "jsdom",
+    "testURL": "http://localhost",
+    "transform": {
+      "^.+\\.(js|jsx|ts|tsx)$": "<rootDir>/node_modules/babel-jest",
+      "^.+\\.css$": "<rootDir>/config/jest/cssTransform.js",
+      "^(?!.*\\.(js|jsx|ts|tsx|css|json)$)": "<rootDir>/config/jest/fileTransform.js"
+    },
+    "transformIgnorePatterns": [
+      "[/\\\\]node_modules[/\\\\].+\\.(js|jsx|ts|tsx)$",
+      "^.+\\.module\\.(css|sass|scss)$"
+    ],
+    "moduleNameMapper": {
+      "^react-native$": "react-native-web",
+      "^.+\\.module\\.(css|sass|scss)$": "identity-obj-proxy"
+    },
+    "moduleFileExtensions": [
+      "web.js",
+      "js",
+      "web.ts",
+      "ts",
+      "web.tsx",
+      "tsx",
+      "json",
+      "web.jsx",
+      "jsx",
+      "node"
+    ]
+  },
+  "babel": {
+    "presets": [
+      "react-app"
+    ]
+  }
 }

dynselect/scripts/build.js

+'use strict';
+
+// Do this as the first thing so that any code reading it knows the right env.
+process.env.BABEL_ENV = 'production';
+process.env.NODE_ENV = 'production';
+
+// 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 => {
+    throw err;
+});
+
+// Ensure environment variables are read.
+require('../config/env');
+
+
+const path = require('path');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const webpack = require('webpack');
+const bfj = require('bfj');
+const configFactory = require('../config/webpack.config');
+const paths = require('../config/paths');
+const checkRequiredFiles = require('react-dev-utils/checkRequiredFiles');
+const formatWebpackMessages = require('react-dev-utils/formatWebpackMessages');
+const printHostingInstructions = require('react-dev-utils/printHostingInstructions');
+const FileSizeReporter = require('react-dev-utils/FileSizeReporter');
+const printBuildError = require('react-dev-utils/printBuildError');
+
+const measureFileSizesBeforeBuild =
+    FileSizeReporter.measureFileSizesBeforeBuild;
+const printFileSizesAfterBuild = FileSizeReporter.printFileSizesAfterBuild;
+const useYarn = fs.existsSync(paths.yarnLockFile);
+
+// 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;
+
+const isInteractive = process.stdout.isTTY;
+
+// Warn and crash if required files are missing
+if (!checkRequiredFiles([paths.appHtml, paths.appIndexJs])) {
+    process.exit(1);
+}
+
+// Process CLI arguments
+const argv = process.argv.slice(2);
+const writeStatsJson = argv.indexOf('--stats') !== -1;
+
+// Generate configuration
+const config = configFactory('production');
+
+// We require that you explicitly set browsers and do not fall back to
+// browserslist defaults.
+const {checkBrowsers} = require('react-dev-utils/browsersHelper');
+checkBrowsers(paths.appPath, isInteractive)
+    .then(() => {
+        // First, read the current file sizes in build directory.
+        // This lets us display how much they changed later.
+        return 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);
+        // Merge with the public folder
+        copyPublicFolder();
+        // Start the webpack build
+        return build(previousFileSizes);
+    })
+    .then(
+        ({stats, previousFileSizes, warnings}) => {
+            if (warnings.length) {
+                console.log(chalk.yellow('Compiled with warnings.\n'));
+                console.log(warnings.join('\n\n'));
+                console.log(
+                    '\nSearch for the ' +
+                    chalk.underline(chalk.yellow('keywords')) +
+                    ' to learn more about each warning.'
+                );
+                console.log(
+                    'To ignore, add ' +
+                    chalk.cyan('// eslint-disable-next-line') +
+                    ' to the line before.\n'
+                );
+            } 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
+            );
+            console.log();
+
+            const appPackage = require(paths.appPackageJson);
+            const publicUrl = paths.publicUrl;
+            const publicPath = config.output.publicPath;
+            const buildFolder = path.relative(process.cwd(), paths.appBuild);
+            printHostingInstructions(
+                appPackage,
+                publicUrl,
+                publicPath,
+                buildFolder,
+                useYarn
+            );
+        },
+        err => {
+            console.log(chalk.red('Failed to compile.\n'));
+            printBuildError(err);
+            process.exit(1);
+        }
+    )
+    .catch(err => {
+        if (err && err.message) {
+            console.log(err.message);
+        }
+        process.exit(1);
+    });
+
+// Create the production build and print the deployment instructions.
+function build(previousFileSizes) {
+    console.log('Creating an optimized production build...');
+
+    let compiler = webpack(config);
+    return new Promise((resolve, reject) => {
+        compiler.run((err, stats) => {
+            let messages;
+            if (err) {
+                if (!err.message) {
+                    return reject(err);
+                }
+                messages = formatWebpackMessages({
+                    errors: [err.message],
+                    warnings: [],
+                });
+            } else {
+                messages = formatWebpackMessages(
+                    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.join('\n\n')));
+            }
+            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,
+            };
+            if (writeStatsJson) {
+                return bfj
+                    .write(paths.appBuild + '/bundle-stats.json', stats.toJson())
+                    .then(() => resolve(resolveArgs))
+                    .catch(error => reject(new Error(error)));
+            }
+
+            return resolve(resolveArgs);
+        });
+    });
+}
+
+function copyPublicFolder() {
+    fs.copySync(paths.appPublic, paths.appBuild, {
+        dereference: true,
+        filter: file => file !== paths.appHtml,
+    });
+}

dynselect/scripts/start.js

+'use strict';
+
+// Do this as the first thing so that any code reading it knows the right env.
+process.env.BABEL_ENV = 'development';
+process.env.NODE_ENV = 'development';
+
+// 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 => {
+    throw err;
+});
+
+// Ensure environment variables are read.
+require('../config/env');
+
+
+const fs = require('fs');
+const chalk = require('chalk');
+const webpack = require('webpack');
+const WebpackDevServer = require('webpack-dev-server');
+const clearConsole = require('react-dev-utils/clearConsole');
+const checkRequiredFiles = require('react-dev-utils/checkRequiredFiles');
+const {
+    choosePort,
+    createCompiler,
+    prepareProxy,
+    prepareUrls,
+} = require('react-dev-utils/WebpackDevServerUtils');
+const openBrowser = require('react-dev-utils/openBrowser');
+const paths = require('../config/paths');
+const configFactory = require('../config/webpack.config');
+const createDevServerConfig = require('../config/webpackDevServer.config');
+
+const useYarn = fs.existsSync(paths.yarnLockFile);
+const isInteractive = process.stdout.isTTY;
+
+// Warn and crash if required files are missing
+if (!checkRequiredFiles([paths.appHtml, paths.appIndexJs])) {
+    process.exit(1);
+}
+
+// Tools like Cloud9 rely on this.
+const DEFAULT_PORT = parseInt(process.env.PORT, 10) || 3000;
+const HOST = process.env.HOST || '0.0.0.0';
+
+if (process.env.HOST) {
+    console.log(
+        chalk.cyan(
+            `Attempting to bind to HOST environment variable: ${chalk.yellow(
+                chalk.bold(process.env.HOST)
+            )}`
+        )
+    );
+    console.log(
+        `If this was unintentional, check that you haven't mistakenly set it in your shell.`
+    );
+    console.log(
+        `Learn more here: ${chalk.yellow('http://bit.ly/CRA-advanced-config')}`
+    );
+    console.log();
+}
+
+// We require that you explictly set browsers and do not fall back to
+// browserslist defaults.
+const {checkBrowsers} = require('react-dev-utils/browsersHelper');
+checkBrowsers(paths.appPath, isInteractive)
+    .then(() => {
+        // We attempt to use the default port but if it is busy, we offer the user to
+        // run on a different port. `choosePort()` Promise resolves to the next free port.
+        return choosePort(HOST, DEFAULT_PORT);
+    })
+    .then(port => {
+        if (port == null) {
+            // We have not found a port.
+            return;
+        }
+        const config = configFactory('development');
+        const protocol = process.env.HTTPS === 'true' ? 'https' : 'http';
+        const appName = require(paths.appPackageJson).name;
+        const urls = prepareUrls(protocol, HOST, port);
+        // Create a webpack compiler that is configured with custom messages.
+        const compiler = createCompiler(webpack, config, appName, urls, useYarn);
+        // Load proxy config
+        const proxySetting = require(paths.appPackageJson).proxy;
+        const proxyConfig = prepareProxy(proxySetting, paths.appPublic);
+        // Serve webpack assets generated by the compiler over a web server.
+        const serverConfig = createDevServerConfig(
+            proxyConfig,
+            urls.lanUrlForConfig
+        );
+        const devServer = new WebpackDevServer(compiler, serverConfig);
+        // Launch WebpackDevServer.
+        devServer.listen(port, HOST, err => {
+            if (err) {
+                return console.log(err);
+            }
+            if (isInteractive) {
+                clearConsole();
+            }
+            console.log(chalk.cyan('Starting the development server...\n'));
+            openBrowser(urls.localUrlForBrowser);
+        });
+
+        ['SIGINT', 'SIGTERM'].forEach(function (sig) {
+            process.on(sig, function () {
+                devServer.close();
+                process.exit();
+            });
+        });
+    })
+    .catch(err => {
+        if (err && err.message) {
+            console.log(err.message);
+        }
+        process.exit(1);
+    });

dynselect/scripts/test.js

+'use strict';
+
+// Do this as the first thing so that any code reading it knows the right env.
+process.env.BABEL_ENV = 'test';
+process.env.NODE_ENV = 'test';
+process.env.PUBLIC_URL = '';
+
+// 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 => {
+    throw err;
+});
+
+// Ensure environment variables are read.
+require('../config/env');
+
+
+const jest = require('jest');
+const execSync = require('child_process').execSync;
+let argv = process.argv.slice(2);
+
+function isInGitRepository() {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', {stdio: 'ignore'});
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+function isInMercurialRepository() {
+    try {
+        execSync('hg --cwd . root', {stdio: 'ignore'});
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+// Watch unless on CI, in coverage mode, or explicitly running all tests
+if (
+    !process.env.CI &&
+    argv.indexOf('--coverage') === -1 &&
+    argv.indexOf('--watchAll') === -1
+) {
+    // https://github.com/facebook/create-react-app/issues/5210
+    const hasSourceControl = isInGitRepository() || isInMercurialRepository();
+    argv.push(hasSourceControl ? '--watch' : '--watchAll');
+}
+
+
+jest.run(argv);

dynselect/src/App.js

 import React, {Component} from 'react';
-import './App.css';
 import "materialize-css/dist/css/materialize.css";
 
 import M from "materialize-css/dist/js/materialize";

dynselect/src/index.js

 import React from 'react';
 import ReactDOM from 'react-dom';
-import './index.css';
 import App from './App';
 
 ReactDOM.render(<App />, document.getElementById('root'));