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

package/node_modules/@layer0/core/utils/Validator.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const constants_1 = require("../constants");
+const environment_1 = require("../environment");
+const nonWebpackRequire_1 = __importDefault(require("./nonWebpackRequire"));
+// config.backends[x] domainOrIp schema
+const domainOrIpSchema = {
+    $id: '/domainOrIpSchema',
+    type: 'string',
+};
+// config.backends[x] object schema
+const backendObjectSchema = {
+    $id: '/backendObjectSchema',
+    type: 'object',
+    properties: {
+        domainOrIp: {
+            $ref: domainOrIpSchema.$id,
+        },
+        port: {
+            type: 'number',
+            // We allow all ports but we will always use HTTPS protocol no matter the port.
+            minimum: 1,
+            maximum: 65535,
+        },
+        hostHeader: {
+            type: 'string',
+        },
+        disableCheckCert: {
+            type: 'boolean',
+        },
+        firstByteTimeout: {
+            type: 'number',
+        },
+        basePath: {
+            type: 'string',
+        },
+    },
+    additionalProperties: false,
+    required: ['domainOrIp'],
+};
+// config.backends schema
+const backendSchema = {
+    $id: '/backendSchema',
+    type: 'object',
+    patternProperties: {
+        '^.*$': {
+            oneOf: [{ $ref: domainOrIpSchema.$id }, { $ref: backendObjectSchema.$id }],
+        },
+    },
+};
+// layer0.config.js schema
+const layer0FileConfigurationSchema = {
+    $id: '/layer0FileConfigurationSchema',
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        team: { type: 'string' },
+        prerenderConcurrency: { type: 'number' },
+        production: { type: 'boolean' },
+        routes: { type: 'string' },
+        server: {
+            type: 'object',
+            required: ['path'],
+            properties: { path: { type: 'string' }, export: { type: 'string' } },
+        },
+        includeFiles: {
+            type: 'object',
+        },
+        sources: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+        backends: {
+            $ref: backendSchema.$id,
+        },
+        includeNodeModules: { type: 'boolean' },
+        connector: {
+            type: 'string',
+        },
+    },
+    additionalProperties: false,
+    required: [],
+};
+/**
+ * An object used to validate an layer0 config.
+ *
+ * Example:
+ * ```js
+ * Validator.validateLayer0FileConfiguration(config)
+ * ```
+ */
+class Validator {
+    /**
+     * Validates `layer0.config.js`. If the config is validated, it is returned; otherwise,
+     * an error is thrown.
+     * @param config Loaded layer0 configuration
+     * @returns The validated config
+     */
+    static validateLayer0FileConfiguration(config) {
+        if (environment_1.isCloud())
+            return config;
+        // Ajv is really big, so we don't bother validating in the cloud - I've we've gotten this far, let 'er rip, baby!
+        const Ajv = nonWebpackRequire_1.default('ajv');
+        if (config.connector) {
+            try {
+                const configSchema = require(`${config.connector}/configSchema`);
+                // If a configuration schema exists for the connector, merge into the default schema
+                Object.assign(layer0FileConfigurationSchema.properties, configSchema);
+            }
+            catch {
+                // No config schema for connector, nothing to do here
+            }
+        }
+        const ajv = new Ajv({
+            allErrors: true,
+            schemas: [
+                layer0FileConfigurationSchema,
+                backendSchema,
+                backendObjectSchema,
+                domainOrIpSchema,
+            ],
+        });
+        let errors = [];
+        // the type cast on the following line is needed to get coverage to 100%.  In theory getSchema can return undefined, but it won't since we are creating the schema ourselves.
+        const layer0SchemaValidator = ajv.getSchema(layer0FileConfigurationSchema.$id);
+        if (config.backends && config.backends.moov != null) {
+            // Don't allow providing moov backend in layer0.config.js
+            errors.push({
+                message: 'is a reserved backend name',
+                // eslint-disable-next-line quotes
+                dataPath: ".backends['moov']",
+            });
+        }
+        // Don't allow providing static backend in layer0.config.js
+        if (config.backends && config.backends[constants_1.BACKENDS.static]) {
+            errors.push({
+                message: 'is a reserved backend name',
+                // eslint-disable-next-line quotes
+                dataPath: `.backends.${constants_1.BACKENDS.static}`,
+            });
+        }
+        // Don't allow providing js backend in layer0.config.js
+        if (config.backends && config.backends[constants_1.BACKENDS.js]) {
+            errors.push({
+                message: 'is a reserved backend name',
+                // eslint-disable-next-line quotes
+                dataPath: `.backends.${constants_1.BACKENDS.js}`,
+            });
+        }
+        // Run schema validation
+        if (!layer0SchemaValidator(config) && layer0SchemaValidator.errors) {
+            errors = [...errors, ...layer0SchemaValidator.errors];
+        }
+        // If errors length is not 0 throw error
+        if (errors.length) {
+            const errorsString = errors
+                .map((err, i) => {
+                let eString = `${i + 1}) config${err.dataPath}: ${err.message}`;
+                // @ts-ignore
+                if (err.keyword === 'additionalProperties') {
+                    // @ts-ignore
+                    eString += ` '${err.params.additionalProperty}'`;
+                }
+                return eString;
+            })
+                .join(os_1.EOL);
+            throw new Error(`Layer0 configuration validation failed with errors: ${os_1.EOL}${errorsString}`);
+        }
+        return config;
+    }
+}
+exports.default = Validator;

