@nest-vue/vue-security-patched 2.7.16-patch.2

package/src/v3/reactivity/effectScope.ts

@@ -0,0 +1,137 @@
+import Watcher from 'core/observer/watcher'
+import { warn } from 'core/util'
+
+export let activeEffectScope: EffectScope | undefined
+
+export class EffectScope {
+  /**
+   * @internal
+   */
+  active = true
+  /**
+   * @internal
+   */
+  effects: Watcher[] = []
+  /**
+   * @internal
+   */
+  cleanups: (() => void)[] = []
+  /**
+   * @internal
+   */
+  parent: EffectScope | undefined
+  /**
+   * record undetached scopes
+   * @internal
+   */
+  scopes: EffectScope[] | undefined
+  /**
+   * indicates this being a component root scope
+   * @internal
+   */
+  _vm?: boolean
+  /**
+   * track a child scope's index in its parent's scopes array for optimized
+   * removal
+   */
+  private index: number | undefined
+
+  constructor(public detached = false) {
+    this.parent = activeEffectScope
+    if (!detached && activeEffectScope) {
+      this.index =
+        (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+          this
+        ) - 1
+    }
+  }
+
+  run<T>(fn: () => T): T | undefined {
+    if (this.active) {
+      const currentEffectScope = activeEffectScope
+      try {
+        activeEffectScope = this
+        return fn()
+      } finally {
+        activeEffectScope = currentEffectScope
+      }
+    } else if (__DEV__) {
+      warn(`cannot run an inactive effect scope.`)
+    }
+  }
+
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    activeEffectScope = this
+  }
+
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    activeEffectScope = this.parent
+  }
+
+  stop(fromParent?: boolean) {
+    if (this.active) {
+      let i, l
+      for (i = 0, l = this.effects.length; i < l; i++) {
+        this.effects[i].teardown()
+      }
+      for (i = 0, l = this.cleanups.length; i < l; i++) {
+        this.cleanups[i]()
+      }
+      if (this.scopes) {
+        for (i = 0, l = this.scopes.length; i < l; i++) {
+          this.scopes[i].stop(true)
+        }
+      }
+      // nested scope, dereference from parent to avoid memory leaks
+      if (!this.detached && this.parent && !fromParent) {
+        // optimized O(1) removal
+        const last = this.parent.scopes!.pop()
+        if (last && last !== this) {
+          this.parent.scopes![this.index!] = last
+          last.index = this.index!
+        }
+      }
+      this.parent = undefined
+      this.active = false
+    }
+  }
+}
+
+export function effectScope(detached?: boolean) {
+  return new EffectScope(detached)
+}
+
+/**
+ * @internal
+ */
+export function recordEffectScope(
+  effect: Watcher,
+  scope: EffectScope | undefined = activeEffectScope
+) {
+  if (scope && scope.active) {
+    scope.effects.push(effect)
+  }
+}
+
+export function getCurrentScope() {
+  return activeEffectScope
+}
+
+export function onScopeDispose(fn: () => void) {
+  if (activeEffectScope) {
+    activeEffectScope.cleanups.push(fn)
+  } else if (__DEV__) {
+    warn(
+      `onScopeDispose() is called when there is no active effect scope` +
+        ` to be associated with.`
+    )
+  }
+}

package/src/v3/reactivity/operations.ts

@@ -0,0 +1,14 @@
+// using literal strings instead of numbers so that it's easier to inspect
+// debugger events
+
+export const enum TrackOpTypes {
+  GET = 'get',
+  TOUCH = 'touch'
+}
+
+export const enum TriggerOpTypes {
+  SET = 'set',
+  ADD = 'add',
+  DELETE = 'delete',
+  ARRAY_MUTATION = 'array mutation'
+}

package/src/v3/reactivity/reactive.ts

