@ohos-ports/layer0-prefetch 4.20.0-beta.0 → 4.20.0-beta.1

package/node_modules/@layer0/core/deploy/bundle-nft.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file */
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const slash_1 = __importDefault(require("slash"));
+/**
+ * Creates an exploded, tree shaken bundle that more easily fits within Lambda's size limits and
+ * reduces code start times.
+ * @param src The entry point source file
+ * @param destDir The output directory
+ */
+async function bundleWithNft(src, destDir) {
+    const nodeFileTrace = loadNFT();
+    process.stdout.write('> Bundling your app with @vercel/nft...');
+    const { fileList } = await nodeFileTrace([src]);
+    for (let file of fileList) {
+        const dest = path_1.join(destDir, file);
+        fs_extra_1.mkdirpSync(path_1.dirname(dest));
+        fs_extra_1.copyFileSync(file, dest);
+    }
+    const entryPoint = path_1.join(destDir, 'index.js');
+    if (!fs_extra_1.existsSync(entryPoint)) {
+        fs_extra_1.writeFileSync(entryPoint, `require('./${slash_1.default(path_1.relative(process.cwd(), src))}')`, 'utf8');
+    }
+    process.stdout.write(' done.\n');
+}
+exports.default = bundleWithNft;
+function loadNFT() {
+    try {
+        const { nodeFileTrace } = require('@vercel/nft');
+        return nodeFileTrace;
+    }
+    catch (e) {
+        console.log('Required dependency @vercel/nft not found. Install @vercel/nft@^0.21.0 as a devDependency then retry this command.');
+        process.exit(1);
+    }
+}

package/node_modules/@layer0/core/deploy/bundle-webpack.d.ts

@@ -0,0 +1,11 @@
+import webpack from 'webpack';
+/**
+ * Compiles the router and layer0.config.js in production mode.
+ * Returns a promise that resolves to the router.
+ */
+export default function bundle(): Promise<void>;
+/**
+ * Creates a webpack compiler for bundling the router in development.
+ * @private
+ */
+export declare function createCompiler(): webpack.Compiler;

