@salesforce/pwa-kit-react-sdk 3.0.0-preview.0

package/ssr/universal/components/with-react-query/index.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withReactQuery = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));
+var _reactSsrPrepass = _interopRequireDefault(require("react-ssr-prepass"));
+var _reactQuery = require("@tanstack/react-query");
+var _fetchStrategy = require("../fetch-strategy");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } /*
+                                                                                                                                                                                                                                                                                                                                                                                                       * Copyright (c) 2022, Salesforce, Inc.
+                                                                                                                                                                                                                                                                                                                                                                                                       * All rights reserved.
+                                                                                                                                                                                                                                                                                                                                                                                                       * SPDX-License-Identifier: BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                                       * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                                       */
+const STATE_KEY = '__reactQuery';
+
+/**
+ * A HoC for adding React Query support to your application.
+ *
+ * @param {React.ReactElement} Wrapped The component to be wrapped
+ * @param {Object} options
+ * @param {Object} options.queryClientConfig The react query client configuration object to be used. By
+ * default the `retry` option will be set to false to ensure performant server rendering.
+ *
+ * @returns {React.ReactElement}
+ */
+const withReactQuery = (Wrapped, options = {}) => {
+  const isServerSide = typeof window === 'undefined';
+  /* istanbul ignore next */
+  const wrappedComponentName = Wrapped.displayName || Wrapped.name;
+  const queryClientConfig = options.queryClientConfig;
+
+  /**
+   * @private
+   */
+  class WithReactQuery extends _fetchStrategy.FetchStrategy {
+    render() {
+      var _window$__PRELOADED_S;
+      this.props.locals.__queryClient = this.props.locals.__queryClient || new _reactQuery.QueryClient(queryClientConfig);
+      return /*#__PURE__*/_react.default.createElement(_reactQuery.QueryClientProvider, {
+        client: this.props.locals.__queryClient
+      }, /*#__PURE__*/_react.default.createElement(_reactQuery.Hydrate, {
+        state: isServerSide ? {} : (_window$__PRELOADED_S = window.__PRELOADED_STATE__) === null || _window$__PRELOADED_S === void 0 ? void 0 : _window$__PRELOADED_S[STATE_KEY]
+      }, /*#__PURE__*/_react.default.createElement(Wrapped, this.props)));
+    }
+
+    /**
+     * @private
+     */
+    static doInitAppState({
+      res,
+      appJSX
+    }) {
+      return _asyncToGenerator(function* () {
+        const queryClient = res.locals.__queryClient = res.locals.__queryClient || new _reactQuery.QueryClient(queryClientConfig);
+
+        // Use `ssrPrepass` to collect all uses of `useQuery`.
+        yield (0, _reactSsrPrepass.default)(appJSX);
+        const queryCache = queryClient.getQueryCache();
+        const queries = queryCache.getAll().filter(q => q.options.enabled !== false);
+        yield Promise.all(queries.map(q =>
+        // If there's an error in this fetch, react-query will log the error
+        q.fetch().catch(() => {
+          // On our end, simply catch any error and move on to the next query
+        })));
+        return {
+          [STATE_KEY]: (0, _reactQuery.dehydrate)(queryClient)
+        };
+      })();
+    }
+
+    /**
+     * @private
+     */
+    static getInitializers() {
+      var _Wrapped$getInitializ;
+      return [WithReactQuery.doInitAppState, ...(((_Wrapped$getInitializ = Wrapped.getInitializers) === null || _Wrapped$getInitializ === void 0 ? void 0 : _Wrapped$getInitializ.call(Wrapped)) ?? [])];
+    }
+
+    /**
+     * @private
+     */
+    static getHOCsInUse() {
+      var _Wrapped$getHOCsInUse;
+      return [withReactQuery, ...(((_Wrapped$getHOCsInUse = Wrapped.getHOCsInUse) === null || _Wrapped$getHOCsInUse === void 0 ? void 0 : _Wrapped$getHOCsInUse.call(Wrapped)) ?? [])];
+    }
+  }
+  WithReactQuery.displayName = `withReactQuery(${wrappedComponentName})`;
+  const exclude = {
+    doInitAppState: true,
+    getInitializers: true,
+    initAppState: true,
+    getHOCsInUse: true
+  };
+  (0, _hoistNonReactStatics.default)(WithReactQuery, Wrapped, exclude);
+  return WithReactQuery;
+};
+exports.withReactQuery = withReactQuery;