@@ -0,0 +1,137 @@
+import { observe, Observer } from 'core/observer'
+import {
+  def,
+  isArray,
+  isPrimitive,
+  warn,
+  toRawType,
+  isServerRendering
+} from 'core/util'
+import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
+
+export const enum ReactiveFlags {
+  SKIP = '__v_skip',
+  IS_READONLY = '__v_isReadonly',
+  IS_SHALLOW = '__v_isShallow',
+  RAW = '__v_raw'
+}
+
+export interface Target {
+  __ob__?: Observer
+  [ReactiveFlags.SKIP]?: boolean
+  [ReactiveFlags.IS_READONLY]?: boolean
+  [ReactiveFlags.IS_SHALLOW]?: boolean
+  [ReactiveFlags.RAW]?: any
+}
+
+// only unwrap nested ref
+export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>
+
+export function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
+export function reactive(target: object) {
+  makeReactive(target, false)
+  return target
+}
+
+export declare const ShallowReactiveMarker: unique symbol
+
+export type ShallowReactive<T> = T & { [ShallowReactiveMarker]?: true }
+
+/**
+ * Return a shallowly-reactive copy of the original object, where only the root
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
+ * root level).
+ */
+export function shallowReactive<T extends object>(
+  target: T
+): ShallowReactive<T> {
+  makeReactive(target, true)
+  def(target, ReactiveFlags.IS_SHALLOW, true)
+  return target
+}
+
+function makeReactive(target: any, shallow: boolean) {
+  // if trying to observe a readonly proxy, return the readonly version.
+  if (!isReadonly(target)) {
+    if (__DEV__) {
+      if (isArray(target)) {
+        warn(
+          `Avoid using Array as root value for ${
+            shallow ? `shallowReactive()` : `reactive()`
+          } as it cannot be tracked in watch() or watchEffect(). Use ${
+            shallow ? `shallowRef()` : `ref()`
+          } instead. This is a Vue-2-only limitation.`
+        )
+      }
+      const existingOb = target && target.__ob__
+      if (existingOb && existingOb.shallow !== shallow) {
+        warn(
+          `Target is already a ${
+            existingOb.shallow ? `` : `non-`
+          }shallow reactive object, and cannot be converted to ${
+            shallow ? `` : `non-`
+          }shallow.`
+        )
+      }
+    }
+    const ob = observe(
+      target,
+      shallow,
+      isServerRendering() /* ssr mock reactivity */
+    )
+    if (__DEV__ && !ob) {
+      if (target == null || isPrimitive(target)) {
+        warn(`value cannot be made reactive: ${String(target)}`)
+      }
+      if (isCollectionType(target)) {
+        warn(
+          `Vue 2 does not support reactive collection types such as Map or Set.`
+        )
+      }
+    }
+  }
+}
+
+export function isReactive(value: unknown): boolean {
+  if (isReadonly(value)) {
+    return isReactive((value as Target)[ReactiveFlags.RAW])
+  }
+  return !!(value && (value as Target).__ob__)
+}
+
+export function isShallow(value: unknown): boolean {
+  return !!(value && (value as Target).__v_isShallow)
+}
+
+export function isReadonly(value: unknown): boolean {
+  return !!(value && (value as Target).__v_isReadonly)
+}
+
+export function isProxy(value: unknown): boolean {
+  return isReactive(value) || isReadonly(value)
+}
+
+export function toRaw<T>(observed: T): T {
+  const raw = observed && (observed as Target)[ReactiveFlags.RAW]
+  return raw ? toRaw(raw) : observed
+}
+
+export function markRaw<T extends object>(
+  value: T
+): T & { [RawSymbol]?: true } {
+  // non-extensible objects won't be observed anyway
+  if (Object.isExtensible(value)) {
+    def(value, ReactiveFlags.SKIP, true)
+  }
+  return value
+}
+
+/**
+ * @internal
+ */
+export function isCollectionType(value: unknown): boolean {
+  const type = toRawType(value)
+  return (
+    type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet'
+  )
+}

package/src/v3/reactivity/readonly.ts

