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

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `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
+ */
+function minBy(collection, iteratee) {
+    if (!collection || !collection.length) {
+        return undefined;
+    }
+    let min;
+    let minIterateeValue;
+    let minIterateeAssigned = false;
+    for (let item of collection) {
+        if (!minIterateeAssigned) {
+            min = item;
+            if (iteratee) {
+                minIterateeValue = iteratee(item);
+            }
+            minIterateeAssigned = true;
+            continue;
+        }
+        if (iteratee) {
+            const iterateeValue = iteratee(item);
+            if (iterateeValue < minIterateeValue) {
+                min = item;
+                minIterateeValue = iterateeValue;
+            }
+        }
+        else {
+            if (item < min) {
+                min = item;
+            }
+        }
+    }
+    return min;
+}
+exports.default = minBy;

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

@@ -0,0 +1,11 @@
+/**
+ * Loads a module at runtime, ensuring that it won't be bundled by webpack. This function
+ * also ensures proper behavior on windows, *nix, and macos filesystems, even if the module
+ * path is derived from a file path with backslashes. This function will return undefined if
+ * the module could not be loaded.
+ * @param modulePath The path to the module to load
+ * @param options.ignoreErrors Will return undefined if the module fails to load
+ */
+export default function nonWebpackRequire(modulePath: string, { ignoreErrors }?: {
+    ignoreErrors?: boolean;
+}): any;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slash_1 = __importDefault(require("slash"));
+/**
+ * Loads a module at runtime, ensuring that it won't be bundled by webpack. This function
+ * also ensures proper behavior on windows, *nix, and macos filesystems, even if the module
+ * path is derived from a file path with backslashes. This function will return undefined if
+ * the module could not be loaded.
+ * @param modulePath The path to the module to load
+ * @param options.ignoreErrors Will return undefined if the module fails to load
+ */
+function nonWebpackRequire(modulePath, { ignoreErrors = false } = {}) {
+    try {
+        return eval('require')(slash_1.default(modulePath));
+    }
+    catch (e) {
+        if (ignoreErrors) {
+            return undefined;
+        }
+        else {
+            throw e;
+        }
+    }
+}
+exports.default = nonWebpackRequire;

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

@@ -0,0 +1,12 @@
+/**
+ * Read in the contents of package.json
+ * @param [path=package.json] Relative path to the resouce
+ * @return {Object}
+ */
+export declare function read(path?: string): any;
+/**
+ * Writes the contents to package.json
+ * @param contents
+ * @param [path='package.json'] Relative path to the resouce
+ */
+export declare function write(contents: string, path?: string): void;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("./fs");
+/**
+ * Read in the contents of package.json
+ * @param [path=package.json] Relative path to the resouce
+ * @return {Object}
+ */
+function read(path = 'package.json') {
+    return JSON.parse(fs_1.readFileSync(path_1.join(process.cwd(), path), 'utf8'));
+}
+exports.read = read;
+/**
+ * Writes the contents to package.json
+ * @param contents
+ * @param [path='package.json'] Relative path to the resouce
+ */
+function write(contents, path = 'package.json') {
+    fs_1.writeFileSync(path_1.join(process.cwd(), path), contents, 'utf8');
+}
+exports.write = write;

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

@@ -0,0 +1,5 @@
+export declare const port: number;
+export declare const jsPort: number;
+export declare const assetPort: number;
+export declare const localhost = "127.0.0.1";
+export declare const localhostWithPort: string;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.port = Number(process.env.PORT) || 3000;
+exports.jsPort = exports.port + 1;
+exports.assetPort = exports.port + 2;
+exports.localhost = '127.0.0.1';
+exports.localhostWithPort = `${exports.localhost}:${exports.port}`;

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

@@ -0,0 +1,7 @@
+import Request from '../router/Request';
+/**
+ * Reads the request body and adds it to request.body
+ * @param req
+ * @return {Promise}
+ */
+export default function readBody(req: Request): Promise<unknown>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Reads the request body and adds it to request.body
+ * @param req
+ * @return {Promise}
+ */
+function readBody(req) {
+    return new Promise(resolve => {
+        req.body = '';
+        req.on('data', (chunk) => (req.body += chunk.toString()));
+        req.on('end', resolve);
+    });
+}
+exports.default = readBody;

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import Request from '../router/Request';
+/**
+ * Reads the request body and returns it. It can only be used once per request.
+ *
+ * @param req
+ * @return {Promise<Buffer>}
+ */
+export default function readRawBody(req: Request): Promise<Buffer>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Reads the request body and returns it. It can only be used once per request.
+ *
+ * @param req
+ * @return {Promise<Buffer>}
+ */
+function readRawBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunk && chunks.push(chunk));
+        req.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        req.on('abort', (e) => {
+            reject(e);
+        });
+    });
+}
+exports.default = readRawBody;

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

@@ -0,0 +1,12 @@
+/**
+ * Escapes a string to be compatible with a RegExp
+ * @param string
+ * @returns {String}
+ */
+export default function regExpEscape(string: string): string;
+/**
+ * Converts the given string into a RegExp
+ * @param string
+ * @returns {RegExp}
+ */
+export declare function toRegExp(string: string): RegExp;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Escapes a string to be compatible with a RegExp
+ * @param string
+ * @returns {String}
+ */
+function regExpEscape(string) {
+    return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+exports.default = regExpEscape;
+/**
+ * Converts the given string into a RegExp
+ * @param string
+ * @returns {RegExp}
+ */
+function toRegExp(string) {
+    return new RegExp(regExpEscape(string));
+}
+exports.toRegExp = toRegExp;

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

@@ -0,0 +1,7 @@
+/**
+ * Dynamically requires the version of a package listed in @layer0/core's depedencies
+ * This allows us to ensure we are targeting the version of a package, such as globby, that is listed
+ * in @layer0/core's package.json, as opposed to whatever version may or may not be included in the user's
+ * app, which may not be compatible.
+ */
+export default function requireInternal(packagePath: string): any;

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

@@ -0,0 +1,24 @@
+"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"));
+/**
+ * Dynamically requires the version of a package listed in @layer0/core's depedencies
+ * This allows us to ensure we are targeting the version of a package, such as globby, that is listed
+ * in @layer0/core's package.json, as opposed to whatever version may or may not be included in the user's
+ * app, which may not be compatible.
+ */
+function requireInternal(packagePath) {
+    try {
+        const resolved = require.resolve(packagePath, {
+            paths: [require.resolve('@layer0/core')],
+        });
+        return nonWebpackRequire_1.default(resolved);
+    }
+    catch (e) {
+        return nonWebpackRequire_1.default(packagePath);
+    }
+}
+exports.default = requireInternal;

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

@@ -0,0 +1,10 @@
+/**
+ * `set` 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 set(object: {
+    [key: string]: any;
+}, path: string, value: any): {
+    [key: string]: any;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * `set` 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 set(object, path, value) {
+    const components = path.split('.');
+    let subObject = object;
+    for (let i = 0; i < components.length - 1; ++i) {
+        const component = components[i];
+        if (typeof subObject[component] !== 'object') {
+            subObject[component] = {};
+        }
+        subObject = subObject[component];
+    }
+    subObject[components.pop()] = value;
+    return object;
+}
+exports.default = set;

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

@@ -0,0 +1,11 @@
+/**
+ * Converts a JavaScript Regexp instance to a string compatible with edge.
+ * See https://docs.fastly.com/en/guides/vcl-regular-expression-cheat-sheet
+ * @param regex
+ */
+export default function toEdgeRegex(regex: RegExp): string;
+/**
+ * Reverse transformation. Mostly used for unit tests.
+ * @param edgeRegex
+ */
+export declare function fromEdgeRegex(edgeRegex: string): RegExp;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Converts a JavaScript Regexp instance to a string compatible with edge.
+ * See https://docs.fastly.com/en/guides/vcl-regular-expression-cheat-sheet
+ * @param regex
+ */
+function toEdgeRegex(regex) {
+    return `${regex.ignoreCase ? '(?i)' : ''}${regex.source}`.replace(/\\\//g, '/');
+}
+exports.default = toEdgeRegex;
+/**
+ * Reverse transformation. Mostly used for unit tests.
+ * @param edgeRegex
+ */
+function fromEdgeRegex(edgeRegex) {
+    const ignoreCase = edgeRegex.indexOf('(?i)') === 0;
+    if (ignoreCase) {
+        edgeRegex = edgeRegex.slice('(?i)'.length);
+    }
+    return new RegExp(edgeRegex.replace(/\//g, '/'), ignoreCase ? 'i' : '');
+}
+exports.fromEdgeRegex = fromEdgeRegex;

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

@@ -0,0 +1,12 @@
+/**
+ * Converts an HTTP method name to RegExp that it matches in case-insensitive manner.
+ *
+ * Notes:
+ * - We use this in both cloud router and edge router to ensure that we can identify
+ * explicit POST matching (which in turn we need to only turn on POST caching when
+ * explicitly configured)
+ *
+ * @param method
+ * @private
+ */
+export default function toHttpMethodMatchRegex(method: string): RegExp;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Converts an HTTP method name to RegExp that it matches in case-insensitive manner.
+ *
+ * Notes:
+ * - We use this in both cloud router and edge router to ensure that we can identify
+ * explicit POST matching (which in turn we need to only turn on POST caching when
+ * explicitly configured)
+ *
+ * @param method
+ * @private
+ */
+function toHttpMethodMatchRegex(method) {
+    return new RegExp(`^${method}$`, 'i');
+}
+exports.default = toHttpMethodMatchRegex;

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

@@ -0,0 +1 @@
+export default function toLower(str: string): string;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function toLower(str) {
+    if (typeof str !== 'string') {
+        return '';
+    }
+    return str.toLowerCase();
+}
+exports.default = toLower;

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

@@ -0,0 +1,5 @@
+/**
+ * Validates if provided backend exists in the config
+ * @param backend
+ */
+export default function validateBackends(backend: string): void | Error;

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

@@ -0,0 +1,30 @@
+"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 config_1 = __importDefault(require("../config"));
+/**
+ * Validates if provided backend exists in the config
+ * @param backend
+ */
+function validateBackends(backend) {
+    if (Object.values(constants_1.BACKENDS).includes(backend)) {
+        return;
+    }
+    if (config_1.default.get(`backends.${backend}`, false)) {
+        return;
+    }
+    const backends = Object.keys(config_1.default.get('backends'));
+    if (backends && backends.length) {
+        throw new Error(`To fix this problem use one of the "backends" configured in layer0.config.js:${os_1.EOL}${os_1.EOL}` +
+            ` - ${backends.join(`${os_1.EOL} - `)}${os_1.EOL}${os_1.EOL}` +
+            `or add "${backend}" to the "backends" property in layer0.config.js.`);
+    }
+    else {
+        throw new Error(`Add "${backend}" to the "backends" property in layer0.config.js.`);
+    }
+}
+exports.default = validateBackends;

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

@@ -0,0 +1,10 @@
+import { WatchOptions } from 'chokidar';
+/**
+ * Loads a module at runtime, ensuring that it won't be bundled by webpack. This function
+ * also ensures proper behavior on windows, *nix, and macos filesystems, even if the module
+ * path is derived from a file path with backslashes. This function will return undefined if
+ * the module could not be loaded.
+ * @param modulePath The path to the module to load
+ * @param options.ignoreErrors Will return undefined if the module fails to load
+ */
+export default function watch(paths: string | ReadonlyArray<string>, options?: WatchOptions): any;

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

@@ -0,0 +1,17 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+/**
+ * Loads a module at runtime, ensuring that it won't be bundled by webpack. This function
+ * also ensures proper behavior on windows, *nix, and macos filesystems, even if the module
+ * path is derived from a file path with backslashes. This function will return undefined if
+ * the module could not be loaded.
+ * @param modulePath The path to the module to load
+ * @param options.ignoreErrors Will return undefined if the module fails to load
+ */
+function watch(paths, options) {
+    const chokidar = _1.nonWebpackRequire('chokidar');
+    return chokidar.watch(paths, options);
+}
+exports.default = watch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohos-ports/layer0-prefetch",
-  "version": "4.20.0-beta.0",
+  "version": "4.20.0-beta.1",
   "description": "Enables prefetching and caching of pages using Layer0 and Workbox.",
   "main": "index.js",
   "directories": {
@@ -15,7 +15,40 @@
     "workbox-expiration": "^5.1.2",
     "workbox-precaching": "^5.1.4",
     "workbox-routing": "^5.1.2",
-    "workbox-strategies": "^5.1.2"
+    "workbox-strategies": "^5.1.2",
+    "@babel/parser": "^7.18.9",
+    "@babel/traverse": "^7.18.9",
+    "@types/lodash.clonedeep": "^4.5.6",
+    "ajv": "^6.12.6",
+    "babel-loader": "^8.2.2",
+    "chalk": "^4.1.2",
+    "chardet": "^1.4.0",
+    "chokidar": "^3.5.1",
+    "cls-hooked": "^4.2.2",
+    "content-type": "^1.0.4",
+    "cookie": "^0.4.1",
+    "cross-spawn": "^7.0.3",
+    "decode-uri-component": "^0.2.0",
+    "deepmerge": "^4.2.2",
+    "express": "^4.17.1",
+    "fs-extra": "^8.1.0",
+    "globby": "^11.0.2",
+    "http-proxy": "^1.18.1",
+    "lodash.clonedeep": "^4.5.0",
+    "lru-cache": "^6.0.0",
+    "mime-types": "^2.1.35",
+    "node-fetch": "^2.6.1",
+    "path-to-regexp": "^6.2.0",
+    "pino": "^6.13.3",
+    "qs": "^6.10.1",
+    "resolve-package-path": "^4.0.3",
+    "semver": "^7.3.5",
+    "shelljs": "^0.8.5",
+    "slash": "^3.0.0",
+    "tcp-port-used": "^1.0.2",
+    "ts-loader": "^8.2.0",
+    "unixify": "^1.0.0",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@types/cheerio": "0.22.18",
@@ -46,5 +79,16 @@
     "sw/",
     "window/",
     "README.md"
-  ]
+  ],
+  "overrides": {
+    "esbuild": "npm:@ohos-ports/esbuild@0.28.1-beta.2"
+  },
+  "bundleDependencies": [
+    "@layer0/core"
+  ],
+  "peerDependenciesMeta": {
+    "@layer0/devtools": {
+      "optional": true
+    }
+  }
 }