eddev 0.1.50 → 0.2.0-beta.10

package/build/serverless/create-next-app.js

@@ -0,0 +1,434 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNextApp = void 0;
+var path_1 = require("path");
+var fs_extra_1 = require("fs-extra");
+var glob_promise_1 = __importDefault(require("glob-promise"));
+var child_process_1 = require("child_process");
+var fs_1 = require("fs");
+var manifest_blocks_1 = require("../manifests/manifest-blocks");
+var promises_1 = require("fs/promises");
+var manifest_views_1 = require("../manifests/manifest-views");
+var getRepoName_1 = require("../../utils/getRepoName");
+function requireConfig(dir) {
+    var configPath = (0, path_1.resolve)(dir, "ed.config.json");
+    return require(configPath);
+}
+function createNextApp(opts) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var isVercel, serverlessDirectory, sendSignal, repoName, port;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    isVercel = process.env.VERCEL;
+                    serverlessDirectory = isVercel ? opts.baseDirectory : (0, path_1.resolve)(opts.baseDirectory, ".serverless");
+                    sendSignal = opts.sendSignal || (function () { });
+                    sendSignal({ code: "preparing" });
+                    repoName = (0, getRepoName_1.getRepoName)(opts.baseDirectory);
+                    if (!!isVercel) return [3 /*break*/, 2];
+                    return [4 /*yield*/, clean(serverlessDirectory)];
+                case 1:
+                    _b.sent();
+                    _b.label = 2;
+                case 2: 
+                // Copy the template folder
+                return [4 /*yield*/, copyTemplate(serverlessDirectory)
+                    // Update package.json
+                ];
+                case 3:
+                    // Copy the template folder
+                    _b.sent();
+                    if (!!isVercel) return [3 /*break*/, 5];
+                    return [4 /*yield*/, updatePackagesFile(opts.baseDirectory, serverlessDirectory)];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5:
+                    if (!!isVercel) return [3 /*break*/, 9];
+                    // Sync important files during development, as they change
+                    return [4 /*yield*/, syncFiles(opts.baseDirectory, serverlessDirectory, __spreadArray([
+                            "blocks/**/*",
+                            "components/**/*",
+                            "hooks/**/*",
+                            "queries/**/*",
+                            ".env",
+                            "views/**/*",
+                            "theme.css.tsx",
+                            "types.graphql.ts",
+                            "types.views.ts",
+                            "types.blocks.ts",
+                            "utils/**/*",
+                            "ed.config.json"
+                        ], (((_a = requireConfig(opts.baseDirectory).serverless) === null || _a === void 0 ? void 0 : _a.devAssets) || []), true))
+                        // Also sync APIs into the APIs folder
+                    ];
+                case 6:
+                    // Sync important files during development, as they change
+                    _b.sent();
+                    // Also sync APIs into the APIs folder
+                    return [4 /*yield*/, syncFiles(opts.baseDirectory, (0, path_1.join)(serverlessDirectory, "pages/"), ["api/**/*"])
+                        // And public folder
+                    ];
+                case 7:
+                    // Also sync APIs into the APIs folder
+                    _b.sent();
+                    // And public folder
+                    return [4 /*yield*/, syncFiles((0, path_1.join)(opts.baseDirectory, "assets"), (0, path_1.join)(serverlessDirectory, "public/wp-content/themes/".concat(repoName.repoName, "/assets")), ["**/*"])];
+                case 8:
+                    // And public folder
+                    _b.sent();
+                    _b.label = 9;
+                case 9:
+                    if (!!isVercel) return [3 /*break*/, 11];
+                    sendSignal({ code: "packaging" });
+                    return [4 /*yield*/, updatePackages(serverlessDirectory)];
+                case 10:
+                    _b.sent();
+                    _b.label = 11;
+                case 11:
+                    sendSignal({ code: "compiling" });
+                    // Create manifests
+                    initManifests(serverlessDirectory, opts.dev);
+                    if (!opts.dev) return [3 /*break*/, 14];
+                    return [4 /*yield*/, getPort(3000)];
+                case 12:
+                    port = _b.sent();
+                    sendSignal({ code: "url", url: "http://127.0.0.1:".concat(port) });
+                    return [4 /*yield*/, devNext(serverlessDirectory, port)
+                        // await runScript(serverlessDirectory, "dev")
+                    ];
+                case 13:
+                    _b.sent();
+                    return [3 /*break*/, 16];
+                case 14:
+                    if (!opts.build) return [3 /*break*/, 16];
+                    return [4 /*yield*/, runScript(serverlessDirectory, "build")];
+                case 15:
+                    _b.sent();
+                    _b.label = 16;
+                case 16: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.createNextApp = createNextApp;
+function clean(path) {
+    return __awaiter(this, void 0, void 0, function () {
+        var whitelist, files;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(0, fs_1.existsSync)(path))
+                        return [2 /*return*/];
+                    whitelist = ["node_modules", "package.json", "yarn.lock"];
+                    return [4 /*yield*/, (0, fs_extra_1.readdir)(path)];
+                case 1:
+                    files = (_a.sent()).filter(function (file) {
+                        return !whitelist.includes(file);
+                    });
+                    return [4 /*yield*/, Promise.all(files.map(function (file) { return (0, fs_extra_1.removeSync)((0, path_1.resolve)(path, file)); }))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function copyTemplate(targetFolder) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sourceFolder, files;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sourceFolder = (0, path_1.resolve)(__dirname, "../../serverless-template");
+                    (0, fs_extra_1.mkdirp)(targetFolder);
+                    return [4 /*yield*/, (0, glob_promise_1.default)((0, path_1.resolve)(sourceFolder, "**/*.*"))];
+                case 1:
+                    files = _a.sent();
+                    return [4 /*yield*/, Promise.all(files.map(function (src) {
+                            var dest = src.replace(sourceFolder, targetFolder);
+                            return (0, fs_extra_1.copy)(src, dest);
+                        }))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function updatePackages(dir) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var proc;
+        return __generator(this, function (_c) {
+            proc = (0, child_process_1.spawn)("yarn", [], {
+                cwd: dir,
+            });
+            (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout);
+            (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
+            return [2 /*return*/, new Promise(function (resolve) {
+                    proc.on("close", function () {
+                        resolve(null);
+                    });
+                })];
+        });
+    });
+}
+function updatePackagesFile(sourceFolder, targetFolder) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sourcePackageFile, targetPackageFile, sourcePackage, targetPackage, mergedPackage;
+        return __generator(this, function (_a) {
+            sourcePackageFile = (0, path_1.resolve)(sourceFolder, "package.json");
+            targetPackageFile = (0, path_1.resolve)(targetFolder, "package.json");
+            sourcePackage = require(sourcePackageFile);
+            targetPackage = require(targetPackageFile);
+            mergedPackage = __assign(__assign({}, targetPackage), { dependencies: __assign(__assign({}, (sourcePackage.dependencies || {})), (targetPackage.dependencies || {})), devDependencies: __assign(__assign({}, (sourcePackage.devDependencies || {})), (targetPackage.devDependencies || {})) });
+            (0, fs_extra_1.writeJSON)(targetPackageFile, mergedPackage, {
+                spaces: 2,
+            });
+            return [2 /*return*/];
+        });
+    });
+}
+function syncFiles(sourceFolder, targetFolder, patterns) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (ready) { return __awaiter(_this, void 0, void 0, function () {
+                    var chokidar;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("chokidar")); })];
+                            case 1:
+                                chokidar = (_a.sent()).default;
+                                chokidar
+                                    .watch(patterns, {
+                                    cwd: sourceFolder,
+                                })
+                                    .on("add", function (path) {
+                                    (0, fs_extra_1.copy)((0, path_1.join)(sourceFolder, path), (0, path_1.join)(targetFolder, path));
+                                })
+                                    .on("unlink", function (path) {
+                                    (0, fs_extra_1.remove)((0, path_1.join)(targetFolder, path));
+                                })
+                                    .on("change", function (path) {
+                                    (0, fs_extra_1.copy)((0, path_1.join)(sourceFolder, path), (0, path_1.join)(targetFolder, path));
+                                })
+                                    .on("ready", function () {
+                                    ready(undefined);
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                }); })];
+        });
+    });
+}
+function devNext(dir, port) {
+    return __awaiter(this, void 0, void 0, function () {
+        var createServer, parse, next, app, handle;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("http")); })];
+                case 1:
+                    createServer = (_a.sent()).createServer;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("url")); })];
+                case 2:
+                    parse = (_a.sent()).parse;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("next")); })];
+                case 3:
+                    next = (_a.sent()).default;
+                    app = next({
+                        dev: true,
+                        dir: dir,
+                        minimalMode: true,
+                        customServer: true,
+                        port: port,
+                    });
+                    handle = app.getRequestHandler();
+                    app.prepare().then(function () {
+                        console.log("http://127.0.0.1:".concat(port));
+                        createServer(function (req, res) {
+                            handle(req, res, parse(req.url || "", true));
+                        }).listen(app.port);
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function runScript(dir, script) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var proc;
+        return __generator(this, function (_c) {
+            proc = (0, child_process_1.spawn)("yarn", [script], {
+                cwd: dir,
+            });
+            (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout);
+            (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
+            return [2 /*return*/, new Promise(function (resolve) {
+                    proc.on("close", function () {
+                        resolve(null);
+                    });
+                })];
+        });
+    });
+}
+function initManifests(dir, dev) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.all([
+                        (0, manifest_blocks_1.createBlockManifestGenerator)({
+                            baseDirectory: dir,
+                            isAdmin: false,
+                            isDev: dev,
+                            isServerless: true,
+                            onGenerate: function (manifest) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    (0, promises_1.writeFile)((0, path_1.resolve)(dir, "manifest_blocks.ts"), manifest);
+                                    return [2 /*return*/];
+                                });
+                            }); },
+                            watch: dev,
+                        }),
+                        (0, manifest_views_1.createViewManifestGenerator)({
+                            baseDirectory: dir,
+                            isAdmin: false,
+                            isDev: dev,
+                            isServerless: true,
+                            onGenerate: function (manifest) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    (0, promises_1.writeFile)((0, path_1.resolve)(dir, "manifest_views.ts"), manifest);
+                                    return [2 /*return*/];
+                                });
+                            }); },
+                            watch: dev,
+                        }),
+                    ])];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function getPort(port) {
+    if (port === void 0) { port = 3000; }
+    return __awaiter(this, void 0, void 0, function () {
+        var createServer, p;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require("http")); })];
+                case 1:
+                    createServer = (_a.sent()).createServer;
+                    for (p = port; p < port + 100; p++) { }
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            var server = createServer();
+                            server.listen(port, function () {
+                                server.once("close", function () {
+                                    resolve(port);
+                                });
+                                server.close();
+                            });
+                            server.on("error", function () { return __awaiter(_this, void 0, void 0, function () {
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _a = resolve;
+                                            return [4 /*yield*/, getPort(port + 1)];
+                                        case 1:
+                                            _a.apply(void 0, [_b.sent()]);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                        })];
+                case 2: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}