@@ -0,0 +1,127 @@
+import { def, warn, isPlainObject, isArray } from 'core/util'
+import {
+  isCollectionType,
+  isReadonly,
+  isShallow,
+  ReactiveFlags,
+  UnwrapNestedRefs
+} from './reactive'
+import { isRef, Ref, RefFlag } from './ref'
+
+type Primitive = string | number | boolean | bigint | symbol | undefined | null
+type Builtin = Primitive | Function | Date | Error | RegExp
+export type DeepReadonly<T> = T extends Builtin
+  ? T
+  : T extends Map<infer K, infer V>
+  ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
+  : T extends ReadonlyMap<infer K, infer V>
+  ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
+  : T extends WeakMap<infer K, infer V>
+  ? WeakMap<DeepReadonly<K>, DeepReadonly<V>>
+  : T extends Set<infer U>
+  ? ReadonlySet<DeepReadonly<U>>
+  : T extends ReadonlySet<infer U>
+  ? ReadonlySet<DeepReadonly<U>>
+  : T extends WeakSet<infer U>
+  ? WeakSet<DeepReadonly<U>>
+  : T extends Promise<infer U>
+  ? Promise<DeepReadonly<U>>
+  : T extends Ref<infer U>
+  ? Readonly<Ref<DeepReadonly<U>>>
+  : T extends {}
+  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+  : Readonly<T>
+
+const rawToReadonlyFlag = `__v_rawToReadonly`
+const rawToShallowReadonlyFlag = `__v_rawToShallowReadonly`
+
+export function readonly<T extends object>(
+  target: T
+): DeepReadonly<UnwrapNestedRefs<T>> {
+  return createReadonly(target, false)
+}
+
+function createReadonly(target: any, shallow: boolean) {
+  if (!isPlainObject(target)) {
+    if (__DEV__) {
+      if (isArray(target)) {
+        warn(`Vue 2 does not support readonly arrays.`)
+      } else if (isCollectionType(target)) {
+        warn(
+          `Vue 2 does not support readonly collection types such as Map or Set.`
+        )
+      } else {
+        warn(`value cannot be made readonly: ${typeof target}`)
+      }
+    }
+    return target as any
+  }
+
+  if (__DEV__ && !Object.isExtensible(target)) {
+    warn(
+      `Vue 2 does not support creating readonly proxy for non-extensible object.`
+    )
+  }
+
+  // already a readonly object
+  if (isReadonly(target)) {
+    return target as any
+  }
+
+  // already has a readonly proxy
+  const existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag
+  const existingProxy = target[existingFlag]
+  if (existingProxy) {
+    return existingProxy
+  }
+
+  const proxy = Object.create(Object.getPrototypeOf(target))
+  def(target, existingFlag, proxy)
+
+  def(proxy, ReactiveFlags.IS_READONLY, true)
+  def(proxy, ReactiveFlags.RAW, target)
+
+  if (isRef(target)) {
+    def(proxy, RefFlag, true)
+  }
+  if (shallow || isShallow(target)) {
+    def(proxy, ReactiveFlags.IS_SHALLOW, true)
+  }
+
+  const keys = Object.keys(target)
+  for (let i = 0; i < keys.length; i++) {
+    defineReadonlyProperty(proxy, target, keys[i], shallow)
+  }
+
+  return proxy as any
+}
+
+function defineReadonlyProperty(
+  proxy: any,
+  target: any,
+  key: string,
+  shallow: boolean
+) {
+  Object.defineProperty(proxy, key, {
+    enumerable: true,
+    configurable: true,
+    get() {
+      const val = target[key]
+      return shallow || !isPlainObject(val) ? val : readonly(val)
+    },
+    set() {
+      __DEV__ &&
+        warn(`Set operation on key "${key}" failed: target is readonly.`)
+    }
+  })
+}
+
+/**
+ * Returns a reactive-copy of the original object, where only the root level
+ * properties are readonly, and does NOT unwrap refs nor recursively convert
+ * returned properties.
+ * This is used for creating the props proxy object for stateful components.
+ */
+export function shallowReadonly<T extends object>(target: T): Readonly<T> {
+  return createReadonly(target, true)
+}

