@salesforce/pwa-kit-runtime 3.9.0-nightly-20241206080208 → 4.0.0-extensibility-preview.0

package/utils/ssr-config.server.d.ts

@@ -0,0 +1,2 @@
+export function getConfig(opts?: {}): any;
+//# sourceMappingURL=ssr-config.server.d.ts.map

package/utils/ssr-config.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-config.server.d.ts","sourceRoot":"","sources":["../../src/utils/ssr-config.server.js"],"names":[],"mappings":"AA6CO,0CAqDN"}

package/utils/ssr-namespace-paths.d.ts

@@ -0,0 +1,7 @@
+export const ssrNamespace: string;
+export const proxyBasePath: string;
+export const bundleBasePath: string;
+export const cachingBasePath: string;
+export const healthCheckPath: string;
+export const slasPrivateProxyPath: string;
+//# sourceMappingURL=ssr-namespace-paths.d.ts.map

package/utils/ssr-namespace-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-namespace-paths.d.ts","sourceRoot":"","sources":["../../src/utils/ssr-namespace-paths.js"],"names":[],"mappings":"AAoCA,kCAA2C;AAE3C,mCAAgE;AAChE,oCAAkE;AAClE,qCAAoE;AACpE,qCAAmE;AACnE,0CAAsF"}

package/utils/ssr-proxying.d.ts

