const ast = parse(`<div/>`)
const loc = ast.children[0].loc.start
const plugin: Transform = (node, context) => {
- context.onError(
+ context.emitError(
createCompilerError(ErrorCodes.X_INVALID_END_TAG, node.loc.start)
)
}
function createCodegenContext(
ast: RootNode,
- options: CodegenOptions
+ { module = false, filename = `template.vue.html` }: CodegenOptions
): CodegenContext {
const context: CodegenContext = {
- module: false,
- filename: `template.vue.html`,
- ...options,
+ module,
+ filename,
source: ast.loc.source,
code: ``,
column: 1,
children: [node]
})
} else {
- context.onError(
+ context.emitError(
createCompilerError(
ErrorCodes.X_FOR_MALFORMED_EXPRESSION,
dir.loc.start
)
}
} else {
- context.onError(
+ context.emitError(
createCompilerError(ErrorCodes.X_FOR_NO_EXPRESSION, dir.loc.start)
)
}
}
sibling.branches.push(branch)
} else {
- context.onError(
+ context.emitError(
createCompilerError(
dir.name === 'else'
? ErrorCodes.X_ELSE_NO_ADJACENT_IF
loc: Position
}
+export function defaultOnError(error: CompilerError) {
+ throw error
+}
+
export function createCompilerError(
code: ErrorCodes,
loc: Position
+import { parse, ParserOptions } from './parse'
+import { transform, TransformOptions } from './transform'
+import { generate, CodegenOptions, CodegenResult } from './codegen'
+
+export type CompilerOptions = ParserOptions & TransformOptions & CodegenOptions
+
+export function compile(
+ template: string,
+ options: CompilerOptions = {}
+): CodegenResult {
+ const ast = parse(template, options)
+
+ transform(ast, {
+ ...options,
+ transforms: [
+ // TODO include built-in core transforms
+ ...(options.transforms || []) // user transforms
+ ]
+ })
+
+ return generate(ast, options)
+}
+
+// Also expose lower level APIs & types
export { parse, ParserOptions, TextModes } from './parse'
export {
transform,
createDirectiveTransform,
TransformOptions,
- Transform
+ Transform,
+ DirectiveTransform
} from './transform'
export { generate, CodegenOptions, CodegenResult } from './codegen'
export { ErrorCodes, CompilerError, createCompilerError } from './errors'
-
export * from './ast'
-import { ErrorCodes, CompilerError, createCompilerError } from './errors'
+import {
+ ErrorCodes,
+ CompilerError,
+ createCompilerError,
+ defaultOnError
+} from './errors'
import {
assert,
advancePositionWithMutation,
'apos;': "'",
'quot;': '"'
},
- onError(error: CompilerError): void {
- throw error
- }
+ onError: defaultOnError
}
export const enum TextModes {
ATTRIBUTE_VALUE
}
-interface ParserContext extends Required<ParserOptions> {
+interface ParserContext {
+ options: Required<ParserOptions>
readonly originalSource: string
source: string
offset: number
options: ParserOptions
): ParserContext {
return {
- ...defaultParserOptions,
- ...options,
+ options: {
+ ...defaultParserOptions,
+ ...options
+ },
column: 1,
line: 1,
offset: 0,
const s = context.source
let node: any = null
- if (startsWith(s, context.delimiters[0])) {
+ if (startsWith(s, context.options.delimiters[0])) {
// '{{'
node = parseInterpolation(context, mode)
} else if (mode === TextModes.DATA && s[0] === '<') {
if (!__DEV__ && node.type === NodeTypes.COMMENT) {
return
}
- if (context.ignoreSpaces && node.type === NodeTypes.TEXT && node.isEmpty) {
+ if (
+ context.options.ignoreSpaces &&
+ node.type === NodeTypes.TEXT &&
+ node.isEmpty
+ ) {
return
}
const parent = last(ancestors)
const element = parseTag(context, TagType.Start, parent)
- if (element.isSelfClosing || context.isVoidTag(element.tag)) {
+ if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
return element
}
// Children.
ancestors.push(element)
- const mode = (context.getTextMode(
+ const mode = (context.options.getTextMode(
element.tag,
element.ns
) as unknown) as TextModes
const tag = match[1]
const attrs = []
const directives = []
- const ns = context.getNamespace(tag, parent)
+ const ns = context.options.getNamespace(tag, parent)
advanceBy(context, match[0].length)
advanceSpaces(context)
context: ParserContext,
mode: TextModes
): ExpressionNode | undefined {
- const [open, close] = context.delimiters
+ const [open, close] = context.options.delimiters
__DEV__ && assert(startsWith(context.source, open))
const closeIndex = context.source.indexOf(close, open.length)
function parseText(context: ParserContext, mode: TextModes): TextNode {
__DEV__ && assert(context.source.length > 0)
- const [open] = context.delimiters
+ const [open] = context.options.delimiters
const endIndex = Math.min(
...[
context.source.indexOf('<', 1),
--length
) {
name = context.source.substr(1, length)
- value = context.namedCharacterReferences[name]
+ value = context.options.namedCharacterReferences[name]
}
if (value) {
const semi = name.endsWith(';')
loc.offset += offset
loc.column += offset
}
- context.onError(createCompilerError(code, loc))
+ context.options.onError(createCompilerError(code, loc))
}
function isEnd(
DirectiveNode
} from './ast'
import { isString } from '@vue/shared'
-import { CompilerError } from './errors'
+import { CompilerError, defaultOnError } from './errors'
export type Transform = (node: ChildNode, context: TransformContext) => void
) => false | void
export interface TransformOptions {
- transforms: Transform[]
+ transforms?: Transform[]
onError?: (error: CompilerError) => void
}
-interface TransformContext extends Required<TransformOptions> {
+interface TransformContext {
+ transforms: Transform[]
+ emitError: (error: CompilerError) => void
parent: ParentNode
ancestors: ParentNode[]
childIndex: number
options: TransformOptions
): TransformContext {
const context: TransformContext = {
- onError(error: CompilerError) {
- throw error
- },
- ...options,
+ transforms: options.transforms || [],
+ emitError: options.onError || defaultOnError,
parent: root,
ancestors: [],
childIndex: 0,
ancestors: ParentNode[]
) {
// apply transform plugins
- const transforms = context.transforms
+ const { transforms } = context
for (let i = 0; i < transforms.length; i++) {
const plugin = transforms[i]
plugin(node, context)
import {
- parse,
- transform,
- generate,
- CompilerError,
- Transform,
+ compile as baseCompile,
+ CompilerOptions,
CodegenResult
} from '@vue/compiler-core'
import { parserOptionsMinimal } from './parserOptionsMinimal'
import { parserOptionsStandard } from './parserOptionsStandard'
-const parserOptions = __BROWSER__ ? parserOptionsMinimal : parserOptionsStandard
-
-export interface CompilerOptions {
- module?: boolean
- onError?(err: CompilerError): void
- transforms?: Transform[]
-}
-
export function compile(
template: string,
options: CompilerOptions = {}
): CodegenResult {
- const {
- module = false,
- onError = (err: CompilerError) => {
- throw err
- },
- transforms = []
- } = options
- const ast = parse(template, {
- ...parserOptions,
- onError
- })
- transform(ast, {
+ return baseCompile(template, {
+ ...options,
+ ...(__BROWSER__ ? parserOptionsMinimal : parserOptionsStandard),
transforms: [
- // TODO include core transforms
- // TODO include DOM transforms
- ...transforms // user transforms
- ],
- onError
+ // TODO include DOM-specific transforms
+ ...(options.transforms || []) // extra user transforms
+ ]
})
- return generate(ast, { module })
}
export * from '@vue/compiler-core'
isObject
} from '@vue/shared'
import { SuspenseBoundary } from './suspense'
+import { CompilerOptions } from '@vue/compiler-dom'
export type Data = { [key: string]: unknown }
emit: Emit
}
-type RenderFunction = () => VNodeChild
+export type RenderFunction = () => VNodeChild
export interface ComponentInternalInstance {
type: FunctionalComponent | ComponentOptions
finishComponentSetup(instance, parentSuspense)
}
-let compile: Function | undefined
-export function registerCompiler(_compile: Function) {
+type CompileFunction = (
+ template: string,
+ options?: CompilerOptions
+) => RenderFunction
+
+let compile: CompileFunction | undefined
+
+export function registerRuntimeCompiler(_compile: CompileFunction) {
compile = _compile
}
if (!instance.render) {
if (Component.template && !Component.render) {
if (compile) {
- Component.render = compile(Component.template)
+ Component.render = compile(Component.template, {
+ onError(err) {}
+ })
} else if (__DEV__) {
warn(
`Component provides template but the build of Vue you are running ` +
export { resolveComponent, resolveDirective } from './componentOptions'
// Internal, for integration with runtime compiler
-export { registerCompiler } from './component'
+export { registerRuntimeCompiler } from './component'
// Types -----------------------------------------------------------------------
export {
Component,
FunctionalComponent,
- ComponentInternalInstance
+ ComponentInternalInstance,
+ RenderFunction
} from './component'
export {
ComponentOptions,
ComponentOptionsWithProps,
ComponentOptionsWithArrayProps
} from './componentOptions'
+
export { ComponentPublicInstance } from './componentPublicInstanceProxy'
export { RendererOptions } from './createRenderer'
export { Slot, Slots } from './componentSlots'
// This package is the "full-build" that includes both the runtime
// and the compiler, and supports on-the-fly compilation of the template option.
-import { compile as baseCompile, CompilerOptions } from '@vue/compiler-dom'
-import { registerCompiler } from '@vue/runtime-dom'
+import { compile, CompilerOptions } from '@vue/compiler-dom'
+import { registerRuntimeCompiler, RenderFunction } from '@vue/runtime-dom'
-export function compile(template: string, options?: CompilerOptions): Function {
- const { code } = baseCompile(template, options)
- return new Function(`with(this){return ${code}}`)
+function compileToFunction(
+ template: string,
+ options?: CompilerOptions
+): RenderFunction {
+ const { code } = compile(template, options)
+ return new Function(`with(this){return ${code}}`) as RenderFunction
}
-registerCompiler(compile)
+registerRuntimeCompiler(compileToFunction)
+export { compileToFunction as compile }
export * from '@vue/runtime-dom'
if (__BROWSER__ && __DEV__) {
projects / thirdparty / vuejs / core.git / commitdiff
