@sasjs/cli 6.0.0 → 6.2.0

package/build/commands/build/internal/mockSite/mockSite.js

@@ -0,0 +1,475 @@
+"use strict";
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+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.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = void 0;
+exports.buildMockSite = buildMockSite;
+var crypto_1 = require("crypto");
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var utils_1 = require("@sasjs/utils");
+var ASSETS_FOLDER = path_1.default.join(__dirname, 'assets');
+var toPosix = function (value) { return value.split(path_1.default.sep).join('/'); };
+var listFiles = function (folder, base) {
+    var e_1, _a;
+    if (base === void 0) { base = folder; }
+    var entries = fs_1.default.readdirSync(folder, { withFileTypes: true });
+    var files = [];
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            var absolute = path_1.default.join(folder, entry.name);
+            if (entry.isDirectory())
+                files.push.apply(files, __spreadArray([], __read(listFiles(absolute, base)), false));
+            else if (entry.isFile())
+                files.push(toPosix(path_1.default.relative(base, absolute)));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return files;
+};
+var copyFolder = function (from, to) {
+    var e_2, _a;
+    fs_1.default.mkdirSync(to, { recursive: true });
+    try {
+        for (var _b = __values(fs_1.default.readdirSync(from, { withFileTypes: true })), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var entry = _c.value;
+            var source = path_1.default.join(from, entry.name);
+            var target = path_1.default.join(to, entry.name);
+            if (entry.isDirectory())
+                copyFolder(source, target);
+            else
+                fs_1.default.copyFileSync(source, target);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+};
+/**
+ * The drive seed comes from the COMPILE OUTPUT, not the sources: `sasjs
+ * compile` copies every service folder into sasjsbuild/services and then
+ * copies the sync folder's contents over the build folder root, so sasjsbuild
+ * already holds exactly what a SASjs server would receive on its drive.
+ *
+ * Root-level files are skipped on purpose - those are the service pack (.sas),
+ * its manifest (.json), the compile tree and the zip, none of which belong on
+ * the drive.
+ */
+var PROGRAM_FOLDERS = ['services', 'jobs', 'tests'];
+/**
+ * The bounds on what the browser drive seeds. A byte entry is carried as base64
+ * in vfs-seed.json and held in the worker's memory, so a large artefact - an
+ * export, a media file, a vendored archive - makes the generated site
+ * unloadable: one file over the per-file bound, or enough files to pass the
+ * total, is left off the drive and named in a warning, as every non-text file
+ * was when the drive carried text only. Text has no bound: a program folder is
+ * text by nature and the drive has always carried it.
+ */
+exports.MAX_BINARY_SEED_BYTES = 10 * 1024 * 1024;
+exports.MAX_SEED_BYTES = 25 * 1024 * 1024;
+/**
+ * What the drive stores for a file: its text when the bytes survive a UTF-8
+ * round trip, and behind the byte marker (BINARY_PREFIX in runtime-core.js)
+ * otherwise. An archive, an image or an xlsx therefore lands on the drive as
+ * bytes, so a service that downloads a project-supplied file finds it.
+ *
+ * Text that begins with U+0000 is escaped, because the runtime reads a leading
+ * NUL as its own marker - the same rule the runtime applies to a write.
+ */
+var DRIVE_BINARY_PREFIX = '\u0000base64:';
+var DRIVE_TEXT_PREFIX = '\u0000text:';
+/** A byte count in MB, for the message that names a file too large to seed. */
+var megabytes = function (bytes) {
+    return "".concat(Math.round((bytes / 1024 / 1024) * 10) / 10, " MB");
+};
+var readDriveFile = function (absolute) {
+    var buffer = fs_1.default.readFileSync(absolute);
+    var text = buffer.toString('utf8');
+    if (!Buffer.from(text, 'utf8').equals(buffer))
+        return {
+            contents: DRIVE_BINARY_PREFIX + buffer.toString('base64'),
+            // the raw size, which is what the seed bounds are measured in
+            bytes: buffer.length
+        };
+    return {
+        contents: text.startsWith('\u0000') ? DRIVE_TEXT_PREFIX + text : text
+    };
+};
+var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
+    var e_3, _a, e_4, _b, e_5, _c;
+    if (exclude === void 0) { exclude = []; }
+    if (excludeFolders === void 0) { excludeFolders = []; }
+    var files = {};
+    var skipped = [];
+    var driveBase = "/sasjs/drive/files".concat(appLoc);
+    var seededBytes = 0;
+    // Every folder of the build goes on the drive, so a sync folder's content (a
+    // licence store, for instance) survives as well as the program folders.
+    var directories = fs_1.default
+        .readdirSync(buildFolder, { withFileTypes: true })
+        .filter(function (entry) { return entry.isDirectory(); });
+    var candidates = [];
+    try {
+        for (var directories_1 = __values(directories), directories_1_1 = directories_1.next(); !directories_1_1.done; directories_1_1 = directories_1.next()) {
+            var entry = directories_1_1.value;
+            var folder = path_1.default.join(buildFolder, entry.name);
+            if (excludeFolders.includes(path_1.default.resolve(folder)))
+                continue;
+            var _loop_1 = function (relative) {
+                var key = "".concat(driveBase, "/").concat(entry.name, "/").concat(relative);
+                if (exclude.some(function (prefix) { return key.startsWith(prefix); }))
+                    return "continue";
+                candidates.push({ key: key, absolute: path_1.default.join(folder, relative) });
+            };
+            try {
+                for (var _d = (e_4 = void 0, __values(listFiles(folder))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var relative = _e.value;
+                    _loop_1(relative);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (directories_1_1 && !directories_1_1.done && (_a = directories_1.return)) _a.call(directories_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // The budget is spent in path order, not in whatever order the folder listing
+    // returns, so the same project yields the same drive - and the same warning -
+    // on every machine and filesystem.
+    candidates.sort(function (first, second) {
+        return first.key < second.key ? -1 : first.key > second.key ? 1 : 0;
+    });
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var candidate = candidates_1_1.value;
+            var file = readDriveFile(candidate.absolute);
+            // a byte entry counts against both bounds; a text entry counts against
+            // neither, because the drive has always carried the program folders
+            if (file.bytes !== undefined) {
+                if (file.bytes > exports.MAX_BINARY_SEED_BYTES) {
+                    skipped.push({ key: candidate.key, bytes: file.bytes, limit: 'file' });
+                    continue;
+                }
+                if (seededBytes + file.bytes > exports.MAX_SEED_BYTES) {
+                    skipped.push({ key: candidate.key, bytes: file.bytes, limit: 'total' });
+                    continue;
+                }
+                seededBytes += file.bytes;
+            }
+            files[candidate.key] = file.contents;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_c = candidates_1.return)) _c.call(candidates_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return { files: files, skipped: skipped };
+};
+/**
+ * `mockWebFolder` decides a folder that is deleted before it is written, so it
+ * has to name a folder of its own. Anything that would delete the project, the
+ * build output the drive is seeded from, or the web app it is copied from is
+ * refused before a single file is touched.
+ */
+var assertSafeOutputFolder = function (outputFolder, projectDir, buildFolder, webFolder) {
+    var isSameOrChild = function (parent, child) {
+        var relative = path_1.default.relative(parent, child);
+        return (relative === '' ||
+            (relative !== '..' &&
+                !relative.startsWith('..' + path_1.default.sep) &&
+                !path_1.default.isAbsolute(relative)));
+    };
+    var refusal = function (why) {
+        return new Error("Refusing to write the mock site to ".concat(outputFolder, ": ").concat(why, ". ") +
+            'Set streamConfig.mockWebFolder to a folder of its own, for example "sasjsbuild/mock".');
+    };
+    if (isSameOrChild(outputFolder, projectDir))
+        throw refusal('that folder is the project folder or contains it');
+    if (isSameOrChild(outputFolder, buildFolder))
+        throw refusal('that folder holds the build output the drive is seeded from');
+    if (isSameOrChild(outputFolder, webFolder))
+        throw refusal('that folder holds the web app the site is copied from');
+    if (isSameOrChild(webFolder, outputFolder))
+        throw refusal('that folder is inside the web app the site is copied from, so copying it would copy itself');
+    if (!isSameOrChild(projectDir, outputFolder) &&
+        !isSameOrChild(buildFolder, outputFolder))
+        throw refusal('that folder is outside the project');
+};
+var countJsPrograms = function (files) {
+    return Object.keys(files).filter(function (key) {
+        var inProgramFolder = PROGRAM_FOLDERS.some(function (folder) {
+            return key.includes("/".concat(folder, "/"));
+        });
+        return inProgramFolder && key.toLowerCase().endsWith('.js');
+    }).length;
+};
+var loaderScript = function (mainScript, version) { return "<script>\n    // Boot order: register the service worker that hosts the mock backend, wait\n    // until it controls this page, hand it the persisted drive, install the XHR\n    // bridge, then start the app.\n    (function () {\n      function load(src, next, isModule) {\n        var s = document.createElement('script')\n        if (isModule) s.type = 'module'\n        s.src = src\n        s.onload = next\n        s.onerror = function () { console.error('[mock] failed to load ' + src); next() }\n        document.body.appendChild(s)\n      }\n      function start() {\n        load('host/persist.js?v=".concat(version, "', function () {\n          Promise.resolve(window.__sasjsMockReady).then(function (boot) {\n            if (boot && boot.error) console.error('[mock] boot: ' + boot.error)\n            load('host/intercept.js?v=").concat(version, "', function () {\n              load('").concat(mainScript, "', function () {}, true)\n            })\n          })\n        })\n      }\n      if (!('serviceWorker' in navigator)) {\n        console.error('[mock] service workers are unavailable - the mock backend cannot run')\n        start()\n        return\n      }\n      navigator.serviceWorker\n        .register('/sw.js', { scope: '/' })\n        .then(function () { return navigator.serviceWorker.ready })\n        .then(function () {\n          if (navigator.serviceWorker.controller) return\n          return new Promise(function (resolve) {\n            var timer = setTimeout(resolve, 4000)\n            navigator.serviceWorker.addEventListener('controllerchange', function () {\n              clearTimeout(timer)\n              resolve()\n            })\n          })\n        })\n        .then(function () {\n          if (navigator.serviceWorker.controller) return start()\n          if (!sessionStorage.getItem('mock-sw-reloaded')) {\n            sessionStorage.setItem('mock-sw-reloaded', '1')\n            location.reload()\n            return\n          }\n          console.error('[mock] no service worker controller - requests will fail')\n          start()\n        })\n        .catch(function (err) {\n          console.error('[mock] service worker registration failed: ' + err)\n          start()\n        })\n    })()\n  </script>"); };
+/**
+ * Points the app at its own origin and replaces its bundle tag with the
+ * boot loader. Both changes are reported when the expected markup is absent,
+ * rather than producing a site that silently talks to a real server.
+ */
+var patchIndexHtml = function (html, version) {
+    var warnings = [];
+    var patched = html;
+    if (/<sasjs[^>]*>/i.test(patched)) {
+        patched = patched.replace(/(<sasjs[^>]*?)\sserverurl="[^"]*"/i, '$1 serverurl=""');
+        patched = patched.replace(/(<sasjs[^>]*?)\sloginmechanism="[^"]*"/i, '$1 loginmechanism="Default"');
+    }
+    else {
+        warnings.push('no <sasjs> element found - check the adapter configuration manually');
+    }
+    var mainMatch = patched.match(/<script[^>]*src="([^"]*main[^"]*\.js)"[^>]*><\/script>/i);
+    if (mainMatch) {
+        patched = patched.replace(mainMatch[0], loaderScript(mainMatch[1], version));
+    }
+    else {
+        warnings.push('no main bundle script tag found - the mock loader was not installed');
+    }
+    return { patched: patched, warnings: warnings };
+};
+/**
+ * Builds a static site that runs the project's JS services (its mocks) in the
+ * browser, so a frontend can be tested with no server and no SAS.
+ *
+ * The output is an ordinary folder of static files: serve it over http(s) and
+ * the app behaves as though it were talking to a single-user SASjs server. The
+ * work happens in a service worker, so every request is still a real request -
+ * visible in DevTools > Network, marked "(from ServiceWorker)" - and the drive
+ * it writes to is persisted in IndexedDB, so refreshes keep their state.
+ *
+ * Everything comes from the target: appLoc, streamConfig.mockWebFolder for the
+ * output, streamConfig.webSourcePath for the built app, and the compile output
+ * for the drive.
+ */
+function buildMockSite(target) {
+    return __awaiter(this, void 0, void 0, function () {
+        var projectDir, appLocRaw, appLoc, buildFolder, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
+        var e_6, _e;
+        var _f, _g, _h;
+        return __generator(this, function (_j) {
+            switch (_j.label) {
+                case 0:
+                    projectDir = process.projectDir || process.cwd();
+                    appLocRaw = target.appLoc;
+                    if (!appLocRaw) {
+                        throw new Error('No appLoc. Set appLoc on the target - it has to match the appLoc the app is built with.');
+                    }
+                    appLoc = '/' + appLocRaw.replace(/^\/+/, '').replace(/\/+$/, '');
+                    buildFolder = process.sasjsConstants.buildDestinationFolder ||
+                        path_1.default.join(projectDir, 'sasjsbuild');
+                    return [4 /*yield*/, (0, utils_1.folderExists)(buildFolder)];
+                case 1:
+                    if (!(_j.sent())) {
+                        throw new Error("Build folder not found: ".concat(buildFolder, ". Run `sasjs compile` first."));
+                    }
+                    webSourceRaw = (_f = target.streamConfig) === null || _f === void 0 ? void 0 : _f.webSourcePath;
+                    if (!webSourceRaw) {
+                        throw new Error('No built web app. Set streamConfig.webSourcePath on the target (for example ./client/dist), and build the frontend first.');
+                    }
+                    webFolder = path_1.default.resolve(projectDir, webSourceRaw);
+                    return [4 /*yield*/, (0, utils_1.folderExists)(webFolder)];
+                case 2:
+                    if (!(_j.sent())) {
+                        throw new Error("Web source folder not found: ".concat(webFolder, ". Check streamConfig.webSourcePath - build the frontend first."));
+                    }
+                    if (!fs_1.default.existsSync(path_1.default.join(webFolder, 'index.html'))) {
+                        throw new Error("".concat(webFolder, " does not contain an index.html - is streamConfig.webSourcePath pointing at the built app?"));
+                    }
+                    outputFolder = ((_g = target.streamConfig) === null || _g === void 0 ? void 0 : _g.mockWebFolder)
+                        ? path_1.default.resolve(projectDir, target.streamConfig.mockWebFolder)
+                        : path_1.default.join(buildFolder, 'mock');
+                    assertSafeOutputFolder(outputFolder, projectDir, buildFolder, webFolder);
+                    streamConfig = target.streamConfig;
+                    excluded = [];
+                    // streamWebFolder is defaulted by the config validator, so a streamed app
+                    // always names its folder.
+                    if ((streamConfig === null || streamConfig === void 0 ? void 0 : streamConfig.streamWeb) && streamConfig.streamWebFolder) {
+                        excluded.push("/sasjs/drive/files".concat(appLoc, "/services/").concat(streamConfig.streamWebFolder, "/"));
+                    }
+                    _a = seedFromBuild(buildFolder, appLoc, excluded, [outputFolder]), seed = _a.files, skipped = _a.skipped;
+                    jsPrograms = countJsPrograms(seed);
+                    driveEntries = Object.keys(seed).length;
+                    if (jsPrograms === 0) {
+                        throw new Error("No .js programs in ".concat(buildFolder, "/services, /jobs or /tests. This target builds SAS code, which cannot run in a browser. ") +
+                            'Build a target whose services are JavaScript (typically a mocks project).');
+                    }
+                    if (skipped.length) {
+                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("Left ".concat(skipped.length, " file(s) off the mock drive, over the ").concat(megabytes(exports.MAX_BINARY_SEED_BYTES), " per-file or ").concat(megabytes(exports.MAX_SEED_BYTES), " total the browser build seeds: ") +
+                            "".concat(skipped
+                                .slice(0, 3)
+                                .map(function (file) {
+                                return "".concat(file.key, " (").concat(megabytes(file.bytes), ", ").concat(file.limit === 'file'
+                                    ? 'over the per-file limit'
+                                    : 'over the drive budget', ")");
+                            })
+                                .join(', ')).concat(skipped.length > 3 ? ', ...' : ''));
+                    }
+                    // Only now is the previous site expendable.
+                    fs_1.default.rmSync(outputFolder, { recursive: true, force: true });
+                    fs_1.default.mkdirSync(outputFolder, { recursive: true });
+                    // 1. the app
+                    copyFolder(webFolder, outputFolder);
+                    webFileCount = listFiles(outputFolder).length;
+                    hostFolder = path_1.default.join(outputFolder, 'host');
+                    fs_1.default.mkdirSync(hostFolder, { recursive: true });
+                    try {
+                        for (_b = __values([
+                            'md5.js',
+                            'runtime-core.js',
+                            'persist.js',
+                            'intercept.js'
+                        ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            asset = _c.value;
+                            fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, asset), path_1.default.join(hostFolder, asset));
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                    // sw.js sits at the site root: a worker can only control the folder it is
+                    // served from, and the app has to be controlled from /
+                    fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, 'sw.js'), path_1.default.join(outputFolder, 'sw.js'));
+                    hostVersion = (0, crypto_1.createHash)('md5')
+                        .update(['runtime-core.js', 'persist.js', 'intercept.js']
+                        .map(function (asset) { return fs_1.default.readFileSync(path_1.default.join(hostFolder, asset)); })
+                        .reduce(function (all, buf) { return Buffer.concat([all, buf]); }, Buffer.alloc(0)))
+                        .digest('hex')
+                        .slice(0, 10);
+                    swPath = path_1.default.join(outputFolder, 'sw.js');
+                    fs_1.default.writeFileSync(swPath, fs_1.default
+                        .readFileSync(swPath, 'utf8')
+                        .replace("importScripts('/host/runtime-core.js')", "importScripts('/host/runtime-core.js?v=".concat(hostVersion, "')")));
+                    snapshotSource = path_1.default.join(buildFolder, 'mock-snapshot.json');
+                    hasSnapshot = fs_1.default.existsSync(snapshotSource);
+                    if (hasSnapshot) {
+                        fs_1.default.copyFileSync(snapshotSource, path_1.default.join(hostFolder, 'vfs-snapshot.json'));
+                    }
+                    // 3. the drive, laid out from the compile output
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-seed.json'), JSON.stringify({ files: seed }));
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'mock-config.json'), JSON.stringify({
+                        appLoc: appLoc,
+                        seedPath: '/host/vfs-seed.json',
+                        driveEntries: driveEntries,
+                        jsPrograms: jsPrograms,
+                        programFolders: PROGRAM_FOLDERS,
+                        snapshot: hasSnapshot,
+                        builtAt: new Date().toISOString()
+                    }, null, 2));
+                    indexPath = path_1.default.join(outputFolder, 'index.html');
+                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion), patched = _d.patched, warnings = _d.warnings;
+                    fs_1.default.writeFileSync(indexPath, patched);
+                    warnings.forEach(function (warning) { var _a; return (_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn(warning); });
+                    return [2 /*return*/, {
+                            outputFolder: outputFolder,
+                            appLoc: appLoc,
+                            driveEntries: driveEntries,
+                            jsPrograms: jsPrograms,
+                            webFileCount: webFileCount,
+                            snapshot: hasSnapshot
+                        }];
+            }
+        });
+    });
+}

package/build/commands/build/internal/mockSite/spec/intercept.spec.d.ts

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