@vue/test-utils - npm Package Compare versions

Comparing version 2.0.0-rc.17 to 2.0.0-rc.18

dist/baseWrapper.d.ts

 import type { TriggerOptions } from './createDomEvent';
-import { ComponentInternalInstance, ComponentPublicInstance } from 'vue';
+import { ComponentInternalInstance, ComponentPublicInstance, FunctionalComponent } from 'vue';
 import { DomEventNameWithModifier } from './constants/dom-events';
 import type { VueWrapper } from './vueWrapper';
+import { DefinedComponent, FindAllComponentsSelector, FindComponentSelector, NameSelector, RefSelector, VueNode } from './types';
+import WrapperLike from './interfaces/wrapperLike';
 import type { DOMWrapper } from './domWrapper';
-import { FindAllComponentsSelector, FindComponentSelector } from './types';
-export default abstract class BaseWrapper<ElementType extends Element> {
-    private readonly wrapperElement;
-    get element(): ElementType & {
-        __vueParentComponent?: ComponentInternalInstance | undefined;
-    };
+export default abstract class BaseWrapper<ElementType extends Node> implements WrapperLike {
+    protected readonly wrapperElement: VueNode<ElementType>;
+    protected abstract getRootNodes(): VueNode[];
+    get element(): VueNode<ElementType>;
     constructor(element: ElementType);
-    abstract find(selector: string): DOMWrapper<Element>;
-    abstract findAll(selector: string): DOMWrapper<Element>[];
-    abstract findComponent<T extends ComponentPublicInstance>(selector: FindComponentSelector | (new () => T)): VueWrapper<T>;
-    abstract findAllComponents(selector: FindAllComponentsSelector): VueWrapper<any>[];
-    abstract html(): string;
+    find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
+    find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
+    find<T extends Element = Element>(selector: string): DOMWrapper<T>;
+    find<T extends Node = Node>(selector: string | RefSelector): DOMWrapper<T>;
+    findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
+    findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
+    findAll<T extends Element>(selector: string): DOMWrapper<T>[];
+    findComponent<T extends never>(selector: string): WrapperLike;
+    findComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>;
+    findComponent<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>;
+    findComponent<T extends FunctionalComponent>(selector: string): DOMWrapper<Element>;
+    findComponent<T extends never>(selector: NameSelector | RefSelector): VueWrapper;
+    findComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): VueWrapper<T>;
+    findComponent<T extends never>(selector: FindComponentSelector): WrapperLike;
+    findAllComponents<T extends never>(selector: string): WrapperLike[];
+    findAllComponents<T extends DefinedComponent>(selector: T | Exclude<FindAllComponentsSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>[];
+    findAllComponents<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>[];
+    findAllComponents<T extends FunctionalComponent>(selector: string): DOMWrapper<Element>[];
+    findAllComponents<T extends never>(selector: NameSelector): VueWrapper[];
+    findAllComponents<T extends ComponentPublicInstance>(selector: T | FindAllComponentsSelector): VueWrapper<T>[];
+    findAllComponents<T extends never>(selector: FindAllComponentsSelector): WrapperLike[];
+    abstract setValue(value?: any): Promise<void>;
+    html(): string;
     classes(): string[];
@@ -28,7 +46,15 @@ classes(className: string): boolean;
     get<K extends keyof SVGElementTagNameMap>(selector: K): Omit<DOMWrapper<SVGElementTagNameMap[K]>, 'exists'>;
-    get<T extends Element>(selector: string): Omit<DOMWrapper<T>, 'exists'>;
-    getComponent<T extends ComponentPublicInstance>(selector: FindComponentSelector | (new () => T)): Omit<VueWrapper<T>, 'exists'>;
+    get<T extends Element = Element>(selector: string): Omit<DOMWrapper<T>, 'exists'>;
+    get<T extends Node = Node>(selector: string | RefSelector): Omit<DOMWrapper<T>, 'exists'>;
+    getComponent<T extends never>(selector: string): Omit<WrapperLike, 'exists'>;
+    getComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): Omit<VueWrapper<InstanceType<T>>, 'exists'>;
+    getComponent<T extends FunctionalComponent>(selector: T | string): Omit<DOMWrapper<Element>, 'exists'>;
+    getComponent<T extends never>(selector: NameSelector | RefSelector): Omit<VueWrapper, 'exists'>;
+    getComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): Omit<VueWrapper<T>, 'exists'>;
+    getComponent<T extends never>(selector: FindComponentSelector): Omit<WrapperLike, 'exists'>;
     protected isDisabled: () => boolean;
