Enum PatchFlags

pub enum PatchFlags {
    Text,
    Class,
    Style,
    Props,
    FullProps,
    NeedHydration,
    StableFragment,
    KeyedFragment,
    UnkeyedFragment,
    NeedPatch,
    DynamicSlots,
    DevRootFragment,
    Hoisted,
    Bail,
}

From https://github.com/vuejs/core/blob/b8fc18c0b23be9a77b05dc41ed452a87a0becf82/packages/shared/src/patchFlags.ts

Variants

Text

• Indicates an element with dynamic textContent (children fast path)

Class

• Indicates an element with dynamic class binding.

Style

• Indicates an element with dynamic style
• The compiler pre-compiles static string styles into static objects
• • detects and hoists inline static objects
• e.g. style="color: red" and :style="{ color: 'red' }" both get hoisted
• as:
• const style = { color: ‘red’ }
• render() { return e(‘div’, { style }) }

Props

• Indicates an element that has non-class/style dynamic props.
• Can also be on a component that has any dynamic props (includes
• class/style). when this flag is present, the vnode also has a dynamicProps
• array that contains the keys of the props that may change so the runtime
• can diff them faster (without having to worry about removed props)

FullProps

• Indicates an element with props with dynamic keys. When keys change, a full
• diff is always needed to remove the old key. This flag is mutually
• exclusive with CLASS, STYLE and PROPS.

NeedHydration

• Indicates an element that requires props hydration
• (but not necessarily patching)
• e.g. event listeners & v-bind with prop modifier

StableFragment

• Indicates a fragment whose children order doesn’t change.

KeyedFragment

• Indicates a fragment with keyed or partially keyed children

UnkeyedFragment

• Indicates a fragment with unkeyed children.

NeedPatch

• Indicates an element that only needs non-props patching, e.g. ref or
• directives (onVnodeXXX hooks). since every patched vnode checks for refs
• and onVnodeXXX hooks, it simply marks the vnode so that a parent block
• will track it.

DynamicSlots

• Indicates a component with dynamic slots (e.g. slot that references a v-for
• iterated value, or dynamic slot names).
• Components with this flag are always force updated.

DevRootFragment

• Indicates a fragment that was created only because the user has placed
• comments at the root level of a template. This is a dev-only flag since
• comments are stripped in production.

Hoisted

• SPECIAL FLAGS ———————————————————––

• Special flags are negative integers. They are never matched against using

• bitwise operators (bitwise matching should only happen in branches where

• patchFlag > 0), and are mutually exclusive. When checking for a special

• flag, simply check patchFlag === FLAG.

• Indicates a hoisted static vnode. This is a hint for hydration to skip

• the entire sub tree since static content never needs to be updated.

Bail

• A special flag that indicates that the diffing algorithm should bail out
• of optimized mode. For example, on block fragments created by renderSlot()
• when encountering non-compiler generated slots (i.e. manually written
• render functions, which should always be fully diffed)
• OR manually cloneVNodes

Trait Implementations

impl<R> BitAnd<R> for PatchFlags

where R: Into<FlagSet<PatchFlags>>,

type Output = FlagSet<PatchFlags>

The resulting type after applying the & operator.

fn bitand(self, rhs: R) -> <PatchFlags as BitAnd<R>>::Output

Performs the & operation.

impl<R> BitOr<R> for PatchFlags

where R: Into<FlagSet<PatchFlags>>,

type Output = FlagSet<PatchFlags>

The resulting type after applying the | operator.

fn bitor(self, rhs: R) -> <PatchFlags as BitOr<R>>::Output

Performs the | operation.

impl<R> BitXor<R> for PatchFlags

where R: Into<FlagSet<PatchFlags>>,

type Output = FlagSet<PatchFlags>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: R) -> <PatchFlags as BitXor<R>>::Output

Performs the ^ operation.

impl Clone for PatchFlags

fn clone(&self) -> PatchFlags

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PatchFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for PatchFlags

fn default() -> PatchFlags

Returns the “default value” for a type.

impl From<PatchFlags> for FlagSet<PatchFlags>

fn from(value: PatchFlags) -> FlagSet<PatchFlags>

Converts to this type from the input type.

impl Not for PatchFlags

type Output = FlagSet<PatchFlags>

The resulting type after applying the ! operator.

fn not(self) -> <PatchFlags as Not>::Output

Performs the unary ! operation.

impl PartialEq for PatchFlags

fn eq(&self, other: &PatchFlags) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R> Rem<R> for PatchFlags

where R: Into<FlagSet<PatchFlags>>,

type Output = FlagSet<PatchFlags>

The resulting type after applying the % operator.

fn rem(self, rhs: R) -> <PatchFlags as Rem<R>>::Output

Performs the % operation.

impl<R> Sub<R> for PatchFlags

where R: Into<FlagSet<PatchFlags>>,

type Output = FlagSet<PatchFlags>

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> <PatchFlags as Sub<R>>::Output

Performs the - operation.

impl Copy for PatchFlags

impl Eq for PatchFlags

impl StructuralPartialEq for PatchFlags