package/src/v3/reactivity/ref.ts

@@ -0,0 +1,293 @@
+import { defineReactive } from 'core/observer/index'
+import {
+  isReactive,
+  ReactiveFlags,
+  type ShallowReactiveMarker
+} from './reactive'
+import type { IfAny } from 'types/utils'
+import Dep from 'core/observer/dep'
+import { warn, isArray, def, isServerRendering } from 'core/util'
+import { TrackOpTypes, TriggerOpTypes } from './operations'
+
+declare const RefSymbol: unique symbol
+export declare const RawSymbol: unique symbol
+
+/**
+ * @internal
+ */
+export const RefFlag = `__v_isRef`
+
+export interface Ref<T = any> {
+  value: T
+  /**
+   * Type differentiator only.
+   * We need this to be in public d.ts but don't want it to show up in IDE
+   * autocomplete, so we use a private Symbol instead.
+   */
+  [RefSymbol]: true
+  /**
+   * @internal
+   */
+  dep?: Dep
+  /**
+   * @internal
+   */
+  [RefFlag]: true
+}
+
+export function isRef<T>(r: Ref<T> | unknown): r is Ref<T>
+export function isRef(r: any): r is Ref {
+  return !!(r && (r as Ref).__v_isRef === true)
+}
+
+export function ref<T extends Ref>(value: T): T
+export function ref<T>(value: T): Ref<UnwrapRef<T>>
+export function ref<T = any>(): Ref<T | undefined>
+export function ref(value?: unknown) {
+  return createRef(value, false)
+}
+
+declare const ShallowRefMarker: unique symbol
+
+export type ShallowRef<T = any> = Ref<T> & { [ShallowRefMarker]?: true }
+
+export function shallowRef<T>(value: T | Ref<T>): Ref<T> | ShallowRef<T>
+export function shallowRef<T extends Ref>(value: T): T
+export function shallowRef<T>(value: T): ShallowRef<T>
+export function shallowRef<T = any>(): ShallowRef<T | undefined>
+export function shallowRef(value?: unknown) {
+  return createRef(value, true)
+}
+
+function createRef(rawValue: unknown, shallow: boolean) {
+  if (isRef(rawValue)) {
+    return rawValue
+  }
+  const ref: any = {}
+  def(ref, RefFlag, true)
+  def(ref, ReactiveFlags.IS_SHALLOW, shallow)
+  def(
+    ref,
+    'dep',
+    defineReactive(ref, 'value', rawValue, null, shallow, isServerRendering())
+  )
+  return ref
+}
+
+export function triggerRef(ref: Ref) {
+  if (__DEV__ && !ref.dep) {
+    warn(`received object is not a triggerable ref.`)
+  }
+  if (__DEV__) {
+    ref.dep &&
+      ref.dep.notify({
+        type: TriggerOpTypes.SET,
+        target: ref,
+        key: 'value'
+      })
+  } else {
+    ref.dep && ref.dep.notify()
+  }
+}
+
+export function unref<T>(ref: T | Ref<T>): T {
+  return isRef(ref) ? (ref.value as any) : ref
+}
+
+export function proxyRefs<T extends object>(
+  objectWithRefs: T
+): ShallowUnwrapRef<T> {
+  if (isReactive(objectWithRefs)) {
+    return objectWithRefs as any
+  }
+  const proxy = {}
+  const keys = Object.keys(objectWithRefs)
+  for (let i = 0; i < keys.length; i++) {
+    proxyWithRefUnwrap(proxy, objectWithRefs, keys[i])
+  }
+  return proxy as any
+}
+
+export function proxyWithRefUnwrap(
+  target: any,
+  source: Record<string, any>,
+  key: string
+) {
+  Object.defineProperty(target, key, {
+    enumerable: true,
+    configurable: true,
+    get: () => {
+      const val = source[key]
+      if (isRef(val)) {
+        return val.value
+      } else {
+        const ob = val && val.__ob__
+        if (ob) ob.dep.depend()
+        return val
+      }
+    },
+    set: value => {
+      const oldValue = source[key]
+      if (isRef(oldValue) && !isRef(value)) {
+        oldValue.value = value
+      } else {
+        source[key] = value
+      }
+    }
+  })
+}
+
+export type CustomRefFactory<T> = (
+  track: () => void,
+  trigger: () => void
+) => {
+  get: () => T
+  set: (value: T) => void
+}
+
+export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
+  const dep = new Dep()
+  const { get, set } = factory(
+    () => {
+      if (__DEV__) {
+        dep.depend({
+          target: ref,
+          type: TrackOpTypes.GET,
+          key: 'value'
+        })
+      } else {
+        dep.depend()
+      }
+    },
+    () => {
+      if (__DEV__) {
+        dep.notify({
+          target: ref,
+          type: TriggerOpTypes.SET,
+          key: 'value'
+        })
+      } else {
+        dep.notify()
+      }
+    }
+  )
+  const ref = {
+    get value() {
+      return get()
+    },
+    set value(newVal) {
+      set(newVal)
+    }
+  } as any
+  def(ref, RefFlag, true)
+  return ref
+}
+
+export type ToRefs<T = any> = {
+  [K in keyof T]: ToRef<T[K]>
+}
+
+export function toRefs<T extends object>(object: T): ToRefs<T> {
+  if (__DEV__ && !isReactive(object)) {
+    warn(`toRefs() expects a reactive object but received a plain one.`)
+  }
+  const ret: any = isArray(object) ? new Array(object.length) : {}
+  for (const key in object) {
+    ret[key] = toRef(object, key)
+  }
+  return ret
+}
+
+export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>
+
+export function toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K
+): ToRef<T[K]>
+
+export function toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K,
+  defaultValue: T[K]
+): ToRef<Exclude<T[K], undefined>>
+
+export function toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K,
+  defaultValue?: T[K]
+): ToRef<T[K]> {
+  const val = object[key]
+  if (isRef(val)) {
+    return val as any
+  }
+  const ref = {
+    get value() {
+      const val = object[key]
+      return val === undefined ? (defaultValue as T[K]) : val
+    },
+    set value(newVal) {
+      object[key] = newVal
+    }
+  } as any
+  def(ref, RefFlag, true)
+  return ref
+}
+
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module 'vue' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ *
+ * Note that api-extractor somehow refuses to include `declare module`
+ * augmentations in its generated d.ts, so we have to manually append them
+ * to the final generated d.ts in our build process.
+ */
+export interface RefUnwrapBailTypes {
+  runtimeDOMBailTypes: Node | Window
+}
+
+export type ShallowUnwrapRef<T> = {
+  [K in keyof T]: T[K] extends Ref<infer V>
+    ? V
+    : // if `V` is `unknown` that means it does not extend `Ref` and is undefined
+    T[K] extends Ref<infer V> | undefined
+    ? unknown extends V
+      ? undefined
+      : V | undefined
+    : T[K]
+}
+
+export type UnwrapRef<T> = T extends ShallowRef<infer V>
+  ? V
+  : T extends Ref<infer V>
+  ? UnwrapRefSimple<V>
+  : UnwrapRefSimple<T>
+
+type BaseTypes = string | number | boolean
+type CollectionTypes = IterableCollections | WeakCollections
+type IterableCollections = Map<any, any> | Set<any>
+type WeakCollections = WeakMap<any, any> | WeakSet<any>
+
+export type UnwrapRefSimple<T> = T extends
+  | Function
+  | CollectionTypes
+  | BaseTypes
+  | Ref
+  | RefUnwrapBailTypes[keyof RefUnwrapBailTypes]
+  | { [RawSymbol]?: true }
+  ? T
+  : T extends Array<any>
+  ? { [K in keyof T]: UnwrapRefSimple<T[K]> }
+  : T extends object & { [ShallowReactiveMarker]?: never }
+  ? {
+      [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>
+    }
+  : T