Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 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 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 | 2x 2x 2x 370x 76x 294x 2x 165x 165x 165x 165x 165x 21x 21x 144x 315x 315x 315x 1x 315x 315x 144x 144x 144x 144x 2x 216x 216x 216x 216x 216x 216x 332x 172x 188x 165x 332x 4x 4x 4x 4x 4x 4x 4x 4x 4x 4x 4x 4x 4x 332x 216x 2x 51x 51x 51x 51x 51x 51x 3x 51x 3x 3x 3x 3x 51x 51x 51x 2x 94x 94x 94x 94x 94x 187x 130x 130x 187x 94x 2x 2393x 2393x 2393x 2393x 2393x 2393x 276x 276x 82x 82x 29x 29x 268x 194x 194x 2392x 21x 21x 2393x 2x 196x 196x 196x 196x 196x 196x 196x 196x 37x 37x 15x 6x 6x 15x 3x 9x 6x 6x 37x 22x 22x 22x 37x 196x 30x 30x 30x 196x 192x 66x 7x 7x 66x 192x 196x | import { type ComponentInternalInstance, currentInstance } from './component'
import {
type VNode,
type VNodeChild,
type VNodeNormalizedChildren,
normalizeVNode,
} from './vnode'
import {
EMPTY_OBJ,
type IfAny,
type Prettify,
ShapeFlags,
SlotFlags,
def,
isArray,
isFunction,
} from '@vue/shared'
import { warn } from './warning'
import { isKeepAlive } from './components/KeepAlive'
import { type ContextualRenderFn, withCtx } from './componentRenderContext'
import { isHmrUpdating } from './hmr'
import { DeprecationTypes, isCompatEnabled } from './compat/compatConfig'
import { TriggerOpTypes, trigger } from '@vue/reactivity'
import { createInternalObject } from './internalObject'
export type Slot<T extends any = any> = (
...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>
) => VNode[]
export type InternalSlots = {
[name: string]: Slot | undefined
}
export type Slots = Readonly<InternalSlots>
declare const SlotSymbol: unique symbol
export type SlotsType<T extends Record<string, any> = Record<string, any>> = {
[SlotSymbol]?: T
}
export type StrictUnwrapSlotsType<
S extends SlotsType,
T = NonNullable<S[typeof SlotSymbol]>,
> = [keyof S] extends [never] ? Slots : Readonly<T> & T
export type UnwrapSlotsType<
S extends SlotsType,
T = NonNullable<S[typeof SlotSymbol]>,
> = [keyof S] extends [never]
? Slots
: Readonly<
Prettify<{
[K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any
? T[K]
: Slot<T[K]>
}>
>
export type RawSlots = {
[name: string]: unknown
// manual render fn hint to skip forced children updates
$stable?: boolean
/**
* for tracking slot owner instance. This is attached during
* normalizeChildren when the component vnode is created.
* @internal
*/
_ctx?: ComponentInternalInstance | null
/**
* indicates compiler generated slots
* we use a reserved property instead of a vnode patchFlag because the slots
* object may be directly passed down to a child component in a manual
* render function, and the optimization hint need to be on the slot object
* itself to be preserved.
* @internal
*/
_?: SlotFlags
}
const isInternalKey = (key: string) => key[0] === '_' || key === '$stable'
const normalizeSlotValue = (value: unknown): VNode[] =>
isArray(value)
? value.map(normalizeVNode)
: [normalizeVNode(value as VNodeChild)]
const normalizeSlot = (
key: string,
rawSlot: Function,
ctx: ComponentInternalInstance | null | undefined,
): Slot => {
if ((rawSlot as any)._n) {
// already normalized - #5353
return rawSlot as Slot
}
const normalized = withCtx((...args: any[]) => {
if (
__DEV__ &&
currentInstance &&
(!ctx || ctx.root === currentInstance.root)
) {
warn(
`Slot "${key}" invoked outside of the render function: ` +
`this will not track dependencies used in the slot. ` +
`Invoke the slot function inside the render function instead.`,
)
}
return normalizeSlotValue(rawSlot(...args))
}, ctx) as Slot
// NOT a compiled slot
;(normalized as ContextualRenderFn)._c = false
return normalized
}
const normalizeObjectSlots = (
rawSlots: RawSlots,
slots: InternalSlots,
instance: ComponentInternalInstance,
) => {
const ctx = rawSlots._ctx
for (const key in rawSlots) {
if (isInternalKey(key)) continue
const value = rawSlots[key]
if (isFunction(value)) {
slots[key] = normalizeSlot(key, value, ctx)
} else if (value != null) {
if (
__DEV__ &&
!(
__COMPAT__ &&
isCompatEnabled(DeprecationTypes.RENDER_FUNCTION, instance)
)
) {
warn(
`Non-function value encountered for slot "${key}". ` +
`Prefer function slots for better performance.`,
)
}
const normalized = normalizeSlotValue(value)
slots[key] = () => normalized
}
}
}
const normalizeVNodeSlots = (
instance: ComponentInternalInstance,
children: VNodeNormalizedChildren,
) => {
if (
__DEV__ &&
!isKeepAlive(instance.vnode) &&
!(__COMPAT__ && isCompatEnabled(DeprecationTypes.RENDER_FUNCTION, instance))
) {
warn(
`Non-function value encountered for default slot. ` +
`Prefer function slots for better performance.`,
)
}
const normalized = normalizeSlotValue(children)
instance.slots.default = () => normalized
}
const assignSlots = (
slots: InternalSlots,
children: Slots,
optimized: boolean,
) => {
for (const key in children) {
// #2893
// when rendering the optimized slots by manually written render function,
// do not copy the `slots._` compiler flag so that `renderSlot` creates
// slot Fragment with BAIL patchFlag to force full updates
if (optimized || key !== '_') {
slots[key] = children[key]
}
}
}
export const initSlots = (
instance: ComponentInternalInstance,
children: VNodeNormalizedChildren,
optimized: boolean,
): void => {
const slots = (instance.slots = createInternalObject())
if (instance.vnode.shapeFlag & ShapeFlags.SLOTS_CHILDREN) {
const type = (children as RawSlots)._
if (type) {
assignSlots(slots, children as Slots, optimized)
// make compiler marker non-enumerable
if (optimized) {
def(slots, '_', type, true)
}
} else {
normalizeObjectSlots(children as RawSlots, slots, instance)
}
} else if (children) {
normalizeVNodeSlots(instance, children)
}
}
export const updateSlots = (
instance: ComponentInternalInstance,
children: VNodeNormalizedChildren,
optimized: boolean,
): void => {
const { vnode, slots } = instance
let needDeletionCheck = true
let deletionComparisonTarget = EMPTY_OBJ
if (vnode.shapeFlag & ShapeFlags.SLOTS_CHILDREN) {
const type = (children as RawSlots)._
if (type) {
// compiled slots.
if (__DEV__ && isHmrUpdating) {
// Parent was HMR updated so slot content may have changed.
// force update slots and mark instance for hmr as well
assignSlots(slots, children as Slots, optimized)
trigger(instance, TriggerOpTypes.SET, '$slots')
} else if (optimized && type === SlotFlags.STABLE) {
// compiled AND stable.
// no need to update, and skip stale slots removal.
needDeletionCheck = false
} else {
// compiled but dynamic (v-if/v-for on slots) - update slots, but skip
// normalization.
assignSlots(slots, children as Slots, optimized)
}
} else {
needDeletionCheck = !(children as RawSlots).$stable
normalizeObjectSlots(children as RawSlots, slots, instance)
}
deletionComparisonTarget = children as RawSlots
} else if (children) {
// non slot object children (direct value) passed to a component
normalizeVNodeSlots(instance, children)
deletionComparisonTarget = { default: 1 }
}
// delete stale slots
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
delete slots[key]
}
}
}
}
|