package/node_modules/@layer0/core/utils/bindParamsToPath.d.ts

@@ -0,0 +1,15 @@
+declare const _default: (path: string, params: any) => string;
+/**
+ * Binds params to path.
+ *
+ * Example:
+ * ```js
+ * bindParamsToPath('/:foo/:bar*', { foo: 'p1', bar: 'p2/p3' })
+ * ```
+ * Output: `/p1/p2/p3`
+ *
+ * @param path The path, with param substitutions in braces `{}`.
+ * @param params An object with keys matching the params in braces.
+ * @returns A string with the params substituted with their values.
+ */
+export default _default;

package/node_modules/@layer0/core/utils/bindParamsToPath.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Binds params to path.
+ *
+ * Example:
+ * ```js
+ * bindParamsToPath('/:foo/:bar*', { foo: 'p1', bar: 'p2/p3' })
+ * ```
+ * Output: `/p1/p2/p3`
+ *
+ * @param path The path, with param substitutions in braces `{}`.
+ * @param params An object with keys matching the params in braces.
+ * @returns A string with the params substituted with their values.
+ */
+exports.default = (path, params) => {
+    let p = path;
+    // We allow edge interpolation params which begin with `${` but we no longer
+    // allow old path options that only begin with `{`.
+    if (/(^|[^$]){/.test(path)) {
+        throw new Error(`{variable} syntax in the path option is no longer supported, use :variable instead (${path})`);
+    }
+    for (let paramName in params) {
+        let value = params[paramName];
+        if (Array.isArray(value)) {
+            value = value.join('/');
+        }
+        // Here we decide *not* to use path-to-regexp `compile()` function
+        // as bindParamsToPath is used by other string which are not paths.
+        // For example it is used to interpolate setHeader values, which can be a CORS header like
+        // 'https://www.domain.com/:path'. The ':' behind https is not a valid path-to-regexp expression.
+        // p = p.replace(new RegExp(`:${paramName}(\\?|\\*|\\(.*\\)[?*]?)?`, 'g'), value)
+        p = p.replace(new RegExp(`:${paramName}(\\([^)]*\\))?[?*+]?`, 'g'), value === undefined ? '' : value);
+    }
+    // For optional matchers (:path* and :path?), path may not be defined in params
+    // after matching a route but should still be replaced by a blank value
+    //
+    // ex: pathToRegexp.match('/public/:param?')('/').params returns {}
+    //     so bindParamsToPath('/public/:param?', {}) should return '/public/'
+    //
+    p = p.replace(/:\w+(\*|\+|\?)?/, '');
+    // We un-escape '?' character that needed to be escape from path-to-regexp expression
+    // to *not* be considered as optional parameter matcher
+    p = p.replace('\\?', '?');
+    p = p
+        .replace(/\/+/g, '/') // finally dedupe /'s that result from missing optional parameters
+        .replace(/^([^:]+:)\//gi, '$1//'); // but don't replace http://domain with http:/domain
+    return p;
+};

package/node_modules/@layer0/core/utils/convertParamsToBackReferences.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Replaces named parameters in the specified path with back references so
+ * that the edge can create a path using the matched params with a regex replace in VCL.
+ *
+ * **Note** this method can return a replacement that, when applied, can result in duplicated '/' characters,
+ * which must be collapsed.  For example, if the route pattern is /:locale?/products and the url is '/products',
+ * where the optional parameter is not provided, url.replace(pattern, replacement) will result in '//products'
+ *
+ * @param matcher A route-parser route
+ * @param path The request path
+ * @returns A path with params replaced by back references
+ */
+export default function convertParamsToBackReferences(source: any | null | undefined, dest: string): string;
+export declare function getBackReferences(path?: string): {
+    [key: string]: string;
+};

package/node_modules/@layer0/core/utils/convertParamsToBackReferences.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bindParamsToPath_1 = __importDefault(require("./bindParamsToPath"));
+const path_to_regexp_1 = require("path-to-regexp");
+/**
+ * Replaces named parameters in the specified path with back references so
+ * that the edge can create a path using the matched params with a regex replace in VCL.
+ *
+ * **Note** this method can return a replacement that, when applied, can result in duplicated '/' characters,
+ * which must be collapsed.  For example, if the route pattern is /:locale?/products and the url is '/products',
+ * where the optional parameter is not provided, url.replace(pattern, replacement) will result in '//products'
+ *
+ * @param matcher A route-parser route
+ * @param path The request path
+ * @returns A path with params replaced by back references
+ */
+function convertParamsToBackReferences(source, dest) {
+    if (source == null)
+        return dest;
+    const sourceTokens = getBackReferences(source);
+    return bindParamsToPath_1.default(dest, sourceTokens);
+}
+exports.default = convertParamsToBackReferences;
+function getBackReferences(path) {
+    if (!path)
+        return {};
+    // In case path is an absolute path
+    const absolutePathMatch = path.match(/https?:\/\/[^/]+(.*)/);
+    if (absolutePathMatch) {
+        path = `/${absolutePathMatch[1]}`;
+    }
+    // Back reference counting starts from 1
+    let backReferenceCounter = 1;
+    const references = {};
+    path_to_regexp_1.parse(path).forEach(token => {
+        if (typeof token !== 'string') {
+            references[token.name] = `\\${backReferenceCounter++}`;
+        }
+    });
+    return references;
+}
+exports.getBackReferences = getBackReferences;

package/node_modules/@layer0/core/utils/convertStringMatcherToRegex.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns either null or regex even if input is string matcher.
+ *
+ * @param potentialRegex
+ * @private
+ */
+export default function convertStringMatcherToRegex(potentialRegex: string | RegExp | null): RegExp;

package/node_modules/@layer0/core/utils/convertStringMatcherToRegex.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toEdgeRegex_1 = __importDefault(require("./toEdgeRegex"));
+/**
+ * Returns either null or regex even if input is string matcher.
+ *
+ * @param potentialRegex
+ * @private
+ */
+function convertStringMatcherToRegex(potentialRegex) {
+    let regex;
+    if (potentialRegex === null) {
+        regex = null;
+    }
+    else if (typeof potentialRegex === 'string') {
+        regex = toEdgeRegex_1.default(new RegExp(`^${potentialRegex}$`, 'i'));
+    }
+    else {
+        regex = toEdgeRegex_1.default(potentialRegex);
+    }
+    return regex;
+}
+exports.default = convertStringMatcherToRegex;

package/node_modules/@layer0/core/utils/decode.d.ts

@@ -0,0 +1,9 @@
+import Response from '../router/Response';
+/**
+ * If needed decodes the body in place from the response content-encoding.
+ * Removes the content-encoding header and updates the content-length as the
+ * decoded body has no encoding and will have a different length.
+ * @param response
+ * @returns True if decoding happened or wasn't needed, false otherwise
+ */
+export default function decode(response: Response): Boolean;

package/node_modules/@layer0/core/utils/decode.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const constants_1 = require("../constants");
+/**
+ * If needed decodes the body in place from the response content-encoding.
+ * Removes the content-encoding header and updates the content-length as the
+ * decoded body has no encoding and will have a different length.
+ * @param response
+ * @returns True if decoding happened or wasn't needed, false otherwise
+ */
+function decode(response) {
+    var _a;
+    const contentEncoding = (_a = response.getHeader(constants_1.HTTP_HEADERS.contentEncoding)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    // When there is no encoding, then there is nothing to decode.
+    if (!contentEncoding) {
+        return true;
+    }
+    switch (contentEncoding) {
+        case constants_1.GZIP_ENCODING: {
+            if (!Buffer.isBuffer(response.body)) {
+                return false;
+            }
+            response.body = zlib_1.gunzipSync(response.body);
+            response.removeHeader(constants_1.HTTP_HEADERS.contentEncoding);
+            response.setHeader(constants_1.HTTP_HEADERS.contentLength, Buffer.byteLength(response.body));
+            return true;
+        }
+        case constants_1.BROTLI_ENCODING: {
+            if (!Buffer.isBuffer(response.body)) {
+                return false;
+            }
+            response.body = zlib_1.brotliDecompressSync(response.body);
+            response.removeHeader(constants_1.HTTP_HEADERS.contentEncoding);
+            response.setHeader(constants_1.HTTP_HEADERS.contentLength, Buffer.byteLength(response.body));
+            return true;
+        }
+        default: {
+            // We cannot decode the body for unsupported encodings.
+            return false;
+        }
+    }
+}
+exports.default = decode;

package/node_modules/@layer0/core/utils/esImport.d.ts

@@ -0,0 +1 @@
+export default function esImport(path: string): Promise<any>;

package/node_modules/@layer0/core/utils/esImport.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file */
+// Workaround for importing ES module within CJS module
+// https://github.com/microsoft/TypeScript/issues/43329#issuecomment-1008361973
+async function esImport(path) {
+    return Function(`return import("${path}")`)();
+}
+exports.default = esImport;

package/node_modules/@layer0/core/utils/fs.d.ts

@@ -0,0 +1 @@
+export { readFileSync, writeFileSync, existsSync } from 'fs';

package/node_modules/@layer0/core/utils/fs.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* istanbul ignore file */
+var fs_1 = require("fs");
+exports.readFileSync = fs_1.readFileSync;
+exports.writeFileSync = fs_1.writeFileSync;
+exports.existsSync = fs_1.existsSync;

package/node_modules/@layer0/core/utils/get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `get` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ */
+export default function get(object: any, path: string): any;

package/node_modules/@layer0/core/utils/get.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `get` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ */
+function get(object, path) {
+    let value = object;
+    const components = path.split('.');
+    for (let component of components) {
+        if (typeof value === 'undefined') {
+            return undefined;
+        }
+        value = value[component];
+    }
+    return value;
+}
+exports.default = get;

package/node_modules/@layer0/core/utils/getPackageVersion.d.ts

@@ -0,0 +1,7 @@
+import SemVer from 'semver/classes/semver';
+/**
+ * Returns the semver version of the specified package. Returns null if the package cannot be found or does not have a main export
+ * @param packageName
+ * @returns
+ */
+export default function getPackageVersion(packageName: string): SemVer | null;

package/node_modules/@layer0/core/utils/getPackageVersion.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_1 = __importDefault(require("semver/functions/parse"));
+const resolve_package_path_1 = __importDefault(require("resolve-package-path"));
+/**
+ * Returns the semver version of the specified package. Returns null if the package cannot be found or does not have a main export
+ * @param packageName
+ * @returns
+ */
+function getPackageVersion(packageName) {
+    // This will return the path to the main module, which will not necessarily be in the root
+    // directory of the package. Next.js is one such example.
+    const packagePath = resolve_package_path_1.default(packageName, process.cwd());
+    return packagePath ? parse_1.default(eval('require')(packagePath).version) : null;
+}
+exports.default = getPackageVersion;

package/node_modules/@layer0/core/utils/has.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `has` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ */
+export default function has(object: any, path: string): any;

package/node_modules/@layer0/core/utils/has.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_1 = __importDefault(require("./get"));
+/**
+ * `has` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ */
+function has(object, path) {
+    return !!get_1.default(object, path);
+}
+exports.default = has;

package/node_modules/@layer0/core/utils/identity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Identity function instead of importing lodash.
+ *
+ * @param x Any object
+ * @returns The same object
+ */
+export default function identity(x: any): any;

package/node_modules/@layer0/core/utils/identity.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Identity function instead of importing lodash.
+ *
+ * @param x Any object
+ * @returns The same object
+ */
+function identity(x) {
+    return x;
+}
+exports.default = identity;

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

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

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var nonWebpackRequire_1 = require("./nonWebpackRequire");
+exports.nonWebpackRequire = nonWebpackRequire_1.default;

package/node_modules/@layer0/core/utils/isEmpty.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `isEmpty` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ */
+export default function isEmpty(value: any): boolean;

package/node_modules/@layer0/core/utils/isEmpty.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `isEmpty` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ */
+function isEmpty(value) {
+    if (!value) {
+        return true;
+    }
+    if (typeof value.length === 'number') {
+        return !value.length;
+    }
+    if (typeof value === 'object' && Object.keys(value).length) {
+        return false;
+    }
+    return true;
+}
+exports.default = isEmpty;

package/node_modules/@layer0/core/utils/isString.d.ts

@@ -0,0 +1 @@
+export default function isString(x: any): boolean;

package/node_modules/@layer0/core/utils/isString.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isString(x) {
+    return typeof x === 'string';
+}
+exports.default = isString;

package/node_modules/@layer0/core/utils/logo.d.ts

@@ -0,0 +1,5 @@
+declare let logo: string;
+export declare const infoLogLabel: string;
+export declare const warnLogLabel: string;
+export declare const errorLogLabel: string;
+export default logo;

package/node_modules/@layer0/core/utils/logo.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nonWebpackRequire_1 = __importDefault(require("./nonWebpackRequire"));
+let logo;
+let label;
+let info = 'info', warn = 'warn', error = 'error';
+try {
+    // We don't bundle chalk in the user lambda because it is a large module that is not required
+    // during runtime. Thus if it cannot be required we default to plain ASCII logo definitions.
+    const chalk = nonWebpackRequire_1.default('chalk');
+    const c1 = chalk.hex('D355A7');
+    label = chalk.grey(`Layer0`);
+    logo = chalk.bold(`Layer${c1('0')}`);
+    info = chalk.cyan(info);
+    warn = chalk.yellow(warn);
+    error = chalk.red(error);
+}
+catch (e) {
+    logo = label = 'Layer0';
+}
+exports.infoLogLabel = `${label} ${info} -`;
+exports.warnLogLabel = `${label} ${warn} -`;
+exports.errorLogLabel = `${label} ${error} -`;
+exports.default = logo;

package/node_modules/@layer0/core/utils/mapValues.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Lightweight port of lodash.mapValues
+ * https://lodash.com/docs/4.17.15#mapValues
+ * @param obj
+ * @param callback
+ */
+export default function mapValues(obj: any, callback: (value: any, key: string) => any): any;

package/node_modules/@layer0/core/utils/mapValues.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Lightweight port of lodash.mapValues
+ * https://lodash.com/docs/4.17.15#mapValues
+ * @param obj
+ * @param callback
+ */
+function mapValues(obj, callback) {
+    const result = {};
+    for (let [key, value] of Object.entries(obj)) {
+        result[key] = callback(value, key);
+    }
+    return result;
+}
+exports.default = mapValues;

package/node_modules/@layer0/core/utils/minBy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `minBy` function instead of importing lodash.
+ *
+ * Note that this function is not entirely equivalent to lodash's but it uses far less space in the bundle.
+ *
+ * @param collection Array of items of type T
+ */
+export default function minBy<T>(collection: T[] | null | undefined, iteratee: (t: T) => any): T | undefined;