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

package/node_modules/@layer0/core/test-utils/matchers/toBeCachedByTheEdge.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const getMessage_1 = __importDefault(require("../utils/getMessage"));
+/**
+ * Matches the edge cache-control header in the response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeCachedByTheEdge()
+ * ...
+ * expect(response).toBeCachedByTheEdge(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be cached for
+ * @returns
+ */
+function toBeCachedByTheEdge(received, duration) {
+    const response = received;
+    const request = response.request;
+    const header = response.getHeader(constants_1.HTTP_HEADERS.x0CacheControl);
+    let pass = !!header;
+    if (header && duration) {
+        pass = new RegExp(`max-age=${duration}`).test(header);
+    }
+    return {
+        message: () => getMessage_1.default(
+        // @ts-ignore
+        this, `toBeCachedByTheEdge${duration ? 'For' : ''}`, `'${request.path}' [[to]] be cached by the edge${duration ? ` for ${duration}ms` : ''}`, header),
+        pass,
+    };
+}
+exports.toBeCachedByTheEdge = toBeCachedByTheEdge;
+exports.toBeCachedByTheEdgeFor = toBeCachedByTheEdge;

package/node_modules/@layer0/core/test-utils/matchers/toBeCachedByTheServiceWorker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Matches the service-worker cache-control header in the response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeCachedByTheServiceWorker()
+ * ...
+ * expect(response).toBeCachedByTheServiceWorker(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be cached for
+ * @returns
+ */
+export declare function toBeCachedByTheServiceWorker(received: any, duration?: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare const toBeCachedByTheServiceWorkerFor: typeof toBeCachedByTheServiceWorker;

package/node_modules/@layer0/core/test-utils/matchers/toBeCachedByTheServiceWorker.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 constants_1 = require("../../constants");
+const getMessage_1 = __importDefault(require("../utils/getMessage"));
+/**
+ * Matches the service-worker cache-control header in the response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeCachedByTheServiceWorker()
+ * ...
+ * expect(response).toBeCachedByTheServiceWorker(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be cached for
+ * @returns
+ */
+function toBeCachedByTheServiceWorker(received, duration) {
+    const response = received;
+    const request = response.request;
+    const header = response.getHeader(constants_1.HTTP_HEADERS.xSwCacheControl);
+    let pass = !!header;
+    if (header) {
+        // @ts-ignore
+        if (this.isNot) {
+            pass = !/no-cache/.test(header);
+            duration = 0;
+        }
+        else if (pass && duration) {
+            pass = new RegExp(`max-age=${duration}`).test(header);
+        }
+    }
+    return {
+        message: () => getMessage_1.default(
+        // @ts-ignore
+        this, `toBeCachedByTheServiceWorker${duration ? 'For' : ''}`, `'${request.path}' [[to]] be cached by the service worker${duration ? ` for ${duration}ms` : ''}`, header),
+        pass,
+    };
+}
+exports.toBeCachedByTheServiceWorker = toBeCachedByTheServiceWorker;
+exports.toBeCachedByTheServiceWorkerFor = toBeCachedByTheServiceWorker;

package/node_modules/@layer0/core/test-utils/matchers/toBeServedStale.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Matches the edge cache-control header for `stale-while-revalidate` in the
+ * response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeServedStale()
+ * ...
+ * expect(response).toBeServedStale(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be stale for
+ * @returns
+ */
+export declare function toBeServedStale(received: any, duration?: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare const toBeServedStaleFor: typeof toBeServedStale;

package/node_modules/@layer0/core/test-utils/matchers/toBeServedStale.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const getMessage_1 = __importDefault(require("../utils/getMessage"));
+/**
+ * Matches the edge cache-control header for `stale-while-revalidate` in the
+ * response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeServedStale()
+ * ...
+ * expect(response).toBeServedStale(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be stale for
+ * @returns
+ */
+function toBeServedStale(received, duration) {
+    const response = received;
+    const request = response.request;
+    const header = response.getHeader(constants_1.HTTP_HEADERS.x0CacheControl);
+    const swrName = 'stale-while-revalidate';
+    const hasDuration = typeof duration !== 'undefined';
+    let pass = !!header, label, message;
+    if (header) {
+        if (!hasDuration) {
+            pass = new RegExp(`${swrName}`).test(header);
+            label = 'toBeServedStale';
+            message = `'${request.path}' [[to]] be served stale`;
+        }
+        else {
+            pass = new RegExp(`${swrName}=${duration}`).test(header);
+            label = 'toBeServedStaleFor';
+            message = `'${request.path}' [[to]] be served stale for ${duration}s`;
+        }
+    }
+    return {
+        message: () => getMessage_1.default(
+        // @ts-ignore
+        this, label, message, header),
+        pass,
+    };
+}
+exports.toBeServedStale = toBeServedStale;
+exports.toBeServedStaleFor = toBeServedStale;

package/node_modules/@layer0/core/test-utils/matchers/toHaveBody.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Matches the response body with the passed string or pattern
+ *
+ * **Example**
+ * ```js
+ * expect(response).toHaveBody('<h1>my title</h1>')
+ * ...
+ * expect(response).toHaveBody(/<h1>.*<\/h1>/)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {String|RegExp} body The value or pattern to match in the response body
+ * @returns
+ */
+export declare function toHaveBody(received: any, body: string | RegExp): {
+    message: () => string;
+    pass: boolean;
+};

package/node_modules/@layer0/core/test-utils/matchers/toHaveBody.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isString_1 = __importDefault(require("../../utils/isString"));
+const getMessage_1 = __importDefault(require("../utils/getMessage"));
+/**
+ * Matches the response body with the passed string or pattern
+ *
+ * **Example**
+ * ```js
+ * expect(response).toHaveBody('<h1>my title</h1>')
+ * ...
+ * expect(response).toHaveBody(/<h1>.*<\/h1>/)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {String|RegExp} body The value or pattern to match in the response body
+ * @returns
+ */
+function toHaveBody(received, body) {
+    const response = received;
+    const request = response.request;
+    const { body: resBody } = response;
+    let pass;
+    if (isString_1.default(body)) {
+        pass = resBody === body;
+    }
+    else {
+        pass = body.test(resBody);
+    }
+    return {
+        message: () => getMessage_1.default(
+        // @ts-ignore
+        this, `toHaveBody`, `'${request.path}' [[to]] have body ${body}`, resBody),
+        pass,
+    };
+}
+exports.toHaveBody = toHaveBody;

package/node_modules/@layer0/core/test-utils/matchers/toHaveHeader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Matches the response header with the passed string or pattern
+ *
+ * **Example**
+ * ```js
+ * expect(response).toHaveHeader('x-my-header', 'foo')
+ * ...
+ * expect(response).toHaveHeader('x-my-header', /foo|bar/)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {String} name The name of the header
+ * @param {String|RegExp} [value] The value or pattern to match
+ * @returns
+ */
+export declare function toHaveHeader(received: any, name: string, value?: string | RegExp): {
+    message: () => string;
+    pass: boolean;
+};

package/node_modules/@layer0/core/test-utils/matchers/toHaveHeader.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isString_1 = __importDefault(require("../../utils/isString"));
+const getMessage_1 = __importDefault(require("../utils/getMessage"));
+/**
+ * Matches the response header with the passed string or pattern
+ *
+ * **Example**
+ * ```js
+ * expect(response).toHaveHeader('x-my-header', 'foo')
+ * ...
+ * expect(response).toHaveHeader('x-my-header', /foo|bar/)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {String} name The name of the header
+ * @param {String|RegExp} [value] The value or pattern to match
+ * @returns
+ */
+function toHaveHeader(received, name, value) {
+    const response = received;
+    const request = response.request;
+    const header = response.getHeader(name);
+    let pass = !!header;
+    if (header && value) {
+        if (isString_1.default(value)) {
+            pass = header === value;
+        }
+        else {
+            pass = value.test(header);
+        }
+    }
+    return {
+        message: () => getMessage_1.default(
+        // @ts-ignore
+        this, `toHaveHeader`, `'${request.path}' [[to]] have header ${name}${value ? `=${value}` : ''}`, header),
+        pass,
+    };
+}
+exports.toHaveHeader = toHaveHeader;

package/node_modules/@layer0/core/test-utils/matchers.d.ts

@@ -0,0 +1,6 @@
+export { toHaveHeader } from './matchers/toHaveHeader';
+export { toBeCachedByTheEdge, toBeCachedByTheEdgeFor } from './matchers/toBeCachedByTheEdge';
+export { toBeCachedByTheBrowser, toBeCachedByTheBrowserFor, } from './matchers/toBeCachedByTheBrowser';
+export { toBeCachedByTheServiceWorker, toBeCachedByTheServiceWorkerFor, } from './matchers/toBeCachedByTheServiceWorker';
+export { toBeServedStale, toBeServedStaleFor } from './matchers/toBeServedStale';
+export { toHaveBody } from './matchers/toHaveBody';

package/node_modules/@layer0/core/test-utils/matchers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var toHaveHeader_1 = require("./matchers/toHaveHeader");
+exports.toHaveHeader = toHaveHeader_1.toHaveHeader;
+var toBeCachedByTheEdge_1 = require("./matchers/toBeCachedByTheEdge");
+exports.toBeCachedByTheEdge = toBeCachedByTheEdge_1.toBeCachedByTheEdge;
+exports.toBeCachedByTheEdgeFor = toBeCachedByTheEdge_1.toBeCachedByTheEdgeFor;
+var toBeCachedByTheBrowser_1 = require("./matchers/toBeCachedByTheBrowser");
+exports.toBeCachedByTheBrowser = toBeCachedByTheBrowser_1.toBeCachedByTheBrowser;
+exports.toBeCachedByTheBrowserFor = toBeCachedByTheBrowser_1.toBeCachedByTheBrowserFor;
+var toBeCachedByTheServiceWorker_1 = require("./matchers/toBeCachedByTheServiceWorker");
+exports.toBeCachedByTheServiceWorker = toBeCachedByTheServiceWorker_1.toBeCachedByTheServiceWorker;
+exports.toBeCachedByTheServiceWorkerFor = toBeCachedByTheServiceWorker_1.toBeCachedByTheServiceWorkerFor;
+var toBeServedStale_1 = require("./matchers/toBeServedStale");
+exports.toBeServedStale = toBeServedStale_1.toBeServedStale;
+exports.toBeServedStaleFor = toBeServedStale_1.toBeServedStaleFor;
+var toHaveBody_1 = require("./matchers/toHaveBody");
+exports.toHaveBody = toHaveBody_1.toHaveBody;

package/node_modules/@layer0/core/test-utils/utils/createRouteMock.d.ts

@@ -0,0 +1,21 @@
+import MockRequest from '../MockRequest';
+import MockResponse from '../MockResponse';
+import Headers from '../../router/Headers';
+export interface MockRun {
+    request: MockRequest;
+    response: MockResponse;
+}
+interface RequestOptions {
+    path: string;
+    method?: string;
+    headers?: Headers;
+    body?: string;
+}
+/**
+ * Creates a mock Request and Response object the router will
+ * consume when running the specified request
+ * @param options
+ * @returns
+ */
+export default function createRouteMock(options: string | RequestOptions): MockRun;
+export {};

package/node_modules/@layer0/core/test-utils/utils/createRouteMock.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 MockRequest_1 = __importDefault(require("../MockRequest"));
+const MockResponse_1 = __importDefault(require("../MockResponse"));
+const isString_1 = __importDefault(require("../../utils/isString"));
+/**
+ * Creates a mock Request and Response object the router will
+ * consume when running the specified request
+ * @param options
+ * @returns
+ */
+function createRouteMock(options) {
+    const requestOptions = {};
+    if (isString_1.default(options)) {
+        Object.assign(requestOptions, { path: options, url: options });
+    }
+    else {
+        Object.assign(requestOptions, options);
+    }
+    const request = new MockRequest_1.default(requestOptions);
+    const response = new MockResponse_1.default({ request });
+    return { request, response };
+}
+exports.default = createRouteMock;

package/node_modules/@layer0/core/test-utils/utils/getBackend.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Gets the default host for the app
+ */
+export declare function appHost(): string;
+/**
+ * Gets the default host for static assets
+ */
+export declare function staticHost(): string;
+/**
+ * Gets the host for the given backend name
+ * @param backend
+ */
+export declare function backendHost(backend: string): string;

package/node_modules/@layer0/core/test-utils/utils/getBackend.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 config_1 = __importDefault(require("../../config"));
+const ports_1 = require("../../utils/ports");
+/**
+ * Gets the default host for the app
+ */
+function appHost() {
+    return `${ports_1.localhost}:${ports_1.jsPort}`;
+}
+exports.appHost = appHost;
+/**
+ * Gets the default host for static assets
+ */
+function staticHost() {
+    return `${ports_1.localhost}:${ports_1.assetPort}`;
+}
+exports.staticHost = staticHost;
+/**
+ * Gets the host for the given backend name
+ * @param backend
+ */
+function backendHost(backend) {
+    const { domainOrIp, port } = config_1.default.all.backends[backend];
+    return port ? `${domainOrIp}:${port}` : domainOrIp;
+}
+exports.backendHost = backendHost;

package/node_modules/@layer0/core/test-utils/utils/getMessage.d.ts

@@ -0,0 +1 @@
+export default function getMessage(context: any, matcher: string, label: string, received: any): string;

package/node_modules/@layer0/core/test-utils/utils/getMessage.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+function getMessage(context, matcher, label, received) {
+    const to = context.isNot ? 'not to' : 'to';
+    label = label.replace(/\[\[to\]\]/g, to);
+    return [
+        `Matcher: ${context.isNot ? '.not' : ''}.${matcher}`,
+        chalk_1.default.green(`${chalk_1.default.bold('Expected:')} ${label}`),
+        chalk_1.default.red(`${chalk_1.default.bold('Received:')} ${received}`),
+    ].join('\n');
+}
+exports.default = getMessage;

package/node_modules/@layer0/core/test-utils/utils/runRoute.d.ts

@@ -0,0 +1,10 @@
+import Router from '../../router/Router';
+import { MockRun } from './createRouteMock';
+import MockResponse from '../MockResponse';
+/**
+ * Runs the provided path against the router, returning the mocked response
+ * @param router A router instance
+ * @param path The path, or result from `createRouteMock`, to run on the router
+ * @returns Promise<MockResponse>
+ */
+export default function runRoute(router: Router, path: string | MockRun): Promise<MockResponse>;

package/node_modules/@layer0/core/test-utils/utils/runRoute.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRouteMock_1 = __importDefault(require("./createRouteMock"));
+const constants_1 = require("../../constants");
+const ports_1 = require("../../utils/ports");
+/**
+ * Runs the provided path against the router, returning the mocked response
+ * @param router A router instance
+ * @param path The path, or result from `createRouteMock`, to run on the router
+ * @returns Promise<MockResponse>
+ */
+async function runRoute(router, path) {
+    let request, response;
+    if (typeof path === 'string') {
+        ;
+        ({ request, response } = createRouteMock_1.default(path));
+    }
+    else {
+        ;
+        ({ request, response } = path);
+    }
+    router
+        .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: ports_1.localhost, port: ports_1.jsPort });
+    // @ts-ignore
+    await router.run(request, response);
+    return response;
+}
+exports.default = runRoute;

package/node_modules/@layer0/core/timing.d.ts

@@ -0,0 +1,115 @@
+import Response from './router/Response';
+export declare const NOT_ENDED_VALUE = "na";
+export declare class InternalTiming {
+    /**
+     * The name assigned to the timing in response headers
+     */
+    readonly name: string;
+    /**
+     * The time the timing started
+     */
+    startTime?: Date;
+    /**
+     * The number of milliseconds elapsed
+     */
+    duration: number;
+    /**
+     * A discrete value for the timing, for example "hit" for "ecc"
+     */
+    discreteValue?: string;
+    /**
+     * Set to true if the timing has been ended
+     */
+    ended: boolean;
+    /**
+     * @param name The name of the timing component that will be reported in the `x-0-user-t` header
+     */
+    constructor(name: string, internal?: boolean);
+    /**
+     * Starts the timing.
+     * @returns A self-reference, suitable for chaining
+     */
+    start(): this;
+    /**
+     * Sets the discrete value for this timing
+     * @param discreteValue
+     * @returns A self-reference, suitable for chaining
+     */
+    set(discreteValue: string): this;
+    /**
+     * Ends the timing.
+     * @returns A self-reference, suitable for chaining
+     */
+    end(): this;
+    /**
+     * Convenience method that is the same as `end`, but meant to indicate
+     * that the timing may be resumed later
+     */
+    pause(): this;
+    /**
+     * Convenience method that is the same as `start`, but meant to indicate
+     * that the timing has been paused.
+     */
+    resume(): this;
+    /**
+     * Gets the value of the timing for response headers. Will be 'na' if not started, otherwise
+     * the numeric duration in milliseconds.
+     */
+    get value(): string | number;
+}
+/**
+ * A higher order function that wraps the provided function in a request context with user
+ * and internal timings reset
+ * @private
+ * @param handler
+ */
+export declare function withTimings<T extends Promise<any>>(handler: (...args: any[]) => T): (...args: any[]) => any;
+/**
+ * Returns the value of the internal timing with the specified name
+ * @private
+ * @param name The name of an internal timing, for example "ecc"
+ */
+export declare function getInternalTiming(name: string): string | number | undefined;
+/**
+ * Adds x-0-t, x-0-user-t, and server-timing headers to the response
+ * @private
+ * @param response
+ */
+export declare function addTimings(response: Response): void;
+/**
+ * Allows you to track the performance of your code and asynchronous operations such as fetches.
+ * Timings will be returned as a comma delimited list in the `x-0-user-t` header.
+ *
+ * ** Example **
+ *
+ * ```js
+ * import Timing from '@layer0/core/timing'
+ *
+ * const timing = new Timing('fetch').start()
+ * const result = await fetch('http://my-api.com/products/1')
+ * timing.end() // will result in `x-0-user-t: fetch=(millis)` response header
+ * ```
+ *
+ * If a timing is started but not finished by the time the response is sent, the value will be `na`.
+ */
+export default class Timing extends InternalTiming {
+    constructor(name: string);
+}
+/**
+ * Names for x-0-t components
+ */
+export declare enum InternalNames {
+    edgeCache = "ecc",
+    transformRequest = "wa",
+    transformResponse = "wz",
+    routeMatching = "wr",
+    proxying = "wp"
+}
+/**
+ * Values for edgeCache component of x-0-t
+ */
+export declare enum CacheValue {
+    hit = "hit",
+    pass = "pass",
+    cached = "cached"
+}