package/ssr/universal/components/with-react-query/index.test.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _index = require("./index");
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright (c) 2022, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+describe('withReactQuery', function () {
+  let windowSpy;
+  beforeEach(() => {
+    windowSpy = jest.spyOn(window, 'window', 'get');
+    jest.spyOn(console, 'warn').mockImplementation(jest.fn());
+  });
+  afterEach(() => {
+    console.warn.mockRestore();
+    windowSpy.mockRestore();
+  });
+  test('Renders correctly', () => {
+    const Wrapped = () => /*#__PURE__*/_react2.default.createElement("p", null, "Hello world");
+    const Component = (0, _index.withReactQuery)(Wrapped);
+    (0, _react.render)( /*#__PURE__*/_react2.default.createElement(Component, {
+      locals: {}
+    }));
+    expect(_react.screen.getByText(/Hello world/i)).toBeInTheDocument();
+  });
+  test(`Has working getInitializers method`, () => {
+    expect((0, _index.withReactQuery)({}).getInitializers()).toHaveLength(1);
+    expect((0, _index.withReactQuery)({
+      getInitializers: () => ['xyz']
+    }).getInitializers()).toHaveLength(2);
+  });
+  test(`Has working getHOCsInUse method`, () => {
+    expect((0, _index.withReactQuery)({}).getHOCsInUse()).toHaveLength(1);
+    expect((0, _index.withReactQuery)({
+      getHOCsInUse: () => ['xyz']
+    }).getHOCsInUse()).toHaveLength(2);
+  });
+});

package/ssr/universal/contexts/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServerContext = exports.CorrelationIdProvider = exports.CorrelationIdContext = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactRouterDom = require("react-router-dom");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+const CorrelationIdContext = /*#__PURE__*/_react.default.createContext();
+exports.CorrelationIdContext = CorrelationIdContext;
+const ServerContext = /*#__PURE__*/_react.default.createContext();
+
+/**
+ * This provider initializes the correlation id,
+ * and will generate a new id whenever there is a location change
+ * @private
+ * @param children
+ * @param correlationId - default correlation id
+ * @param resetOnPageChange - a boolean to indicate if it needs to generate a new id when navigating to a new page
+ */
+exports.ServerContext = ServerContext;
+const CorrelationIdProvider = ({
+  children,
+  correlationId,
+  resetOnPageChange = true
+}) => {
+  const _correlationIdFn = typeof correlationId === 'function' && correlationId;
+  const _correlationId = typeof correlationId !== 'function' && correlationId;
+  if (resetOnPageChange && !_correlationIdFn) {
+    console.warn('correlationId needs to be a function returning a uuid string when resetOnPageChange is true');
+  }
+  const [id, setId] = _react.default.useState(_correlationId || _correlationIdFn());
+  const location = (0, _reactRouterDom.useLocation)();
+  const isFirstRun = (0, _react.useRef)(true);
+  (0, _react.useEffect)(() => {
+    // this hook only runs on client-side
+    // don't run this on first render
+    if (isFirstRun.current) {
+      isFirstRun.current = false;
+      return;
+    }
+    if (resetOnPageChange && _correlationIdFn) {
+      // NOTE: the function needs to be an uuid v4.
+      const newId = _correlationIdFn();
+      setId(newId);
+    }
+  }, [location.pathname]);
+  return /*#__PURE__*/_react.default.createElement(CorrelationIdContext.Provider, {
+    value: {
+      correlationId: id
+    }
+  }, children);
+};
+exports.CorrelationIdProvider = CorrelationIdProvider;
+CorrelationIdProvider.propTypes = {
+  children: _propTypes.default.element.isRequired,
+  resetOnPageChange: _propTypes.default.bool,
+  correlationId: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.func]).isRequired,
+  location: _propTypes.default.object
+};