@@ -0,0 +1,173 @@
+export const X_PROXY_REQUEST_URL: "x-proxy-request-url";
+export const X_MOBIFY_REQUEST_CLASS: "x-mobify-request-class";
+export const MAX_URL_LENGTH_BYTES: 8192;
+/**
+ * This class provides a representation of HTTP request or response
+ * headers, that operates in the same way in multiple contexts
+ * (i.e. within the Express app as well as the request-processor).
+ *
+ * Within a Headers instance, headers are referenced using lower-case
+ * names. Use getHeader to access the value for a header. If there
+ * are multiple values, this will return the first value. This class
+ * internally supports round-trip preservation of multi-value headers,
+ * but does not yet provide a way to access them.
+ */
+export class Headers {
+    /**
+     * Construct a Headers object from either an AWS Lambda Event headers
+     * object, or an http.IncomingMessage headers object.
+     *
+     * Project code should never need to call this constructor.
+     *
+     * @private
+     * @param headers {Object} the input headers
+     * @param format {String} either 'http' or 'aws'
+     */
+    private constructor();
+    httpFormat: boolean;
+    headers: {};
+    _modified: boolean;
+    /**
+     * Return true if and only if any set or delete methods were called on
+     * this instance after construction. This does not actually test if
+     * the headers values have been changed, just whether any mutating
+     * methods have been called.
+     * @returns {Boolean}
+     */
+    get modified(): boolean;
+    /**
+     * Return an array of the header keys (all lower-case)
+     */
+    keys(): string[];
+    /**
+     * Get the value of the set-cookie header(s), returning an array
+     * of strings. Always returns an array, even if it's empty.
+     */
+    getSetCookie(): any;
+    /**
+     * Set the value of the set-cookie header(s)
+     * @param values {string[]}
+     */
+    setSetCookie(values: string[]): void;
+    /**
+     * Return the FIRST value of the header with the given key.
+     * This is for single-value headers only: Location, Access-Control-*, etc
+     * If the header is not present, returns undefined.
+     * @param key {String} header name
+     */
+    getHeader(key: string): any;
+    /**
+     * Set the value of the header with the given key. This is for single-
+     * value headers only (see getHeader). Setting the value removes ALL other
+     * values for the given key.
+     * @param key {String} header name
+     * @param value {String} header value
+     */
+    setHeader(key: string, value: string): void;
+    /**
+     * Remove any header with the given key
+     * @param key
+     */
+    deleteHeader(key: any): void;
+    /**
+     * Return the headers in AWS (Lambda event) format.
+     *
+     * Project code should never need to use this method.
+     */
+    toAWSFormat(): {};
+    /**
+     * Return the headers in Express (http.IncomingMessage) format.
+     *
+     * RFC2616 allows some flexibility in how multiple values are
+     * combined into a single header value. We separate with ', '
+     * rather than just ',' to maintain previous behaviour.
+     *
+     * Project code should never need to use this method.
+     */
+    toHTTPFormat(): {};
+    /**
+     * Return the headers in the same format (aws or http) that was
+     * used to construct them.
+     *
+     * Project code should never need to use this method.
+     */
+    toObject(): {};
+}
+export function rfc1123(date: Date): string;
+export function cookieAsString(cookie: any): string;
+export function parseHost(host: string): ParsedHost;
+export function rewriteDomain(domain: any, appHostname: any, targetHost: any): any;
+export function rewriteSetCookies({ appHostname, setCookies, targetHost, logging }: string): any;
+export function rewriteProxyResponseHeaders({ appHostname, caching, headers, headerFormat, proxyPath, requestUrl, statusCode, targetProtocol, targetHost, appProtocol, logging }: string): Object;
+/**
+ * List of x- headers that are removed from proxied requests.
+ * @private
+ * @type {string[]}
+ */
+export const X_HEADERS_TO_REMOVE_PROXY: string[];
+/**
+ * List of x- headers that are removed from origin requests.
+ * @private
+ * @type {string[]}
+ */
+export const X_HEADERS_TO_REMOVE_ORIGIN: string[];
+/**
+ * X-header key and values to add to proxied requests
+ * @private
+ * @type {Object}
+ */
+export const X_HEADERS_TO_ADD: Object;
+/**
+ * List of headers that are allowed for a caching proxy request.
+ * This must match the allowlist that CloudFront uses for a
+ * CacheBehavior that does not pass cookies and is not configured
+ * to cache based on headers.
+ *
+ * This is a map from lower-case header name to 'true' - we use an object
+ * to make lookups fast, since this mapping might be used for many requests.
+ *
+ * Also see what is configured in the SSR Manager (ssr-infrastructure repo),
+ * in the CloudFront configuration. This list is a superset of that list,
+ * since the proxying code must also allow headers that it adds, such as
+ * Host, Origin, etc.
+ *
+ * See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/header-caching.html
+ * See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/Cookies.html
+ *
+ * @private
+ */
+export const ALLOWED_CACHING_PROXY_REQUEST_HEADERS: {
+    accept: boolean;
+    'accept-charset': boolean;
+    'accept-encoding': boolean;
+    'accept-language': boolean;
+    authorization: boolean;
+    range: boolean;
+    host: boolean;
+    origin: boolean;
+    'if-match': boolean;
+    'if-modified-since': boolean;
+    'if-none-match': boolean;
+    'if-range': boolean;
+    'if-unmodified-since': boolean;
+};
+export function rewriteProxyRequestHeaders({ caching, headers, headerFormat, targetProtocol, targetHost, logging }: boolean): Object;
+export type ParsedHost = {
+    /**
+     * The host (10.10.10.10:port), which includes the port (if any)
+     */
+    host: string;
+    /**
+     * The hostname (10.10.10.10), which excludes the port
+     */
+    hostname: string;
+    /**
+     * The host's port
+     */
+    port: string;
+    /**
+     * Whether the hostname is an IP or localhost
+     */
+    isIPOrLocalhost: boolean;
+};
+//# sourceMappingURL=ssr-proxying.d.ts.map

