@shuvi/service 1.0.0-rc.9 → 1.0.0

package/lib/bundler/bundler.d.ts

@@ -17,6 +17,7 @@ export interface NormalizedBundlerOptions {
 }
 export declare type BundlerOptions = Partial<NormalizedBundlerOptions>;
 export interface Bunlder {
+    targets: Target[];
     watching: Watching;
     watch(): Watching;
     build(): Promise<BundlerResult>;

package/lib/bundler/bundler.js

@@ -42,7 +42,7 @@ const forkTsCheckerWebpackPlugin_1 = __importStar(require("@shuvi/toolpack/lib/u
 const formatWebpackMessages_1 = __importDefault(require("@shuvi/toolpack/lib/utils/formatWebpackMessages"));
 const logger_1 = __importDefault(require("@shuvi/utils/lib/logger"));
 const util_1 = require("util");
-const webpack_1 = __importStar(require("@shuvi/toolpack/lib/webpack"));
+const webpack_1 = require("@shuvi/toolpack/lib/webpack");
 const config_1 = require("@shuvi/toolpack/lib/webpack/config");
 const constants_1 = require("@shuvi/shared/lib/constants");
 const error_1 = require("../error");
@@ -55,7 +55,6 @@ const defaultBundleOptions = {
     preBundle: false,
     ignoreTypeScriptErrors: false
 };
-const logger = (0, logger_1.default)('shuvi:bundler');
 const hasEntry = (chain) => chain.entryPoints.values().length > 0;
 class WebpackBundler {
     constructor(options, cliContext) {
@@ -66,6 +65,8 @@ class WebpackBundler {
         this._watching = new watchingProxy_1.WatchingProxy();
         this._devMiddlewares = [];
         this._inited = false;
+        this._startTime = null;
+        this._isCompiling = false;
         this._options = options;
         this._cliContext = cliContext;
     }
@@ -81,7 +82,7 @@ class WebpackBundler {
                     rootDir: this._cliContext.paths.rootDir,
                     exclude: [/react-refresh/],
                     resolveWebpackModule(module) {
-                        return require(`${webpack_1.webpackResolveContext}/${module}`);
+                        return (0, webpack_1.resolveWebpackModule)(module);
                     }
                 });
                 this._devMiddlewares.push(dynamicDll.middleware);
@@ -113,7 +114,7 @@ class WebpackBundler {
             return this._watching;
         }
         this._targets.forEach(({ name }) => {
-            if (name === constants_1.BUNDLER_DEFAULT_TARGET) {
+            if (name === constants_1.BUNDLER_TARGET_CLIENT) {
                 this._setupListenersForTarget(name, {
                     typeChecking: true
                 });
@@ -134,7 +135,7 @@ class WebpackBundler {
         return __awaiter(this, void 0, void 0, function* () {
             const compiler = this._compiler;
             if (this._options.ignoreTypeScriptErrors) {
-                console.log('Skipping validation of types');
+                logger_1.default.info('Skipping validation of types');
                 this._compiler.compilers.forEach(compiler => {
                     forkTsCheckerWebpackPlugin_1.default.getCompilerHooks(compiler).issues.tap('afterTypeScriptCheck', (issues) => issues.filter(msg => msg.severity !== 'error'));
                 });
@@ -147,12 +148,15 @@ class WebpackBundler {
             return yield this._getTargets();
         });
     }
+    get targets() {
+        return this._targets;
+    }
     _getWebpackCompiler(dynamicDll) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._compiler) {
                 this._targets = yield this._getTargets();
                 if (dynamicDll) {
-                    this._compiler = (0, webpack_1.default)(this._targets.map(({ config }) => {
+                    this._compiler = (0, webpack_1.webpack)(this._targets.map(({ config }) => {
                         if (config.target === 'node') {
                             return config;
                         }
@@ -160,12 +164,22 @@ class WebpackBundler {
                     }));
                 }
                 else {
-                    this._compiler = (0, webpack_1.default)(this._targets.map(t => t.config));
+                    this._compiler = (0, webpack_1.webpack)(this._targets.map(t => t.config));
                 }
                 let isFirstSuccessfulCompile = true;
                 this._compiler.hooks.done.tap('done', (stats) => __awaiter(this, void 0, void 0, function* () {
                     const warnings = [];
                     const errors = [];
+                    this._isCompiling = false;
+                    let timeMessage = '';
+                    if (this._startTime) {
+                        const time = performance.now() - this._startTime;
+                        this._startTime = 0;
+                        timeMessage =
+                            time > 2000
+                                ? ` in ${Math.round(time / 100) / 10}s`
+                                : ` in ${Math.ceil(time)} ms`;
+                    }
                     stats.stats.forEach(s => {
                         const statsData = s.toJson({
                             all: false,
@@ -177,13 +191,24 @@ class WebpackBundler {
                     });
                     const isSuccessful = !warnings.length && !errors.length;
                     if (isSuccessful) {
+                        if (!isFirstSuccessfulCompile) {
+                            logger_1.default.info(`Compiled client and server successfully${timeMessage}`);
+                        }
                         setImmediate(first => {
                             // make sure this event is fired after all bundler:target-done
                             this._cliContext.pluginRunner.afterBundlerDone({ first, stats });
                         }, isFirstSuccessfulCompile);
                         isFirstSuccessfulCompile = false;
                     }
+                    //reset the startTime
+                    this._startTime = null;
                 }));
+                this._compiler.hooks.invalid.tap('invalid', () => {
+                    if (!this._isCompiling) {
+                        this._isCompiling = true;
+                        logger_1.default.info('Compiling client and server...');
+                    }
+                });
             }
             return this._compiler;
         });
@@ -204,13 +229,11 @@ class WebpackBundler {
         let tsMessagesPromise;
         let tsMessagesResolver;
         let isInvalid = true;
-        const _log = (...args) => console.log(`[${name}]`, ...args);
-        const _error = (...args) => console.error(`[${name}]`, ...args);
-        const _warn = (...args) => console.warn(`[${name}]`, ...args);
+        const _error = (...args) => logger_1.default.error(`[${name}]`, ...args);
+        const _warn = (...args) => logger_1.default.warn(`[${name}]`, ...args);
         compiler.hooks.invalid.tap(`invalid`, () => {
             tsMessagesPromise = undefined;
             isInvalid = true;
-            _log('Compiling...');
         });
         const useTypeScript = !!((_a = compiler.options.plugins) === null || _a === void 0 ? void 0 : _a.find(plugin => plugin instanceof forkTsCheckerWebpackPlugin_1.default));
         if (options.typeChecking && useTypeScript) {
@@ -238,6 +261,11 @@ class WebpackBundler {
                 return issues;
             });
         }
+        compiler.hooks.beforeCompile.tap('beforeCompile', () => {
+            if (this._startTime === null) {
+                this._startTime = performance.now();
+            }
+        });
         // "done" event fires when Webpack has finished recompiling the bundle.
         // Whether or not you have warnings or errors, you will get this event.
         compiler.hooks.done.tap('done', (stats) => __awaiter(this, void 0, void 0, function* () {
@@ -261,7 +289,6 @@ class WebpackBundler {
             const messages = (0, formatWebpackMessages_1.default)(statsData);
             const isSuccessful = !((_b = messages.errors) === null || _b === void 0 ? void 0 : _b.length) && !((_c = messages.warnings) === null || _c === void 0 ? void 0 : _c.length);
             if (isSuccessful) {
-                _log('Compiled successfully!');
                 yield this._cliContext.pluginRunner.afterBundlerTargetDone({
                     first: isFirstSuccessfulCompile,
                     name: compiler.name,
@@ -313,16 +340,16 @@ class WebpackBundler {
     _initDefaultBuildTarget() {
         const defaultWebpackHelpers = (0, config_1.webpackHelpers)();
         const defaultChain = (0, config_2.createWebpackConfig)(this._cliContext, {
-            name: constants_1.BUNDLER_DEFAULT_TARGET,
+            name: constants_1.BUNDLER_TARGET_CLIENT,
             node: false,
             entry: {},
-            outputDir: constants_2.BUILD_DEFAULT_DIR,
+            outputDir: constants_2.CLIENT_OUTPUT_DIR,
             webpackHelpers: defaultWebpackHelpers
         });
         return [
             {
                 chain: defaultChain,
-                name: constants_1.BUNDLER_DEFAULT_TARGET
+                name: constants_1.BUNDLER_TARGET_CLIENT
             }
         ];
     }
@@ -336,7 +363,7 @@ class WebpackBundler {
             const extraTargets = (yield this._cliContext.pluginRunner.addExtraTarget({
                 createConfig: this._createConfig.bind(this),
                 mode: this._cliContext.mode,
-                webpack: webpack_1.default
+                webpack: webpack_1.webpack
             })).filter(Boolean);
             buildTargets.push(...extraTargets);
             for (const buildTarget of buildTargets) {
@@ -346,18 +373,15 @@ class WebpackBundler {
                     name,
                     mode: this._cliContext.mode,
                     helpers: defaultWebpackHelpers,
-                    webpack: webpack_1.default,
+                    webpack: webpack_1.webpack,
                     resolveWebpackModule(path) {
-                        if (!path.startsWith('webpack/')) {
-                            console.error('path need startWith "webpack/" to resolve webpack module');
-                        }
-                        return require(`${webpack_1.webpackResolveContext}${path}`);
+                        return (0, webpack_1.resolveWebpackModule)(path);
                     }
                 });
                 if (hasEntry(chain)) {
                     const chainConfig = chain.toConfig();
-                    logger.debug(`${name} Config`);
-                    logger.debug((0, util_1.inspect)((_a = chainConfig.resolve) === null || _a === void 0 ? void 0 : _a.alias, { depth: 10 }));
+                    logger_1.default.debug(`${name} Config`);
+                    logger_1.default.debug((0, util_1.inspect)((_a = chainConfig.resolve) === null || _a === void 0 ? void 0 : _a.alias, { depth: 10 }));
                     targets.push({ name, config: chainConfig });
                 }
             }
@@ -368,7 +392,7 @@ class WebpackBundler {
 function getBundler(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield (0, typescript_1.setupTypeScript)(ctx.paths);
+            yield (0, typescript_1.setupTypeScript)(ctx.paths, ctx.mode === 'production');
             const options = Object.assign(Object.assign({}, defaultBundleOptions), { preBundle: ctx.config.experimental.preBundle, ignoreTypeScriptErrors: ctx.config.typescript.ignoreBuildErrors });
             if (ctx.mode !== 'development') {
                 options.preBundle = false;
@@ -379,7 +403,7 @@ function getBundler(ctx) {
         }
         catch (err) {
             if ((0, error_1.isFatalError)(err)) {
-                console.error(err.message);
+                logger_1.default.error(err.message);
                 process.exit(1);
             }
             throw err;

package/lib/bundler/config.js

@@ -14,7 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWebpackConfig = void 0;
 const config_1 = require("@shuvi/toolpack/lib/webpack/config");
 const typescript_1 = require("./typescript");
-const constants_1 = require("../constants");
+const AppSourceRegexp = /([/\\]shuvi-app[/\\])|([/\\]\.shuvi[/\\])/;
 function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
     var { webpackHelpers } = _a, opts = __rest(_a, ["webpackHelpers"]);
     const dev = mode === 'development';
@@ -27,10 +27,15 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
     const cacheDir = paths.cacheDir;
     const publicPath = assetPublicPath;
     const env = config.env;
-    const include = [paths.appDir, paths.srcDir, ...(opts.include || [])];
-    const parcelCss = !!config.experimental.parcelCss;
+    const include = [
+        paths.srcDir,
+        paths.appDir,
+        AppSourceRegexp,
+        ...(opts.include || [])
+    ];
+    const lightningCss = !!config.experimental.lightningCss;
     const experimental = config.experimental;
-    const compiler = config.compiler;
+    const compiler = Object.assign(Object.assign({}, config.compiler), { modularizeImports: experimental.modularizeImports, swcPlugins: experimental.swcPlugins });
     const typescript = (0, typescript_1.getTypeScriptInfo)();
     if (opts.node) {
         chain = (0, config_1.createNodeWebpackChain)({
@@ -40,14 +45,12 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
             outputDir,
             cacheDir,
             publicPath,
-            parcelCss,
-            experimental,
+            lightningCss,
             compiler,
             typescript,
             include,
             env,
-            webpackHelpers,
-            buildManifestFilename: constants_1.SERVER_BUILD_MANIFEST_PATH
+            webpackHelpers
         });
     }
     else {
@@ -58,17 +61,14 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
             outputDir,
             cacheDir,
             publicPath,
-            parcelCss,
-            experimental,
+            lightningCss,
             compiler,
             typescript,
             include,
             env,
             webpackHelpers,
-            analyze: config.analyze,
-            buildManifestFilename: constants_1.CLIENT_BUILD_MANIFEST_PATH
+            analyze: config.analyze
         });
-        chain.optimization.runtimeChunk({ name: constants_1.BUILD_CLIENT_RUNTIME_WEBPACK });
     }
     chain.name(opts.name);
     chain.merge({
@@ -76,7 +76,7 @@ function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
     });
     chain.resolve.alias.set('@shuvi/app', paths.appDir);
     chain.resolve.alias.set('@shuvi/runtime', paths.runtimeDir);
-    chain.resolve.alias.set('@shuvi/user', paths.srcDir);
+    chain.resolve.alias.set('@', paths.srcDir);
     return chain;
 }
 exports.createWebpackConfig = createWebpackConfig;

package/lib/bundler/helper/getOnline.d.ts

@@ -0,0 +1 @@
+export declare function getOnline(): Promise<boolean>;

package/lib/bundler/helper/getOnline.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOnline = void 0;
+const child_process_1 = require("child_process");
+const dns_1 = __importDefault(require("dns"));
+const url_1 = __importDefault(require("url"));
+function getProxy() {
+    if (process.env.https_proxy) {
+        return process.env.https_proxy;
+    }
+    try {
+        const httpsProxy = (0, child_process_1.execSync)('npm config get https-proxy').toString().trim();
+        return httpsProxy !== 'null' ? httpsProxy : undefined;
+    }
+    catch (e) {
+        return;
+    }
+}
+function getOnline() {
+    return new Promise(resolve => {
+        dns_1.default.lookup('registry.yarnpkg.com', registryErr => {
+            if (!registryErr) {
+                return resolve(true);
+            }
+            const proxy = getProxy();
+            if (!proxy) {
+                return resolve(false);
+            }
+            const { hostname } = url_1.default.parse(proxy);
+            if (!hostname) {
+                return resolve(false);
+            }
+            dns_1.default.lookup(hostname, proxyErr => {
+                resolve(proxyErr == null);
+            });
+        });
+    });
+}
+exports.getOnline = getOnline;

package/lib/bundler/runCompiler.d.ts

@@ -1,5 +1,5 @@
 import { Compiler, MultiCompiler } from '@shuvi/toolpack/lib/webpack';
-import type webpack from '@shuvi/toolpack/lib/webpack';
+import type { webpack } from '@shuvi/toolpack/lib/webpack';
 export declare type BundlerResult = {
     errors: webpack.StatsError[];
     warnings: webpack.StatsError[];

package/lib/bundler/typescript/getTypeScriptInfo.d.ts

@@ -8,6 +8,6 @@ export declare type CheckedDependenciesResult = {
     missing: PackageDep[];
 };
 export declare function hasTypescriptFiles(projectDir: string): Promise<boolean>;
-export declare function checkNecessarytDeps(projectDir: string): CheckedDependenciesResult;
+export declare function checkNecessaryDeps(projectDir: string): CheckedDependenciesResult;
 export declare function hasTsConfig(tsConfigPath: string): Promise<boolean>;
 export declare function getTsConfig(ts: TypeScriptModule, tsConfigPath: string): Promise<TsConfig>;

package/lib/bundler/typescript/getTypeScriptInfo.js

@@ -12,11 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTsConfig = exports.hasTsConfig = exports.checkNecessarytDeps = exports.hasTypescriptFiles = void 0;
+exports.getTsConfig = exports.hasTsConfig = exports.checkNecessaryDeps = exports.hasTypescriptFiles = void 0;
 const fs_extra_1 = require("fs-extra");
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("@shuvi/utils/lib/chalk"));
+const logger_1 = __importDefault(require("@shuvi/utils/lib/logger"));
 const resolve_1 = require("@shuvi/utils/lib/resolve");
 const recursiveReaddir_1 = require("@shuvi/utils/lib/recursiveReaddir");
 const requiredPackages = [
@@ -29,7 +30,7 @@ function checkDependencies(dir, deps) {
     let resolutions = new Map();
     const missingPackages = deps.filter(p => {
         try {
-            resolutions.set(p.pkg, (0, resolve_1.resolve)(p.file, { basedir: `${dir}/` }));
+            resolutions.set(p.pkg, (0, resolve_1.resolve)(p.file, { basedir: dir }));
             return false;
         }
         catch (_) {
@@ -60,10 +61,10 @@ function hasTypescriptFiles(projectDir) {
     });
 }
 exports.hasTypescriptFiles = hasTypescriptFiles;
-function checkNecessarytDeps(projectDir) {
+function checkNecessaryDeps(projectDir) {
     return checkDependencies(projectDir, requiredPackages);
 }
-exports.checkNecessarytDeps = checkNecessarytDeps;
+exports.checkNecessaryDeps = checkNecessaryDeps;
 function hasTsConfig(tsConfigPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const hasTsConfig = yield (0, fs_extra_1.pathExists)(tsConfigPath);
@@ -106,7 +107,7 @@ function getTsConfig(ts, tsConfigPath) {
         }
         catch (err) {
             if (err && err.name === 'SyntaxError') {
-                console.error(chalk_1.default.red.bold('Could not parse', chalk_1.default.cyan('tsconfig.json') + '.', 'Please make sure it contains syntactically correct JSON.'));
+                logger_1.default.error('Could not parse', chalk_1.default.cyan('tsconfig.json') + '.', 'Please make sure it contains syntactically correct JSON.');
             }
             console.info((err === null || err === void 0 ? void 0 : err.message) ? `${err.message}` : '');
             throw err;

package/lib/bundler/typescript/installDependencies.d.ts

@@ -0,0 +1,26 @@
+import { PackageManager } from '../helper/getPkgManager';
+interface InstallArgs {
+    /**
+     * Indicate whether to install packages using npm, pnpm or Yarn.
+     */
+    packageManager: PackageManager;
+    /**
+     * Indicate whether there is an active Internet connection.
+     */
+    isOnline: boolean;
+    /**
+     * Indicate whether the given dependencies are devDependencies.
+     */
+    devDependencies?: boolean;
+}
+export declare type Dependencies = {
+    resolved: Map<string, string>;
+};
+/**
+ * Spawn a package manager installation with either Yarn or NPM.
+ *
+ * @returns A Promise that resolves once the installation is finished.
+ */
+export declare function install(root: string, dependencies: string[] | null, { packageManager, isOnline, devDependencies }: InstallArgs): Promise<void>;
+export declare function installDependencies(baseDir: string, deps: any, dev?: boolean): Promise<void>;
+export {};

package/lib/bundler/typescript/installDependencies.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDependencies = exports.install = void 0;
+const chalk_1 = __importDefault(require("@shuvi/utils/lib/chalk"));
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const path = __importStar(require("path"));
+const getPkgManager_1 = require("../helper/getPkgManager");
+const getOnline_1 = require("../helper/getOnline");
+/**
+ * Spawn a package manager installation with either Yarn or NPM.
+ *
+ * @returns A Promise that resolves once the installation is finished.
+ */
+function install(root, dependencies, { packageManager, isOnline, devDependencies }) {
+    /**
+     * (p)npm-specific command-line flags.
+     */
+    const npmFlags = [];
+    /**
+     * Yarn-specific command-line flags.
+     */
+    const yarnFlags = [];
+    /**
+     * Return a Promise that resolves once the installation is finished.
+     */
+    return new Promise((resolve, reject) => {
+        let args;
+        let command = packageManager;
+        const useYarn = packageManager === 'yarn';
+        if (dependencies && dependencies.length) {
+            /**
+             * If there are dependencies, run a variation of `{packageManager} add`.
+             */
+            if (useYarn) {
+                /**
+                 * Call `yarn add --exact (--offline)? (-D)? ...`.
+                 */
+                args = ['add', '--exact'];
+                if (!isOnline)
+                    args.push('--offline');
+                args.push('--cwd', root);
+                if (devDependencies)
+                    args.push('--dev');
+                args.push(...dependencies);
+            }
+            else {
+                /**
+                 * Call `(p)npm install [--save|--save-dev] ...`.
+                 */
+                args = ['install', '--save-exact'];
+                args.push(devDependencies ? '--save-dev' : '--save');
+                args.push(...dependencies);
+            }
+        }
+        else {
+            /**
+             * If there are no dependencies, run a variation of `{packageManager}
+             * install`.
+             */
+            args = ['install'];
+            if (!isOnline) {
+                console.log(chalk_1.default.yellow('You appear to be offline.'));
+                if (useYarn) {
+                    console.log(chalk_1.default.yellow('Falling back to the local Yarn cache.'));
+                    console.log();
+                    args.push('--offline');
+                }
+                else {
+                    console.log();
+                }
+            }
+        }
+        /**
+         * Add any package manager-specific flags.
+         */
+        if (useYarn) {
+            args.push(...yarnFlags);
+        }
+        else {
+            args.push(...npmFlags);
+        }
+        /**
+         * Spawn the installation process.
+         */
+        const child = (0, cross_spawn_1.default)(command, args, {
+            stdio: 'inherit',
+            env: Object.assign(Object.assign({}, process.env), { ADBLOCK: '1', 
+                // we set NODE_ENV to development as pnpm skips dev
+                // dependencies when production
+                NODE_ENV: 'development', DISABLE_OPENCOLLECTIVE: '1' })
+        });
+        child.on('close', code => {
+            if (code !== 0) {
+                reject({ command: `${command} ${args.join(' ')}` });
+                return;
+            }
+            resolve();
+        });
+    });
+}
+exports.install = install;
+function installDependencies(baseDir, deps, dev = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageManager = (0, getPkgManager_1.getPkgManager)(baseDir);
+        const isOnline = yield (0, getOnline_1.getOnline)();
+        if (deps.length) {
+            console.log();
+            console.log(`Installing ${dev ? 'devDependencies' : 'dependencies'} (${packageManager}):`);
+            for (const dep of deps) {
+                console.log(`- ${chalk_1.default.cyan(dep.pkg)}`);
+            }
+            console.log();
+            yield install(path.resolve(baseDir), deps.map((dep) => dep.pkg), { devDependencies: dev, isOnline, packageManager });
+            console.log();
+        }
+    });
+}
+exports.installDependencies = installDependencies;

package/lib/bundler/typescript/setupTypeScript.d.ts

@@ -8,5 +8,5 @@ interface TypeScriptInfo {
     resolvedBaseUrl?: string;
 }
 export declare function getTypeScriptInfo(): TypeScriptInfo;
-export declare function setupTypeScript(paths: IPaths): Promise<void>;
+export declare function setupTypeScript(paths: IPaths, reportMissingError?: Boolean): Promise<void>;
 export {};

package/lib/bundler/typescript/setupTypeScript.js

@@ -43,6 +43,7 @@ const error_1 = require("../../error");
 const getPkgManager_1 = require("../helper/getPkgManager");
 const configTypeScript_1 = require("./configTypeScript");
 const getTypeScriptInfo_1 = require("./getTypeScriptInfo");
+const installDependencies_1 = require("./installDependencies");
 let hasSetup = false;
 let useTypeScript;
 let typeScriptPath;
@@ -64,7 +65,7 @@ function missingPackagesError(dir, pkgs) {
     const removalMsg = '\n\n' +
         chalk_1.default.bold('If you are not trying to use TypeScript, please remove the ' +
             chalk_1.default.cyan('tsconfig.json') +
-            ' file from your package root (and any TypeScript files in your pages directory).');
+            ' file from your package root (and any TypeScript files in your routes directory).');
     throw error_1.Error.Fatal(chalk_1.default.bold.red(`It looks like you're trying to use TypeScript but do not have the required package(s) installed.`) +
         '\n\n' +
         chalk_1.default.bold(`Please install ${chalk_1.default.bold(packagesHuman)} by running:`) +
@@ -92,7 +93,7 @@ function getTypeScriptInfo() {
     };
 }
 exports.getTypeScriptInfo = getTypeScriptInfo;
-function setupTypeScript(paths) {
+function setupTypeScript(paths, reportMissingError = false) {
     return __awaiter(this, void 0, void 0, function* () {
         if (hasSetup) {
             return;
@@ -102,9 +103,28 @@ function setupTypeScript(paths) {
         useTypeScript = yield (0, getTypeScriptInfo_1.hasTypescriptFiles)(paths.srcDir);
         tsCompilerOptions = {};
         if (useTypeScript) {
-            const deps = (0, getTypeScriptInfo_1.checkNecessarytDeps)(projectDir);
+            let deps = (0, getTypeScriptInfo_1.checkNecessaryDeps)(projectDir);
             if (deps.missing.length > 0) {
-                missingPackagesError(projectDir, deps.missing);
+                if (reportMissingError) {
+                    missingPackagesError(projectDir, deps.missing);
+                }
+                console.log(chalk_1.default.bold.yellow(`It looks like you're trying to use TypeScript but do not have the required package(s) installed.`) +
+                    '\n' +
+                    'Installing dependencies' +
+                    '\n\n' +
+                    chalk_1.default.bold('If you are not trying to use TypeScript, please remove the ' +
+                        chalk_1.default.cyan('tsconfig.json') +
+                        ' file from your package root (and any TypeScript files in your pages directory).') +
+                    '\n');
+                yield (0, installDependencies_1.installDependencies)(paths.srcDir, deps.missing, true).catch(err => {
+                    if (err && typeof err === 'object' && 'command' in err) {
+                        console.error(`Failed to install required TypeScript dependencies, please install them manually to continue:\n` +
+                            err.command +
+                            '\n');
+                    }
+                    throw err;
+                });
+                deps = (0, getTypeScriptInfo_1.checkNecessaryDeps)(projectDir);
             }
             typeScriptPath = deps.resovled.get('typescript');
             tsConfigPath = path.join(projectDir, 'tsconfig.json');
@@ -114,8 +134,7 @@ function setupTypeScript(paths) {
                 console.log();
                 yield fs_extra_1.default.writeJson(tsConfigPath, {});
             }
-            // @ts-ignore
-            const { default: ts } = (yield import(typeScriptPath));
+            const ts = require(typeScriptPath);
             const tsConfig = yield (0, getTypeScriptInfo_1.getTsConfig)(ts, tsConfigPath);
             tsCompilerOptions = tsConfig.options;
             yield (0, configTypeScript_1.writeDefaultConfigurations)(ts, tsConfigPath, tsConfig, paths, needDefaultTsConfig);