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

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

@@ -0,0 +1,24 @@
+"use strict";
+
+var utils = _interopRequireWildcard(require("./utils"));
+var _ssrShared = require("@salesforce/pwa-kit-runtime/utils/ssr-shared");
+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; }
+/**
+ * @jest-environment node
+ */
+/*
+ * 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
+ */
+// Jest requires the @jest-environment comment at the start of file, which
+// conflicts with the eslint header rule.
+/* eslint-disable header/header */
+
+describe('getProxyConfigs (server-side)', () => {
+  test('should return the currently used proxy configs', () => {
+    expect(utils.getProxyConfigs()).toEqual(_ssrShared.proxyConfigs);
+  });
+});

package/utils/assets.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadScript = void 0;
+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
+ */
+
+/**
+ * loadScriptCounter is used as a key to the window.Mobify object handlers. We
+ * Want this outside the loadScript function so that it can be updated every
+ * loadScript is called with a new script to be embedded to the head tag.
+ * @private
+ */
+let loadScriptCounter = 0;
+
+/**
+ * Writes script tag to the document, head tag
+ * @function
+ * @param {string} id - The id for script
+ * @param {string} src - The path to script
+ * @param {boolean} isAsync=true - Writes an asynchronous function
+ * @param {boolean} docwrite=false - Writes a string of text to a document
+ * @param {function} onload - The onload callback function
+ * @param {boolean} onerror - Rejects the function
+ * @example
+ * import {loadScript} from '@salesforce/pwa-kit-react-sdk/utils/utils'
+ *
+ * loadScript({
+ *     id: 'loadScriptTest1',
+ *     src: 'loadScriptTest1src'
+ * })
+ */
+const loadScript = ({
+  id,
+  src,
+  isAsync = true,
+  docwrite = false,
+  onload,
+  onerror
+}) => {
+  const hasTriedLoadScript = ({
+    id,
+    src,
+    method
+  }) => {
+    const idQuery = id ? `[id="${id}"]` : '';
+    return document.querySelectorAll(`script${idQuery}` + `[src="${src}"]` + `[data-load-method="${method}"]`).length > 0;
+  };
+  const loadMethod = docwrite ? 'document.write()' : 'DOM';
+  if (hasTriedLoadScript({
+    id,
+    src,
+    method: loadMethod
+  })) {
+    console.warn(`[mobify.progressive] loadScript() already called for this script. Ignoring call. (method='${loadMethod}' id='${id}' src='${src}')`);
+    return;
+  }
+  if (onload && typeof onload !== 'function') {
+    throw new Error(`loadScript()'s 'onload' parameter must be a function but was passed a ${typeof onload}!`);
+  }
+  if (onerror && typeof onerror !== 'function') {
+    throw new Error(`loadScript()'s 'onerror' parameter must be a function but was passed a ${typeof onerror}!`);
+  }
+
+  // TODO: Check for navigator.connection. Need Android for this.
+  /* istanbul ignore next */
+  if (docwrite && document.readyState === 'loading') {
+    window.Mobify = window.Mobify || {};
+    let onLoadString = '';
+    let onErrorString = '';
+    if (typeof onload === 'function') {
+      window.Mobify.scriptOnLoads = _extends({}, window.Mobify.scriptOnLoads, {
+        [loadScriptCounter]: onload
+      });
+      // Space prefix is important for valid rendered HTML
+      onLoadString = ` onload="window.Mobify.scriptOnLoads['${loadScriptCounter}'] && window.Mobify.scriptOnLoads['${loadScriptCounter}']()"`;
+    }
+    if (typeof onerror === 'function') {
+      window.Mobify.scriptOnErrors = _extends({}, window.Mobify.scriptOnErrors, {
+        [loadScriptCounter]: onerror
+      });
+      // Space prefix is important for valid rendered HTML
+      onErrorString = ` onerror="window.Mobify.scriptOnErrors['${loadScriptCounter}'] && window.Mobify.scriptOnErrors['${loadScriptCounter}']()"`;
+    }
+    document.write(`<script id='${id}' src='${src}' data-load-method='${loadMethod}' charset='utf-8'${onLoadString}${onErrorString}></script>`);
+    loadScriptCounter++;
+  } else {
+    const script = document.createElement('script');
+
+    // Setting UTF-8 as our encoding ensures that certain strings (i.e.
+    // Japanese text) are not improperly converted to something else. We
+    // do this on the vendor scripts also just in case any libs we
+    // import have localized strings in them.
+    script.charset = 'utf-8';
+    script.async = isAsync;
+    if (id) {
+      script.id = id;
+    }
+    script.src = src;
+    script.dataset.loadMethod = loadMethod;
+
+    /* istanbul ignore next */
+    if (typeof onload === 'function') {
+      script.onload = onload;
+    }
+    /* istanbul ignore next */
+    if (typeof onerror === 'function') {
+      script.onerror = onerror;
+    }
+    document.getElementsByTagName('head')[0].appendChild(script);
+  }
+};
+exports.loadScript = loadScript;

