refactor: transformHArgs -> transformVNodeArgs

packages/runtime-core/src/h.ts

@@ -18,7 +18,6 @@ import {
   ComponentOptions
 } from './apiOptions'
 import { ExtractPropTypes } from './componentProps'
-import { currentRenderingInstance } from './componentRenderUtils'
 
 // `h` is a more user-friendly version of `createVNode` that allows omitting the
 // props when possible. It is intended for manually written render functions.
@@ -78,52 +77,52 @@ interface Constructor<P = any> {
 // manually written render functions.
 
 // element
-function _h(type: string, children?: RawChildren): VNode
-function _h(
+export function h(type: string, children?: RawChildren): VNode
+export function h(
   type: string,
   props?: RawProps | null,
   children?: RawChildren
 ): VNode
 
 // fragment
-function _h(type: typeof Fragment, children?: VNodeArrayChildren): VNode
-function _h(
+export function h(type: typeof Fragment, children?: VNodeArrayChildren): VNode
+export function h(
   type: typeof Fragment,
   props?: RawProps | null,
   children?: VNodeArrayChildren
 ): VNode
 
 // portal (target prop is required)
-function _h(
+export function h(
   type: typeof Portal,
   props: RawProps & PortalProps,
   children: RawChildren
 ): VNode
 
 // suspense
-function _h(type: typeof Suspense, children?: RawChildren): VNode
-function _h(
+export function h(type: typeof Suspense, children?: RawChildren): VNode
+export function h(
   type: typeof Suspense,
   props?: (RawProps & SuspenseProps) | null,
   children?: RawChildren | RawSlots
 ): VNode
 
 // functional component
-function _h(type: FunctionalComponent, children?: RawChildren): VNode
-function _h<P>(
+export function h(type: FunctionalComponent, children?: RawChildren): VNode
+export function h<P>(
   type: FunctionalComponent<P>,
   props?: (RawProps & P) | ({} extends P ? null : never),
   children?: RawChildren | RawSlots
 ): VNode
 
 // stateful component
-function _h(type: ComponentOptions, children?: RawChildren): VNode
-function _h(
+export function h(type: ComponentOptions, children?: RawChildren): VNode
+export function h(
   type: ComponentOptionsWithoutProps | ComponentOptionsWithArrayProps,
   props?: RawProps | null,
   children?: RawChildren | RawSlots
 ): VNode
-function _h<O>(
+export function h<O>(
   type: ComponentOptionsWithObjectProps<O>,
   props?:
     | (RawProps & ExtractPropTypes<O>)
@@ -132,15 +131,15 @@ function _h<O>(
 ): VNode
 
 // fake constructor type returned by `defineComponent` or class component
-function _h(type: Constructor, children?: RawChildren): VNode
-function _h<P>(
+export function h(type: Constructor, children?: RawChildren): VNode
+export function h<P>(
   type: Constructor<P>,
   props?: (RawProps & P) | ({} extends P ? null : never),
   children?: RawChildren | RawSlots
 ): VNode
 
 // Actual implementation
-function _h(type: any, propsOrChildren?: any, children?: any): VNode {
+export function h(type: any, propsOrChildren?: any, children?: any): VNode {
   if (arguments.length === 2) {
     if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
       // single vnode without props
@@ -160,24 +159,3 @@ function _h(type: any, propsOrChildren?: any, children?: any): VNode {
     return createVNode(type, propsOrChildren, children)
   }
 }
-
-export const h: typeof _h = __DEV__ ? (applyTransformedH as typeof _h) : _h
-
-let argsTransformer: Function | undefined
-
-// This is used to hook into the h function and transform its arguments
-// Useful for re-implementing behavior that was previously done with createElement in Vue 2
-function applyTransformedH(...args: unknown[]): VNode {
-  if (argsTransformer) {
-    args = argsTransformer(args, currentRenderingInstance)
-  }
-  return _h(...(args as Parameters<typeof _h>))
-}
-
-export function transformHArgs(transformer: Function): void {
-  argsTransformer = transformer
-}
-
-export function resetTransformHArgs(): void {
-  argsTransformer = undefined
-}

packages/runtime-core/src/index.ts

@@ -109,6 +109,9 @@ export { toDisplayString, camelize } from '@vue/shared'
 // For integration with runtime compiler
 export { registerRuntimeCompiler } from './component'
 
+// For test-utils
+export { transformVNodeArgs } from './vnode'
+
 // SSR -------------------------------------------------------------------------
 
 import { createComponentInstance, setupComponent } from './component'

packages/runtime-core/src/vnode.ts

@@ -211,7 +211,32 @@ export function isSameVNodeType(n1: VNode, n2: VNode): boolean {
   return n1.type === n2.type && n1.key === n2.key
 }
 
-export function createVNode(
+let vnodeArgsTransformer:
+  | ((
+      args: Parameters<typeof _createVNode>,
+      instance: ComponentInternalInstance | null
+    ) => Parameters<typeof _createVNode>)
+  | undefined
+
+// Internal API for registering an arguments transform for createVNode
+// used for creating stubs in the test-utils
+export function transformVNodeArgs(transformer?: typeof vnodeArgsTransformer) {
+  vnodeArgsTransformer = transformer
+}
+
+const createVNodeWithArgsTransform = (
+  ...args: Parameters<typeof _createVNode>
+): VNode => {
+  return _createVNode(
+    ...(vnodeArgsTransformer
+      ? vnodeArgsTransformer(args, currentRenderingInstance)
+      : args)
+  )
+}
+
+export const createVNode = __DEV__ ? createVNodeWithArgsTransform : _createVNode
+
+function _createVNode(
   type: VNodeTypes | ClassComponent,
   props: (Data & VNodeProps) | null = null,
   children: unknown = null,