package/utils/ssr-proxying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-proxying.d.ts","sourceRoot":"","sources":["../../src/utils/ssr-proxying.js"],"names":[],"mappings":"AA8BA,wDAAwD;AACxD,8DAA8D;AAC9D,wCAAwC;AAExC;;;;;;;;;;GAUG;AACH;IAkCI;;;;;;;;;OASG;IACH,sBA4BC;IAxBG,oBAAmC;IAInC,YAAiB;IAmBjB,mBAAsB;IAG1B;;;;;;OAMG;IACH,wBAEC;IAED;;OAEG;IACH,iBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,qBAFkB,MAAM,EAAE,QAYzB;IAED;;;;;OAKG;IACH,4BAOC;IAED;;;;;;OAMG;IACH,4CAIC;IAED;;;OAGG;IACH,6BAIC;IAED;;;;OAIG;IACH,kBAgBC;IAED;;;;;;;;OAQG;IACH,mBAWC;IAED;;;;;OAKG;IACH,eAEC;CACJ;AA+BM,8BAHS,IAAI,UAiBnB;AAOM,oDA2BN;AAkFM,yCAFK,UAAU,CA0CrB;AAGM,mFAyCN;AAeM,iGA6BN;AAuCM,2LAFM,MAAM,CA4IlB;AAED;;;;GAIG;AACH,wCAFU,MAAM,EAAE,CAEuE;AAEzF;;;;GAIG;AACH,yCAFU,MAAM,EAAE,CAQjB;AAED;;;;GAIG;AACH,+BAFU,MAAM,CAIf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;;;;;;;;;;;;;;EAsBC;AAuBM,8HAFM,MAAM,CAiGlB"}

package/utils/ssr-request-processing.d.ts

@@ -0,0 +1,90 @@
+/**
+ * A class that represents and can manipulate a parsed
+ * query string as a subclass of Array.
+ *
+ * The values in the Array are objects.
+ *
+ * The values in the Array are objects with 'key', 'originalKey'
+ * 'value' and 'originalValue'. The 'key' is decoded (from %-encoding)
+ * and lowercased.
+ * The 'originalKey' is as it originally occurred in the query string. It's
+ * not decoded or lowercased.
+ * The 'originalValue' is as it originally occurred in the query string. It's
+ * not decoded.
+ * The 'value' is decoded (from %-encoding).
+ *
+ * If the query parameter is 'key=value', all fields are set.
+ * If the query parameter is 'key=' then 'value' and 'originalValue' will be
+ * the empty string.
+ * If the query parameter is just 'key' then 'value' and 'originalValue' will
+ * be null.
+ * If the query parameter is empty (double-&) then 'key' and 'originalKey' will
+ * be '', 'value' and 'originalValue' will be null.
+ *
+ * It's important that we PRESERVE the order of the parameters
+ * because some projects rely on it. The 'querystring' module
+ * assigns values to the resulting object in the order that it
+ * encounters them in the input string. Since ES2015 there are
+ * specific rules defining the order of properties, and apart
+ * from one particular case the order is chronological, which is
+ * what we want. The order of properties in an object depends on
+ * the type of the included properties and their values. Unfortunately,
+ * integer indices always come first, and the rules state that
+ * "an integer index is a string that, if converted to a 53-bit
+ * non-negative integer and back is the same value". This means that
+ * any parameter whose key is an integer index will appear out of
+ * order in the result. Thus we can't use the 'querystring' module.
+ */
+export class QueryParameters {
+    /**
+     * Construct a new QueryParameters from the output of
+     * any filtering or mapping done on another QueryParameters
+     * instance's 'parameters' array.
+     * @return {QueryParameters}
+     */
+    static from(...args: any[]): QueryParameters;
+    constructor(querystring: any);
+    _parameters: any;
+    /**
+     * Access the array of parameters owned by this QueryParameters
+     * object.
+     */
+    get parameters(): any;
+    /**
+     * Delete any query parameters with the given key.
+     * Key names are matched in a case-insensitive way.
+     * @param key {String}
+     * @returns {Boolean} true if a parameter was deleted,
+     * false if not.
+     */
+    deleteByKey(key: string): boolean;
+    /**
+     * Add a query parameter to the array (at the end)
+     * @param key {String} Parameter name (key)
+     * @param value {String} Parameter value (may be
+     * omitted or set to null to store only a key).
+     */
+    appendParameter(key: string, value?: string): void;
+    /**
+     * An Array of all the keys (as lowercased, unescaped strings)
+     */
+    get keys(): any;
+    /**
+     * Return a querystring built from the parameters in this
+     * instance, using the originalKey and originalValue properties
+     * of each parameter.
+     *
+     * Any strings that *this* class escapes will be correctly encoded (using
+     * %20 for space). There is an issue with input querystrings that
+     * are supposed to be encoded correctly, but which contain space
+     * characters (in either the key or the value). We don't want to convert
+     * them on input because that might cause the querystring as represented
+     * by this class to differ from the actual input. Instead, we define the
+     * behaviour of this function such that it will rebuild the querystring
+     * exactly as input EXCEPT that any spaces will be +-encoded.
+     *
+     * @return {string}
+     */
+    toString(): string;
+}
+//# sourceMappingURL=ssr-request-processing.d.ts.map