package/ssr/universal/contexts/index.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _reactRouterDom = require("react-router-dom");
+var _history = require("history");
+var _index = require("./index");
+var _hooks = require("../hooks");
+var _crypto = _interopRequireDefault(require("crypto"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _userEvent = _interopRequireDefault(require("@testing-library/user-event"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } /*
+                                                                                                                                                                                                                                                                                                                                                                                                       * Copyright (c) 2022, salesforce.com, inc.
+                                                                                                                                                                                                                                                                                                                                                                                                       * All rights reserved.
+                                                                                                                                                                                                                                                                                                                                                                                                       * SPDX-License-Identifier: BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                                       * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                                       */
+const SampleProvider = props => {
+  const {
+    correlationId,
+    resetOnPageChange
+  } = props;
+  return /*#__PURE__*/_react.default.createElement(_index.CorrelationIdProvider, {
+    correlationId: correlationId,
+    resetOnPageChange: resetOnPageChange
+  }, props.children);
+};
+SampleProvider.propTypes = {
+  children: _propTypes.default.element.isRequired,
+  resetOnPageChange: _propTypes.default.bool,
+  correlationId: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.func]).isRequired
+};
+const Component = () => {
+  const {
+    correlationId
+  } = (0, _hooks.useCorrelationId)();
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: 'correlation-id'
+  }, correlationId);
+};
+describe('CorrelationIdProvider', function () {
+  test('Renders without errors', () => {
+    const history = (0, _history.createMemoryHistory)();
+    const id = _crypto.default.randomUUID();
+    (0, _react2.render)( /*#__PURE__*/_react.default.createElement(_reactRouterDom.Router, {
+      history: history
+    }, /*#__PURE__*/_react.default.createElement(SampleProvider, {
+      correlationId: () => id
+    }, /*#__PURE__*/_react.default.createElement(Component, null))));
+    expect(_react2.screen.getByText(id)).toBeInTheDocument();
+  });
+  test('renders when correlationId is passed as a function', () => {
+    const id = _crypto.default.randomUUID();
+    const history = (0, _history.createMemoryHistory)();
+    (0, _react2.render)( /*#__PURE__*/_react.default.createElement(_reactRouterDom.Router, {
+      history: history
+    }, /*#__PURE__*/_react.default.createElement(SampleProvider, {
+      correlationId: () => id
+    }, /*#__PURE__*/_react.default.createElement(Component, null))));
+    expect(_react2.screen.getByText(id)).toBeInTheDocument();
+  });
+  test('renders when correlationId is passed as a string', () => {
+    const id = _crypto.default.randomUUID();
+    const history = (0, _history.createMemoryHistory)();
+    (0, _react2.render)( /*#__PURE__*/_react.default.createElement(_reactRouterDom.Router, {
+      history: history
+    }, /*#__PURE__*/_react.default.createElement(SampleProvider, {
+      correlationId: id,
+      resetOnPageChange: false
+    }, /*#__PURE__*/_react.default.createElement(Component, null))));
+    expect(_react2.screen.getByText(id)).toBeInTheDocument();
+  });
+  test('generates a new id when changing page', /*#__PURE__*/_asyncToGenerator(function* () {
+    const user = _userEvent.default.setup();
+    const history = (0, _history.createMemoryHistory)();
+    const Component = () => {
+      const {
+        correlationId
+      } = (0, _hooks.useCorrelationId)();
+      return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("div", {
+        "data-testid": "correlation-id"
+      }, correlationId), /*#__PURE__*/_react.default.createElement("button", {
+        className: "button",
+        onClick: () => history.push('/page-1')
+      }, "Go to another page"));
+    };
+    (0, _react2.render)( /*#__PURE__*/_react.default.createElement(_reactRouterDom.Router, {
+      history: history
+    }, /*#__PURE__*/_react.default.createElement(SampleProvider, {
+      correlationId: () => _crypto.default.randomUUID()
+    }, /*#__PURE__*/_react.default.createElement(Component, null))));
+    const firstRenderedId = _react2.screen.getByTestId('correlation-id').innerHTML;
+    const button = _react2.screen.getByText(/go to another page/i);
+    yield user.click(button);
+    const secondRenderedId = _react2.screen.getByTestId('correlation-id').innerHTML;
+    // expecting the provider to have a different correlation id when a page navigation happens
+    expect(firstRenderedId).not.toEqual(secondRenderedId);
+  }));
+});

