{"version":3,"file":"vue-reactive-reactive.production.cjs","sources":["../src/store-native.ts","../src/utils.ts","../src/decorator.ts","../src/store-prototype.ts","../src/store.ts","../src/adm.ts","../src/effectScope.ts","../src/computed.ts","../src/observable.ts","../src/scheduler.ts","../src/reactivity.ts","../src/watch.ts","../src/watchEffect.ts","../src/index.ts","../src/makeObservable.ts"],"sourcesContent":["import type { ReactiveDecorator } from './decorator'\r\nimport type { DecoratorsMap } from './store-prototype'\r\nimport { STORED_METADATA_KEY } from './decorator'\r\n\r\nexport function storeMetaDataByNative(value: any, context: DecoratorContext, decorator: ReactiveDecorator) {\r\n  const metadata = context.metadata\r\n  const fieldName = (context.name ?? 'unknown').toString()\r\n  if (__DEV__ && isOverridden(decorator) && !hasProp(metadata, STORED_METADATA_KEY)) {\r\n    throw new Error(`'${fieldName}' is decorated with 'override', `\r\n      + `but no such decorated member was found on prototype.`)\r\n  }\r\n\r\n  if (!hasProp(metadata, STORED_METADATA_KEY)) {\r\n    addProp(metadata, STORED_METADATA_KEY, {})\r\n  }\r\n\r\n  // if (!isOverridden(decorator))\r\n  (metadata as any)[STORED_METADATA_KEY][context.name!] = decorator\r\n}\r\n\r\nexport function getMetaDataByNative(instance: object) {\r\n  const metaData = instance.constructor[Symbol.metadata]\r\n  if (!metaData || !metaData[STORED_METADATA_KEY])\r\n    throw new Error('Decorator metadata is not defined')\r\n  return metaData[STORED_METADATA_KEY]\r\n}\r\n\r\nfunction hasProp(target: any, key: PropertyKey) {\r\n  return key in target\r\n}\r\n\r\nfunction addProp(target: any, key: PropertyKey, value: any) {\r\n  Object.defineProperty(target, key, {\r\n    enumerable: false,\r\n    configurable: true,\r\n    writable: true,\r\n    value,\r\n  })\r\n}\r\n\r\nfunction isOverridden(decorator: ReactiveDecorator): boolean {\r\n  return decorator.decoratorType === 'override'\r\n}\r\n\r\nexport function collectDecoratorsByNative(instance: any): DecoratorsMap {\r\n  const metadata = instance.constructor[Symbol.metadata]\r\n  if (!metadata)\r\n    throw new Error('Decorator metadata is not defined')\r\n  return metadata[STORED_METADATA_KEY]\r\n}\r\n","const objectPrototype = Object.prototype\r\nconst hasGetOwnPropertySymbols = typeof Object.getOwnPropertySymbols !== 'undefined'\r\n\r\nexport function hasProp(target: object, key: PropertyKey): boolean {\r\n  return Object.prototype.hasOwnProperty.call(target, key)\r\n}\r\n\r\nexport function addHiddenProp(target: object, key: PropertyKey, value: any) {\r\n  Object.defineProperty(target, key, {\r\n    enumerable: false,\r\n    configurable: true,\r\n    writable: true,\r\n    value,\r\n  })\r\n}\r\n\r\nexport function isPropertyKey(key: any): key is PropertyKey {\r\n  switch (typeof key) {\r\n    case 'string':\r\n    case 'number':\r\n    case 'symbol':\r\n      return true\r\n    default:\r\n      return false\r\n  }\r\n}\r\n\r\nexport function assertPropertyDecorator(name: string, args: any[]) {\r\n  if (args.length < 2 || typeof args[0] !== 'object' || !isPropertyKey(args[1]))\r\n    throw new TypeError(`@${name} decorator can only be used on properties.`)\r\n}\r\n\r\nexport function NOOP() {}\r\n\r\nexport const ownKeys: (target: any) => PropertyKey[]\r\n  = typeof Reflect !== 'undefined' && Reflect.ownKeys\r\n    ? Reflect.ownKeys\r\n    : hasGetOwnPropertySymbols\r\n      ? obj => Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj) as any)\r\n      : /* istanbul ignore next */ Object.getOwnPropertyNames\r\n\r\nexport function getDescriptor(target: any, key: PropertyKey): PropertyDescriptor | undefined {\r\n  let source = target\r\n\r\n  while (source && source !== objectPrototype) {\r\n    const descriptor = Object.getOwnPropertyDescriptor(source, key)\r\n    if (descriptor)\r\n      return descriptor\r\n\r\n    source = Object.getPrototypeOf(source)\r\n  }\r\n\r\n  return undefined\r\n}\r\n\r\n// eslint-disable-next-line ts/no-unsafe-function-type\r\nexport function isFunction(val: any): val is Function {\r\n  return typeof val === 'function'\r\n}\r\n\r\nexport function isArray<T = any>(val: any): val is T[] {\r\n  return Array.isArray(val)\r\n}\r\n","import type { Decorator } from './decorator-fills'\r\nimport { storeMetaDataByNative } from './store-native'\r\nimport { storeMetaDataByPrototype } from './store-prototype'\r\n\r\nexport const STORED_METADATA_KEY: unique symbol = Symbol('VUE_REACTIVE_DECORATOR_METADATA')\r\n\r\nlet DECORATOR_VERSION: '2021' | '2023' | undefined\r\n\r\nexport interface ReactiveDecorator {\r\n  decoratorType: string\r\n  decorate2023?: (value: any, context: DecoratorContext) => void\r\n  decorate2021?: (value: any, propertyKey: string | symbol) => void\r\n  make: (\r\n    target: any,\r\n    key: PropertyKey,\r\n    descriptor: PropertyDescriptor,\r\n  ) => any\r\n  options?: any\r\n}\r\n\r\nexport function createDecorator<D extends Decorator = Decorator>(\r\n  decorator: ReactiveDecorator,\r\n): PropertyDecorator & ReactiveDecorator & D {\r\n  function _decorator(arg1: any, arg2: any) {\r\n    if (is2023DecoratorByContext(arg2)) {\r\n      const [value, context] = [arg1, arg2]\r\n      if (DECORATOR_VERSION === undefined)\r\n        DECORATOR_VERSION = '2023'\r\n      // return decorator.decorate2023(decorator, target)\r\n      storeMetaDataByNative(value, context, decorator)\r\n    }\r\n    else {\r\n      // return decorator.decorate2021(decorator, target)\r\n      const [target, property] = [arg1, arg2]\r\n      if (DECORATOR_VERSION === undefined)\r\n        DECORATOR_VERSION = '2021'\r\n      storeMetaDataByPrototype(target, property, decorator)\r\n    }\r\n  }\r\n  return Object.assign(_decorator, decorator) as any\r\n}\r\n\r\nexport function isReactiveDecorator(thing: any): thing is ReactiveDecorator {\r\n  return (\r\n    thing != null\r\n    && thing instanceof Object\r\n    && typeof thing.decoratorType === 'string'\r\n  )\r\n}\r\nexport function assert20223DecoratorType(\r\n  context: DecoratorContext,\r\n  types: DecoratorContext['kind'][],\r\n) {\r\n  if (!types.includes(context.kind)) {\r\n    console.error(\r\n      `The decorator applied to '${String(context.name)}' cannot be used on a ${\r\n        context.kind\r\n      } element`,\r\n    )\r\n  }\r\n}\r\n\r\nexport function is2023DecoratorByContext(context: any): context is DecoratorContext {\r\n  return typeof context == 'object' && typeof context.kind == 'string'\r\n}\r\n\r\nexport function is2023Decorator() {\r\n  if (DECORATOR_VERSION === undefined) {\r\n    if (__DEV__) {\r\n      throw new Error('No decorator has been applied yet before calling is2023Decorator. Should be called after any decorator is applied.')\r\n    }\r\n  }\r\n  return DECORATOR_VERSION === '2023'\r\n}\r\n","import type { ReactiveDecorator } from './decorator'\r\nimport { STORED_METADATA_KEY } from './decorator'\r\nimport { addHiddenProp, hasProp } from './utils'\r\n\r\nexport function isOverridden(decorator: ReactiveDecorator): boolean {\r\n  return decorator.decoratorType === 'override'\r\n}\r\n\r\nexport function getDecoratorType(decorator: ReactiveDecorator): string {\r\n  return decorator.decoratorType\r\n}\r\n\r\nexport function storeMetaDataByPrototype(prototype: any, key: PropertyKey, decorator: ReactiveDecorator) {\r\n  if (!hasProp(prototype, STORED_METADATA_KEY)) {\r\n    addHiddenProp(prototype, STORED_METADATA_KEY, {\r\n      ...prototype[STORED_METADATA_KEY],\r\n    })\r\n  }\r\n\r\n  if (__DEV__) {\r\n    /**\r\n     * Check if the decorator is 'override' and if the member is not found on prototype.\r\n     */\r\n    if (isOverridden(decorator) && !hasProp(prototype[STORED_METADATA_KEY], key)) {\r\n      const fieldName = `${prototype.constructor.name}.prototype.${key.toString()}`\r\n      if (__DEV__)\r\n        throw new Error(`'${fieldName}' is decorated with 'override', but no such decorated member was found on prototype.`)\r\n    }\r\n    /**\r\n     * Check if the member is already decorated with another decorator.\r\n     */\r\n    if (!isOverridden(decorator) && hasProp(prototype[STORED_METADATA_KEY], key)) {\r\n      const fieldName = `${prototype.constructor.name}.prototype.${key.toString()}`\r\n      const prevType = getDecoratorType(prototype[STORED_METADATA_KEY][key])\r\n      const currentType = getDecoratorType(decorator)\r\n\r\n      if (__DEV__)\r\n        throw new Error(`'${fieldName}' is decorated with '${currentType}', but '${prevType}' is already defined.`)\r\n    }\r\n  }\r\n\r\n  // if (!isOverridden(decorator))\r\n  prototype[STORED_METADATA_KEY][key] = decorator\r\n}\r\n\r\nexport type DecoratorMapEntry =\r\n  | ReactiveDecorator\r\n\r\nexport type DecoratorsMap = Record<PropertyKey, DecoratorMapEntry>\r\n\r\nexport function collectDecoratorsByPrototype(target: any): DecoratorsMap {\r\n  if (!hasProp(target, STORED_METADATA_KEY)) {\r\n    if (__DEV__ && !target[STORED_METADATA_KEY])\r\n      throw new Error(`No decorators found. Please check if you have used any decorators.`)\r\n\r\n    addHiddenProp(target, STORED_METADATA_KEY, {\r\n      ...target[STORED_METADATA_KEY],\r\n    })\r\n  }\r\n\r\n  return target[STORED_METADATA_KEY]\r\n}\r\n","import { is2023Decorator, is2023DecoratorByContext } from './decorator'\r\nimport { collectDecoratorsByNative, storeMetaDataByNative } from './store-native'\r\nimport { collectDecoratorsByPrototype, storeMetaDataByPrototype } from './store-prototype'\r\n\r\nexport function storeMetaData(...args:\r\n  Parameters<typeof storeMetaDataByPrototype> |\r\n  Parameters<typeof storeMetaDataByNative>) {\r\n  const [target, property, decorator] = args\r\n  if (is2023DecoratorByContext(property))\r\n    return storeMetaDataByNative(target, property, decorator)\r\n  else\r\n    return storeMetaDataByPrototype(target, property, decorator)\r\n}\r\n\r\nexport function collectDecorators(...args:\r\n  Parameters<typeof collectDecoratorsByPrototype> |\r\n  Parameters<typeof collectDecoratorsByNative>) {\r\n  const [target] = args\r\n  if (is2023Decorator())\r\n    return collectDecoratorsByNative(target)\r\n  else\r\n    return collectDecoratorsByPrototype(target)\r\n}\r\n","import { isReactiveDecorator, type ReactiveDecorator } from './decorator'\r\nimport { collectDecorators } from './store'\r\nimport { addHiddenProp, getDescriptor, hasProp } from './utils'\r\n\r\nexport const STORED_ADM_KEY = Symbol('VUE_REACTIVE_STORED_ADM')\r\n\r\nexport class ObservableObjectAdministration {\r\n  target: any\r\n  records: Record<PropertyKey, {\r\n    raw: any\r\n    decorator: ReactiveDecorator\r\n  }> = {}\r\n\r\n  constructor(target: any) {\r\n    this.target = target\r\n    this.records = getAdministration(target) ?? {}\r\n  }\r\n\r\n  getRecord(key: PropertyKey) {\r\n    return this.records[key]\r\n  }\r\n\r\n  setRecord(key: PropertyKey, value: any, decorator: ReactiveDecorator) {\r\n    this.records[key] = {\r\n      raw: value,\r\n      decorator,\r\n    }\r\n  }\r\n\r\n  make(key: PropertyKey, decorator: ReactiveDecorator) {\r\n    if (!(key in this.target)) {\r\n      if (key in collectDecorators(this.target)) {\r\n        // the key may be defined in the child class\r\n        return\r\n      }\r\n      else {\r\n        throw new Error(\r\n          `${key.toString()}@${decorator.decoratorType} cannot be used on non-existent member.`,\r\n        )\r\n      }\r\n    }\r\n\r\n    const record = this.getRecord(key)\r\n\r\n    if (record) {\r\n      // already been made\r\n      if (record.decorator === decorator) {\r\n        // the same decorator\r\n        return\r\n      }\r\n      if (record.decorator !== decorator) {\r\n        // the different decorator\r\n        throw new Error(`property ${String(key)} already been decorated by ${record.decorator.decoratorType}`)\r\n      }\r\n    }\r\n\r\n    // have not been made\r\n    const descriptor = getDescriptor(this.target, key)\r\n    if (descriptor) {\r\n      if (!descriptor.configurable)\r\n        throw new Error(`property ${String(key)} is not configurable.`)\r\n    }\r\n    if (!descriptor)\r\n      throw new Error(`property ${String(key)} is not defined.`)\r\n\r\n    const value = decorator.make(this.target, key, descriptor)\r\n    this.setRecord(key, value, decorator)\r\n  }\r\n}\r\nexport interface IIsObservableObject {\r\n  [STORED_ADM_KEY]: ObservableObjectAdministration\r\n}\r\n\r\nexport function asObservableObject(target: any): IIsObservableObject {\r\n  return {\r\n    [STORED_ADM_KEY]: new ObservableObjectAdministration(target),\r\n  }\r\n}\r\n\r\nexport function getAdministration(target: any): Record<\r\n  PropertyKey,\r\n  {\r\n    raw: any\r\n    decorator: ReactiveDecorator\r\n  }\r\n> {\r\n  if (!hasProp(target, STORED_ADM_KEY))\r\n    addHiddenProp(target, STORED_ADM_KEY, {})\r\n\r\n  return target[STORED_ADM_KEY]\r\n}\r\n\r\n// isWatchEffect\r\n// isObservable\r\n// isComputed\r\n\r\nexport function createDecoratorTypeChecker(\r\n  checker: (decorator: ReactiveDecorator) => boolean,\r\n): {\r\n    (decorator: ReactiveDecorator): boolean\r\n    <T extends object>(target: T, key: keyof T): boolean\r\n  } {\r\n  function checkHandle<T extends object>(arg1: ReactiveDecorator | T, arg2?: keyof T): boolean {\r\n    if (isReactiveDecorator(arg1)) {\r\n      return checker(arg1)\r\n    }\r\n    if (arg2 !== undefined) {\r\n      const [target, key] = [arg1, arg2]\r\n      const records = getAdministration(target)\r\n      const decorator = records[key]?.decorator\r\n      return checkHandle(decorator)\r\n    }\r\n    return false\r\n  }\r\n\r\n  return checkHandle\r\n}\r\n","import type { EffectScope } from '@vue/reactivity'\r\nimport { effectScope } from '@vue/reactivity'\r\nimport { addHiddenProp, hasProp } from './utils'\r\n\r\nconst STORED_EFFECT_SCOPE_KEY = Symbol('VUE_REACTIVE_STORED_EFFECT_SCOPE')\r\n\r\nexport function getEffectScope(target: any): EffectScope {\r\n  if (hasProp(target, STORED_EFFECT_SCOPE_KEY))\r\n    return target[STORED_EFFECT_SCOPE_KEY]\r\n\r\n  const scope = effectScope(true)\r\n\r\n  addHiddenProp(target, STORED_EFFECT_SCOPE_KEY, scope)\r\n\r\n  return scope\r\n}\r\n","import type { ClassGetterDecorator } from './decorator-fills'\nimport { computed } from '@vue/reactivity'\nimport { createDecoratorTypeChecker } from './adm'\nimport { createDecorator, type ReactiveDecorator } from './decorator'\nimport { getEffectScope } from './effectScope'\nimport { NOOP } from './utils'\n\nconst COMPUTED = 'computed'\n\nexport const isComputed = createDecoratorTypeChecker(\n  (decorator: ReactiveDecorator) => decorator.decoratorType === COMPUTED,\n)\n\nfunction make(target: any, key: PropertyKey, descriptor: PropertyDescriptor) {\n  /**\n   * Cannot be used on static member.\n   * Can only be used on getter.\n   */\n  if (typeof target === 'function')\n    throw new Error('computed cannot be used on static member')\n\n  if (\n    descriptor == null\n    || typeof descriptor !== 'object'\n    || typeof descriptor.get !== 'function'\n  ) {\n    throw new Error('computed can only be used on getter')\n  }\n\n  const effectScope = getEffectScope(target)\n\n  const value = effectScope.run(() =>\n    computed(\n      {\n        get: descriptor.get!.bind(target),\n        set: descriptor.set?.bind(target) ?? NOOP,\n      },\n    ),\n  )!\n\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: false,\n    get() {\n      return value.value\n    },\n    set: descriptor.set && (val => (value.value = val)),\n  })\n}\n\nexport const Computed = createDecorator<ClassGetterDecorator>({\n  decoratorType: COMPUTED,\n  make,\n})\n","import type { Ref, ShallowRef } from '@vue/reactivity'\r\nimport type { ReactiveDecorator } from './decorator'\r\nimport type { ClassFieldDecorator } from './decorator-fills'\r\nimport { reactive, ref, shallowReactive, shallowRef } from '@vue/reactivity'\r\nimport { createDecoratorTypeChecker } from './adm'\r\nimport { createDecorator } from './decorator'\r\n\r\nexport interface IObservableFactory extends ReactiveDecorator, PropertyDecorator, ClassFieldDecorator {\r\n  ref: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator\r\n  shallowRef: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator\r\n  reactive: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator\r\n  shallowReactive: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator\r\n}\r\n\r\ninterface CreateObservableOptions {\r\n  ref: boolean\r\n  deep: boolean\r\n}\r\n\r\nexport function createObservable(name: string, options: CreateObservableOptions): ReactiveDecorator {\r\n  return {\r\n    decoratorType: name,\r\n    make: (target: any, key: PropertyKey, descriptor: PropertyDescriptor) => make(target, key, descriptor, options),\r\n    options,\r\n  }\r\n}\r\n\r\nfunction make(target: any, key: PropertyKey, descriptor: PropertyDescriptor, options: CreateObservableOptions) {\r\n  if (\r\n    __DEV__\r\n    && (!('value' in descriptor) || typeof descriptor.value === 'function')\r\n  ) {\r\n    throw new Error(`@observable can only be used with non-function properties.`)\r\n  }\r\n\r\n  const initialValue = descriptor.value\r\n\r\n  if (options.ref === true) {\r\n    let refValue: ShallowRef | Ref\r\n\r\n    if (options.deep === true)\r\n      refValue = ref(initialValue)\r\n    else\r\n      refValue = shallowRef(initialValue)\r\n\r\n    Object.defineProperty(target, key, {\r\n      enumerable: true,\r\n      configurable: true,\r\n      get() {\r\n        return refValue.value\r\n      },\r\n      set(v: any) {\r\n        refValue.value = v\r\n      },\r\n    })\r\n  }\r\n  else {\r\n    let reactiveValue: any\r\n\r\n    if (options.deep === true)\r\n      reactiveValue = reactive(initialValue)\r\n    else\r\n      reactiveValue = shallowReactive(initialValue)\r\n\r\n    Object.defineProperty(target, key, {\r\n      enumerable: true,\r\n      configurable: true,\r\n      get() {\r\n        return reactiveValue\r\n      },\r\n      set(v: any) {\r\n        reactiveValue = v\r\n      },\r\n    })\r\n  }\r\n}\r\n\r\nconst observableDecorator = createObservable('observable', { ref: true, deep: true })\r\nconst observableShallowRefDecorator = createObservable('observable.shallowRef', { ref: true, deep: false })\r\nconst observableShallowReactiveDecorator = createObservable('observable.shallowReactive', { ref: false, deep: false })\r\nconst observableReactiveDecorator = createObservable('observable.reactive', { ref: false, deep: true })\r\n\r\nconst _observable = createDecorator(observableDecorator)\r\n\r\nconst observableFactories: IObservableFactory = {\r\n  shallowRef: createDecorator(observableShallowRefDecorator),\r\n  ref: _observable,\r\n  shallowReactive: createDecorator(observableShallowReactiveDecorator),\r\n  reactive: createDecorator(observableReactiveDecorator),\r\n} as any\r\n\r\nexport const Observable: IObservableFactory = Object.assign(_observable, observableFactories)\r\n\r\n/*\r\nConsidering two schemes:\r\n1. Using a function to create decorator type checkers for each decorator type.\r\n2. Code respectively for each decorator type\r\n\r\nexport function isObservable(decorator: ReactiveDecorator): boolean\r\nexport function isObservable<T extends object>(target: T, key: keyof T): boolean\r\n\r\nexport function isObservable<T extends object>(arg1: ReactiveDecorator | T, arg2?: keyof T): boolean {\r\n  if (isReactiveDecorator(arg1)) {\r\n    return arg1.decoratorType === 'observable'\r\n  }\r\n  if (arg2 !== undefined) {\r\n    const [target, key] = [arg1, arg2]\r\n    const records = getAdministration(target)\r\n    const decorator = records[key]?.decorator\r\n    return decorator ? isObservable(decorator) : false\r\n  }\r\n\r\n  return false\r\n}\r\n*/\r\nexport const isObservable = createDecoratorTypeChecker(\r\n  (decorator: ReactiveDecorator) => decorator.decoratorType.match(/^observable/) !== null,\r\n)\r\n","// ported from https://github.com/vuejs/core/blob/main/packages/runtime-core/src/scheduler.ts\n// and https://github.com/vue-mini/vue-mini/blob/master/packages/core/src/scheduler.ts\n\nimport { isArray, NOOP } from './utils'\n\nexport enum SchedulerJobFlags {\n  // eslint-disable-next-line ts/prefer-literal-enum-member\n  QUEUED = 1 << 0,\n  // eslint-disable-next-line ts/prefer-literal-enum-member\n  ALLOW_RECURSE = 1 << 2,\n}\n\n// eslint-disable-next-line ts/no-unsafe-function-type\nexport interface SchedulerJob extends Function {\n  id?: number\n  /**\n   * flags can technically be undefined, but it can still be used in bitwise\n   * operations just like 0.\n   */\n  flags?: SchedulerJobFlags\n}\n\nexport type SchedulerJobs = SchedulerJob | SchedulerJob[]\n\nconst queue: SchedulerJob[] = []\nlet flushIndex = -1\n\nconst pendingPostFlushCbs: SchedulerJob[] = []\nlet activePostFlushCbs: SchedulerJob[] | null = null\nlet postFlushIndex = 0\n\nconst resolvedPromise = /* @__PURE__ */ Promise.resolve() as Promise<any>\nlet currentFlushPromise: Promise<void> | null = null\n\nconst RECURSION_LIMIT = 100\ntype CountMap = Map<SchedulerJob, number>\n\nexport function nextTick<T = void, R = void>(\n  this: T,\n  fn?: (this: T) => R,\n): Promise<Awaited<R>> {\n  const p = currentFlushPromise || resolvedPromise\n  return fn ? p.then(this ? fn.bind(this) : fn) : p\n}\n\n// 简化\nexport function queueJob(job: SchedulerJob): void {\n  // check if the job is already in the queue\n  if (!(job.flags! & SchedulerJobFlags.QUEUED)) {\n    queue.push(job)\n    // set the job as queued\n    job.flags! |= SchedulerJobFlags.QUEUED\n    queueFlush()\n  }\n}\n\nfunction queueFlush(): void {\n  if (!currentFlushPromise) {\n    currentFlushPromise = resolvedPromise.then(flushJobs)\n  }\n}\n\nexport function queuePostFlushCb(cb: SchedulerJob): void {\n  if (!isArray(cb)) {\n    if (activePostFlushCbs && cb.id === -1) {\n      activePostFlushCbs.splice(postFlushIndex + 1, 0, cb)\n    }\n    else if (!(cb.flags! & SchedulerJobFlags.QUEUED)) {\n      pendingPostFlushCbs.push(cb)\n      cb.flags! |= SchedulerJobFlags.QUEUED\n    }\n  }\n  else {\n    // if cb is an array, it is a component lifecycle hook which can only be\n    // triggered by a job, which is already deduped in the main queue, so\n    // we can skip duplicate check here to improve perf\n    pendingPostFlushCbs.push(...cb)\n  }\n  queueFlush()\n}\n\nexport function flushPostFlushCbs(seen?: CountMap): void {\n  if (pendingPostFlushCbs.length) {\n    const deduped = [...new Set(pendingPostFlushCbs)]\n\n    // #1947 already has active queue, nested flushPostFlushCbs call\n    if (activePostFlushCbs) {\n      activePostFlushCbs.push(...deduped)\n      return\n    }\n\n    activePostFlushCbs = deduped\n\n    if (__DEV__) {\n      seen = seen || new Map()\n    }\n\n    pendingPostFlushCbs.length = 0\n\n    for (\n      postFlushIndex = 0;\n      postFlushIndex < activePostFlushCbs.length;\n      postFlushIndex++\n    ) {\n      const cb = activePostFlushCbs[postFlushIndex]\n      if (__DEV__ && checkRecursiveUpdates(seen!, cb)) {\n        continue\n      }\n      if (cb.flags! & SchedulerJobFlags.ALLOW_RECURSE) {\n        cb.flags! &= ~SchedulerJobFlags.QUEUED\n      }\n\n      // if (!(cb.flags! & SchedulerJobFlags.DISPOSED)) cb()\n      cb()\n      cb.flags! &= ~SchedulerJobFlags.QUEUED\n    }\n\n    activePostFlushCbs = null\n    postFlushIndex = 0\n  }\n}\n\nfunction flushJobs(seen?: CountMap): void {\n  /* istanbul ignore else -- @preserve  */\n  if (__DEV__) {\n    seen = seen || new Map()\n  }\n\n  // conditional usage of checkRecursiveUpdate must be determined out of\n  // try ... catch block since Rollup by default de-optimizes treeshaking\n  // inside try-catch. This can leave all warning code unshaked. Although\n  // they would get eventually shaken by a minifier like terser, some minifiers\n  // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610)\n  const check\n    = __DEV__\n      ? (job: SchedulerJob) => checkRecursiveUpdates(seen!, job)\n      : NOOP\n\n  try {\n    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\n      const job = queue[flushIndex]\n\n      // if (job && !(job.flags! & SchedulerJobFlags.DISPOSED)) {\n      if (job) {\n        if (__DEV__ && check(job)) {\n          continue\n        }\n\n        if (job.flags! & SchedulerJobFlags.ALLOW_RECURSE) {\n          job.flags! &= ~SchedulerJobFlags.QUEUED\n        }\n\n        job()\n        if (!(job.flags! & SchedulerJobFlags.ALLOW_RECURSE)) {\n          job.flags! &= ~SchedulerJobFlags.QUEUED\n        }\n      }\n    }\n  }\n  finally {\n    // If there was an error we still need to clear the QUEUED flags\n    for (; flushIndex < queue.length; flushIndex++) {\n      const job = queue[flushIndex]\n      if (job) {\n        job.flags! &= ~SchedulerJobFlags.QUEUED\n      }\n    }\n\n    flushIndex = -1\n    queue.length = 0\n\n    flushPostFlushCbs(seen)\n\n    currentFlushPromise = null\n\n    if (queue.length || pendingPostFlushCbs.length) {\n      flushJobs(seen)\n    }\n  }\n}\n\nfunction checkRecursiveUpdates(seen: CountMap, fn: SchedulerJob): boolean {\n  const count = seen.get(fn) || 0\n  /* istanbul ignore if -- @preserve */\n  if (count > RECURSION_LIMIT) {\n    console.warn(\n      `Maximum recursive updates exceeded. `\n      + `This means you have a reactive effect that is mutating its own `\n      + `dependencies and thus recursively triggering itself.`,\n    )\n    return true\n  }\n\n  seen.set(fn, count + 1)\n  return false\n}\n","// ported from https://github.com/vuejs/core/blob/main/packages/runtime-core/src/apiWatch.ts\n// and https://github.com/vue-mini/vue-mini/blob/master/packages/core/src/watch.ts\n\nimport type {\n  WatchOptions as BaseWatchOptions,\n  DebuggerOptions,\n  ReactiveMarker,\n  WatchCallback,\n  WatchEffect,\n  WatchHandle,\n  WatchSource,\n} from '@vue/reactivity'\nimport type { SchedulerJob } from './scheduler'\nimport { watch as baseWatch } from '@vue/reactivity'\nimport { queueJob, queuePostFlushCb, SchedulerJobFlags } from './scheduler'\nimport { isFunction } from './utils'\n\nexport type {\n  OnCleanup,\n  WatchCallback,\n  WatchEffect,\n  WatchHandle,\n  WatchSource,\n  WatchStopHandle,\n} from '@vue/reactivity'\n\ntype MaybeUndefined<T, I> = I extends true ? T | undefined : T\n\ntype MapSources<T, Immediate> = {\n  [K in keyof T]: T[K] extends WatchSource<infer V> ?\n    MaybeUndefined<V, Immediate>\n    : T[K] extends object ? MaybeUndefined<T[K], Immediate>\n      : never\n}\n\nexport interface WatchEffectOptions extends DebuggerOptions {\n  flush?: 'pre' | 'post' | 'sync'\n}\n\nexport interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {\n  immediate?: Immediate\n  deep?: boolean | number\n  once?: boolean\n}\n\n// Simple effect.\nexport function watchEffect(\n  effect: WatchEffect,\n  options?: WatchEffectOptions,\n): WatchHandle {\n  return doWatch(effect, null, options)\n}\n\nexport function watchPostEffect(\n  effect: WatchEffect,\n  options?: DebuggerOptions,\n): WatchHandle {\n  return doWatch(\n    effect,\n    null,\n    __DEV__\n      ? { ...options, flush: 'post' }\n      : { flush: 'post' },\n  )\n}\n\nexport function watchSyncEffect(\n  effect: WatchEffect,\n  options?: DebuggerOptions,\n): WatchHandle {\n  return doWatch(\n    effect,\n    null,\n    __DEV__\n      ? { ...options, flush: 'sync' }\n      : { flush: 'sync' },\n  )\n}\n\nexport type MultiWatchSources = Array<WatchSource<unknown> | object>\n\n// overload: single source + cb\nexport function watch<T, Immediate extends Readonly<boolean> = false>(\n  source: WatchSource<T>,\n  cb: WatchCallback<T, MaybeUndefined<T, Immediate>>,\n  options?: WatchOptions<Immediate>,\n): WatchHandle\n\n// overload: reactive array or tuple of multiple sources + cb\nexport function watch<\n  T extends Readonly<MultiWatchSources>,\n  Immediate extends Readonly<boolean> = false,\n>(\n  sources: readonly [...T] | T,\n  cb: [T] extends [ReactiveMarker] ?\n    WatchCallback<T, MaybeUndefined<T, Immediate>>\n    : WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,\n  options?: WatchOptions<Immediate>,\n): WatchHandle\n\n// overload: array of multiple sources + cb\nexport function watch<\n  T extends MultiWatchSources,\n  Immediate extends Readonly<boolean> = false,\n>(\n  sources: [...T],\n  cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,\n  options?: WatchOptions<Immediate>,\n): WatchHandle\n\n// overload: watching reactive object w/ cb\nexport function watch<\n  T extends object,\n  Immediate extends Readonly<boolean> = false,\n>(\n  source: T,\n  cb: WatchCallback<T, MaybeUndefined<T, Immediate>>,\n  options?: WatchOptions<Immediate>,\n): WatchHandle\n\n// implementation\nexport function watch<T = any, Immediate extends Readonly<boolean> = false>(\n  source: T | WatchSource<T>,\n  cb: any,\n  options?: WatchOptions<Immediate>,\n): WatchHandle {\n  if (__DEV__ && !isFunction(cb)) {\n    console.warn(\n      `\\`watch(fn, options?)\\` signature has been moved to a separate API. `\n      + `Use \\`watchEffect(fn, options?)\\` instead. \\`watch\\` now only `\n      + `supports \\`watch(source, cb, options?) signature.`,\n    )\n  }\n\n  return doWatch(source as any, cb, options)\n}\n\nfunction doWatch(\n  source: WatchSource | WatchSource[] | WatchEffect | object,\n  cb: WatchCallback | null,\n  options: WatchOptions = {},\n): WatchHandle {\n  const { immediate, deep, flush, once } = options\n\n  if (__DEV__ && !cb) {\n    if (immediate !== undefined) {\n      console.warn(\n        `watch() \"immediate\" option is only respected when using the `\n        + `watch(source, callback, options?) signature.`,\n      )\n    }\n\n    if (deep !== undefined) {\n      console.warn(\n        `watch() \"deep\" option is only respected when using the `\n        + `watch(source, callback, options?) signature.`,\n      )\n    }\n\n    if (once !== undefined) {\n      console.warn(\n        `watch() \"once\" option is only respected when using the `\n        + `watch(source, callback, options?) signature.`,\n      )\n    }\n  }\n\n  const baseWatchOptions: BaseWatchOptions = { ...options }\n\n  // scheduler\n  if (flush === 'post') {\n    baseWatchOptions.scheduler = (job) => {\n      queuePostFlushCb(job)\n    }\n  }\n  else if (flush !== 'sync') {\n    baseWatchOptions.scheduler = (job, isFirstRun) => {\n      if (isFirstRun) {\n        job()\n      }\n      else {\n        queueJob(job)\n      }\n    }\n  }\n\n  // @ts-expect-error scheduler is not part of the public API\n  baseWatchOptions.augmentJob = (job: SchedulerJob) => {\n    // important: mark the job as a watcher callback so that scheduler knows\n    // it is allowed to self-trigger\n    if (cb) {\n      job.flags! |= SchedulerJobFlags.ALLOW_RECURSE\n    }\n  }\n\n  const watchHandle = baseWatch(source, cb, baseWatchOptions)\n\n  return watchHandle\n}\n","import type { WatchCallback, WatchOptions } from '@vue/reactivity'\nimport type { ClassMethodDecorator } from './decorator-fills'\nimport { createDecoratorTypeChecker } from './adm'\nimport { createDecorator, type ReactiveDecorator } from './decorator'\nimport { getEffectScope } from './effectScope'\nimport { isObservable } from './observable'\nimport { watch } from './reactivity'\n\nconst WATCH = 'watch'\n\nexport const isWatch = createDecoratorTypeChecker(\n  (decorator: ReactiveDecorator) => decorator.decoratorType === WATCH,\n)\n\ntype WatchSourceFunction<TTarget extends object, TValue> = (this: TTarget) => TValue\ntype WatchSourceProperty<TTarget, TKey extends keyof TTarget> = TKey\n\ntype DecoratorWatchSource<TTarget extends object, TKey extends keyof TTarget, Tvalue> =\n  | WatchSourceFunction<TTarget, Tvalue>\n  | WatchSourceProperty<TTarget, TKey>\n\ninterface CreateWatchOptions<TTarget extends object, TKey extends keyof TTarget, TValue> {\n  source: DecoratorWatchSource<TTarget, TKey, TValue>\n  watchOptions?: WatchOptions\n}\n\ninterface EffectDescriptor<T> extends PropertyDescriptor {\n  value?: WatchCallback<T>\n}\n\nfunction make<\n  TTarget extends object,\n  TKey extends keyof TTarget,\n  TValue,\n>(target: TTarget, key: PropertyKey, descriptor: EffectDescriptor<any>, options: CreateWatchOptions<TTarget, TKey, TValue>) {\n  if (\n    __DEV__\n    && (!('value' in descriptor) || typeof descriptor.value !== 'function')\n  ) {\n    throw new Error(`@watch can only be used with methods.`)\n  }\n  const effectScope = getEffectScope(target)\n\n  const { watchOptions } = options\n\n  const source\n  = typeof options.source === 'function'\n    ? options.source.bind(target)\n    : options.source\n\n  if (!source) {\n    throw new Error(`@watch source is not defined.`)\n  }\n\n  const callback = descriptor.value?.bind(target)\n\n  if (callback === undefined) {\n    throw new Error(`@watch callback is not defined.`)\n  }\n\n  if (typeof source == 'function') {\n    effectScope.run(() => {\n      watch(source, callback, watchOptions)\n    })\n  }\n  else if (typeof source == 'string' || typeof source == 'symbol' || typeof source == 'number') {\n    if (!(source in target)) {\n      throw new Error(`@watch source '${source.toString()}' is not defined in the target.`)\n    }\n    if (!isObservable(target, source)) {\n      throw new Error(`@watch source '${source.toString()}' is not observable.`)\n    }\n    effectScope.run(() => {\n      watch(() => target[source], callback, watchOptions)\n    })\n  }\n}\n\nfunction createWatchDecorator<\n  TTarget extends object,\n  TKey extends keyof TTarget,\n  TValue,\n>(name: string, options: CreateWatchOptions<TTarget, TKey, TValue>): ReactiveDecorator {\n  return {\n    decoratorType: name,\n    make: (target: TTarget, key: PropertyKey, descriptor: EffectDescriptor<TValue>) => make(target, key, descriptor, options),\n    options,\n  }\n}\n\nexport function Watch<\n  TTarget extends object,\n  TKey extends keyof TTarget,\n  TValue = TTarget[TKey],\n  TCallback extends WatchCallback<TValue> = WatchCallback<TValue>,\n>(source: TKey, options?: WatchOptions): ClassMethodDecorator<TTarget, TCallback>\n\nexport function Watch<\n  TTarget extends object,\n  TValue,\n  TCallback extends WatchCallback<TValue> = WatchCallback<TValue>,\n>(source: ((this: TTarget) => TValue), options?: WatchOptions): ClassMethodDecorator<TTarget, TCallback>\n\nexport function Watch<\n  TTarget extends object,\n  TKey extends keyof TTarget,\n  TValue = TTarget[TKey],\n  TCallback extends WatchCallback<TValue> = WatchCallback<TValue>,\n>(source: TKey | ((this: TTarget) => TValue), options?: WatchOptions): ClassMethodDecorator<TTarget, TCallback> {\n  return createDecorator<ClassMethodDecorator<TTarget, TCallback>>(\n    createWatchDecorator<TTarget, TKey, TValue>(\n      WATCH,\n      { source, watchOptions: options },\n    ),\n  )\n}\n","import type { ReactiveDecorator } from './decorator'\r\nimport type { ClassMethodDecorator } from './decorator-fills'\r\nimport { createDecoratorTypeChecker } from './adm'\r\nimport { createDecorator } from './decorator'\r\nimport { getEffectScope } from './effectScope'\r\nimport { watchEffect, watchSyncEffect } from './reactivity'\r\n\r\nconst WATCH_EFFECT = 'watchEffect'\r\n\r\nconst WATCH_SYNC_EFFECT = 'watchEffect.sync'\r\n\r\n// can only be used on class methods\r\n\r\ninterface CreateWatchEffectOptions {\r\n  sync: boolean\r\n}\r\n\r\nfunction createWatchEffectDecorator(name: string, options: CreateWatchEffectOptions): ReactiveDecorator {\r\n  return {\r\n    decoratorType: name,\r\n    make: (target: any, key: PropertyKey, descriptor: PropertyDescriptor) => make(target, key, descriptor, options),\r\n    options,\r\n  }\r\n}\r\n\r\nfunction make(target: any, key: PropertyKey, descriptor: PropertyDescriptor, options: CreateWatchEffectOptions) {\r\n  if (\r\n    __DEV__\r\n    && (!('value' in descriptor) || typeof descriptor.value !== 'function')\r\n  ) {\r\n    throw new Error(`@watchEffect can only be used with methods.`)\r\n  }\r\n\r\n  const effectScope = getEffectScope(target)\r\n\r\n  if (options.sync) {\r\n    effectScope.run(() => {\r\n      watchSyncEffect(descriptor.value.bind(target))\r\n    })\r\n  }\r\n  else {\r\n    effectScope.run(() => {\r\n      watchEffect(descriptor.value.bind(target))\r\n    })\r\n  }\r\n}\r\n\r\nexport const WatchEffect = createDecorator<ClassMethodDecorator>(\r\n  createWatchEffectDecorator(\r\n    WATCH_EFFECT,\r\n    { sync: false },\r\n  ),\r\n)\r\n\r\nexport const WatchSyncEffect = createDecorator<ClassMethodDecorator>(\r\n  createWatchEffectDecorator(\r\n    WATCH_SYNC_EFFECT,\r\n    { sync: true },\r\n  ),\r\n)\r\n\r\nexport const isWatchEffect = createDecoratorTypeChecker(\r\n  (decorator: ReactiveDecorator) => decorator.decoratorType.match(/^watchEffect/) !== null,\r\n)\r\n","// runtime polyfill\nif (typeof Symbol.metadata === 'undefined') {\n  // @ts-expect-error runtime polyfill\n  Symbol.metadata = Symbol('Symbol.metadata')\n}\n\nexport {\n  IIsObservableObject,\n} from './adm'\n\nexport {\n  Computed,\n  isComputed,\n} from './computed'\n\nexport {\n  is2023Decorator,\n  isReactiveDecorator,\n  ReactiveDecorator,\n} from './decorator'\n\nexport {\n  getEffectScope,\n} from './effectScope'\n\n// export {\n//   isOverride,\n//   Override,\n// } from './override'\n\nexport {\n  makeObservable,\n} from './makeObservable'\n\nexport {\n  IObservableFactory,\n  isObservable,\n  Observable,\n} from './observable'\n\nexport {\n  OnCleanup,\n  WatchCallback,\n  WatchHandle,\n  WatchOptions,\n  WatchSource,\n  WatchStopHandle,\n} from './reactivity'\n\nexport {\n  nextTick,\n} from './scheduler'\n\nexport {\n  isWatch,\n  Watch,\n} from './watch'\n\nexport {\n  isWatchEffect,\n  WatchEffect,\n  WatchSyncEffect,\n} from './watchEffect'\n","import type { ReactiveDecorator } from './decorator'\r\nimport { asObservableObject, STORED_ADM_KEY } from './adm'\r\nimport { isComputed } from './computed'\r\nimport { isObservable } from './observable'\r\nimport { collectDecorators } from './store'\r\nimport { ownKeys } from './utils'\r\nimport { isWatch } from './watch'\r\nimport { isWatchEffect } from './watchEffect'\r\n\r\ntype DecoratorType = 'observable' | 'computed' | 'watch'\r\n\r\ninterface DecoratorRecord {\r\n  key: PropertyKey\r\n  decorator: ReactiveDecorator\r\n  type: DecoratorType\r\n}\r\n\r\nfunction getDecoratorType(decorator: ReactiveDecorator): DecoratorType | null {\r\n  if (isObservable(decorator))\r\n    return 'observable'\r\n  if (isComputed(decorator))\r\n    return 'computed'\r\n  if (isWatch(decorator) || isWatchEffect(decorator))\r\n    return 'watch'\r\n  return null\r\n}\r\n\r\nexport function makeObservable<T extends object>(target: T): T {\r\n  const decorators = collectDecorators(target)\r\n  const adm = asObservableObject(target)[STORED_ADM_KEY]\r\n\r\n  const decoratorRecords = ownKeys(decorators)\r\n    .map(key => ({\r\n      key,\r\n      decorator: decorators[key],\r\n      type: getDecoratorType(decorators[key]),\r\n    }))\r\n    .filter((record): record is DecoratorRecord => record.type !== null)\r\n    .sort((a, b) => {\r\n      const order = { observable: 0, computed: 1, watch: 2 }\r\n      return order[a.type] - order[b.type]\r\n    })\r\n\r\n  decoratorRecords.forEach(({ key, decorator }) => {\r\n    adm.make(key, decorator)\r\n  })\r\n\r\n  return target\r\n}\r\n"],"names":["storeMetaDataByNative","value","context","decorator","metadata","name","toString","STORED_METADATA_KEY","target","key","Object","defineProperty","enumerable","configurable","writable","addProp","objectPrototype","prototype","hasGetOwnPropertySymbols","getOwnPropertySymbols","hasProp","hasOwnProperty","call","addHiddenProp","NOOP","ownKeys","Reflect","obj","getOwnPropertyNames","concat","Symbol","DECORATOR_VERSION","createDecorator","assign","arg1","arg2","kind","undefined","property","storeMetaDataByPrototype","isReactiveDecorator","thing","decoratorType","is2023Decorator","collectDecorators","args","instance","constructor","Error","collectDecoratorsByNative","collectDecoratorsByPrototype","STORED_ADM_KEY","ObservableObjectAdministration","records","this","getAdministration","getRecord","setRecord","raw","make","record","String","descriptor","source","getOwnPropertyDescriptor","getPrototypeOf","getDescriptor","createDecoratorTypeChecker","checker","checkHandle","STORED_EFFECT_SCOPE_KEY","getEffectScope","scope","effectScope","COMPUTED","isComputed","Computed","get","run","computed","bind","set","val","createObservable","options","initialValue","ref","refValue","deep","shallowRef","v","reactiveValue","reactive","shallowReactive","observableDecorator","observableShallowRefDecorator","observableShallowReactiveDecorator","observableReactiveDecorator","_observable","observableFactories","Observable","isObservable","match","SchedulerJobFlags","queue","flushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","Promise","resolve","currentFlushPromise","queueFlush","then","flushJobs","queuePostFlushCb","cb","Array","isArray","push","id","splice","flags","QUEUED","seen","length","job","ALLOW_RECURSE","deduped","Set","flushPostFlushCbs","watch","doWatch","immediate","flush","once","baseWatchOptions","scheduler","isFirstRun","queueJob","augmentJob","baseWatch","WATCH","isWatch","createWatchDecorator","watchOptions","callback","createWatchEffectDecorator","sync","effect","watchEffect","WatchEffect","WatchSyncEffect","isWatchEffect","decorators","adm","asObservableObject","map","type","filter","sort","a","b","order","observable","forEach","fn","p"],"mappings":"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"}