package/build/state/serverless-state.d.ts

@@ -0,0 +1,26 @@
+export declare type ServerlessStatus = "starting" | "packaging" | "preparing" | "compiling" | "success" | "waiting" | "error";
+export declare type ServerlessState = {
+    title: string;
+    status: ServerlessStatus;
+    statusLabel?: string;
+    duration?: number;
+    log?: string;
+    url?: string;
+};
+export declare type ServerlessSignal = {
+    code: "packaging";
+} | {
+    code: "preparing";
+} | {
+    code: "compiling";
+} | {
+    code: "finished";
+    duration: number;
+} | {
+    code: "error";
+} | {
+    code: "log";
+} | {
+    code: "url";
+    url: string;
+};

package/build/state/serverless-state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/workers/serverless-worker-dev-script.d.ts

@@ -0,0 +1 @@
+export {};

package/build/workers/serverless-worker-dev-script.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var worker_threads_1 = require("worker_threads");
+var create_next_app_1 = require("../serverless/create-next-app");
+var sendSignal = function (sig) {
+    if (worker_threads_1.parentPort) {
+        worker_threads_1.parentPort.postMessage(sig);
+    }
+};
+function beginWork() {
+    process.on("uncaughtException", function (err) {
+        sendSignal({ code: "error" });
+    });
+    (0, create_next_app_1.createNextApp)({
+        baseDirectory: process.cwd(),
+        build: false,
+        dev: true,
+        sendSignal: sendSignal,
+    });
+}
+beginWork();

