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

package/CHANGELOG.md

@@ -0,0 +1,86 @@
+## v3.0.0-preview.0 (May 31, 2023)
+## v3.0.0-dev (May 12, 2023)
+
+- Remove usage of `device-context` due to deprecation of user agent string. [#1168](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1168)
+
+-   Remove usage of `device-context` due to deprecation of user agent string. [#1168](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1168)
+-   Upgrade React 18, React DOM 18, Remove Enzyme, add Testing library 14 [#1166](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1166)
+
+## v2.7.1 (May 11, 2023)
+
+-   Fix `multi-value` params being lost [#1150](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1150)
+
+## v2.7.0 (Mar 03, 2023)
+
+## v2.6.0 (Jan 25, 2023)
+
+## v2.5.0 (Jan 05, 2023)
+
+-   Replace morgan stream to use console.log [#847](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/847)
+-   Do not use a proxy to call Einstein [#857](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/857)
+-   Reuse Server Correlation ID when Hydrating Error Pages [#846](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/846)
+
+## v2.4.0 (Dec 01, 2022)
+
+-   Fix `useServerContext` returning isServerSide=false when on server. [#782](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/782)
+-   Upgrade minimatch [#793](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/793)
+
+## v2.3.0 (Oct 27, 2022)
+
+-   Support `react-query` server-side data fetching. [#724](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/724)
+-   Add server-safe default configuration for `queryClientConfig` option. [#734](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/734)
+-   Add `useServerContext` hook with the `res` response object and the `isServerSide` flag. [#737](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/737)
+-   Handle `react-query` server-side errors. [#735](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/735)
+-   Fix internal build script. [#706](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/706)
+-   Add Correlation ID to SCAPI requests. [#728](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/728)
+
+## v2.2.0 (Aug 25, 2022)
+
+## v2.1.0 (Jul 05, 2022)
+
+-   Remove console logs from route component. [#651](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/651)
+
+## v2.0.0 (May 16, 2022)
+
+-   Drop node 12 support for [#589](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/589)
+-   Improve test coverage [#550](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/550)
+-   Remove lodash and bluebird. [#534](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/534)
+-   Support Multi-site implementation using dynamic config [#469](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/469)
+-   Support functions as default exports in the applications `routes.jsx` file. [#447](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/447)
+-   Serialize application configuration in the HTML during rendering process. [#447](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/447)
+-   Remove `create-hash-manifest.js` [#425](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/425)
+-   Fix upload bug with extending an options object [#419](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/419)
+
+## v1.5.0 (Mar 17, 2022)
+
+-   Add boolean flag `enableLegacyBodyParser` to `createApp` options. [#446](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/446)
+-   Add environment specific configuration support. [#421](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/421)
+-   Remove unused url-parse dependency [#411](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/411)
+-   Fix bug with extending an options object on upload.js script [#419](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/419)
+
+## v1.4.0 (Jan 27, 2022)
+
+-   Add `proxyKeepAliveAgent` ssr-server option. [#306](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/306)
+-   Add React 17 support [#278](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/278)
+-   Fix an error handling bug that could cause server to hang [#326](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/326)
+-   Add support for npm 7 and npm 8 [#302](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/302)
+
+## v1.3.0 (Jan 06, 2022)
+
+-   Add `__server_only` and `__pretty_print` server rendering flags aliases. [#250](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/250)
+-   Do not show stack trace in remote environment windowGlobals [#230](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/230/files)
+-   `createApp` takes a new option `enableLegacyRemoteProxying` which defaults to `true`. When set to `false`, local development proxying is disabled when running remotely. In future, local development proxying will _always_ be disabled when running remotely. [#205](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/205)
+-   Add `PwaKitConfigPlugin` webpack plugin. [#255](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/255)
+
+## v1.2.0 (Nov 18, 2021)
+
+-   Security package updates
+-   Upgrade `copy-webpack-plugin` to latest `^9.0.1` version. [#3191](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/181)
+
+## v1.1.0 (Sep 27, 2021)
+
+-   Update the bundle push command to remove legacy bundle upload preview URL from console output. [#81](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/81)
+
+## v1.0.0 (Sep 08, 2021)
+
+-   PWA Kit General Avaliability and open source. 🎉

package/LICENSE

@@ -0,0 +1,14 @@
+BSD 3-Clause License
+
+Copyright (c) 2021, Salesforce.com, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of Salesforce.com nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,37 @@
+# The Progressive Web App (PWA) Kit SDK
+
+[![NPM](https://nodei.co/npm/pwa-kit-react-sdk.png?downloads=true&stars=true)](https://nodei.co/npm/pwa-kit-react-sdk/) [![SalesforceCommerceCloud/pwa-kit/test](https://github.com/SalesforceCommerceCloud/pwa-kit/actions/workflows/test.yml/badge.svg)](https://github.com/SalesforceCommerceCloud/pwa-kit/actions/workflows/test.yml)
+
+A library of components and utilities that supports the rendering pipeline for the Progressive Web App (PWA) Kit from Salesforce.
+
+## Requirements
+
+-   Node 16.11 or later
+-   npm 8 or later
+
+## Install Dependencies
+
+```bash
+npm i
+```
+
+## Documentation
+
+The full documentation for PWA Kit and Managed Runtime is hosted on the [Salesforce Developers](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/overview) portal.
+
+### Useful Links:
+
+-   [Get Started](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/getting-started.html)
+-   [Skills for Success](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/skills-for-success.html)
+-   [Set Up API Access](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/setting-up-api-access.html)
+-   [Configuration Options](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/configuration-options.html)
+-   [Proxy Requests](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/proxying-requests.html)
+-   [Push and Deploy Bundles](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/pushing-and-deploying-bundles.html)
+-   [The Retail React App](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/retail-react-app.html)
+-   [Rendering](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/rendering.html)
+-   [Routing](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/routing.html)
+-   [Phased Headless Rollouts](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/phased-headless-rollouts.html)
+-   [Launch Your Storefront](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/launching-your-storefront.html)
+
+## Support Policy
+Security patches are provided for 24 months after the general availability of each major version of the SDK (1.0, 2.0, and so on).

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@salesforce/pwa-kit-react-sdk",
+  "version": "3.0.0-preview.0",
+  "description": "A library that supports the isomorphic React rendering pipeline for Commerce Cloud Managed Runtime apps",
+  "homepage": "https://github.com/SalesforceCommerceCloud/pwa-kit/tree/develop/packages/pwa-kit-react-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/SalesforceCommerceCloud/pwa-kit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SalesforceCommerceCloud/pwa-kit.git"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "cc-pwa-kit@salesforce.com",
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "scripts",
+    "ssr",
+    "utils"
+  ],
+  "scripts": {
+    "build": "cross-env NODE_ENV=production internal-lib-build build",
+    "build:watch": "nodemon --watch 'src/**' --exec 'npm run build'",
+    "format": "internal-lib-build format \"**/*.{js,jsx}\"",
+    "lint": "npm run lint:js",
+    "lint:fix": "npm run lint:js -- --fix",
+    "lint:js": "pwa-kit-dev lint \"**/*.{js,jsx}\"",
+    "prepare": "npm run build",
+    "test": "pwa-kit-dev test",
+    "test:inspect": "node --inspect-brk jest --runInBand",
+    "test:watch": "npm test -- --watch",
+    "version": "node ./scripts/version.js"
+  },
+  "dependencies": {
+    "@loadable/babel-plugin": "^5.15.3",
+    "@loadable/server": "^5.15.3",
+    "@loadable/webpack-plugin": "^5.15.2",
+    "@salesforce/pwa-kit-runtime": "3.0.0-preview.0",
+    "@tanstack/react-query": "^4.28.0",
+    "cross-env": "^5.2.1",
+    "event-emitter": "^0.3.5",
+    "hoist-non-react-statics": "^3.3.2",
+    "prop-types": "^15.8.1",
+    "react-ssr-prepass": "^1.5.0",
+    "react-uid": "^2.3.2",
+    "serialize-javascript": "^6.0.1",
+    "svg-sprite-loader": "^6.0.11"
+  },
+  "devDependencies": {
+    "@loadable/component": "^5.15.3",
+    "@salesforce/pwa-kit-dev": "3.0.0-preview.0",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^14.0.0",
+    "@testing-library/user-event": "^14.4.3",
+    "internal-lib-build": "3.0.0-preview.0",
+    "node-html-parser": "^3.3.6",
+    "nodemon": "^2.0.22",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-helmet": "5.2.1",
+    "react-router-dom": "^5.3.4",
+    "regenerator-runtime": "^0.13.11",
+    "sinon": "^13.0.2",
+    "supertest": "^4.0.2"
+  },
+  "peerDependencies": {
+    "@loadable/component": "^5.15.0",
+    "react": "^18",
+    "react-dom": "^18",
+    "react-helmet": "6",
+    "react-router-dom": "^5.1.2"
+  },
+  "engines": {
+    "node": "^16.11.0 || ^18.0.0",
+    "npm": "^8.0.0 || ^9.0.0"
+  },
+  "publishConfig": {
+    "directory": "dist"
+  },
+  "gitHead": "a9f820893b7714244a0af509a5aefecc1344153c"
+}

package/scripts/file-utils.js

@@ -0,0 +1,80 @@
+/*
+ * 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
+ */
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const fs = require('fs')
+
+// TODO: Update tests so that fs.promises can be used directly
+const promisify = require('util').promisify
+const readFileAsync = promisify(fs.readFile)
+const writeFileAsync = promisify(fs.writeFile)
+const statAsync = promisify(fs.stat)
+const mkdirAsync = promisify(fs.mkdir)
+const readdirAsync = promisify(fs.readdir)
+
+const readFile = (path) => readFileAsync(path, 'utf8')
+const writeFile = (path, contents) => writeFileAsync(path, contents, 'utf8')
+
+const writeToPath = (path) => (contents) => writeFile(path, contents)
+
+const mkdirIfNonexistent = (dirname) => statAsync(dirname).catch(() => mkdirAsync(dirname))
+
+const existsSync = (path) => {
+    try {
+        fs.statSync(path)
+        return true
+    } catch (e) {
+        return false
+    }
+}
+
+const filterOnStat = (pathBuilder, statCondition) => async (items) => {
+    const promises = items.map(async (item) => {
+        try {
+            const stats = await statAsync(pathBuilder(item))
+            return statCondition(stats) ? item : null
+        } catch (_) {
+            // Ignoring the error because we only care about valid paths
+            return null
+        }
+    })
+    const results = await Promise.all(promises)
+    return results.filter((item) => item != null)
+}
+
+const filterDirectories = (pathBuilder) => filterOnStat(pathBuilder, (stats) => stats.isDirectory())
+
+const filterFiles = (pathBuilder) => filterOnStat(pathBuilder, (stats) => stats.isFile())
+
+const jsonRead = (path) => {
+    return readFile(path).then((text) => JSON.parse(text))
+}
+
+const jsonWrite = (path) => (contents) => {
+    return writeFile(path, JSON.stringify(contents, null, 2))
+}
+
+module.exports = {
+    // Just passing through
+    createWriteStream: fs.createWriteStream,
+
+    // Async fs functions
+    readdirAsync,
+    statAsync,
+    readFileAsync,
+
+    // Local utilities
+    readFile,
+    writeFile,
+    writeToPath,
+    mkdirIfNonexistent,
+    existsSync,
+    filterDirectories,
+    filterFiles,
+    jsonRead,
+    jsonWrite
+}

package/scripts/file-utils.test.js

@@ -0,0 +1,189 @@
+/*
+ * 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
+ */
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+jest.mock('fs')
+const fs = require('fs')
+
+const fileUtils = require('./file-utils')
+
+const successCallbackAdapter =
+    (value = true) =>
+    (...args) => {
+        args[args.length - 1](null, value)
+    }
+
+const failureCallbackAdapter =
+    (value = {}) =>
+    (...args) => {
+        args[args.length - 1](value)
+    }
+
+const argsIgnoringCallback = (mock, index = 0) => mock.mock.calls[index].slice(0, -1)
+
+beforeEach(() => {
+    jest.resetAllMocks()
+})
+
+test('readFile reads as utf8', () => {
+    fs.readFile.mockImplementation(successCallbackAdapter())
+
+    return fileUtils.readFile('test.dat').then(() => {
+        expect(fs.readFile).toHaveBeenCalled()
+        expect(fs.readFile.mock.calls[0].slice(0, -1)).toEqual(['test.dat', 'utf8'])
+    })
+})
+
+test('writeFile writes as utf8', () => {
+    fs.writeFile.mockImplementation(successCallbackAdapter())
+
+    return fileUtils.writeFile('myfile.json', '{"test": true, "json": "JSON"}').then(() => {
+        expect(fs.writeFile.mock.calls).toHaveLength(1)
+        expect(fs.writeFile.mock.calls[0].slice(0, -1)).toEqual([
+            'myfile.json',
+            '{"test": true, "json": "JSON"}',
+            'utf8'
+        ])
+    })
+})
+
+test('writeToPath returns a function that writes to a given path', () => {
+    fs.writeFile.mockImplementation(successCallbackAdapter())
+
+    const writer = fileUtils.writeToPath('test/summary.dat')
+
+    expect(typeof writer).toBe('function')
+    expect(fs.writeFile).not.toHaveBeenCalled()
+
+    return writer('ABC 123').then(() => {
+        expect(fs.writeFile).toHaveBeenCalled()
+        expect(fs.writeFile.mock.calls[0].slice(0, -1)).toEqual([
+            'test/summary.dat',
+            'ABC 123',
+            'utf8'
+        ])
+    })
+})
+
+test('mkdirIfNonexistent does not make a directory if it exists', () => {
+    fs.stat.mockImplementation(successCallbackAdapter({test: true}))
+
+    return fileUtils.mkdirIfNonexistent('testdir').then((result) => {
+        expect(fs.stat).toHaveBeenCalledTimes(1)
+        expect(argsIgnoringCallback(fs.stat)).toEqual(['testdir'])
+        expect(fs.mkdir).not.toHaveBeenCalled()
+        expect(result.test).toBe(true)
+    })
+})
+
+test("mkdirIfNonexistent makes a directory if it doesn't exist", () => {
+    fs.stat.mockImplementation(failureCallbackAdapter('test'))
+    fs.mkdir.mockImplementation(successCallbackAdapter())
+
+    return fileUtils.mkdirIfNonexistent('testdir').then(() => {
+        expect(fs.stat).toHaveBeenCalled()
+        expect(argsIgnoringCallback(fs.stat)).toEqual(['testdir'])
+        expect(fs.mkdir).toHaveBeenCalled()
+        expect(argsIgnoringCallback(fs.mkdir)).toEqual(['testdir'])
+    })
+})
+
+test('existsSync calls statSync and returns true if it succeeds', () => {
+    fs.statSync.mockReturnValueOnce(true)
+    expect(fileUtils.existsSync('test.dat')).toBe(true)
+    expect(fs.statSync.mock.calls).toHaveLength(1)
+    expect(fs.statSync.mock.calls[0][0]).toBe('test.dat')
+})
+
+test('existsSync returns false if statSync throws', () => {
+    fs.statSync.mockImplementation(() => {
+        throw new Error('test')
+    })
+
+    expect(fileUtils.existsSync('test.dat')).toBe(false)
+})
+
+test('filterDirectories returns the names that are directories after passing through the pathBuilder', () => {
+    const dirList = ['a', 'c', 'r']
+    const itemList = ['a', 'b', 'c', 'r', 's', 't']
+
+    fs.stat.mockImplementation((fn, callback) => {
+        if (dirList.indexOf(fn) !== -1) {
+            callback(null, {isDirectory: () => true})
+        } else if (fn === 's') {
+            callback({err: true})
+        } else {
+            callback(null, {isDirectory: () => false})
+        }
+    })
+
+    const pathBuilder = jest.fn().mockImplementation((x) => x)
+
+    return fileUtils
+        .filterDirectories(pathBuilder)(itemList)
+        .then((result) => {
+            expect(fs.stat.mock.calls).toHaveLength(itemList.length)
+            expect(pathBuilder.mock.calls).toHaveLength(itemList.length)
+            itemList.forEach((item) => {
+                expect(pathBuilder).toHaveBeenCalledWith(item)
+            })
+
+            expect(result).toEqual(dirList)
+        })
+})
+
+test('filterFiles returns the names that are directories after passing through the pathBuilder', () => {
+    const fileList = ['b', 't']
+    const itemList = ['a', 'b', 'c', 'r', 's', 't']
+
+    fs.stat.mockImplementation((fn, callback) => {
+        if (fileList.indexOf(fn) !== -1) {
+            callback(null, {isFile: () => true})
+        } else if (fn === 's') {
+            callback({err: true})
+        } else {
+            callback(null, {isFile: () => false})
+        }
+    })
+
+    const pathBuilder = jest.fn().mockImplementation((x) => x)
+
+    return fileUtils
+        .filterFiles(pathBuilder)(itemList)
+        .then((result) => {
+            expect(fs.stat.mock.calls).toHaveLength(itemList.length)
+            expect(pathBuilder.mock.calls).toHaveLength(itemList.length)
+            itemList.forEach((item) => {
+                expect(pathBuilder).toHaveBeenCalledWith(item)
+            })
+
+            expect(result).toEqual(fileList)
+        })
+})
+
+test('jsonRead reads JSON from a file', () => {
+    fs.readFile.mockImplementation(successCallbackAdapter('{"test": true}'))
+
+    return fileUtils.jsonRead('test.json').then((result) => {
+        expect(fs.readFile).toHaveBeenCalled()
+        expect(fs.readFile.mock.calls[0][0]).toBe('test.json')
+
+        expect(result).toEqual({test: true})
+    })
+})
+
+test('jsonWrite writes JSON to a file', () => {
+    fs.writeFile.mockImplementation(successCallbackAdapter())
+
+    return fileUtils
+        .jsonWrite('test.json')({test: true})
+        .then(() => {
+            expect(fs.writeFile).toHaveBeenCalled()
+            expect(fs.writeFile.mock.calls[0][0]).toBe('test.json')
+            expect(fs.writeFile.mock.calls[0][1]).toBe('{\n  "test": true\n}')
+        })
+})

package/scripts/setup-jsdom.js

@@ -0,0 +1,20 @@
+/*
+ * 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
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+global.document = require('jsdom').jsdom('<body></body>')
+global.window = document.defaultView
+global.window.matchMedia =
+    global.window.matchMedia ||
+    function () {
+        return {
+            matches: false,
+            addListener: () => {},
+            removeListener: () => {}
+        }
+    }
+global.navigator = window.navigator

package/scripts/version.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2023, 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
+ */
+/* eslint-disable @typescript-eslint/no-var-requires */
+// Update Change Log heading
+const pkg = require('../package.json')
+const path = require('path')
+const os = require('os')
+const fs = require('fs')
+
+const date = new Date().toString().split(' ').slice(1, 4)
+const heading = `## v${pkg.version} (${date[0]} ${date[1]}, ${date[2]})\n`
+
+const changelog = path.resolve(os.tmpdir(), 'CHANGELOG.md')
+
+fs.writeFileSync(changelog, heading, 'utf8')
+fs.appendFileSync(changelog, fs.readFileSync('CHANGELOG.md'), 'utf8')
+fs.copyFileSync(changelog, 'CHANGELOG.md')

package/ssr/browser/main.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.start = exports.registerServiceWorker = exports.OuterApp = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _client = require("react-dom/client");
+var _reactRouterDom = require("react-router-dom");
+var _contexts = require("../universal/contexts");
+var _app = _interopRequireDefault(require("../universal/components/_app"));
+var _compatibility = require("../universal/compatibility");
+var _switch = _interopRequireDefault(require("../universal/components/switch"));
+var _routeComponent = require("../universal/components/route-component");
+var _component = require("@loadable/component");
+var _uuidv = require("../../utils/uuidv4.client");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+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; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); } /*
+                                                                                                                                                                                                                                                                                                                                                     * 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
+                                                                                                                                                                                                                                                                                                                                                     */ /* global __webpack_require__ */
+/* istanbul ignore next */
+const registerServiceWorker = url => {
+  return Promise.resolve().then(() => {
+    if ('serviceWorker' in navigator) {
+      return Promise.resolve().then(() => new Promise(resolve => window.addEventListener('load', resolve))).then(() => navigator.serviceWorker.register(url)).then(registration => console.log(`ServiceWorker registration successful with scope: ${registration.scope}`)).catch(err => console.log('ServiceWorker registration failed: ', err));
+    }
+  });
+};
+exports.registerServiceWorker = registerServiceWorker;
+const OuterApp = ({
+  routes,
+  error,
+  WrappedApp,
+  locals,
+  onHydrate
+}) => {
+  const AppConfig = (0, _compatibility.getAppConfig)();
+  const isInitialPageRef = (0, _react.useRef)(true);
+  return /*#__PURE__*/_react.default.createElement(_contexts.ServerContext.Provider, {
+    value: {}
+  }, /*#__PURE__*/_react.default.createElement(_reactRouterDom.BrowserRouter, {
+    ref: onHydrate
+  }, /*#__PURE__*/_react.default.createElement(_contexts.CorrelationIdProvider, {
+    correlationId: () => {
+      // If we are hydrating an error page use the server correlation id.
+      if (isInitialPageRef.current && window.__ERROR__) {
+        isInitialPageRef.current = false;
+        return window.__INITIAL_CORRELATION_ID__;
+      }
+      return (0, _uuidv.uuidv4)();
+    }
+  }, /*#__PURE__*/_react.default.createElement(AppConfig, {
+    locals: locals
+  }, /*#__PURE__*/_react.default.createElement(_switch.default, {
+    error: error,
+    appState: window.__PRELOADED_STATE__,
+    routes: routes,
+    App: WrappedApp
+  })))));
+};
+exports.OuterApp = OuterApp;
+OuterApp.propTypes = {
+  routes: _propTypes.default.array.isRequired,
+  error: _propTypes.default.object,
+  WrappedApp: _propTypes.default.func.isRequired,
+  locals: _propTypes.default.object,
+  onHydrate: _propTypes.default.func
+};
+/* istanbul ignore next */
+const start = () => {
+  const AppConfig = (0, _compatibility.getAppConfig)();
+  const rootEl = document.getElementsByClassName('react-target')[0];
+  const data = JSON.parse(document.getElementById('mobify-data').innerHTML);
+
+  // Set all globals sent from the server on the window object.
+  Object.entries(data).forEach(([key, value]) => {
+    window[key] = value;
+  });
+
+  // Tell webpack how to find javascript files
+  Object.defineProperty(__webpack_require__, 'p', {
+    get: () => window.Progressive.buildOrigin
+  });
+
+  // On the browser we don't have request.locals, so we just provide an empty
+  // object that exists for the lifetime of the app. AppConfig components can use
+  // this to set up, eg. Redux stores.
+  const locals = {};
+
+  // AppConfig.restore *must* come before getRoutes()
+  AppConfig.restore(locals, window.__PRELOADED_STATE__.__STATE_MANAGEMENT_LIBRARY);
+
+  // We need to tell the routeComponent HOC when the app is hydrating in order to
+  // prevent pages from re-fetching data on the first client-side render. The
+  // reason we do this is that we expect a render to have taken place
+  // on the server already. That server-side render already called getProps()
+  // and froze the application state as a JSON blob on the page.
+  //
+  // This is VERY fiddly – don't go crazy with window.__HYDRATING__. You have
+  // been warned.
+  window.__HYDRATING__ = true;
+  const props = {
+    error: window.__ERROR__,
+    locals: locals,
+    routes: (0, _routeComponent.getRoutes)(locals),
+    WrappedApp: (0, _routeComponent.routeComponent)(_app.default, false, locals)
+  };
+  return Promise.resolve().then(() => new Promise(resolve => (0, _component.loadableReady)(resolve))).then(() => {
+    (0, _client.hydrateRoot)(rootEl, /*#__PURE__*/_react.default.createElement(OuterApp, _extends({}, props, {
+      onHydrate: () => {
+        window.__HYDRATING__ = false;
+      }
+    })));
+  });
+};
+exports.start = start;