package/utils/assets.test.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _assets = require("./assets");
+var _sinon = _interopRequireDefault(require("sinon"));
+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 sandbox = _sinon.default.createSandbox();
+
+// Silence the error messages, they're on purpose here
+let consoleError;
+beforeEach(() => {
+  consoleError = console.error;
+  console.error = jest.fn();
+});
+afterEach(() => {
+  console.error = consoleError;
+  sandbox.restore();
+});
+describe('loadScript', () => {
+  let fakeScriptElement;
+  const headElement = document.getElementsByTagName('head')[0];
+  const originalReadyState = document.readyState;
+  beforeEach(() => {
+    fakeScriptElement = {
+      id: null,
+      src: null,
+      async: null,
+      charset: null,
+      onload: null,
+      onerror: null,
+      dataset: {}
+    };
+
+    // Mock out createElement and body.appendChild so that we don't have
+    // to fetch an actual script
+    sandbox.stub(document, 'createElement').returns(fakeScriptElement);
+    sandbox.stub(headElement, 'appendChild');
+    sandbox.stub(document, 'write');
+    Object.defineProperty(document, 'readyState', {
+      value: 'loading',
+      writable: true
+    });
+
+    // If you need to actually see the logging from these modules,
+    // change these `.stub()` calls to `.spy()`. Tests won't be affected.
+    sandbox.stub(console, 'log');
+    sandbox.stub(console, 'warn');
+  });
+  afterAll(() => {
+    sandbox.restore();
+    document.readyState = originalReadyState;
+  });
+  test('loadScript defaults to using the DOM to load the script', () => {
+    (0, _assets.loadScript)({
+      id: 'loadScriptTest1',
+      src: 'loadScriptTest1src'
+    });
+    expect(document.createElement.called).toBe(true);
+    expect(headElement.appendChild.called).toBe(true);
+    const element = headElement.appendChild.getCall(0).args[0];
+    expect(element.id).toBe('loadScriptTest1');
+    expect(element.src).toBe('loadScriptTest1src');
+  });
+  test('loadScript uses document.write when the flag is enabled', () => {
+    (0, _assets.loadScript)({
+      id: 'loadScriptTest1',
+      src: 'loadScriptTest1src',
+      docwrite: true
+    });
+    expect(document.write.called).toBe(true);
+  });
+  test('loadScript aborts if it finds the requested script has already been attempted', () => {
+    sandbox.stub(document, 'querySelectorAll').returns([1]);
+    (0, _assets.loadScript)({
+      id: 'loadScriptTest1',
+      src: 'loadScriptTest1src'
+    });
+
+    // Shouldn't have tried either method of inserting the script
+    expect(document.createElement.called).toBe(false);
+    expect(headElement.appendChild.called).toBe(false);
+    expect(document.write.called).toBe(false);
+  });
+  test('loadScript throws if `onload` is provided but is not a function', () => {
+    expect(() => {
+      (0, _assets.loadScript)({
+        src: 'loadScriptTest2src',
+        onload: 'onload expects this to be a function'
+      });
+    }).toThrow();
+  });
+  test('loadScript throws if `onerror` is provided but is not a function', () => {
+    expect(() => {
+      (0, _assets.loadScript)({
+        src: 'loadScriptTest2src',
+        onerror: 'onerror expects this to be a function'
+      });
+    }).toThrow();
+  });
+});

