function compileToFunction(template: string) {
const { code } = baseCompile(template)
const render = new Function('Vue', code)(runtimeTest) as RenderFunction
- render.isRuntimeCompiled = true
+ render._rc = true // isRuntimeCompiled
return render
}
export type RenderFunction = {
(): VNodeChild
- isRuntimeCompiled?: boolean
+ _rc?: boolean // isRuntimeCompiled
}
export interface ComponentInternalInstance {
instance.render = Component.render as RenderFunction
}
} else if (!instance.render) {
- if (__RUNTIME_COMPILE__ && Component.template && !Component.render) {
- // __RUNTIME_COMPILE__ ensures `compile` is provided
- Component.render = compile!(Component.template, {
+ if (compile && Component.template && !Component.render) {
+ Component.render = compile(Component.template, {
isCustomElement: instance.appContext.config.isCustomElement || NO
})
// mark the function as runtime compiled
- ;(Component.render as RenderFunction).isRuntimeCompiled = true
+ ;(Component.render as RenderFunction)._rc = true
}
if (__DEV__ && !Component.render) {
/* istanbul ignore if */
- if (!__RUNTIME_COMPILE__ && Component.template) {
+ if (!compile && Component.template) {
warn(
`Component provides template but the build of Vue you are running ` +
`does not support runtime template compilation. Either use the ` +
`full build or pre-compile the template using Vue CLI.`
)
} else {
- warn(
- `Component is missing${
- __RUNTIME_COMPILE__ ? ` template or` : ``
- } render function.`
- )
+ warn(`Component is missing template or render function.`)
}
}
// for runtime-compiled render functions using `with` blocks, the render
// proxy used needs a different `has` handler which is more performant and
// also only allows a whitelist of globals to fallthrough.
- if (__RUNTIME_COMPILE__ && instance.render.isRuntimeCompiled) {
+ if (instance.render._rc) {
instance.withProxy = new Proxy(
instance,
runtimeCompiledRenderProxyHandlers
export const PublicInstanceProxyHandlers: ProxyHandler<any> = {
get(target: ComponentInternalInstance, key: string) {
- // fast path for unscopables when using `with` block
- if (__RUNTIME_COMPILE__ && (key as any) === Symbol.unscopables) {
- return
- }
const {
renderContext,
data,
export const runtimeCompiledRenderProxyHandlers = {
...PublicInstanceProxyHandlers,
+ get(target: ComponentInternalInstance, key: string) {
+ // fast path for unscopables when using `with` block
+ if ((key as any) === Symbol.unscopables) {
+ return
+ }
+ return PublicInstanceProxyHandlers.get!(target, key, target)
+ },
has(_target: ComponentInternalInstance, key: string) {
return key[0] !== '_' && !isGloballyWhitelisted(key)
}
const container = normalizeContainer(containerOrSelector)
if (!container) return
const component = app._component
- if (
- __RUNTIME_COMPILE__ &&
- !isFunction(component) &&
- !component.render &&
- !component.template
- ) {
+ if (!isFunction(component) && !component.render && !component.template) {
component.template = container.innerHTML
}
// clear content before mounting
],
"buildOptions": {
"name": "Vue",
- "isRuntimeCompileBuild": true,
"formats": [
"esm-bundler",
"esm-bundler-runtime",
const isRawESMBuild = format === 'esm'
const isNodeBuild = format === 'cjs'
const isBundlerESMBuild = /esm-bundler/.test(format)
- const isRuntimeCompileBuild = packageOptions.isRuntimeCompileBuild
if (isGlobalBuild) {
output.name = packageOptions.name
// isBrowserBuild?
(isGlobalBuild || isRawESMBuild || isBundlerESMBuild) &&
!packageOptions.enableNonBrowserBranches,
- isRuntimeCompileBuild,
isGlobalBuild,
isNodeBuild
),
isProduction,
isBundlerESMBuild,
isBrowserBuild,
- isRuntimeCompileBuild,
isGlobalBuild,
isNodeBuild
) {
__BROWSER__: isBrowserBuild,
// is targeting bundlers?
__BUNDLER__: isBundlerESMBuild,
- // support compile in browser?
- __RUNTIME_COMPILE__: isRuntimeCompileBuild,
__GLOBAL__: isGlobalBuild,
// is targeting Node (SSR)?
__NODE_JS__: isNodeBuild,