package/utils/ssr-request-processing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-request-processing.d.ts","sourceRoot":"","sources":["../../src/utils/ssr-request-processing.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IA8BI;;;;;OAKG;IACH,6BAFY,eAAe,CAM1B;IAvCD,8BAmBC;IAjBO,iBAAqB;IAmB7B;;;OAGG;IACH,sBAEC;IAcD;;;;;;OAMG;IACH,kCAMC;IAED;;;;;OAKG;IACH,mDAOC;IAED;;OAEG;IACH,gBAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,YAFY,MAAM,CASjB;CACJ"}

package/utils/ssr-server/cached-response.d.ts

@@ -0,0 +1,62 @@
+export class CachedResponse {
+    /**
+     * Construct a CachedResponse from a cache entry. Project
+     * code should never need to call this.
+     * @private
+     */
+    private constructor();
+    _found: boolean;
+    _key: any;
+    _namespace: any;
+    _data: any;
+    _metadata: any;
+    _expiration: any;
+    _req: any;
+    _res: any;
+    /**
+     * Send this response
+     * @private
+     */
+    private _send;
+    /**
+     * Get the key used to retrieve this CachedResponse
+     */
+    get key(): any;
+    /**
+     * Get the namespace used to retrieve this CachedResponse
+     */
+    get namespace(): any;
+    /**
+     * true if this instance represents a found entry in the cache,
+     * false if no entry was found.
+     * @returns {Boolean}
+     */
+    get found(): boolean;
+    /**
+     * The status code of this CachedResponse (as a Number)
+     * @returns {Number}
+     */
+    get status(): number;
+    /**
+     * A reference to the data for the response, which will
+     * be a Buffer, or undefined if the response is empty.
+     * @returns {Buffer|undefined}
+     */
+    get data(): Buffer | undefined;
+    /**
+     * A reference to the headers for the response. The value is
+     * a plain JS object containing the headers in the format used
+     * by ExpressJS: keys are always lower-case, values are strings
+     * except for set-cookie, which is an array of strings.
+     * @returns {{}}
+     */
+    get headers(): {};
+    /**
+     * Get the date & time when this entry would expire. If this
+     * instance represents an entry that was not found, returns
+     * undefined.
+     * @returns {Date|undefined}
+     */
+    get expiration(): Date | undefined;
+}
+//# sourceMappingURL=cached-response.d.ts.map

package/utils/ssr-server/cached-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cached-response.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/cached-response.js"],"names":[],"mappings":"AAQA;IACI;;;;OAIG;IACH,sBASC;IARG,gBAA2B;IAC3B,UAAqB;IACrB,gBAAiC;IACjC,WAAuB;IACvB,eAAqC;IACrC,iBAAmC;IACnC,UAAe;IACf,UAAe;IAGnB;;;OAGG;IACH,cAaC;IAED;;OAEG;IACH,eAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,+BAEC;IAED;;;;;;OAMG;IACH,kBAEC;IAED;;;;;OAKG;IACH,mCAEC;CACJ"}