package/node_modules/@layer0/core/deploy/bundle-webpack.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("../config"));
+const webpack_1 = __importDefault(require("webpack"));
+const path_1 = require("path");
+const paths_1 = require("./paths");
+const resolveInPackage_1 = __importDefault(require("./resolveInPackage"));
+const fs_1 = require("fs");
+const logo_1 = __importDefault(require("../utils/logo"));
+// compatible type definitions are not yet available for this after updating to webpack 5
+const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
+const destDir = path_1.join(process.cwd(), paths_1.JS_DIR);
+/**
+ * Compiles the router and layer0.config.js in production mode.
+ * Returns a promise that resolves to the router.
+ */
+async function bundle() {
+    var _a;
+    // Use process.stdout.write to be able to concatenate `done.` to the same output line.
+    process.stdout.write(`> Bundling ${logo_1.default} router... `);
+    const webpackConfig = createConfig({ mode: 'production' });
+    const webpackStats = await new Promise((resolve, reject) => {
+        webpack_1.default(webpackConfig, (err, stats) => (err ? reject(err) : resolve(stats)));
+    });
+    const compilationErrors = (_a = webpackStats === null || webpackStats === void 0 ? void 0 : webpackStats.compilation) === null || _a === void 0 ? void 0 : _a.errors;
+    if (compilationErrors === null || compilationErrors === void 0 ? void 0 : compilationErrors.length) {
+        console.error('Errors occurred while bundling your router:', compilationErrors);
+        throw new Error('Bundling router failed.');
+    }
+    process.stdout.write('done.\n');
+}
+exports.default = bundle;
+/**
+ * Creates a webpack compiler for bundling the router in development.
+ * @private
+ */
+function createCompiler() {
+    return webpack_1.default(createConfig());
+}
+exports.createCompiler = createCompiler;
+/**
+ * Creates a webpack config for bundling the router
+ * @private
+ */
+function createConfig(webpackConfig) {
+    const routesPath = path_1.join(process.cwd(), config_1.default.get('routes'));
+    const configPath = [
+        path_1.join(process.cwd(), 'layer0.config.js'),
+        path_1.join(process.cwd(), 'layer0.config.cjs'),
+    ].find(fs_1.existsSync);
+    if (!configPath) {
+        throw new Error('layer0.config.js not found. Run "layer0 init" to create this file.');
+    }
+    const rules = [];
+    try {
+        // skip ts-loader if typescript is not installed in the project
+        require.resolve('typescript');
+        rules.push({
+            test: /\.ts$/,
+            use: [
+                {
+                    loader: resolveInPackage_1.default('ts-loader'),
+                    options: {
+                        onlyCompileBundledFiles: true,
+                        compilerOptions: {
+                            noEmit: false,
+                        },
+                    },
+                },
+            ],
+            exclude: /node_modules/,
+        });
+        // eslint-disable-next-line no-empty
+    }
+    catch (e) { }
+    try {
+        // skip babel-loader if babel is not installed in the project
+        require.resolve('@babel/core');
+        rules.push({
+            test: /\.js$/,
+            use: resolveInPackage_1.default('babel-loader'),
+            exclude: /node_modules/,
+        });
+        // eslint-disable-next-line no-empty
+    }
+    catch (e) { }
+    const plugins = [];
+    if (process.env.ANALYZE === 'true') {
+        plugins.push(new BundleAnalyzerPlugin({
+            analyzerMode: 'static',
+            reportFilename: '../bundle-analysis.html',
+        }));
+    }
+    return {
+        stats: 'errors-warnings',
+        devtool: process.env.NODE_ENV === 'production' ? false : 'cheap-module-source-map',
+        entry: {
+            routes: routesPath,
+            'layer0.config': configPath,
+        },
+        optimization: {
+            // This prevents webpack from string replacing process.env.NODE_ENV, which has been found to cause trouble on the server
+            // For example, without this, process.env.NODE_ENV doesn't have the correct value in the user's routes file.
+            nodeEnv: false,
+        },
+        output: {
+            path: destDir,
+            libraryTarget: 'umd',
+        },
+        module: {
+            rules,
+        },
+        resolve: {
+            extensions: ['.ts', '.js'],
+        },
+        externals: {
+            chalk: 'chalk',
+        },
+        target: 'node',
+        mode: 'development',
+        ...webpackConfig,
+        plugins: [...plugins, ...((webpackConfig === null || webpackConfig === void 0 ? void 0 : webpackConfig.plugins) || [])],
+    };
+}

package/node_modules/@layer0/core/deploy/index.d.ts

@@ -0,0 +1,19 @@
+export { default as DeploymentBuilder } from './DeploymentBuilder';
+export { ExecOptions } from './DeploymentBuilder';
+export { default as resolveInPackage } from './resolveInPackage';
+/**
+ * Options for build entry points
+ */
+export interface BuildOptions {
+    /**
+     * When set to true, the framework build entry point should skip the framework
+     * build (e.g. next build, sapper build, nuxt build, etc...)
+     */
+    skipFramework: boolean;
+    /**
+     * Excludes the prod entry point from being bundled
+     *
+     * @default false
+     */
+    excludeProdEntryPoint?: boolean;
+}

package/node_modules/@layer0/core/deploy/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var DeploymentBuilder_1 = require("./DeploymentBuilder");
+exports.DeploymentBuilder = DeploymentBuilder_1.default;
+var resolveInPackage_1 = require("./resolveInPackage");
+exports.resolveInPackage = resolveInPackage_1.default;