package/utils/url.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAppOrigin = 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
+ */
+
+/**
+ * Returns the application's origin.
+ *
+ * NOTE: This utility can only be used server-side after your application has been
+ * initialized using the `_createApp` method (This happens in your /app/ssr.js file).
+ *
+ * @function
+ * @returns {string} Returns the ORIGIN under which we are serving the page.
+ * @example
+ * import {getAppOrigin} from '@salesforce/pwa-kit-react-sdk/utils/url'
+ *
+ * const url = `${getAppOrigin()}/path`
+ */
+const getAppOrigin = () => {
+  if (typeof window !== 'undefined') {
+    return window.location.origin;
+  }
+  const {
+    APP_ORIGIN
+  } = process.env;
+  if (!APP_ORIGIN) {
+    throw new Error(`Application is not initialized. Please ensure '_createApp' has been invoked before using this method.`);
+  }
+  return process.env.APP_ORIGIN;
+};
+exports.getAppOrigin = getAppOrigin;

package/utils/url.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _url = require("./url");
+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
+                                                                                                                                                                                                                                                                                                                                                                                           */
+describe('getAppOrigin', () => {
+  const OLD_ENV = process.env;
+  const OLD_WINDOW = global.window;
+  const TEST_ORIGIN = 'https://www.example.com';
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = _objectSpread({}, OLD_ENV);
+  });
+  afterEach(() => {
+    process.env = OLD_ENV;
+    global.window = OLD_WINDOW;
+  });
+  test('returns `process.env.APP_ORIGIN` when on server', () => {
+    // Simulate being on the server by deleting the window.
+    delete global.window;
+
+    // Simulate starting the app server by simply setting the `APP_ORIGIN`
+    process.env.APP_ORIGIN = TEST_ORIGIN;
+    expect((0, _url.getAppOrigin)()).toBe(TEST_ORIGIN);
+  });
+  test('returns `window.location.origin` when on client', () => {
+    expect((0, _url.getAppOrigin)()).toBe('http://localhost');
+  });
+  test('throws error when APP_ORIGIN is not defined on server.', () => {
+    // Simulate being on the server by deleting the window.
+    delete global.window;
+
+    // Simulate app server not being initialized.
+    process.env.APP_ORIGIN = undefined;
+    expect(() => {
+      (0, _url.getAppOrigin)();
+    }).toThrow();
+  });
+});

package/utils/uuidv4.client.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uuidv4 = uuidv4;
+/*
+ * 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
+ */
+
+/**
+ * Simple implementation to create a uuid using crypto
+ * See: https://stackoverflow.com/questions/105034/how-do-i-create-a-guid-uuid
+ * @returns {*}
+ */
+function uuidv4() {
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
+}

package/utils/uuidv4.client.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _uuidv = require("./uuidv4.client");
+/*
+ * 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
+ */
+
+let originalCrypto;
+describe('uuidv4', () => {
+  beforeEach(() => {
+    originalCrypto = global.crypto;
+  });
+  afterEach(() => {
+    global.crypto = originalCrypto;
+  });
+  test('returns correct format', () => {
+    global.crypto = {
+      // we mock the module because crypto.getRandomValues
+      // is not available on node v14 (came out in node v15)
+      getRandomValues: () => [123]
+    };
+    expect((0, _uuidv.uuidv4)()).toBe('abbbbbbb-abbb-4bbb-bbbb-abbbbbbbbbbb');
+  });
+});

