forked from vuejs/core
/
warning.ts
176 lines (156 loc) 路 4.6 KB
/
warning.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
import { VNode } from './vnode'
import {
Data,
ComponentInternalInstance,
ConcreteComponent,
formatComponentName
} from './component'
import { isString, isFunction } from '@vue/shared'
import { toRaw, isRef, pauseTracking, resetTracking } from '@vue/reactivity'
import { callWithErrorHandling, ErrorCodes } from './errorHandling'
type ComponentVNode = VNode & {
type: ConcreteComponent
}
const stack: VNode[] = []
type TraceEntry = {
vnode: ComponentVNode
recurseCount: number
}
type ComponentTraceStack = TraceEntry[]
export function pushWarningContext(vnode: VNode) {
stack.push(vnode)
}
export function popWarningContext() {
stack.pop()
}
export function warn(msg: string, ...args: any[]) {
if (!__DEV__) return
// avoid props formatting or warn handler tracking deps that might be mutated
// during patch, leading to infinite recursion.
pauseTracking()
const instance = stack.length ? stack[stack.length - 1].component : null
const appWarnHandler = instance && instance.appContext.config.warnHandler
const trace = getComponentTrace()
if (appWarnHandler) {
callWithErrorHandling(
appWarnHandler,
instance,
ErrorCodes.APP_WARN_HANDLER,
[
msg + args.join(''),
instance && instance.proxy,
trace
.map(
({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
)
.join('\n'),
trace
]
)
} else {
const warnArgs = [`[Vue warn]: ${msg}`, ...args]
/* istanbul ignore if */
if (
trace.length &&
// avoid spamming console during tests
!__TEST__
) {
warnArgs.push(`\n`, ...formatTrace(trace))
}
console.warn(...warnArgs)
}
resetTracking()
}
export function getComponentTrace(): ComponentTraceStack {
let currentVNode: VNode | null = stack[stack.length - 1]
if (!currentVNode) {
return []
}
// we can't just use the stack because it will be incomplete during updates
// that did not start from the root. Re-construct the parent chain using
// instance parent pointers.
const normalizedStack: ComponentTraceStack = []
while (currentVNode) {
const last = normalizedStack[0]
if (last && last.vnode === currentVNode) {
last.recurseCount++
} else {
normalizedStack.push({
vnode: currentVNode as ComponentVNode,
recurseCount: 0
})
}
const parentInstance: ComponentInternalInstance | null =
currentVNode.component && currentVNode.component.parent
currentVNode = parentInstance && parentInstance.vnode
}
return normalizedStack
}
/* istanbul ignore next */
function formatTrace(trace: ComponentTraceStack): any[] {
const logs: any[] = []
trace.forEach((entry, i) => {
logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry))
})
return logs
}
function formatTraceEntry({ vnode, recurseCount }: TraceEntry): any[] {
const postfix =
recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``
const isRoot = vnode.component ? vnode.component.parent == null : false
const open = ` at <${formatComponentName(
vnode.component,
vnode.type,
isRoot
)}`
const close = `>` + postfix
return vnode.props
? [open, ...formatProps(vnode.props), close]
: [open + close]
}
/* istanbul ignore next */
function formatProps(props: Data): any[] {
const res: any[] = []
const keys = Object.keys(props)
keys.slice(0, 3).forEach(key => {
res.push(...formatProp(key, props[key]))
})
if (keys.length > 3) {
res.push(` ...`)
}
return res
}
function formatProp(key: string, value: unknown): any[]
function formatProp(key: string, value: unknown, raw: true): any
/* istanbul ignore next */
function formatProp(key: string, value: unknown, raw?: boolean): any {
if (isString(value)) {
value = JSON.stringify(value)
return raw ? value : [`${key}=${value}`]
} else if (
typeof value === 'number' ||
typeof value === 'boolean' ||
value == null
) {
return raw ? value : [`${key}=${value}`]
} else if (isRef(value)) {
value = formatProp(key, toRaw(value.value), true)
return raw ? value : [`${key}=Ref<`, value, `>`]
} else if (isFunction(value)) {
return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]
} else {
value = toRaw(value)
return raw ? value : [`${key}=`, value]
}
}
/**
* @internal
*/
export function assertNumber(val: unknown, type: string) {
if (!__DEV__) return
if (typeof val !== 'number') {
warn(`${type} is not a valid number - ` + `got ${JSON.stringify(val)}.`)
} else if (isNaN(val)) {
warn(`${type} is NaN - ` + 'the duration expression might be incorrect.')
}
}