package/node_modules/@layer0/core/deploy/listSources.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns source files that should be added to the bundle based on:
+ *
+ *  - The `sources` property of layer0.config.js, or, if not present
+ *  - Excluding gitignored files
+ *
+ * @param appDir The application root directory
+ * @param sourcesConfig The value of the sources config in layer0.config.js
+ * @private
+ */
+export default function listSources(appDir: string, sourcesConfig: string[] | null): Promise<string[]>;

package/node_modules/@layer0/core/deploy/listSources.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globby_1 = require("globby");
+/**
+ * Returns source files that should be added to the bundle based on:
+ *
+ *  - The `sources` property of layer0.config.js, or, if not present
+ *  - Excluding gitignored files
+ *
+ * @param appDir The application root directory
+ * @param sourcesConfig The value of the sources config in layer0.config.js
+ * @private
+ */
+async function listSources(appDir, sourcesConfig) {
+    const globs = (sourcesConfig || ['**/*']).concat('!node_modules', '!.env');
+    return globby_1.sync(globs, { gitignore: true, cwd: appDir });
+}
+exports.default = listSources;

package/node_modules/@layer0/core/deploy/paths.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The .layer0 build directory
+ */
+export declare const LAYER0_DIR = ".layer0";
+/**
+ * The destination directory for JS server code
+ */
+export declare const JS_DIR: string;
+/**
+ * The destination directory for static assets
+ */
+export declare const ASSETS_DIR: string;
+export declare const PERMANENT_ASSETS_DIR: string;
+/**
+ * The directory into which source code is copied for debugging purposes
+ */
+export declare const SOURCES_DIR: string;
+/**
+ * The name of the compiled routes file
+ */
+export declare const ROUTES_FILE_NAME = "routes.js";
+/**
+ * Returns the destination path within the lambda dir for the specified backend
+ * @param backend A backend name
+ * @return a file path
+ */
+export declare function pathForBackend(backend: string): string;

package/node_modules/@layer0/core/deploy/paths.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+/**
+ * The .layer0 build directory
+ */
+exports.LAYER0_DIR = '.layer0';
+/**
+ * The destination directory for JS server code
+ */
+exports.JS_DIR = path_1.join(exports.LAYER0_DIR, 'lambda');
+/**
+ * The destination directory for static assets
+ */
+exports.ASSETS_DIR = path_1.join(exports.LAYER0_DIR, 's3');
+exports.PERMANENT_ASSETS_DIR = path_1.join(exports.LAYER0_DIR, 's3-permanent');
+/**
+ * The directory into which source code is copied for debugging purposes
+ */
+exports.SOURCES_DIR = path_1.join(exports.LAYER0_DIR, 'src');
+/**
+ * The name of the compiled routes file
+ */
+exports.ROUTES_FILE_NAME = 'routes.js';
+/**
+ * Returns the destination path within the lambda dir for the specified backend
+ * @param backend A backend name
+ * @return a file path
+ */
+function pathForBackend(backend) {
+    return path_1.join('__backends__', `${backend}.js`);
+}
+exports.pathForBackend = pathForBackend;

package/node_modules/@layer0/core/deploy/resolveInPackage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the path to a file within a node package
+ * @param pkg The name of a node package
+ * @param file The path to the file within the package
+ * @return A file path
+ */
+export default function resolveInPackage(pkg: string, ...file: string[]): string;

package/node_modules/@layer0/core/deploy/resolveInPackage.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolve_package_path_1 = __importDefault(require("resolve-package-path"));
+const path_1 = require("path");
+/**
+ * Returns the path to a file within a node package
+ * @param pkg The name of a node package
+ * @param file The path to the file within the package
+ * @return A file path
+ */
+function resolveInPackage(pkg, ...file) {
+    let path = resolve_package_path_1.default(pkg, __dirname) || resolve_package_path_1.default(pkg, process.cwd());
+    if (!path)
+        throw new Error(`Package ${pkg} not found.`);
+    const packagePath = path_1.dirname(path);
+    return path_1.join(packagePath, ...file);
+}
+exports.default = resolveInPackage;