package/utils/warnings.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.experimental = exports.deprecated = 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
+ */
+/**
+ * @module progressive-web-sdk/utils/warnings
+ * @private
+ */
+
+let displayed = {};
+
+/**
+ *
+ * Prints a warning to the console that a deprecated function is being used.
+ * This allows you to say when the function will be removed and what alternate
+ * function should be used. Example: "This function will be removed in version
+ * 1.2.3. Please use alternateFunction() instead."
+ *
+ * @function
+ * @param {String} message A message to follow the initial deprecation warning
+ */
+const deprecated = message => {
+  warn('deprecated', message);
+};
+
+/**
+ * Prints a warning to the console that an experimental function is being used.
+ *
+ * @function
+ * @param {String} message A message to follow the initial experimental warning
+ */
+exports.deprecated = deprecated;
+const experimental = message => {
+  warn('experimental', message);
+};
+
+/**
+ * Displays a warning once per hard navigation.
+ * Does not display a warning when in production mode.
+ * @private
+ */
+exports.experimental = experimental;
+const shouldDisplay = name => {
+  if (process.env.NODE_ENV === 'production' || displayed[name]) {
+    return false;
+  } else {
+    displayed[name] = true;
+    return true;
+  }
+};
+
+/**
+ * Logs a warning to the console
+ * @param type Warning type
+ * @param message A message to follow the initial warning
+ */
+const warn = (type, message) => {
+  let functionName = '';
+
+  // Get caller name by reading an Error stack trace instead of getting
+  // function property `caller` because it is not allowed in `strict` mode.
+  try {
+    throw new Error();
+  } catch (e) {
+    functionName = e.stack.split('\n')[3].split(' ')[5];
+  }
+  const messages = {
+    experimental: `You are currently using an experimental function: [${functionName}] This function may change at any time.`,
+    deprecated: `You are currently using an deprecated function: [${functionName}].`
+  };
+  if (!shouldDisplay(functionName)) return;
+  console.warn(`[PWA Kit API WARNING]: ${messages[type]} ${message ? message : ''}`);
+};

package/utils/warnings.test.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _warnings = require("./warnings");
+/*
+ * 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('warnings', () => {
+  let original;
+  beforeEach(() => {
+    original = console.warn;
+    console.warn = jest.fn();
+  });
+  afterEach(() => {
+    console.warn = original;
+  });
+  test('deprecated', () => {
+    const testFunction1 = () => {
+      (0, _warnings.deprecated)('msg');
+    };
+    testFunction1();
+    expect(console.warn.mock.calls[0][0]).toBe(`[PWA Kit API WARNING]: You are currently using an deprecated function: [testFunction1]. msg`);
+    testFunction1();
+    expect(console.warn).toHaveBeenCalledTimes(1);
+    const testFunction2 = () => {
+      (0, _warnings.deprecated)();
+    };
+    testFunction2();
+    expect(console.warn.mock.calls[1][0]).toBe(`[PWA Kit API WARNING]: You are currently using an deprecated function: [testFunction2]. `);
+  });
+  test('experimental', () => {
+    const testFunction3 = () => {
+      (0, _warnings.experimental)('msg');
+    };
+    testFunction3();
+    expect(console.warn.mock.calls[0][0]).toBe(`[PWA Kit API WARNING]: You are currently using an experimental function: [testFunction3] This function may change at any time. msg`);
+    testFunction3();
+    expect(console.warn).toHaveBeenCalledTimes(1);
+    const testFunction4 = () => {
+      (0, _warnings.experimental)();
+    };
+    testFunction4();
+    expect(console.warn.mock.calls[1][0]).toBe(`[PWA Kit API WARNING]: You are currently using an experimental function: [testFunction4] This function may change at any time. `);
+  });
+});