refactor: remove const enum

packages/reactivity/__tests__/computed.spec.ts

@@ -7,9 +7,7 @@ import {
   isReadonly,
   DebuggerEvent,
   toRaw,
-  TrackOpTypes,
-  ITERATE_KEY,
-  TriggerOpTypes
+  ITERATE_KEY
 } from '../src'
 
 describe('reactivity/computed', () => {
@@ -236,19 +234,19 @@ describe('reactivity/computed', () => {
       {
         effect: c.effect,
         target: toRaw(obj),
-        type: TrackOpTypes.GET,
+        type: 'get',
         key: 'foo'
       },
       {
         effect: c.effect,
         target: toRaw(obj),
-        type: TrackOpTypes.HAS,
+        type: 'has',
         key: 'bar'
       },
       {
         effect: c.effect,
         target: toRaw(obj),
-        type: TrackOpTypes.ITERATE,
+        type: 'iterate',
         key: ITERATE_KEY
       }
     ])
@@ -271,7 +269,7 @@ describe('reactivity/computed', () => {
     expect(events[0]).toEqual({
       effect: c.effect,
       target: toRaw(obj),
-      type: TriggerOpTypes.SET,
+      type: 'set',
       key: 'foo',
       oldValue: 1,
       newValue: 2
@@ -283,7 +281,7 @@ describe('reactivity/computed', () => {
     expect(events[1]).toEqual({
       effect: c.effect,
       target: toRaw(obj),
-      type: TriggerOpTypes.DELETE,
+      type: 'delete',
       key: 'foo',
       oldValue: 2
     })

packages/reactivity/__tests__/effect.spec.ts

@@ -4,8 +4,6 @@ import {
   effect,
   stop,
   toRaw,
-  TrackOpTypes,
-  TriggerOpTypes,
   DebuggerEvent,
   markRaw,
   shallowReactive,
@@ -732,19 +730,19 @@ describe('reactivity/effect', () => {
       {
         effect: runner.effect,
         target: toRaw(obj),
-        type: TrackOpTypes.GET,
+        type: 'get',
         key: 'foo'
       },
       {
         effect: runner.effect,
         target: toRaw(obj),
-        type: TrackOpTypes.HAS,
+        type: 'has',
         key: 'bar'
       },
       {
         effect: runner.effect,
         target: toRaw(obj),
-        type: TrackOpTypes.ITERATE,
+        type: 'iterate',
         key: ITERATE_KEY
       }
     ])
@@ -770,7 +768,7 @@ describe('reactivity/effect', () => {
     expect(events[0]).toEqual({
       effect: runner.effect,
       target: toRaw(obj),
-      type: TriggerOpTypes.SET,
+      type: 'set',
       key: 'foo',
       oldValue: 1,
       newValue: 2
@@ -782,7 +780,7 @@ describe('reactivity/effect', () => {
     expect(events[1]).toEqual({
       effect: runner.effect,
       target: toRaw(obj),
-      type: TriggerOpTypes.DELETE,
+      type: 'delete',
       key: 'foo',
       oldValue: 2
     })

packages/reactivity/src/baseHandlers.ts

@@ -2,7 +2,6 @@ import {
   reactive,
   readonly,
   toRaw,
-  ReactiveFlags,
   Target,
   readonlyMap,
   reactiveMap,
@@ -11,7 +10,6 @@ import {
   isReadonly,
   isShallow
 } from './reactive'
-import { TrackOpTypes, TriggerOpTypes } from './operations'
 import {
   track,
   trigger,
@@ -54,7 +52,7 @@ function createArrayInstrumentations() {
     instrumentations[key] = function (this: unknown[], ...args: unknown[]) {
       const arr = toRaw(this) as any
       for (let i = 0, l = this.length; i < l; i++) {
-        track(arr, TrackOpTypes.GET, i + '')
+        track(arr, 'get', i + '')
       }
       // we run the method using the original args first (which may be reactive)
       const res = arr[key](...args)
@@ -81,7 +79,7 @@ function createArrayInstrumentations() {
 
 function hasOwnProperty(this: object, key: string) {
   const obj = toRaw(this)
-  track(obj, TrackOpTypes.HAS, key)
+  track(obj, 'has', key)
   return obj.hasOwnProperty(key)
 }
 
@@ -94,14 +92,14 @@ class BaseReactiveHandler implements ProxyHandler<Target> {
   get(target: Target, key: string | symbol, receiver: object) {
     const isReadonly = this._isReadonly,
       shallow = this._shallow
-    if (key === ReactiveFlags.IS_REACTIVE) {
+    if (key === '__v_isReactive') {
       return !isReadonly
-    } else if (key === ReactiveFlags.IS_READONLY) {
+    } else if (key === '__v_isReadonly') {
       return isReadonly
-    } else if (key === ReactiveFlags.IS_SHALLOW) {
+    } else if (key === '__v_isShallow') {
       return shallow
     } else if (
-      key === ReactiveFlags.RAW &&
+      key === '__v_raw' &&
       receiver ===
         (isReadonly
           ? shallow
@@ -133,7 +131,7 @@ class BaseReactiveHandler implements ProxyHandler<Target> {
     }
 
     if (!isReadonly) {
-      track(target, TrackOpTypes.GET, key)
+      track(target, 'get', key)
     }
 
     if (shallow) {
@@ -192,9 +190,9 @@ class MutableReactiveHandler extends BaseReactiveHandler {
     // don't trigger if target is something up in the prototype chain of original
     if (target === toRaw(receiver)) {
       if (!hadKey) {
-        trigger(target, TriggerOpTypes.ADD, key, value)
+        trigger(target, 'add', key, value)
       } else if (hasChanged(value, oldValue)) {
-        trigger(target, TriggerOpTypes.SET, key, value, oldValue)
+        trigger(target, 'set', key, value, oldValue)
       }
     }
     return result
@@ -205,24 +203,20 @@ class MutableReactiveHandler extends BaseReactiveHandler {
     const oldValue = (target as any)[key]
     const result = Reflect.deleteProperty(target, key)
     if (result && hadKey) {
-      trigger(target, TriggerOpTypes.DELETE, key, undefined, oldValue)
+      trigger(target, 'delete', key, undefined, oldValue)
     }
     return result
   }
 
   has(target: object, key: string | symbol): boolean {
     const result = Reflect.has(target, key)
     if (!isSymbol(key) || !builtInSymbols.has(key)) {
-      track(target, TrackOpTypes.HAS, key)
+      track(target, 'has', key)
     }
     return result
   }
   ownKeys(target: object): (string | symbol)[] {
-    track(
-      target,
-      TrackOpTypes.ITERATE,
-      isArray(target) ? 'length' : ITERATE_KEY
-    )
+    track(target, 'iterate', isArray(target) ? 'length' : ITERATE_KEY)
     return Reflect.ownKeys(target)
   }
 }

packages/reactivity/src/collectionHandlers.ts

@@ -1,6 +1,6 @@
-import { toRaw, ReactiveFlags, toReactive, toReadonly } from './reactive'
+import { toRaw, toReactive, toReadonly } from './reactive'
 import { track, trigger, ITERATE_KEY, MAP_KEY_ITERATE_KEY } from './effect'
-import { TrackOpTypes, TriggerOpTypes } from './operations'
+import { TriggerOpTypesUnion } from './operations'
 import { capitalize, hasOwn, hasChanged, toRawType, isMap } from '@vue/shared'
 
 export type CollectionTypes = IterableCollections | WeakCollections
@@ -23,14 +23,14 @@ function get(
 ) {
   // #1772: readonly(reactive(Map)) should return readonly + reactive version
   // of the value
-  target = (target as any)[ReactiveFlags.RAW]
+  target = (target as any).__v_raw
   const rawTarget = toRaw(target)
   const rawKey = toRaw(key)
   if (!isReadonly) {
     if (hasChanged(key, rawKey)) {
-      track(rawTarget, TrackOpTypes.GET, key)
+      track(rawTarget, 'get', key)
     }
-    track(rawTarget, TrackOpTypes.GET, rawKey)
+    track(rawTarget, 'get', rawKey)
   }
   const { has } = getProto(rawTarget)
   const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive
@@ -46,23 +46,23 @@ function get(
 }
 
 function has(this: CollectionTypes, key: unknown, isReadonly = false): boolean {
-  const target = (this as any)[ReactiveFlags.RAW]
+  const target = (this as any).__v_raw
   const rawTarget = toRaw(target)
   const rawKey = toRaw(key)
   if (!isReadonly) {
     if (hasChanged(key, rawKey)) {
-      track(rawTarget, TrackOpTypes.HAS, key)
+      track(rawTarget, 'has', key)
     }
-    track(rawTarget, TrackOpTypes.HAS, rawKey)
+    track(rawTarget, 'has', rawKey)
   }
   return key === rawKey
     ? target.has(key)
     : target.has(key) || target.has(rawKey)
 }
 
 function size(target: IterableCollections, isReadonly = false) {
-  target = (target as any)[ReactiveFlags.RAW]
-  !isReadonly && track(toRaw(target), TrackOpTypes.ITERATE, ITERATE_KEY)
+  target = (target as any).__v_raw
+  !isReadonly && track(toRaw(target), 'iterate', ITERATE_KEY)
   return Reflect.get(target, 'size', target)
 }
 
@@ -73,7 +73,7 @@ function add(this: SetTypes, value: unknown) {
   const hadKey = proto.has.call(target, value)
   if (!hadKey) {
     target.add(value)
-    trigger(target, TriggerOpTypes.ADD, value, value)
+    trigger(target, 'add', value, value)
   }
   return this
 }
@@ -94,9 +94,9 @@ function set(this: MapTypes, key: unknown, value: unknown) {
   const oldValue = get.call(target, key)
   target.set(key, value)
   if (!hadKey) {
-    trigger(target, TriggerOpTypes.ADD, key, value)
+    trigger(target, 'add', key, value)
   } else if (hasChanged(value, oldValue)) {
-    trigger(target, TriggerOpTypes.SET, key, value, oldValue)
+    trigger(target, 'set', key, value, oldValue)
   }
   return this
 }
@@ -116,7 +116,7 @@ function deleteEntry(this: CollectionTypes, key: unknown) {
   // forward the operation before queueing reactions
   const result = target.delete(key)
   if (hadKey) {
-    trigger(target, TriggerOpTypes.DELETE, key, undefined, oldValue)
+    trigger(target, 'delete', key, undefined, oldValue)
   }
   return result
 }
@@ -132,7 +132,7 @@ function clear(this: IterableCollections) {
   // forward the operation before queueing reactions
   const result = target.clear()
   if (hadItems) {
-    trigger(target, TriggerOpTypes.CLEAR, undefined, undefined, oldTarget)
+    trigger(target, 'clear', undefined, undefined, oldTarget)
   }
   return result
 }
@@ -144,10 +144,10 @@ function createForEach(isReadonly: boolean, isShallow: boolean) {
     thisArg?: unknown
   ) {
     const observed = this as any
-    const target = observed[ReactiveFlags.RAW]
+    const target = observed.__v_raw
     const rawTarget = toRaw(target)
     const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive
-    !isReadonly && track(rawTarget, TrackOpTypes.ITERATE, ITERATE_KEY)
+    !isReadonly && track(rawTarget, 'iterate', ITERATE_KEY)
     return target.forEach((value: unknown, key: unknown) => {
       // important: make sure the callback is
       // 1. invoked with the reactive map as `this` and 3rd arg
@@ -179,7 +179,7 @@ function createIterableMethod(
     this: IterableCollections,
     ...args: unknown[]
   ): Iterable & Iterator {
-    const target = (this as any)[ReactiveFlags.RAW]
+    const target = (this as any).__v_raw
     const rawTarget = toRaw(target)
     const targetIsMap = isMap(rawTarget)
     const isPair =
@@ -188,11 +188,7 @@ function createIterableMethod(
     const innerIterator = target[method](...args)
     const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive
     !isReadonly &&
-      track(
-        rawTarget,
-        TrackOpTypes.ITERATE,
-        isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
-      )
+      track(rawTarget, 'iterate', isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY)
     // return a wrapped iterator which returns observed versions of the
     // values emitted from the real iterator
     return {
@@ -214,7 +210,7 @@ function createIterableMethod(
   }
 }
 
-function createReadonlyMethod(type: TriggerOpTypes): Function {
+function createReadonlyMethod(type: TriggerOpTypesUnion): Function {
   return function (this: CollectionTypes, ...args: unknown[]) {
     if (__DEV__) {
       const key = args[0] ? `on key "${args[0]}" ` : ``
@@ -223,7 +219,7 @@ function createReadonlyMethod(type: TriggerOpTypes): Function {
         toRaw(this)
       )
     }
-    return type === TriggerOpTypes.DELETE ? false : this
+    return type === 'delete' ? false : this
   }
 }
 
@@ -268,10 +264,10 @@ function createInstrumentations() {
     has(this: MapTypes, key: unknown) {
       return has.call(this, key, true)
     },
-    add: createReadonlyMethod(TriggerOpTypes.ADD),
-    set: createReadonlyMethod(TriggerOpTypes.SET),
-    delete: createReadonlyMethod(TriggerOpTypes.DELETE),
-    clear: createReadonlyMethod(TriggerOpTypes.CLEAR),
+    add: createReadonlyMethod('add'),
+    set: createReadonlyMethod('set'),
+    delete: createReadonlyMethod('delete'),
+    clear: createReadonlyMethod('clear'),
     forEach: createForEach(true, false)
   }
 
@@ -285,10 +281,10 @@ function createInstrumentations() {
     has(this: MapTypes, key: unknown) {
       return has.call(this, key, true)
     },
-    add: createReadonlyMethod(TriggerOpTypes.ADD),
-    set: createReadonlyMethod(TriggerOpTypes.SET),
-    delete: createReadonlyMethod(TriggerOpTypes.DELETE),
-    clear: createReadonlyMethod(TriggerOpTypes.CLEAR),
+    add: createReadonlyMethod('add'),
+    set: createReadonlyMethod('set'),
+    delete: createReadonlyMethod('delete'),
+    clear: createReadonlyMethod('clear'),
     forEach: createForEach(true, true)
   }
 
@@ -345,11 +341,11 @@ function createInstrumentationGetter(isReadonly: boolean, shallow: boolean) {
     key: string | symbol,
     receiver: CollectionTypes
   ) => {
-    if (key === ReactiveFlags.IS_REACTIVE) {
+    if (key === '__v_isReactive') {
       return !isReadonly
-    } else if (key === ReactiveFlags.IS_READONLY) {
+    } else if (key === '__v_isReadonly') {
       return isReadonly
-    } else if (key === ReactiveFlags.RAW) {
+    } else if (key === '__v_raw') {
       return target
     }