+    isVisible(): boolean;
+    protected abstract getCurrentComponent(): ComponentInternalInstance | void;
     trigger(eventString: DomEventNameWithModifier, options?: TriggerOptions): Promise<void>;
     trigger(eventString: string, options?: TriggerOptions): Promise<void>;
 }

dist/config.d.ts

@@ -1,2 +0,1 @@
-import { ComponentPublicInstance } from 'vue';
 import { GlobalMountOptions } from './types';
@@ -8,4 +7,4 @@ import { VueWrapper } from './vueWrapper';
     plugins: {
-        VueWrapper: Pluggable<VueWrapper<ComponentPublicInstance>>;
-        DOMWrapper: Pluggable<DOMWrapper<Element>>;
+        VueWrapper: Pluggable<VueWrapper>;
+        DOMWrapper: Pluggable<DOMWrapper<Node>>;
     };
@@ -19,3 +18,3 @@ renderStubDefaultSlot: boolean;
 }
-declare class Pluggable<Instance = DOMWrapper<Element>> {
+declare class Pluggable<Instance = DOMWrapper<Node>> {
     installedPlugins: Plugin<Instance, any>[];
@@ -22,0 +21,0 @@ install<O>(handler: (instance: Instance) => Record<string, any>): void;

dist/domWrapper.d.ts

 import BaseWrapper from './baseWrapper';
-import WrapperLike from './interfaces/wrapperLike';
-import { ComponentPublicInstance } from 'vue';
-import { FindAllComponentsSelector, FindComponentSelector } from './types';
-import type { createWrapper, VueWrapper } from './vueWrapper';
-export declare class DOMWrapper<ElementType extends Element> extends BaseWrapper<ElementType> implements WrapperLike {
-    private createVueWrapper;
-    constructor(element: ElementType, createVueWrapper: typeof createWrapper);
-    isVisible(): boolean;
-    html(): string;
-    find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
-    find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
-    find<T extends Element>(selector: string): DOMWrapper<T>;
-    findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
-    findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
-    findAll<T extends Element>(selector: string): DOMWrapper<T>[];
-    findComponent<T extends ComponentPublicInstance>(selector: FindComponentSelector | (new () => T)): VueWrapper<T>;
-    findAllComponents(selector: FindAllComponentsSelector): VueWrapper<any>[];
+import { RefSelector } from './types';
+export declare class DOMWrapper<NodeType extends Node> extends BaseWrapper<NodeType> {
+    constructor(element: NodeType);
+    getRootNodes(): import("./types").VueNode<NodeType>[];
+    getCurrentComponent(): import("vue").ComponentInternalInstance | undefined;
+    find(selector: string | RefSelector): DOMWrapper<any>;
+    findAllComponents(selector: any): any;
     private setChecked;
@@ -20,0 +10,0 @@ setValue(value?: any): Promise<void>;

dist/index.d.ts

@@ -0,6 +1,6 @@
+import { DOMWrapper } from './domWrapper';
+import { VueWrapper } from './vueWrapper';
 import { mount, shallowMount } from './mount';
 import { MountingOptions } from './types';
 import { RouterLinkStub } from './components/RouterLinkStub';
-import { VueWrapper } from './vueWrapper';
-import { DOMWrapper } from './domWrapper';
 import { createWrapperError } from './errorWrapper';
@@ -7,0 +7,0 @@ import { config } from './config';

dist/interfaces/wrapperLike.d.ts

@@ -1,7 +0,11 @@
-import { DOMWrapper } from '../domWrapper';
+import { DefinedComponent, FindAllComponentsSelector, FindComponentSelector, NameSelector, RefSelector } from 'src/types';
+import { VueWrapper } from 'src/vueWrapper';
+import { ComponentPublicInstance, FunctionalComponent } from 'vue';
+import type { DOMWrapper } from '../domWrapper';
 export default interface WrapperLike {
+    readonly element: Node;
     find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
     find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
-    find<T extends Element>(selector: string): DOMWrapper<T>;
-    find(selector: string): DOMWrapper<Element>;
+    find<T extends Element = Element>(selector: string): DOMWrapper<T>;
+    find<T extends Node = Node>(selector: string | RefSelector): DOMWrapper<T>;
     findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
@@ -11,8 +15,34 @@ findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
     findAll(selector: string): DOMWrapper<Element>[];
+    findComponent<T extends never>(selector: string): WrapperLike;
+    findComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>;
+    findComponent<T extends FunctionalComponent>(selector: T | string): DOMWrapper<Element>;
+    findComponent<T extends never>(selector: NameSelector | RefSelector): VueWrapper;
+    findComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): VueWrapper<T>;
+    findComponent(selector: FindComponentSelector): WrapperLike;
+    findAllComponents<T extends never>(selector: string): WrapperLike[];
+    findAllComponents<T extends DefinedComponent>(selector: T | Exclude<FindAllComponentsSelector, FunctionalComponent>): VueWrapper<InstanceType<T>>[];
+    findAllComponents<T extends FunctionalComponent>(selector: string): DOMWrapper<Element>[];
+    findAllComponents<T extends FunctionalComponent>(selector: T): DOMWrapper<Node>[];
+    findAllComponents<T extends never>(selector: NameSelector): VueWrapper[];
+    findAllComponents<T extends ComponentPublicInstance>(selector: T | FindAllComponentsSelector): VueWrapper<T>[];
+    findAllComponents(selector: FindAllComponentsSelector): WrapperLike[];
     get<K extends keyof HTMLElementTagNameMap>(selector: K): Omit<DOMWrapper<HTMLElementTagNameMap[K]>, 'exists'>;
     get<K extends keyof SVGElementTagNameMap>(selector: K): Omit<DOMWrapper<SVGElementTagNameMap[K]>, 'exists'>;
-    get<T extends Element>(selector: string): Omit<DOMWrapper<T>, 'exists'>;
-    get(selector: string): Omit<DOMWrapper<Element>, 'exists'>;
+    get<T extends Element = Element>(selector: string): Omit<DOMWrapper<T>, 'exists'>;
+    get<T extends Node = Node>(selector: string | RefSelector): Omit<DOMWrapper<T>, 'exists'>;
+    getComponent<T extends never>(selector: string): Omit<WrapperLike, 'exists'>;
+    getComponent<T extends DefinedComponent>(selector: T | Exclude<FindComponentSelector, FunctionalComponent>): Omit<VueWrapper<InstanceType<T>>, 'exists'>;
+    getComponent<T extends FunctionalComponent>(selector: T | string): Omit<DOMWrapper<Element>, 'exists'>;
+    getComponent<T extends ComponentPublicInstance>(selector: T | FindComponentSelector): Omit<VueWrapper<T>, 'exists'>;
+    getComponent<T extends never>(selector: FindComponentSelector): Omit<WrapperLike, 'exists'>;
     html(): string;
+    attributes(): {
+        [key: string]: string;
+    };
+    attributes(key: string): string;
+    attributes(key?: string): {
+        [key: string]: string;
+    } | string;
+    exists(): boolean;
     setValue(value: any): Promise<void>;
 }

dist/stubs.d.ts

@@ -8,4 +8,9 @@ import { VNodeTypes, ConcreteComponent, ComponentPropsOptions } from 'vue';
 }
-export declare const registerStub: (source: ConcreteComponent, stub: ConcreteComponent) => void;
+export declare const registerStub: ({ source, stub, originalStub }: {
+    source: ConcreteComponent;
+    stub: ConcreteComponent;
+    originalStub?: ConcreteComponent<{}, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+}) => void;
 export declare const getOriginalVNodeTypeFromStub: (type: ConcreteComponent) => VNodeTypes | undefined;
+export declare const getOriginalStubFromSpecializedStub: (type: ConcreteComponent) => VNodeTypes | undefined;
 export declare const addToDoNotStubComponents: (type: ConcreteComponent) => WeakSet<ConcreteComponent<{}, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
@@ -12,0 +17,0 @@ export declare const createStub: ({ name, propsDeclaration, renderStubDefaultSlot }: StubOptions) => import("vue").DefineComponent<ComponentPropsOptions<{

dist/types.d.ts

@@ -1,16 +0,11 @@
-import { Component, ComponentOptions, Directive, Plugin, AppConfig, VNode, VNodeProps } from 'vue';
-interface RefSelector {
+import { Component, ComponentOptions, Directive, Plugin, AppConfig, VNode, VNodeProps, FunctionalComponent, ComponentInternalInstance } from 'vue';
+export interface RefSelector {
     ref: string;
 }
-interface NameSelector {
+export interface NameSelector {
     name: string;
+    length?: never;
 }
-interface RefSelector {
-    ref: string;
-}
-interface NameSelector {
-    name: string;
-}
-export declare type FindComponentSelector = RefSelector | NameSelector | string;
-export declare type FindAllComponentsSelector = NameSelector | string;
+export declare type FindAllComponentsSelector = DefinedComponent | FunctionalComponent | NameSelector | string;
+export declare type FindComponentSelector = RefSelector | FindAllComponentsSelector;
 export declare type Slot = VNode | string | {
@@ -124,5 +119,8 @@ render: Function;
 };
-export declare type VueElement = Element & {
+export declare type VueNode<T extends Node = Node> = T & {
     __vue_app__?: any;
+    __vueParentComponent?: ComponentInternalInstance;
 };
+export declare type VueElement = VueNode<Element>;
+export declare type DefinedComponent = new (...args: any[]) => any;
 export {};

dist/utils.d.ts

@@ -1,2 +0,2 @@
-import { GlobalMountOptions } from './types';
+import { GlobalMountOptions, RefSelector } from './types';
 import { ComponentOptions, ConcreteComponent, FunctionalComponent } from 'vue';
@@ -10,3 +10,5 @@ export declare function mergeGlobalProperties(mountGlobal?: GlobalMountOptions): Required<GlobalMountOptions>;
 export declare function isObjectComponent(component: unknown): component is ComponentOptions;
-export declare function textContent(element: Element): string;
+export declare function textContent(element: Node): string;
 export declare function hasOwnProperty<O extends {}, P extends PropertyKey>(obj: O, prop: P): obj is O & Record<P, unknown>;
+export declare function isNotNullOrUndefined<T extends {}>(obj: T | null | undefined): obj is T;
+export declare function isRefSelector(selector: string | RefSelector): selector is RefSelector;

dist/utils/find.d.ts

@@ -1,2 +0,2 @@
-import { ComponentPublicInstance, VNode } from 'vue';
+import { ComponentInternalInstance, VNode } from 'vue';
 import { FindAllComponentsSelector } from '../types';
@@ -10,2 +10,2 @@ /**
 export declare function matches(node: VNode, rawSelector: FindAllComponentsSelector): boolean;
-export declare function find(root: VNode, selector: FindAllComponentsSelector): ComponentPublicInstance[];
+export declare function find(root: VNode, selector: FindAllComponentsSelector): ComponentInternalInstance[];

dist/vueWrapper.d.ts

@@ -1,7 +0,7 @@
-import { ComponentPublicInstance, App } from 'vue';
-import { DOMWrapper } from './domWrapper';
-import { FindAllComponentsSelector, FindComponentSelector } from './types';
+import { App, ComponentCustomProperties, ComponentPublicInstance } from 'vue';
+import { VueNode } from './types';
 import BaseWrapper from './baseWrapper';
-import WrapperLike from './interfaces/wrapperLike';
-export declare class VueWrapper<T extends ComponentPublicInstance> extends BaseWrapper<T['$el']> implements WrapperLike {
+export declare class VueWrapper<T extends Omit<ComponentPublicInstance, '$emit' | keyof ComponentCustomProperties> & {
+    $emit: (event: any, ...args: any[]) => void;
+} & ComponentCustomProperties = ComponentPublicInstance> extends BaseWrapper<Node> {
     private componentVM;
@@ -11,5 +11,7 @@ private rootVM;
     private __setProps;
-    constructor(app: App | null, vm: ComponentPublicInstance, setProps?: (props: Record<string, unknown>) => void);
+    constructor(app: App | null, vm: T, setProps?: (props: Record<string, unknown>) => void);
     private get hasMultipleRoots();
+    protected getRootNodes(): VueNode[];
     private get parentElement();
+    getCurrentComponent(): import("vue").ComponentInternalInstance;
     private attachNativeEventListener;
@@ -24,12 +26,2 @@ get element(): Element;
     emitted<T = unknown>(eventName: string): undefined | T[];
-    html(): string;
-    find<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>;
-    find<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>;
-    find<T extends Element>(selector: string): DOMWrapper<T>;
-    findComponent<T extends ComponentPublicInstance>(selector: FindComponentSelector | (new () => T)): VueWrapper<T>;
-    getComponent<T extends ComponentPublicInstance>(selector: FindComponentSelector | (new () => T)): Omit<VueWrapper<T>, 'exists'>;
-    findAllComponents(selector: FindAllComponentsSelector): VueWrapper<T>[];
-    findAll<K extends keyof HTMLElementTagNameMap>(selector: K): DOMWrapper<HTMLElementTagNameMap[K]>[];
-    findAll<K extends keyof SVGElementTagNameMap>(selector: K): DOMWrapper<SVGElementTagNameMap[K]>[];
-    findAll<T extends Element>(selector: string): DOMWrapper<T>[];
     isVisible(): boolean;
@@ -41,2 +33,1 @@ setData(data: Record<string, unknown>): Promise<void>;
 }
-export declare function createWrapper<T extends ComponentPublicInstance>(app: App | null, vm: ComponentPublicInstance, setProps?: (props: Record<string, unknown>) => void): VueWrapper<T>;

package.json

 {
   "name": "@vue/test-utils",
-  "version": "2.0.0-rc.17",
+  "version": "2.0.0-rc.18",
   "license": "MIT",
@@ -15,3 +15,3 @@ "main": "dist/vue-test-utils.cjs.js",
   "devDependencies": {
-    "@babel/core": "^7.16.0",
+    "@babel/core": "^7.16.5",
     "@babel/preset-env": "^7.16.4",
@@ -21,32 +21,32 @@ "@babel/types": "^7.15.4",
     "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.0.6",
+    "@rollup/plugin-node-resolve": "^13.1.1",
     "@rollup/plugin-replace": "^3.0.0",
     "@types/jest": "27.0.3",
-    "@types/node": "16.11.9",
+    "@types/node": "17.0.0",
     "@types/pretty": "^2.0.0",
     "@vue/babel-plugin-jsx": "^1.1.1",
-    "@vue/compat": "3.2.22",
-    "@vue/compiler-dom": "3.2.22",
-    "@vue/compiler-sfc": "3.2.22",
+    "@vue/compat": "3.2.24",
+    "@vue/compiler-dom": "3.2.26",
+    "@vue/compiler-sfc": "3.2.26",
     "babel-jest": "^26.6.3",
-    "babel-preset-jest": "^27.2.0",
+    "babel-preset-jest": "^27.4.0",
     "husky": "^7.0.4",
     "jest": "25.5.4",
-    "jsdom": "^18.1.0",
+    "jsdom": "^19.0.0",
     "jsdom-global": "^3.0.2",
-    "lint-staged": "^11.2.6",
-    "prettier": "^2.4.1",
+    "lint-staged": "^12.1.2",
+    "prettier": "^2.5.1",
     "pretty": "^2.0.0",
     "reflect-metadata": "^0.1.13",
-    "rollup": "^2.60.0",
-    "rollup-plugin-typescript2": "^0.31.0",
+    "rollup": "^2.61.1",
+    "rollup-plugin-typescript2": "^0.31.1",
     "ts-jest": "25.3.1",
     "tslib": "2.3.1",
-    "typescript": "4.5.2",
-    "vitepress": "^0.18.1",
-    "vue": "3.2.22",
+    "typescript": "4.5.4",
+    "vitepress": "^0.20.9",
+    "vue": "3.2.24",
     "vue-class-component": "^8.0.0-rc.1",
     "vue-jest": "^5.0.0-alpha.10",
     "vue-router": "^4.0.12",
-    "vue-tsc": "0.29.5",
+    "vue-tsc": "0.29.8",
     "vuex": "^4.0.2"
@@ -63,5 +63,3 @@ },
     "test": "yarn jest --runInBand tests/",
-    "test:compat": "yarn jest -c tests-compat/jest-compat.config.js --runInBand tests-compat/",
     "test:build": "yarn jest --runInBand tests/ -use-build",
-    "test:compat:build": "yarn jest -c tests-compat/jest-compat.config.js --runInBand tests-compat/ -use-build",
     "tsd": "tsc -p test-dts/tsconfig.tsd.json",
@@ -68,0 +66,0 @@ "build": "yarn rollup -c rollup.config.js",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1441591

increased by1.36%

Number of package files

34

increased by9.68%

Lines of code

35284

increased by1.07%

No dependency changes