package/build/workers/serverless-worker-script.js

@@ -0,0 +1 @@
+"use strict";

package/cli/build.dev.js

@@ -48,18 +48,37 @@ var ink_1 = require("ink");
 var DevCLIDisplay_1 = require("./display/components/DevCLIDisplay");
 var create_webpack_worker_1 = require("../build/create-webpack-worker");
 var create_codegen_worker_1 = require("../build/create-codegen-worker");
+var create_schema_file_1 = require("../config/create-schema-file");
+var get_config_1 = require("../config/get-config");
+var print_zod_errors_1 = require("../config/print-zod-errors");
+var Observable_1 = require("../utils/Observable");
+var fs_extra_1 = require("fs-extra");
+var create_serverless_dev_worker_1 = require("../build/create-serverless-dev-worker");
+var build_favicon_1 = require("../build/build-favicon");
 function devCommand(opts) {
+    var _a;
     return __awaiter(this, void 0, void 0, function () {
-        var themeName, enableFrontend, enableAdmin, enableCodegen, frontendObservable, adminObservable, codegenObservable;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, promptIfRepoNameIncorrect_1.promptIfRepoThemeMismatch)()];
+        var configResult, config, themeName, enableFrontend, enableAdmin, enableCodegen, enableServerless, frontendObservable, adminObservable, codegenObservable, configChanged, serverlessObservable;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    (0, create_schema_file_1.createConfigSchemaFile)(path_1.default.resolve(process.cwd(), ".ed.config.schema.json"));
+                    (0, build_favicon_1.buildFavicon)().catch(function () { });
+                    return [4 /*yield*/, (0, promptIfRepoNameIncorrect_1.promptIfRepoThemeMismatch)()];
                 case 1:
-                    _a.sent();
+                    _b.sent();
+                    configResult = (0, get_config_1.getEDConfig)();
+                    if (!configResult.success) {
+                        (0, print_zod_errors_1.printZodErrors)(configResult.error);
+                        console.log("\nPlease fix the above config errors, and restart the dev command.");
+                        return [2 /*return*/];
+                    }
+                    config = configResult.data;
                     themeName = path_1.default.basename(process.cwd());
                     enableFrontend = !opts.mode || opts.mode === "frontend";
                     enableAdmin = !opts.mode || opts.mode === "admin";
                     enableCodegen = !opts.mode || opts.mode === "codegen";
+                    enableServerless = (_a = config.serverless) === null || _a === void 0 ? void 0 : _a.enabled;
                     frontendObservable = enableFrontend
                         ? (0, create_webpack_worker_1.createWebpackWorker)({
                             title: "Frontend Bundle",
@@ -93,9 +112,13 @@ function devCommand(opts) {
                             retainLog: opts.retainLog,
                         })
                         : undefined;
-                    // Set up a process which will regenerate schemas, and watch for changes
+                    configChanged = new Observable_1.Observable(false);
+                    (0, fs_extra_1.watchFile)((0, get_config_1.getEDConfigFile)(), {}, function () {
+                        configChanged.update(true);
+                    });
+                    serverlessObservable = enableServerless ? (0, create_serverless_dev_worker_1.createServerlessWorker)() : undefined;
                     // Render output to screen
-                    (0, ink_1.render)((0, jsx_runtime_1.jsx)(DevCLIDisplay_1.DevCLIDisplay, { bundles: [frontendObservable, adminObservable].filter(Boolean), codegen: codegenObservable }, void 0));
+                    (0, ink_1.render)((0, jsx_runtime_1.jsx)(DevCLIDisplay_1.DevCLIDisplay, { bundles: [frontendObservable, adminObservable].filter(Boolean), serverless: serverlessObservable, codegen: codegenObservable, configChanged: configChanged }, void 0));
                     return [2 /*return*/];
             }
         });