package/ssr/universal/errors.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HTTPNotFound = exports.HTTPError = void 0;
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+class HTTPError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.constructor = HTTPError;
+    this.__proto__ = HTTPError.prototype;
+    this.message = message;
+    this.status = status;
+  }
+  toString() {
+    return `HTTPError ${this.status}: ${this.message}`;
+  }
+}
+exports.HTTPError = HTTPError;
+class HTTPNotFound extends HTTPError {
+  constructor(message) {
+    super(404, message);
+    this.constructor = HTTPNotFound;
+    this.__proto__ = HTTPNotFound.prototype;
+  }
+}
+exports.HTTPNotFound = HTTPNotFound;

package/ssr/universal/errors.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var errors = _interopRequireWildcard(require("./errors"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+describe('Errors', () => {
+  test('HTTP Errors should have a working toString()', () => {
+    const status = 400;
+    const msg = 'This is a bad request';
+    const err = new errors.HTTPError(status, msg);
+    expect(err.toString()).toBe(`HTTPError ${status}: ${msg}`);
+  });
+});

package/ssr/universal/events.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pages = exports.PAGEEVENTS = void 0;
+var _eventEmitter = _interopRequireDefault(require("event-emitter"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+const PAGEEVENTS = {
+  PAGELOAD: 'PAGELOAD',
+  ERROR: 'ERROR'
+};
+exports.PAGEEVENTS = PAGEEVENTS;
+class Pages {
+  pageLoad(templateName, start, end) {
+    const payload = {
+      templateName,
+      start,
+      end
+    };
+    this.emit(PAGEEVENTS.PAGELOAD, payload);
+  }
+  error(name, content) {
+    const payload = {
+      name,
+      content
+    };
+    this.emit(PAGEEVENTS.ERROR, payload);
+  }
+}
+(0, _eventEmitter.default)(Pages.prototype);
+const pages = new Pages();
+exports.pages = pages;

package/ssr/universal/events.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _events = require("./events");
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+describe('Page Events', () => {
+  test('emit and receive a PAGELOAD Page Event', () => {
+    expect.assertions(1);
+    return new Promise(resolve => {
+      _events.pages.on(_events.PAGEEVENTS.PAGELOAD, evt => {
+        expect(JSON.stringify(evt)).toEqual(JSON.stringify({
+          templateName: 'blah',
+          start: 123,
+          end: 456
+        }));
+        return resolve();
+      });
+      _events.pages.pageLoad('blah', 123, 456);
+    });
+  });
+  test('emit and receive a ERROR Page Event', () => {
+    expect.assertions(1);
+    return new Promise(resolve => {
+      _events.pages.on(_events.PAGEEVENTS.ERROR, evt => {
+        expect(JSON.stringify(evt)).toEqual(JSON.stringify({
+          name: 'blah',
+          content: 'more blah'
+        }));
+        return resolve();
+      });
+      _events.pages.error('blah', 'more blah');
+    });
+  });
+});

package/ssr/universal/hooks/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useServerContext = exports.useCorrelationId = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _contexts = require("../contexts");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+/* istanbul ignore file */
+
+/**
+ * Use this hook to get the correlation id value of the closest CorrelationIdProvider component.
+ *
+ * @returns {object} The correlation id
+ */
+const useCorrelationId = () => {
+  const context = _react.default.useContext(_contexts.CorrelationIdContext);
+  if (context === undefined) {
+    throw new Error('useCorrelationId needs to be used within CorrelationIdProvider');
+  }
+  return context;
+};
+
+/**
+ * Server context
+ * @typedef {Object} ServerContext
+ * @property {Object} req - Request object
+ * @property {Object} res - Response object
+ */
+
+/**
+ * Get the server context
+ * @returns {ServerContext} ServerContext object
+ *
+ * @example
+ * const {res} = useServerContext()
+ * if (res && query.error) { res.status(404) }
+ */
+exports.useCorrelationId = useCorrelationId;
+const useServerContext = () => {
+  const serverContext = (0, _react.useContext)(_contexts.ServerContext);
+  return serverContext;
+};
+exports.useServerContext = useServerContext;

package/ssr/universal/routes.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+const routes = [];
+var _default = routes;
+exports.default = _default;

package/ssr/universal/utils.client.test.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var utils = _interopRequireWildcard(require("./utils"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+describe('getProxyConfigs (client-side)', () => {
+  const configs = [{
+    foo: 'bar'
+  }];
+  beforeEach(() => {
+    global.Progressive = {
+      ssrOptions: {
+        proxyConfigs: configs
+      }
+    };
+  });
+  afterEach(() => {
+    delete global.Progressive;
+  });
+  test('should return proxy configs set on window.Progressive', () => {
+    expect(utils.getProxyConfigs()).toEqual(configs);
+  });
+});
+describe('getAssetUrl (client-side)', () => {
+  beforeEach(() => {
+    global.Progressive = {
+      buildOrigin: 'test.com'
+    };
+  });
+  afterEach(() => {
+    delete global.Progressive;
+  });
+  test('should return build origin when path is undefined', () => {
+    expect(utils.getAssetUrl()).toBe('test.com');
+  });
+  test('should return origin + path', () => {
+    expect(utils.getAssetUrl('/path')).toBe('test.com/path');
+  });
+});

package/ssr/universal/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getProxyConfigs = exports.getAssetUrl = void 0;
+var _ssrShared = require("@salesforce/pwa-kit-runtime/utils/ssr-shared");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /*
+                                                                                                                                                                                                                                                                                                                                                                                           * Copyright (c) 2021, salesforce.com, inc.
+                                                                                                                                                                                                                                                                                                                                                                                           * All rights reserved.
+                                                                                                                                                                                                                                                                                                                                                                                           * SPDX-License-Identifier: BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                           * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                           */ /**
+                                                                                                                                                                                                                                                                                                                                                                                               * @module progressive-web-sdk/ssr/universal/utils
+                                                                                                                                                                                                                                                                                                                                                                                               */
+const onClient = typeof window !== 'undefined';
+
+/**
+ * Get the URL that should be used to load an asset from the bundle.
+ *
+ * @param {string} path - relative path from the build directory to the asset
+ * @function
+ * @returns {string}
+ */
+const getAssetUrl = path => {
+  /* istanbul ignore next */
+  const publicPath = onClient ? `${window.Progressive.buildOrigin}` : `/mobify/bundle/${process.env.BUNDLE_ID || 'development'}/`;
+  return path ? `${publicPath}${path}` : publicPath;
+};
+
+/**
+ * @typedef {Object} ProxyConfig
+ * @property {String} protocol - http or https
+ * @property {String} host - the hostname
+ * @property {String} path - the path element that follows "mobify/proxy"
+ */
+
+/**
+ * Return the set of proxies configured for the app.
+ *
+ * The result is an array of objects, each of which has 'protocol'
+ * (either 'http' or 'https'), 'host' (the hostname) and 'path' (the
+ * path element that follows "/mobify/proxy/", defaulting to 'base' for
+ * the first proxy, and 'base2' for the next).
+ *
+ * @function
+ * @returns {Array<ProxyConfig>}
+ */
+exports.getAssetUrl = getAssetUrl;
+const getProxyConfigs = () => {
+  const configs = onClient ? (window.Progressive.ssrOptions || {}).proxyConfigs || [] : _ssrShared.proxyConfigs;
+
+  // Clone to avoid accidental mutation of important configuration variables.
+  return configs.map(config => _objectSpread({}, config));
+};
+exports.getProxyConfigs = getProxyConfigs;