cypress 10.4.0 → 10.5.0

package/react/dist/types.d.ts

@@ -5,13 +5,6 @@ export interface UnmountArgs {
     log: boolean;
     boundComponentMessage?: string;
 }
-export interface InternalUnmountOptionsReact {
-    unmount: (el: HTMLElement) => boolean;
-}
-export interface InternalUnmountOptionsReact18 {
-    unmount: () => boolean;
-}
-export declare type InternalUnmountOptions = InternalUnmountOptionsReact | InternalUnmountOptionsReact18;
 export declare type MountOptions = Partial<StyleOptions & MountReactComponentOptions>;
 export interface MountReactComponentOptions {
     alias: string;
@@ -31,6 +24,7 @@ export interface InternalMountOptions {
     reactDom: typeof import('react-dom');
     render: (reactComponent: ReturnType<typeof React.createElement>, el: HTMLElement, reactDomToUse: typeof import('react-dom')) => void;
     unmount: (options: UnmountArgs) => void;
+    cleanup: () => boolean;
 }
 export interface MountReturn {
     /**

package/react/package.json

@@ -18,6 +18,7 @@
     "@cypress/mount-utils": "0.0.0-development",
     "@rollup/plugin-commonjs": "^17.1.0",
     "@rollup/plugin-node-resolve": "^11.1.1",
+    "@types/semver": "7.3.9",
     "@vitejs/plugin-react": "1.3.1",
     "axios": "0.21.2",
     "cypress": "0.0.0-development",
@@ -28,6 +29,7 @@
     "react-router-dom": "6.0.0-alpha.1",
     "rollup": "^2.38.5",
     "rollup-plugin-typescript2": "^0.29.0",
+    "semver": "^7.3.2",
     "typescript": "^4.2.3",
     "vite": "3.0.3",
     "vite-plugin-require-transform": "1.0.3"

package/react18/CHANGELOG.md

@@ -0,0 +1,6 @@
+# @cypress/react18-v1.0.0 (2022-08-11)
+
+
+### Features
+
+* React 18 support ([#22876](https://github.com/cypress-io/cypress/issues/22876)) ([f0d3a48](https://github.com/cypress-io/cypress/commit/f0d3a4867907bf6e60468510daa883ccc8dcfb63))

package/react18/dist/cypress-react.cjs.js

@@ -258,7 +258,7 @@ var injectStyles = function (options) {
         return injectStylesBeforeElement(options, document, el);
     };
 };
-var lastMountedReactDom;
+var mountCleanup;
 /**
  * Create an `mount` function. Performs all the non-React-version specific
  * behavior related to mounting. The React-version-specific code
@@ -273,6 +273,7 @@ var makeMountFn = function (type, jsx, options, rerenderKey, internalMountOption
     if (!internalMountOptions) {
         throw Error('internalMountOptions must be provided with `render` and `reactDom` parameters');
     }
+    mountCleanup = internalMountOptions.cleanup;
     // Get the display name property via the component constructor
     // @ts-ignore FIXME
     var componentName = getDisplayName(jsx.type, options.alias);
@@ -286,7 +287,6 @@ var makeMountFn = function (type, jsx, options, rerenderKey, internalMountOption
         .then(function () {
         var _a, _b, _c;
         var reactDomToUse = internalMountOptions.reactDom;
-        lastMountedReactDom = reactDomToUse;
         var el = getContainerEl();
         if (!el) {
             throw new Error([
@@ -346,39 +346,31 @@ var makeMountFn = function (type, jsx, options, rerenderKey, internalMountOption
  * This is designed to be consumed by `npm/react{16,17,18}`, and other React adapters,
  * or people writing adapters for third-party, custom adapters.
  */
-var makeUnmountFn = function (options, internalUnmountOptions) {
+var makeUnmountFn = function (options) {
     return cy.then(function () {
-        return cy.get(ROOT_SELECTOR, { log: false }).then(function ($el) {
-            var _a;
-            if (lastMountedReactDom) {
-                internalUnmountOptions.unmount($el[0]);
-                var wasUnmounted = internalUnmountOptions.unmount($el[0]);
-                if (wasUnmounted && options.log) {
-                    Cypress.log({
-                        name: 'unmount',
-                        type: 'parent',
-                        message: [(_a = options.boundComponentMessage) !== null && _a !== void 0 ? _a : 'Unmounted component'],
-                        consoleProps: function () {
-                            return {
-                                description: 'Unmounts React component',
-                                parent: $el[0],
-                                home: 'https://github.com/cypress-io/cypress',
-                            };
-                        },
-                    });
-                }
-            }
-        });
+        var _a;
+        var wasUnmounted = mountCleanup === null || mountCleanup === void 0 ? void 0 : mountCleanup();
+        if (wasUnmounted && options.log) {
+            Cypress.log({
+                name: 'unmount',
+                type: 'parent',
+                message: [(_a = options.boundComponentMessage) !== null && _a !== void 0 ? _a : 'Unmounted component'],
+                consoleProps: function () {
+                    return {
+                        description: 'Unmounts React component',
+                        parent: getContainerEl().parentNode,
+                        home: 'https://github.com/cypress-io/cypress',
+                    };
+                },
+            });
+        }
     });
 };
 // Cleanup before each run
 // NOTE: we cannot use unmount here because
 // we are not in the context of a test
 var preMountCleanup = function () {
-    var el = getContainerEl();
-    if (el && lastMountedReactDom) {
-        lastMountedReactDom.unmountComponentAtNode(el);
-    }
+    mountCleanup === null || mountCleanup === void 0 ? void 0 : mountCleanup();
 };
 // Side effects from "import { mount } from '@cypress/<my-framework>'" are annoying, we should avoid doing this
 // by creating an explicit function/import that the user can register in their 'component.js' support file,
@@ -393,7 +385,232 @@ var preMountCleanup = function () {
 // @see npm/react/cypress/component/advanced/set-timeout-example/loading-indicator-spec.js
 setupHooks(preMountCleanup);
 
+const debug = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {};
+
+var debug_1 = debug;
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0';
+
+const MAX_LENGTH$1 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */ 9007199254740991;
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16;
+
+var constants = {
+  SEMVER_SPEC_VERSION,
+  MAX_LENGTH: MAX_LENGTH$1,
+  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+  MAX_SAFE_COMPONENT_LENGTH,
+};
+
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+	return fn(module, module.exports), module.exports;
+}
+
+createCommonjsModule(function (module, exports) {
+const { MAX_SAFE_COMPONENT_LENGTH } = constants;
+
+exports = module.exports = {};
+
+// The actual regexps go on exports.re
+const re = exports.re = [];
+const src = exports.src = [];
+const t = exports.t = {};
+let R = 0;
+
+const createToken = (name, value, isGlobal) => {
+  const index = R++;
+  debug_1(name, index, value);
+  t[name] = index;
+  src[index] = value;
+  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+};
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})`);
+
+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
+}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
+}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+
+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+}${src[t.PRERELEASE]}?${
+  src[t.BUILD]}?`);
+
+createToken('FULL', `^${src[t.FULLPLAIN]}$`);
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+}${src[t.PRERELEASELOOSE]}?${
+  src[t.BUILD]}?`);
+
+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
+
+createToken('GTLT', '((?:<|>)?=?)');
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+
+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:${src[t.PRERELEASE]})?${
+                     src[t.BUILD]}?` +
+                   `)?)?`);
+
+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:${src[t.PRERELEASELOOSE]})?${
+                          src[t.BUILD]}?` +
+                        `)?)?`);
+
+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+createToken('COERCE', `${'(^|[^\\d])' +
+              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:$|[^\\d])`);
+createToken('COERCERTL', src[t.COERCE], true);
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+createToken('LONETILDE', '(?:~>?)');
+
+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+exports.tildeTrimReplace = '$1~';
+
+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+createToken('LONECARET', '(?:\\^)');
+
+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
+exports.caretTrimReplace = '$1^';
+
+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+exports.comparatorTrimReplace = '$1$2$3';
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+                   `\\s+-\\s+` +
+                   `(${src[t.XRANGEPLAIN]})` +
+                   `\\s*$`);
+
+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s+-\\s+` +
+                        `(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s*$`);
+
+// Star ranges basically just allow anything at all.
+createToken('STAR', '(<|>)?=?\\s*\\*');
+// >=0.0.0 is like a star
+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
+});
+
 var root;
+var cleanup = function () {
+    if (root) {
+        root.unmount();
+        return true;
+    }
+    return false;
+};
 function mount(jsx, options, rerenderKey) {
     if (options === void 0) { options = {}; }
     var internalOptions = {
@@ -403,19 +620,13 @@ function mount(jsx, options, rerenderKey) {
             return root.render(reactComponent);
         },
         unmount: unmount,
+        cleanup: cleanup,
     };
     return makeMountFn('mount', jsx, __assign({ ReactDom: ReactDOM__default["default"] }, options), rerenderKey, internalOptions);
 }
 function unmount(options) {
     if (options === void 0) { options = { log: true }; }
-    var internalOptions = {
-        // type is ReturnType<typeof ReactDOM.createRoot>
-        unmount: function () {
-            root.unmount();
-            return true;
-        },
-    };
-    return makeUnmountFn(options, internalOptions);
+    return makeUnmountFn(options);
 }
 
 exports.mount = mount;