package/cli/build.prod.js

@@ -45,6 +45,7 @@ var webpack_1 = require("webpack");
 var promptIfRepoNameIncorrect_1 = require("../utils/promptIfRepoNameIncorrect");
 var path_1 = __importDefault(require("path"));
 var clean_1 = require("../build/clean");
+var build_favicon_1 = require("../build/build-favicon");
 function prodCommand(opts) {
     return __awaiter(this, void 0, void 0, function () {
         var contentBase, themeName, compiler, _a, _b;
@@ -52,6 +53,10 @@ function prodCommand(opts) {
             switch (_c.label) {
                 case 0:
                     contentBase = process.cwd() + "/dist/";
+                    (0, build_favicon_1.buildFavicon)().catch(function (err) {
+                        console.log("Error building favicon:");
+                        console.error(err);
+                    });
                     return [4 /*yield*/, (0, promptIfRepoNameIncorrect_1.promptIfRepoThemeMismatch)()];
                 case 1:
                     _c.sent();

package/cli/cli.js

@@ -37,6 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var commander_1 = require("commander");
+var create_next_app_1 = require("../build/serverless/create-next-app");
 var build_dev_1 = require("./build.dev");
 var build_prod_1 = require("./build.prod");
 var setup_1 = require("./setup");
@@ -59,10 +60,38 @@ program
 program
     .command("build")
     .description("Build in production mode")
-    .option("-s, --serverless", 'Build in "serverless" mode')
     .action(function (options) {
-    (0, build_prod_1.prodCommand)({
-        serverless: options.serverless,
+    if (process.env.VERCEL) {
+        (0, create_next_app_1.createNextApp)({
+            baseDirectory: process.cwd(),
+            dev: false,
+            build: true,
+        });
+    }
+    else {
+        (0, build_prod_1.prodCommand)({
+            serverless: options.serverless,
+        });
+    }
+});
+// program
+//   .command("vercel-build")
+//   .description("Create and build a Next.js project in .serverless")
+//   .action((options) => {
+//     createNextApp({
+//       baseDirectory: process.cwd(),
+//       dev: false,
+//       build: true,
+//     })
+//   })
+program
+    .command("next")
+    .description("Create a Next.js project in .serverless")
+    .action(function (options) {
+    (0, create_next_app_1.createNextApp)({
+        baseDirectory: process.cwd(),
+        dev: true,
+        build: false,
     });
 });
 program

package/cli/display/components/DevCLIDisplay.d.ts

@@ -1,10 +1,13 @@
 /// <reference types="react" />
 import { CodegenState } from "../../../build/state/codegen-state";
 import { CompilerState } from "../../../build/state/compiler-state";
+import { ServerlessState } from "../../../build/state/serverless-state";
 import { Observable } from "../../../utils/Observable";
 declare type Props = {
     bundles: Observable<CompilerState>[];
+    serverless?: Observable<ServerlessState>;
     codegen?: Observable<CodegenState>;
+    configChanged: Observable<boolean>;
 };
 export declare function DevCLIDisplay(props: Props): JSX.Element;
 export {};