package/node_modules/@layer0/core/deploy/routeToFiles.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a route path pattern to a glob which captures all of the files
+ * which it could possibly match
+ * @param route The path pattern for a route
+ * @returns a glob pattern
+ */
+export declare function routeToGlob(route: string): string;
+/**
+ * Converts a route path pattern to a relative directory name
+ * that would contain all potential matching files.
+ * @param pathPattern The path pattern passed as the first argument to serveStatic()
+ * @returns a relative directory path
+ */
+export declare function rootDirForPath(pathPattern: string): string;

package/node_modules/@layer0/core/deploy/routeToFiles.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Converts a route path pattern to a glob which captures all of the files
+ * which it could possibly match
+ * @param route The path pattern for a route
+ * @returns a glob pattern
+ */
+function routeToGlob(route) {
+    return `${rootDirForPath(route)}**/*`;
+}
+exports.routeToGlob = routeToGlob;
+/**
+ * Converts a route path pattern to a relative directory name
+ * that would contain all potential matching files.
+ * @param pathPattern The path pattern passed as the first argument to serveStatic()
+ * @returns a relative directory path
+ */
+function rootDirForPath(pathPattern) {
+    return pathPattern
+        .replace(/^\//, '') // remove leading slash - we are searching within the app dir, not the root
+        .replace(/:.*/i, ''); // remove everything after the first variable
+}
+exports.rootDirForPath = rootDirForPath;

package/node_modules/@layer0/core/dev/DevServerOptions.d.ts

@@ -0,0 +1,33 @@
+import { Configuration } from 'webpack';
+/**
+ * Options for `createDevServer`
+ */
+export default interface DevServerOptions {
+    /**
+     * A label to prepend to all output from the application server
+     */
+    label?: string;
+    /**
+     * A manual function to run to start the application server instead of using a command
+     */
+    run?: (port: number) => void;
+    /**
+     * The command to start the application server in development mode
+     */
+    command?: (port: number) => string;
+    /**
+     * An array of regular expressions to search for in application server output. Once all have been
+     * matched, The "Layer0 ready on http://127.0.0.1:3000" line will be displayed.
+     */
+    ready?: RegExp[];
+    /**
+     * A function that is called every time the application server outputs a line to stdout. Return false
+     * to hide that line from the user. This can be useful in hiding lines like "Application ready on 127.0.0.1:3001"
+     * to keep the user from getting confused about which URL to use when testing the app.
+     */
+    filterOutput?: (line: string) => boolean;
+    /**
+     * Optional function that returns a webpack compiler that should halt requests during rebuilds
+     */
+    webpackConfig?: Configuration;
+}

package/node_modules/@layer0/core/dev/DevServerOptions.js

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

package/node_modules/@layer0/core/dev/createDevServer.d.ts

@@ -0,0 +1,8 @@
+import DevServerOptions from './DevServerOptions';
+/**
+ * Creates a development server to simulate Layer0 locally.  Changes to your routes are automatically
+ * applied without restarting `layer0 run`.
+ * @param appReady An optional promise that resolves when your app is to receive requests
+ * @returns A promise that resolves when Layer0 is ready to receive requests
+ */
+export default function createDevServer(options?: DevServerOptions): Promise<any>;

package/node_modules/@layer0/core/dev/createDevServer.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file */
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const express_1 = __importDefault(require("express"));
+const loadRouter_1 = __importDefault(require("../router/loadRouter"));
+const chalk_1 = __importDefault(require("chalk"));
+const Cache_1 = require("../cache/Cache");
+const timing_1 = require("../timing");
+const logo_1 = __importStar(require("../utils/logo"));
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const runLocalApp_1 = __importDefault(require("./runLocalApp"));
+const bundle_esbuild_1 = require("../deploy/bundle-esbuild");
+const config_1 = __importDefault(require("../config"));
+const paths_1 = require("../deploy/paths");
+const serverlessCompatibilityMiddleware_1 = __importDefault(require("./serverlessCompatibilityMiddleware"));
+const ports_1 = require("../utils/ports");
+/**
+ * Creates a development server to simulate Layer0 locally.  Changes to your routes are automatically
+ * applied without restarting `layer0 run`.
+ * @param appReady An optional promise that resolves when your app is to receive requests
+ * @returns A promise that resolves when Layer0 is ready to receive requests
+ */
+function createDevServer(options) {
+    process.env.LAYER0_LOCAL = 'true';
+    const layer0 = express_1.default().disable('x-powered-by');
+    const appReady = (options === null || options === void 0 ? void 0 : options.command) || (options === null || options === void 0 ? void 0 : options.run) ? runLocalApp_1.default(ports_1.jsPort, options) : Promise.resolve();
+    layer0.use(serverlessCompatibilityMiddleware_1.default);
+    // Optional webpack compiler provided by the user
+    if (options === null || options === void 0 ? void 0 : options.webpackConfig) {
+        // compatible type definitions are not yet available for this after updating to webpack 5
+        const middleware = require('webpack-dev-middleware');
+        const webpack = require('webpack');
+        layer0.use(middleware(webpack(options.webpackConfig), {
+            writeToDisk: true,
+            publicPath: path_1.join(process.cwd(), paths_1.ASSETS_DIR),
+        }));
+    }
+    let router;
+    const reloadRouter = () => {
+        const routerPath = path_1.join(process.cwd(), paths_1.JS_DIR, path_1.basename(config_1.default.get('routes')));
+        // Ensure that the router is reloaded when a new version is compiled
+        // Note: there is a known memory leak here, but if we only reload the router when the user changes it,
+        // the memory growth will be slow enough to not be noticeable in most cases.
+        delete require.cache[routerPath];
+        router = loadRouter_1.default(routerPath)
+            .setBackend(constants_1.BACKENDS.permanentStatic, {
+            domainOrIp: ports_1.localhost,
+            port: ports_1.assetPort,
+        })
+            .setBackend(constants_1.BACKENDS.static, {
+            domainOrIp: ports_1.localhost,
+            port: ports_1.assetPort,
+        })
+            .setBackend(constants_1.BACKENDS.js, { domainOrIp: constants_1.JS_BACKEND_HOSTNAME, port: ports_1.jsPort });
+    };
+    const routerReady = bundle_esbuild_1.bundleRouterAndConfig({
+        watch: {
+            onRebuild(error, result) {
+                Cache_1.clearCache();
+                reloadRouter();
+                if (!error) {
+                    console.log(`${logo_1.infoLogLabel} router compiled successfully.`);
+                }
+            },
+        },
+    }).then(reloadRouter);
+    // `router` will always be initialized as the middleware will stop incoming requests until build is done.
+    layer0.use(timing_1.withTimings(async (req, res) => {
+        await routerReady;
+        return router.run(req, res); // @ts-ignore TypeScript complains here because our Request and Response objects don't exactly match express's
+    }));
+    const layer0Ready = new Promise((resolve, reject) => {
+        try {
+            const server = layer0.listen(ports_1.port, resolve);
+            // Proxy websocket requests to the JS backend. Gatsby needs this for example.
+            const proxy = http_proxy_1.default.createProxyServer({
+                target: {
+                    host: constants_1.JS_BACKEND_HOSTNAME,
+                    port: ports_1.jsPort,
+                },
+            });
+            server.on('upgrade', function (req, socket, head) {
+                proxy.ws(req, socket, head);
+            });
+            server.on('error', function (error) {
+                console.log(error.message);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+    return Promise.all([routerReady, appReady, layer0Ready])
+        .then(() => {
+        console.log('\n' +
+            logo_1.default +
+            ' ' +
+            chalk_1.default.green(`ready on ${chalk_1.default.bold(chalk_1.default.underline(`http://${ports_1.localhost}:${ports_1.port}\n`))}`));
+    })
+        .catch(err => console.log('error', err));
+}
+exports.default = createDevServer;

package/node_modules/@layer0/core/dev/index.d.ts

@@ -0,0 +1,3 @@
+export { default as createDevServer } from './createDevServer';
+export { default as DevServerOptions } from './DevServerOptions';
+export { default } from './createDevServer';

package/node_modules/@layer0/core/dev/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var createDevServer_1 = require("./createDevServer");
+exports.createDevServer = createDevServer_1.default;
+var createDevServer_2 = require("./createDevServer");
+exports.default = createDevServer_2.default;

package/node_modules/@layer0/core/dev/runLocalApp.d.ts

@@ -0,0 +1,8 @@
+import DevServerOptions from './DevServerOptions';
+/**
+ * Runs the user's app in development mode
+ * @param port The port on which to listen
+ * @param local Describes how to construct the command that runs the app
+ * @returns A promise that resolves when the app is ready to receive requests.
+ */
+export default function runLocalApp(port: number, options: DevServerOptions): void | Promise<void>;

package/node_modules/@layer0/core/dev/runLocalApp.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const shelljs_1 = __importDefault(require("shelljs"));
+const nonWebpackRequire_1 = __importDefault(require("../utils/nonWebpackRequire"));
+// we don't bundle chalk because it's large and we only use it in development
+const chalk = nonWebpackRequire_1.default('chalk');
+/**
+ * Runs the user's app in development mode
+ * @param port The port on which to listen
+ * @param local Describes how to construct the command that runs the app
+ * @returns A promise that resolves when the app is ready to receive requests.
+ */
+function runLocalApp(port, options) {
+    const { run, command } = options;
+    // If dev server uses a manual run function, skip all command functionality
+    if (run) {
+        return run(port);
+    }
+    /* istanbul ignore next */
+    if (!command)
+        return;
+    const label = chalk.grey(options.label || 'app');
+    return new Promise((resolve, reject) => {
+        var _a, _b;
+        try {
+            const childProcess = shelljs_1.default.exec(command(port), {
+                async: true,
+                env: { ...process.env, PORT: port.toString(), FORCE_COLOR: 'true' },
+                silent: true,
+            }, code => {
+                if (code > 0) {
+                    console.error(chalk.red('Layer0 encountered a fatal error while running your application. Exiting...'));
+                    reject();
+                    process.exit(code);
+                }
+                else {
+                    resolve();
+                }
+            });
+            /* istanbul ignore next */
+            (_a = childProcess.stderr) === null || _a === void 0 ? void 0 : _a.on('data', data => process.stderr.write(`${label} ${data}`));
+            const ready = options.ready || [];
+            const filterOutput = options.filterOutput || ((_line) => true);
+            /* istanbul ignore next */
+            (_b = childProcess.stdout) === null || _b === void 0 ? void 0 : _b.on('data', data => {
+                let matched = false;
+                ready.some((pattern, i) => {
+                    if (pattern.test(data)) {
+                        ready.splice(i, 1);
+                        matched = true;
+                    }
+                });
+                if (ready.length === 0) {
+                    resolve();
+                }
+                if (matched || !filterOutput(data)) {
+                    return; // hide the ready line so that the user doesn't see two URLs and get confused.
+                }
+                process.stdout.write(`${label} ${data}`);
+                if (!data.endsWith('\n')) {
+                    process.stdout.write('\n');
+                }
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.default = runLocalApp;

package/node_modules/@layer0/core/dev/serverlessCompatibilityMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler } from 'express';
+/**
+ * This middleware adds getHeaders(), getHeader(name), setHeader(name, value), and removeHeader(name) to Express's
+ * request object, making it compatible with the request object we provide in serverless.
+ * See lambda/reqResMapper.ts
+ * @param request
+ * @param _response
+ * @param next
+ */
+declare const serverlessCompatibilityMiddleware: RequestHandler;
+export default serverlessCompatibilityMiddleware;