package/utils/ssr-server/configure-proxy.d.ts

@@ -0,0 +1,5 @@
+export const ALLOWED_CACHING_PROXY_REQUEST_METHODS: string[];
+export function applyProxyRequestHeaders({ proxyRequest, incomingRequest, caching, logging, proxyPath, targetHost, targetProtocol }: http.ClientRequest): void;
+export function configureProxy({ appHostname, proxyPath, targetProtocol, targetHost, appProtocol, caching }: string): middleware;
+export function configureProxyConfigs(appHostname: string, appProtocol: string): void;
+//# sourceMappingURL=configure-proxy.d.ts.map

package/utils/ssr-server/configure-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-proxy.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/configure-proxy.js"],"names":[],"mappings":"AAaA,6DAA+E;AAkCxE,+JAwDN;AAmBM,iIAgKN;AAWM,sFAwBN"}

package/utils/ssr-server/metrics-sender.d.ts

@@ -0,0 +1,83 @@
+/**
+ * A class that will handle asynchronous sending of CloudWatch
+ * metrics.
+ *
+ * Use MetricsSender.getSender() to get the singleton instance.
+ *
+ * @private
+ */
+export class MetricsSender {
+    _CW: import("aws-sdk/clients/cloudwatch") | null;
+    _queue: any[];
+    /**
+     * Return the number of metrics waiting to be sent
+     * @returns {number}
+     */
+    get queueLength(): number;
+    /**
+     * Create a CloudWatch AWS SDK client, or return a falsy value
+     * if this MetricsSender is not actually sending metrics.
+     *
+     * @private
+     * @returns {CloudWatch|null}
+     */
+    private _setup;
+    /**
+     * Call putMetricData as needed, including retrying.
+     *
+     * @private
+     * @param {CloudWatch} cw - Cloudwatch client
+     * @param {Array} metrics - Array of metrics to send
+     * @returns {Promise.<*>} resolved when the metrics are sent
+     * (or when they can't be sent).
+     */
+    private _putMetricData;
+    /**
+     * Send any queued metrics. Returns a Promise that resolves when
+     * all sending is done.
+     * The Promise will never reject.
+     */
+    flush(): Promise<void | any[]>;
+    /**
+     * Add one or more custom metric values to the queue of those waiting
+     * to be sent. This function supports simple name-and-value metrics.
+     * It doesn't support more complex CloudWatch types.
+     *
+     * A metric is an object with at least 'name' (string) and 'value'
+     * (number, defaults to 0). It may also optionally include 'timestamp'
+     * (defaults to the time of the call to send()), and 'unit', which
+     * must be one of Seconds, Microseconds, Milliseconds, Bytes, Kilobytes,
+     * Megabytes, Gigabytes, Terabytes, Bits, Kilobits, Megabits, Gigabits,
+     * Terabits, Percent, Count, Bytes/Second, Kilobytes/Second,
+     * Megabytes/Second, Gigabytes/Second, Terabytes/Second,
+     * Bits/Second, Kilobits/Second, Megabits/Second, Gigabits/Second,
+     * Terabits/Second, Count/Second or None (defaults to 'Count').
+     * There may also be a 'dimensions'
+     * object, which has dimension names as keys and dimension
+     * values as values.
+     *
+     * If called in the local development server, the metric information
+     * will be logged, but the code will not actually emit anything. This
+     * can be overridden by defining the SEND_CW_METRICS environment
+     * variable, for testing.
+     *
+     * The metrics are added to an internal queue so that they can be
+     * batched up to send more efficiently. They are only sent when
+     * flush() is called.
+     *
+     * @private
+     * @param metrics {Array<Object>} - array of name, value objects
+     */
+    private send;
+}
+export namespace MetricsSender {
+    const _override: boolean;
+    /**
+     * Get the singleton MetricsSender
+     *
+     * @private
+     * @returns {MetricsSender}
+     */
+    function getSender(): MetricsSender;
+}
+//# sourceMappingURL=metrics-sender.d.ts.map

package/utils/ssr-server/metrics-sender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-sender.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/metrics-sender.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH;IAKQ,iDAAe;IAKf,cAAgB;IAGpB;;;OAGG;IACH,0BAEC;IAED;;;;;;OAMG;IACH,eAaC;IAED;;;;;;;;OAQG;IACH,uBA0BC;IAED;;;;OAIG;IACH,+BAyBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,aA4BC;CACJ;;;IAOD;;;;;OAKG;IACH,oCAKC"}

package/utils/ssr-server/metrics-sender.js

@@ -119,7 +119,7 @@ class MetricsSender {
       // Send the metrics
       promises.push(this._putMetricData(cw, queue));
     }
-    return Promise.all(promises).catch( /* istanbul ignore next */
+    return Promise.all(promises).catch(/* istanbul ignore next */
     err => _loggerInstance.default.warn(`Metrics: error during flush: ${err}`, {
       namespace: 'metrics-sender.flush',
       additionalProperties: {

package/utils/ssr-server/outgoing-request-hook.d.ts

@@ -0,0 +1,2 @@
+export function outgoingRequestHook(wrapped: any, options: any): (...args: any[]) => any;
+//# sourceMappingURL=outgoing-request-hook.d.ts.map

package/utils/ssr-server/outgoing-request-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outgoing-request-hook.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/outgoing-request-hook.js"],"names":[],"mappings":"AAiCO,yFAgGN"}

package/utils/ssr-server/parse-end-parameters.d.ts

@@ -0,0 +1,2 @@
+export function parseEndParameters(params: any): {};
+//# sourceMappingURL=parse-end-parameters.d.ts.map

package/utils/ssr-server/parse-end-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-end-parameters.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/parse-end-parameters.js"],"names":[],"mappings":"AAMO,oDAwBN"}

package/utils/ssr-server/process-express-response.d.ts

@@ -0,0 +1,3 @@
+export function processExpressResponse(response: any): void;
+export function responseSend(originalSend: any): (...args: any[]) => any;
+//# sourceMappingURL=process-express-response.d.ts.map

package/utils/ssr-server/process-express-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-express-response.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/process-express-response.js"],"names":[],"mappings":"AAaO,4DAmCN;AAEM,yEAQN"}

package/utils/ssr-server/process-lambda-response.d.ts

@@ -0,0 +1,2 @@
+export function processLambdaResponse(response: any, event: any): any;
+//# sourceMappingURL=process-lambda-response.d.ts.map

package/utils/ssr-server/process-lambda-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-lambda-response.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/process-lambda-response.js"],"names":[],"mappings":"AASO,sEA4BN"}

package/utils/ssr-server/update-global-agent-options.d.ts

@@ -0,0 +1,3 @@
+export const AGENT_OPTIONS_TO_COPY: string[];
+export function updateGlobalAgentOptions(from?: any, to: Agent): void;
+//# sourceMappingURL=update-global-agent-options.d.ts.map

package/utils/ssr-server/update-global-agent-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-global-agent-options.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/update-global-agent-options.js"],"names":[],"mappings":"AAMA,6CAiBC;AAgBM,sEAWN"}

package/utils/ssr-server/utils.d.ts

@@ -0,0 +1,13 @@
+export const verboseProxyLogging: false;
+export function isRemote(): boolean;
+export function getBundleBaseUrl(): string;
+export function setQuiet(quiet: any): void;
+export function isQuiet(): boolean;
+export function localDevLog(...args: any[]): void;
+export function infoLog(...args: any[]): void;
+export function catchAndLog(err: any, context: any): void;
+export function escapeJSText(text: string): string;
+export function getHashForString(text: any): string;
+export function getFullRequestURL(url: any): any;
+export function parseCacheControl(value: string): Object;
+//# sourceMappingURL=utils.d.ts.map

package/utils/ssr-server/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/utils.js"],"names":[],"mappings":"AAkBA,wCAAwC;AAEjC,oCAC0E;AAE1E,2CAEN;AAIM,2CAEN;AAEM,mCAA2B;AAG3B,kDAKN;AAGM,8CAMN;AAMM,0DAaN;AAUM,mDAAmE;AAEnE,oDAIN;AAEM,iDAWN;AAaM,kDAHM,MAAM,CAWlB"}

package/utils/ssr-server/wrap-response-write.d.ts

@@ -0,0 +1,2 @@
+export function wrapResponseWrite(response: any): void;
+//# sourceMappingURL=wrap-response-write.d.ts.map

package/utils/ssr-server/wrap-response-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-response-write.d.ts","sourceRoot":"","sources":["../../../src/utils/ssr-server/wrap-response-write.js"],"names":[],"mappings":"AAMO,uDA0BN"}

package/utils/ssr-server.d.ts

@@ -0,0 +1,11 @@
+export * from "./ssr-server/cached-response";
+export * from "./ssr-server/configure-proxy";
+export * from "./ssr-server/metrics-sender";
+export * from "./ssr-server/outgoing-request-hook";
+export * from "./ssr-server/parse-end-parameters";
+export * from "./ssr-server/process-express-response";
+export * from "./ssr-server/process-lambda-response";
+export * from "./ssr-server/update-global-agent-options";
+export * from "./ssr-server/utils";
+export * from "./ssr-server/wrap-response-write";
+//# sourceMappingURL=ssr-server.d.ts.map

package/utils/ssr-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-server.d.ts","sourceRoot":"","sources":["../../src/utils/ssr-server.js"],"names":[],"mappings":""}

package/utils/ssr-shared.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module progressive-web-sdk/utils/ssr-shared
+ * @private
+ */
+/**
+ * Set of valid HTTP protocols for proxying
+ * @private
+ * @type {string[]}
+ */
+export const validProxyProtocols: string[];
+export function getPackageMobify(): any;
+export function getSSRParameters(): any;
+/**
+ * Maximum number of proxy configs
+ * @private
+ * @type {number}
+ */
+export const MAX_PROXY_CONFIGS: number;
+/**
+ * An Array of objects with protocol, host, path for each configured proxy.
+ * This is *only* usable server-side, where it's set when the SSRServer
+ * calls updatePackageMobify.
+ *
+ * The objects in this array also have the following additional properties,
+ * added by configureProxyConfigs in utils/ssr-server:
+ * proxyPath is the full /mobify/proxy... path
+ * proxy is an http-proxy-middleware function that can be used to proxy a
+ * request to a target (it's an ExpressJS function taking req, res and next)
+ *
+ * @private
+ * @type {Array}
+ */
+export let proxyConfigs: any[];
+/**
+ * An Array with all the glob patterns from ssrOnly and ssrShared.
+ * The names are relative to the 'build' directory.
+ * @private
+ */
+export let ssrFiles: any[];
+export function updatePackageMobify(newValue: Object): void;
+export function reset(): void;
+//# sourceMappingURL=ssr-shared.d.ts.map

package/utils/ssr-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-shared.d.ts","sourceRoot":"","sources":["../../src/utils/ssr-shared.js"],"names":[],"mappings":"AASA;;;GAGG;AAOH;;;;GAIG;AACH,kCAFU,MAAM,EAAE,CAEkC;AAM7C,wCAAmD;AACnD,wCAAqF;AAE5F;;;;GAIG;AACH,gCAFU,MAAM,CAEkB;AAElC;;;;;;;;;;;;;GAaG;AACH,+BAA4B;AAE5B;;;;GAIG;AACH,2BAAwB;AAmBjB,8CAFa,MAAM,QAqGzB;AAGM,8BAIN"}