/js/ui/vue3/vue/dev/src/vue-dev.js
JavaScript | 1528 lines | 1364 code | 22 blank | 142 comment | 256 complexity | 4d7bbb18ef359cb1b15ed2375256544e MD5 | raw file
- /*!
- * Vue.js v3.2.31
- * (c) 2014-2021 Evan You
- * Released under the MIT License.
- *
- * @source: https://unpkg.com/vue@3.2.31/dist/vue.esm-browser.js
- */
- import {BitrixVue} from "./bitrixvue";
- BitrixVue.developerMode = true;
- BitrixVue.createApp = ((rootComponent, rootProps) => createApp(rootComponent, rootProps).use(BitrixVue));
- export {BitrixVue};
- import {DevTools} from "./devtools";
- const DevToolsConnector = new DevTools;
- export {DevToolsConnector}
- // origin-start
- /**
- * Make a map and return a function for checking if a key
- * is in that map.
- * IMPORTANT: all calls of this function must be prefixed with
- * \/\*#\_\_PURE\_\_\*\/
- * So that rollup can tree-shake them if necessary.
- */
- function makeMap(str, expectsLowerCase) {
- const map = Object.create(null);
- const list = str.split(',');
- for (let i = 0; i < list.length; i++) {
- map[list[i]] = true;
- }
- return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
- }
- /**
- * dev only flag -> name mapping
- */
- const PatchFlagNames = {
- [1 /* TEXT */]: `TEXT`,
- [2 /* CLASS */]: `CLASS`,
- [4 /* STYLE */]: `STYLE`,
- [8 /* PROPS */]: `PROPS`,
- [16 /* FULL_PROPS */]: `FULL_PROPS`,
- [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,
- [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,
- [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,
- [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,
- [512 /* NEED_PATCH */]: `NEED_PATCH`,
- [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,
- [2048 /* DEV_ROOT_FRAGMENT */]: `DEV_ROOT_FRAGMENT`,
- [-1 /* HOISTED */]: `HOISTED`,
- [-2 /* BAIL */]: `BAIL`
- };
- /**
- * Dev only
- */
- const slotFlagsText = {
- [1 /* STABLE */]: 'STABLE',
- [2 /* DYNAMIC */]: 'DYNAMIC',
- [3 /* FORWARDED */]: 'FORWARDED'
- };
- const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +
- 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +
- 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt';
- const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);
- const range = 2;
- function generateCodeFrame(source, start = 0, end = source.length) {
- // Split the content into individual lines but capture the newline sequence
- // that separated each line. This is important because the actual sequence is
- // needed to properly take into account the full line length for offset
- // comparison
- let lines = source.split(/(\r?\n)/);
- // Separate the lines and newline sequences into separate arrays for easier referencing
- const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
- lines = lines.filter((_, idx) => idx % 2 === 0);
- let count = 0;
- const res = [];
- for (let i = 0; i < lines.length; i++) {
- count +=
- lines[i].length +
- ((newlineSequences[i] && newlineSequences[i].length) || 0);
- if (count >= start) {
- for (let j = i - range; j <= i + range || end > count; j++) {
- if (j < 0 || j >= lines.length)
- continue;
- const line = j + 1;
- res.push(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`);
- const lineLength = lines[j].length;
- const newLineSeqLength = (newlineSequences[j] && newlineSequences[j].length) || 0;
- if (j === i) {
- // push underline
- const pad = start - (count - (lineLength + newLineSeqLength));
- const length = Math.max(1, end > count ? lineLength - pad : end - start);
- res.push(` | ` + ' '.repeat(pad) + '^'.repeat(length));
- }
- else if (j > i) {
- if (end > count) {
- const length = Math.max(Math.min(end - count, lineLength), 1);
- res.push(` | ` + '^'.repeat(length));
- }
- count += lineLength + newLineSeqLength;
- }
- }
- break;
- }
- }
- return res.join('\n');
- }
- /**
- * On the client we only need to offer special cases for boolean attributes that
- * have different names from their corresponding dom properties:
- * - itemscope -> N/A
- * - allowfullscreen -> allowFullscreen
- * - formnovalidate -> formNoValidate
- * - ismap -> isMap
- * - nomodule -> noModule
- * - novalidate -> noValidate
- * - readonly -> readOnly
- */
- const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
- const isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);
- /**
- * Boolean attributes should be included if the value is truthy or ''.
- * e.g. `<select multiple>` compiles to `{ multiple: '' }`
- */
- function includeBooleanAttr(value) {
- return !!value || value === '';
- }
- function normalizeStyle(value) {
- if (isArray(value)) {
- const res = {};
- for (let i = 0; i < value.length; i++) {
- const item = value[i];
- const normalized = isString(item)
- ? parseStringStyle(item)
- : normalizeStyle(item);
- if (normalized) {
- for (const key in normalized) {
- res[key] = normalized[key];
- }
- }
- }
- return res;
- }
- else if (isString(value)) {
- return value;
- }
- else if (isObject(value)) {
- return value;
- }
- }
- const listDelimiterRE = /;(?![^(]*\))/g;
- const propertyDelimiterRE = /:(.+)/;
- function parseStringStyle(cssText) {
- const ret = {};
- cssText.split(listDelimiterRE).forEach(item => {
- if (item) {
- const tmp = item.split(propertyDelimiterRE);
- tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
- }
- });
- return ret;
- }
- function normalizeClass(value) {
- let res = '';
- if (isString(value)) {
- res = value;
- }
- else if (isArray(value)) {
- for (let i = 0; i < value.length; i++) {
- const normalized = normalizeClass(value[i]);
- if (normalized) {
- res += normalized + ' ';
- }
- }
- }
- else if (isObject(value)) {
- for (const name in value) {
- if (value[name]) {
- res += name + ' ';
- }
- }
- }
- return res.trim();
- }
- function normalizeProps(props) {
- if (!props)
- return null;
- let { class: klass, style } = props;
- if (klass && !isString(klass)) {
- props.class = normalizeClass(klass);
- }
- if (style) {
- props.style = normalizeStyle(style);
- }
- return props;
- }
- // These tag configs are shared between compiler-dom and runtime-dom, so they
- // https://developer.mozilla.org/en-US/docs/Web/HTML/Element
- const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +
- 'header,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,' +
- 'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +
- 'data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,' +
- 'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +
- 'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +
- 'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +
- 'option,output,progress,select,textarea,details,dialog,menu,' +
- 'summary,template,blockquote,iframe,tfoot';
- // https://developer.mozilla.org/en-US/docs/Web/SVG/Element
- const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +
- 'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +
- 'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +
- 'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +
- 'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +
- 'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +
- 'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +
- 'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +
- 'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +
- 'text,textPath,title,tspan,unknown,use,view';
- const VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';
- /**
- * Compiler only.
- * Do NOT use in runtime code paths unless behind `true` flag.
- */
- const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);
- /**
- * Compiler only.
- * Do NOT use in runtime code paths unless behind `true` flag.
- */
- const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);
- /**
- * Compiler only.
- * Do NOT use in runtime code paths unless behind `true` flag.
- */
- const isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);
- function looseCompareArrays(a, b) {
- if (a.length !== b.length)
- return false;
- let equal = true;
- for (let i = 0; equal && i < a.length; i++) {
- equal = looseEqual(a[i], b[i]);
- }
- return equal;
- }
- function looseEqual(a, b) {
- if (a === b)
- return true;
- let aValidType = isDate(a);
- let bValidType = isDate(b);
- if (aValidType || bValidType) {
- return aValidType && bValidType ? a.getTime() === b.getTime() : false;
- }
- aValidType = isArray(a);
- bValidType = isArray(b);
- if (aValidType || bValidType) {
- return aValidType && bValidType ? looseCompareArrays(a, b) : false;
- }
- aValidType = isObject(a);
- bValidType = isObject(b);
- if (aValidType || bValidType) {
- /* istanbul ignore if: this if will probably never be called */
- if (!aValidType || !bValidType) {
- return false;
- }
- const aKeysCount = Object.keys(a).length;
- const bKeysCount = Object.keys(b).length;
- if (aKeysCount !== bKeysCount) {
- return false;
- }
- for (const key in a) {
- const aHasKey = a.hasOwnProperty(key);
- const bHasKey = b.hasOwnProperty(key);
- if ((aHasKey && !bHasKey) ||
- (!aHasKey && bHasKey) ||
- !looseEqual(a[key], b[key])) {
- return false;
- }
- }
- }
- return String(a) === String(b);
- }
- function looseIndexOf(arr, val) {
- return arr.findIndex(item => looseEqual(item, val));
- }
- /**
- * For converting {{ interpolation }} values to displayed strings.
- * @private
- */
- const toDisplayString = (val) => {
- return isString(val)
- ? val
- : val == null
- ? ''
- : isArray(val) ||
- (isObject(val) &&
- (val.toString === objectToString || !isFunction(val.toString)))
- ? JSON.stringify(val, replacer, 2)
- : String(val);
- };
- const replacer = (_key, val) => {
- // can't use isRef here since @vue/shared has no deps
- if (val && val.__v_isRef) {
- return replacer(_key, val.value);
- }
- else if (isMap(val)) {
- return {
- [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {
- entries[`${key} =>`] = val;
- return entries;
- }, {})
- };
- }
- else if (isSet(val)) {
- return {
- [`Set(${val.size})`]: [...val.values()]
- };
- }
- else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
- return String(val);
- }
- return val;
- };
- const EMPTY_OBJ = Object.freeze({})
- ;
- const EMPTY_ARR = Object.freeze([]) ;
- const NOOP = () => { };
- /**
- * Always return false.
- */
- const NO = () => false;
- const onRE = /^on[^a-z]/;
- const isOn = (key) => onRE.test(key);
- const isModelListener = (key) => key.startsWith('onUpdate:');
- const extend = Object.assign;
- const remove = (arr, el) => {
- const i = arr.indexOf(el);
- if (i > -1) {
- arr.splice(i, 1);
- }
- };
- const hasOwnProperty = Object.prototype.hasOwnProperty;
- const hasOwn = (val, key) => hasOwnProperty.call(val, key);
- const isArray = Array.isArray;
- const isMap = (val) => toTypeString(val) === '[object Map]';
- const isSet = (val) => toTypeString(val) === '[object Set]';
- const isDate = (val) => val instanceof Date;
- const isFunction = (val) => typeof val === 'function';
- const isString = (val) => typeof val === 'string';
- const isSymbol = (val) => typeof val === 'symbol';
- const isObject = (val) => val !== null && typeof val === 'object';
- const isPromise = (val) => {
- return isObject(val) && isFunction(val.then) && isFunction(val.catch);
- };
- const objectToString = Object.prototype.toString;
- const toTypeString = (value) => objectToString.call(value);
- const toRawType = (value) => {
- // extract "RawType" from strings like "[object RawType]"
- return toTypeString(value).slice(8, -1);
- };
- const isPlainObject = (val) => toTypeString(val) === '[object Object]';
- const isIntegerKey = (key) => isString(key) &&
- key !== 'NaN' &&
- key[0] !== '-' &&
- '' + parseInt(key, 10) === key;
- const isReservedProp = /*#__PURE__*/ makeMap(
- // the leading comma is intentional so empty string "" is also included
- ',key,ref,ref_for,ref_key,' +
- 'onVnodeBeforeMount,onVnodeMounted,' +
- 'onVnodeBeforeUpdate,onVnodeUpdated,' +
- 'onVnodeBeforeUnmount,onVnodeUnmounted');
- const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo');
- const cacheStringFunction = (fn) => {
- const cache = Object.create(null);
- return ((str) => {
- const hit = cache[str];
- return hit || (cache[str] = fn(str));
- });
- };
- const camelizeRE = /-(\w)/g;
- /**
- * @private
- */
- const camelize = cacheStringFunction((str) => {
- return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
- });
- const hyphenateRE = /\B([A-Z])/g;
- /**
- * @private
- */
- const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase());
- /**
- * @private
- */
- const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
- /**
- * @private
- */
- const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
- // compare whether a value has changed, accounting for NaN.
- const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
- const invokeArrayFns = (fns, arg) => {
- for (let i = 0; i < fns.length; i++) {
- fns[i](arg);
- }
- };
- const def = (obj, key, value) => {
- Object.defineProperty(obj, key, {
- configurable: true,
- enumerable: false,
- value
- });
- };
- const toNumber = (val) => {
- const n = parseFloat(val);
- return isNaN(n) ? val : n;
- };
- let _globalThis;
- const getGlobalThis = () => {
- return (_globalThis ||
- (_globalThis =
- typeof globalThis !== 'undefined'
- ? globalThis
- : typeof self !== 'undefined'
- ? self
- : typeof window !== 'undefined'
- ? window
- : typeof global !== 'undefined'
- ? global
- : {}));
- };
- function warn(msg, ...args) {
- console.warn(`[Vue warn] ${msg}`, ...args);
- }
- let activeEffectScope;
- class EffectScope {
- constructor(detached = false) {
- this.active = true;
- this.effects = [];
- this.cleanups = [];
- if (!detached && activeEffectScope) {
- this.parent = activeEffectScope;
- this.index =
- (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
- }
- }
- run(fn) {
- if (this.active) {
- try {
- activeEffectScope = this;
- return fn();
- }
- finally {
- activeEffectScope = this.parent;
- }
- }
- else {
- warn(`cannot run an inactive effect scope.`);
- }
- }
- on() {
- activeEffectScope = this;
- }
- off() {
- activeEffectScope = this.parent;
- }
- stop(fromParent) {
- if (this.active) {
- let i, l;
- for (i = 0, l = this.effects.length; i < l; i++) {
- this.effects[i].stop();
- }
- 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.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.active = false;
- }
- }
- }
- function effectScope(detached) {
- return new EffectScope(detached);
- }
- function recordEffectScope(effect, scope = activeEffectScope) {
- if (scope && scope.active) {
- scope.effects.push(effect);
- }
- }
- function getCurrentScope() {
- return activeEffectScope;
- }
- function onScopeDispose(fn) {
- if (activeEffectScope) {
- activeEffectScope.cleanups.push(fn);
- }
- else {
- warn(`onScopeDispose() is called when there is no active effect scope` +
- ` to be associated with.`);
- }
- }
- const createDep = (effects) => {
- const dep = new Set(effects);
- dep.w = 0;
- dep.n = 0;
- return dep;
- };
- const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
- const newTracked = (dep) => (dep.n & trackOpBit) > 0;
- const initDepMarkers = ({ deps }) => {
- if (deps.length) {
- for (let i = 0; i < deps.length; i++) {
- deps[i].w |= trackOpBit; // set was tracked
- }
- }
- };
- const finalizeDepMarkers = (effect) => {
- const { deps } = effect;
- if (deps.length) {
- let ptr = 0;
- for (let i = 0; i < deps.length; i++) {
- const dep = deps[i];
- if (wasTracked(dep) && !newTracked(dep)) {
- dep.delete(effect);
- }
- else {
- deps[ptr++] = dep;
- }
- // clear bits
- dep.w &= ~trackOpBit;
- dep.n &= ~trackOpBit;
- }
- deps.length = ptr;
- }
- };
- const targetMap = new WeakMap();
- // The number of effects currently being tracked recursively.
- let effectTrackDepth = 0;
- let trackOpBit = 1;
- /**
- * The bitwise track markers support at most 30 levels of recursion.
- * This value is chosen to enable modern JS engines to use a SMI on all platforms.
- * When recursion depth is greater, fall back to using a full cleanup.
- */
- const maxMarkerBits = 30;
- let activeEffect;
- const ITERATE_KEY = Symbol('iterate' );
- const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
- class ReactiveEffect {
- constructor(fn, scheduler = null, scope) {
- this.fn = fn;
- this.scheduler = scheduler;
- this.active = true;
- this.deps = [];
- this.parent = undefined;
- recordEffectScope(this, scope);
- }
- run() {
- if (!this.active) {
- return this.fn();
- }
- let parent = activeEffect;
- let lastShouldTrack = shouldTrack;
- while (parent) {
- if (parent === this) {
- return;
- }
- parent = parent.parent;
- }
- try {
- this.parent = activeEffect;
- activeEffect = this;
- shouldTrack = true;
- trackOpBit = 1 << ++effectTrackDepth;
- if (effectTrackDepth <= maxMarkerBits) {
- initDepMarkers(this);
- }
- else {
- cleanupEffect(this);
- }
- return this.fn();
- }
- finally {
- if (effectTrackDepth <= maxMarkerBits) {
- finalizeDepMarkers(this);
- }
- trackOpBit = 1 << --effectTrackDepth;
- activeEffect = this.parent;
- shouldTrack = lastShouldTrack;
- this.parent = undefined;
- }
- }
- stop() {
- if (this.active) {
- cleanupEffect(this);
- if (this.onStop) {
- this.onStop();
- }
- this.active = false;
- }
- }
- }
- function cleanupEffect(effect) {
- const { deps } = effect;
- if (deps.length) {
- for (let i = 0; i < deps.length; i++) {
- deps[i].delete(effect);
- }
- deps.length = 0;
- }
- }
- function effect(fn, options) {
- if (fn.effect) {
- fn = fn.effect.fn;
- }
- const _effect = new ReactiveEffect(fn);
- if (options) {
- extend(_effect, options);
- if (options.scope)
- recordEffectScope(_effect, options.scope);
- }
- if (!options || !options.lazy) {
- _effect.run();
- }
- const runner = _effect.run.bind(_effect);
- runner.effect = _effect;
- return runner;
- }
- function stop(runner) {
- runner.effect.stop();
- }
- let shouldTrack = true;
- const trackStack = [];
- function pauseTracking() {
- trackStack.push(shouldTrack);
- shouldTrack = false;
- }
- function resetTracking() {
- const last = trackStack.pop();
- shouldTrack = last === undefined ? true : last;
- }
- function track(target, type, key) {
- if (shouldTrack && activeEffect) {
- let depsMap = targetMap.get(target);
- if (!depsMap) {
- targetMap.set(target, (depsMap = new Map()));
- }
- let dep = depsMap.get(key);
- if (!dep) {
- depsMap.set(key, (dep = createDep()));
- }
- const eventInfo = { effect: activeEffect, target, type, key }
- ;
- trackEffects(dep, eventInfo);
- }
- }
- function trackEffects(dep, debuggerEventExtraInfo) {
- let shouldTrack = false;
- if (effectTrackDepth <= maxMarkerBits) {
- if (!newTracked(dep)) {
- dep.n |= trackOpBit; // set newly tracked
- shouldTrack = !wasTracked(dep);
- }
- }
- else {
- // Full cleanup mode.
- shouldTrack = !dep.has(activeEffect);
- }
- if (shouldTrack) {
- dep.add(activeEffect);
- activeEffect.deps.push(dep);
- if (activeEffect.onTrack) {
- activeEffect.onTrack(Object.assign({
- effect: activeEffect
- }, debuggerEventExtraInfo));
- }
- }
- }
- function trigger(target, type, key, newValue, oldValue, oldTarget) {
- const depsMap = targetMap.get(target);
- if (!depsMap) {
- // never been tracked
- return;
- }
- let deps = [];
- if (type === "clear" /* CLEAR */) {
- // collection being cleared
- // trigger all effects for target
- deps = [...depsMap.values()];
- }
- else if (key === 'length' && isArray(target)) {
- depsMap.forEach((dep, key) => {
- if (key === 'length' || key >= newValue) {
- deps.push(dep);
- }
- });
- }
- else {
- // schedule runs for SET | ADD | DELETE
- if (key !== void 0) {
- deps.push(depsMap.get(key));
- }
- // also run for iteration key on ADD | DELETE | Map.SET
- switch (type) {
- case "add" /* ADD */:
- if (!isArray(target)) {
- deps.push(depsMap.get(ITERATE_KEY));
- if (isMap(target)) {
- deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
- }
- }
- else if (isIntegerKey(key)) {
- // new index added to array -> length changes
- deps.push(depsMap.get('length'));
- }
- break;
- case "delete" /* DELETE */:
- if (!isArray(target)) {
- deps.push(depsMap.get(ITERATE_KEY));
- if (isMap(target)) {
- deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
- }
- }
- break;
- case "set" /* SET */:
- if (isMap(target)) {
- deps.push(depsMap.get(ITERATE_KEY));
- }
- break;
- }
- }
- const eventInfo = { target, type, key, newValue, oldValue, oldTarget }
- ;
- if (deps.length === 1) {
- if (deps[0]) {
- {
- triggerEffects(deps[0], eventInfo);
- }
- }
- }
- else {
- const effects = [];
- for (const dep of deps) {
- if (dep) {
- effects.push(...dep);
- }
- }
- {
- triggerEffects(createDep(effects), eventInfo);
- }
- }
- }
- function triggerEffects(dep, debuggerEventExtraInfo) {
- // spread into array for stabilization
- for (const effect of isArray(dep) ? dep : [...dep]) {
- if (effect !== activeEffect || effect.allowRecurse) {
- if (effect.onTrigger) {
- effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
- }
- if (effect.scheduler) {
- effect.scheduler();
- }
- else {
- effect.run();
- }
- }
- }
- }
- const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
- const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
- .map(key => Symbol[key])
- .filter(isSymbol));
- const get = /*#__PURE__*/ createGetter();
- const shallowGet = /*#__PURE__*/ createGetter(false, true);
- const readonlyGet = /*#__PURE__*/ createGetter(true);
- const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
- const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
- function createArrayInstrumentations() {
- const instrumentations = {};
- ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
- instrumentations[key] = function (...args) {
- const arr = toRaw(this);
- for (let i = 0, l = this.length; i < l; i++) {
- track(arr, "get" /* GET */, i + '');
- }
- // we run the method using the original args first (which may be reactive)
- const res = arr[key](...args);
- if (res === -1 || res === false) {
- // if that didn't work, run it again using raw values.
- return arr[key](...args.map(toRaw));
- }
- else {
- return res;
- }
- };
- });
- ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
- instrumentations[key] = function (...args) {
- pauseTracking();
- const res = toRaw(this)[key].apply(this, args);
- resetTracking();
- return res;
- };
- });
- return instrumentations;
- }
- function createGetter(isReadonly = false, shallow = false) {
- return function get(target, key, receiver) {
- if (key === "__v_isReactive" /* IS_REACTIVE */) {
- return !isReadonly;
- }
- else if (key === "__v_isReadonly" /* IS_READONLY */) {
- return isReadonly;
- }
- else if (key === "__v_isShallow" /* IS_SHALLOW */) {
- return shallow;
- }
- else if (key === "__v_raw" /* RAW */ &&
- receiver ===
- (isReadonly
- ? shallow
- ? shallowReadonlyMap
- : readonlyMap
- : shallow
- ? shallowReactiveMap
- : reactiveMap).get(target)) {
- return target;
- }
- const targetIsArray = isArray(target);
- if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
- return Reflect.get(arrayInstrumentations, key, receiver);
- }
- const res = Reflect.get(target, key, receiver);
- if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
- return res;
- }
- if (!isReadonly) {
- track(target, "get" /* GET */, key);
- }
- if (shallow) {
- return res;
- }
- if (isRef(res)) {
- // ref unwrapping - does not apply for Array + integer key.
- const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
- return shouldUnwrap ? res.value : res;
- }
- if (isObject(res)) {
- // Convert returned value into a proxy as well. we do the isObject check
- // here to avoid invalid value warning. Also need to lazy access readonly
- // and reactive here to avoid circular dependency.
- return isReadonly ? readonly(res) : reactive(res);
- }
- return res;
- };
- }
- const set = /*#__PURE__*/ createSetter();
- const shallowSet = /*#__PURE__*/ createSetter(true);
- function createSetter(shallow = false) {
- return function set(target, key, value, receiver) {
- let oldValue = target[key];
- if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
- return false;
- }
- if (!shallow && !isReadonly(value)) {
- if (!isShallow(value)) {
- value = toRaw(value);
- oldValue = toRaw(oldValue);
- }
- if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
- oldValue.value = value;
- return true;
- }
- }
- const hadKey = isArray(target) && isIntegerKey(key)
- ? Number(key) < target.length
- : hasOwn(target, key);
- const result = Reflect.set(target, key, value, receiver);
- // don't trigger if target is something up in the prototype chain of original
- if (target === toRaw(receiver)) {
- if (!hadKey) {
- trigger(target, "add" /* ADD */, key, value);
- }
- else if (hasChanged(value, oldValue)) {
- trigger(target, "set" /* SET */, key, value, oldValue);
- }
- }
- return result;
- };
- }
- function deleteProperty(target, key) {
- const hadKey = hasOwn(target, key);
- const oldValue = target[key];
- const result = Reflect.deleteProperty(target, key);
- if (result && hadKey) {
- trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
- }
- return result;
- }
- function has(target, key) {
- const result = Reflect.has(target, key);
- if (!isSymbol(key) || !builtInSymbols.has(key)) {
- track(target, "has" /* HAS */, key);
- }
- return result;
- }
- function ownKeys(target) {
- track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
- return Reflect.ownKeys(target);
- }
- const mutableHandlers = {
- get,
- set,
- deleteProperty,
- has,
- ownKeys
- };
- const readonlyHandlers = {
- get: readonlyGet,
- set(target, key) {
- {
- console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
- }
- return true;
- },
- deleteProperty(target, key) {
- {
- console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
- }
- return true;
- }
- };
- const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
- get: shallowGet,
- set: shallowSet
- });
- // Props handlers are special in the sense that it should not unwrap top-level
- // refs (in order to allow refs to be explicitly passed down), but should
- // retain the reactivity of the normal readonly object.
- const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
- get: shallowReadonlyGet
- });
- const toShallow = (value) => value;
- const getProto = (v) => Reflect.getPrototypeOf(v);
- function get$1(target, key, isReadonly = false, isShallow = false) {
- // #1772: readonly(reactive(Map)) should return readonly + reactive version
- // of the value
- target = target["__v_raw" /* RAW */];
- const rawTarget = toRaw(target);
- const rawKey = toRaw(key);
- if (key !== rawKey) {
- !isReadonly && track(rawTarget, "get" /* GET */, key);
- }
- !isReadonly && track(rawTarget, "get" /* GET */, rawKey);
- const { has } = getProto(rawTarget);
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
- if (has.call(rawTarget, key)) {
- return wrap(target.get(key));
- }
- else if (has.call(rawTarget, rawKey)) {
- return wrap(target.get(rawKey));
- }
- else if (target !== rawTarget) {
- // #3602 readonly(reactive(Map))
- // ensure that the nested reactive `Map` can do tracking for itself
- target.get(key);
- }
- }
- function has$1(key, isReadonly = false) {
- const target = this["__v_raw" /* RAW */];
- const rawTarget = toRaw(target);
- const rawKey = toRaw(key);
- if (key !== rawKey) {
- !isReadonly && track(rawTarget, "has" /* HAS */, key);
- }
- !isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
- return key === rawKey
- ? target.has(key)
- : target.has(key) || target.has(rawKey);
- }
- function size(target, isReadonly = false) {
- target = target["__v_raw" /* RAW */];
- !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
- return Reflect.get(target, 'size', target);
- }
- function add(value) {
- value = toRaw(value);
- const target = toRaw(this);
- const proto = getProto(target);
- const hadKey = proto.has.call(target, value);
- if (!hadKey) {
- target.add(value);
- trigger(target, "add" /* ADD */, value, value);
- }
- return this;
- }
- function set$1(key, value) {
- value = toRaw(value);
- const target = toRaw(this);
- const { has, get } = getProto(target);
- let hadKey = has.call(target, key);
- if (!hadKey) {
- key = toRaw(key);
- hadKey = has.call(target, key);
- }
- else {
- checkIdentityKeys(target, has, key);
- }
- const oldValue = get.call(target, key);
- target.set(key, value);
- if (!hadKey) {
- trigger(target, "add" /* ADD */, key, value);
- }
- else if (hasChanged(value, oldValue)) {
- trigger(target, "set" /* SET */, key, value, oldValue);
- }
- return this;
- }
- function deleteEntry(key) {
- const target = toRaw(this);
- const { has, get } = getProto(target);
- let hadKey = has.call(target, key);
- if (!hadKey) {
- key = toRaw(key);
- hadKey = has.call(target, key);
- }
- else {
- checkIdentityKeys(target, has, key);
- }
- const oldValue = get ? get.call(target, key) : undefined;
- // forward the operation before queueing reactions
- const result = target.delete(key);
- if (hadKey) {
- trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
- }
- return result;
- }
- function clear() {
- const target = toRaw(this);
- const hadItems = target.size !== 0;
- const oldTarget = isMap(target)
- ? new Map(target)
- : new Set(target)
- ;
- // forward the operation before queueing reactions
- const result = target.clear();
- if (hadItems) {
- trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
- }
- return result;
- }
- function createForEach(isReadonly, isShallow) {
- return function forEach(callback, thisArg) {
- const observed = this;
- const target = observed["__v_raw" /* RAW */];
- const rawTarget = toRaw(target);
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
- !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
- return target.forEach((value, key) => {
- // important: make sure the callback is
- // 1. invoked with the reactive map as `this` and 3rd arg
- // 2. the value received should be a corresponding reactive/readonly.
- return callback.call(thisArg, wrap(value), wrap(key), observed);
- });
- };
- }
- function createIterableMethod(method, isReadonly, isShallow) {
- return function (...args) {
- const target = this["__v_raw" /* RAW */];
- const rawTarget = toRaw(target);
- const targetIsMap = isMap(rawTarget);
- const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
- const isKeyOnly = method === 'keys' && targetIsMap;
- const innerIterator = target[method](...args);
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
- !isReadonly &&
- track(rawTarget, "iterate" /* 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 {
- // iterator protocol
- next() {
- const { value, done } = innerIterator.next();
- return done
- ? { value, done }
- : {
- value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
- done
- };
- },
- // iterable protocol
- [Symbol.iterator]() {
- return this;
- }
- };
- };
- }
- function createReadonlyMethod(type) {
- return function (...args) {
- {
- const key = args[0] ? `on key "${args[0]}" ` : ``;
- console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
- }
- return type === "delete" /* DELETE */ ? false : this;
- };
- }
- function createInstrumentations() {
- const mutableInstrumentations = {
- get(key) {
- return get$1(this, key);
- },
- get size() {
- return size(this);
- },
- has: has$1,
- add,
- set: set$1,
- delete: deleteEntry,
- clear,
- forEach: createForEach(false, false)
- };
- const shallowInstrumentations = {
- get(key) {
- return get$1(this, key, false, true);
- },
- get size() {
- return size(this);
- },
- has: has$1,
- add,
- set: set$1,
- delete: deleteEntry,
- clear,
- forEach: createForEach(false, true)
- };
- const readonlyInstrumentations = {
- get(key) {
- return get$1(this, key, true);
- },
- get size() {
- return size(this, true);
- },
- has(key) {
- return has$1.call(this, key, true);
- },
- add: createReadonlyMethod("add" /* ADD */),
- set: createReadonlyMethod("set" /* SET */),
- delete: createReadonlyMethod("delete" /* DELETE */),
- clear: createReadonlyMethod("clear" /* CLEAR */),
- forEach: createForEach(true, false)
- };
- const shallowReadonlyInstrumentations = {
- get(key) {
- return get$1(this, key, true, true);
- },
- get size() {
- return size(this, true);
- },
- has(key) {
- return has$1.call(this, key, true);
- },
- add: createReadonlyMethod("add" /* ADD */),
- set: createReadonlyMethod("set" /* SET */),
- delete: createReadonlyMethod("delete" /* DELETE */),
- clear: createReadonlyMethod("clear" /* CLEAR */),
- forEach: createForEach(true, true)
- };
- const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
- iteratorMethods.forEach(method => {
- mutableInstrumentations[method] = createIterableMethod(method, false, false);
- readonlyInstrumentations[method] = createIterableMethod(method, true, false);
- shallowInstrumentations[method] = createIterableMethod(method, false, true);
- shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
- });
- return [
- mutableInstrumentations,
- readonlyInstrumentations,
- shallowInstrumentations,
- shallowReadonlyInstrumentations
- ];
- }
- const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
- function createInstrumentationGetter(isReadonly, shallow) {
- const instrumentations = shallow
- ? isReadonly
- ? shallowReadonlyInstrumentations
- : shallowInstrumentations
- : isReadonly
- ? readonlyInstrumentations
- : mutableInstrumentations;
- return (target, key, receiver) => {
- if (key === "__v_isReactive" /* IS_REACTIVE */) {
- return !isReadonly;
- }
- else if (key === "__v_isReadonly" /* IS_READONLY */) {
- return isReadonly;
- }
- else if (key === "__v_raw" /* RAW */) {
- return target;
- }
- return Reflect.get(hasOwn(instrumentations, key) && key in target
- ? instrumentations
- : target, key, receiver);
- };
- }
- const mutableCollectionHandlers = {
- get: /*#__PURE__*/ createInstrumentationGetter(false, false)
- };
- const shallowCollectionHandlers = {
- get: /*#__PURE__*/ createInstrumentationGetter(false, true)
- };
- const readonlyCollectionHandlers = {
- get: /*#__PURE__*/ createInstrumentationGetter(true, false)
- };
- const shallowReadonlyCollectionHandlers = {
- get: /*#__PURE__*/ createInstrumentationGetter(true, true)
- };
- function checkIdentityKeys(target, has, key) {
- const rawKey = toRaw(key);
- if (rawKey !== key && has.call(target, rawKey)) {
- const type = toRawType(target);
- console.warn(`Reactive ${type} contains both the raw and reactive ` +
- `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
- `which can lead to inconsistencies. ` +
- `Avoid differentiating between the raw and reactive versions ` +
- `of an object and only use the reactive version if possible.`);
- }
- }
- const reactiveMap = new WeakMap();
- const shallowReactiveMap = new WeakMap();
- const readonlyMap = new WeakMap();
- const shallowReadonlyMap = new WeakMap();
- function targetTypeMap(rawType) {
- switch (rawType) {
- case 'Object':
- case 'Array':
- return 1 /* COMMON */;
- case 'Map':
- case 'Set':
- case 'WeakMap':
- case 'WeakSet':
- return 2 /* COLLECTION */;
- default:
- return 0 /* INVALID */;
- }
- }
- function getTargetType(value) {
- return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
- ? 0 /* INVALID */
- : targetTypeMap(toRawType(value));
- }
- function reactive(target) {
- // if trying to observe a readonly proxy, return the readonly version.
- if (isReadonly(target)) {
- return target;
- }
- return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
- }
- /**
- * 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).
- */
- function shallowReactive(target) {
- return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
- }
- /**
- * Creates a readonly copy of the original object. Note the returned copy is not
- * made reactive, but `readonly` can be called on an already reactive object.
- */
- function readonly(target) {
- return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
- }
- /**
- * 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.
- */
- function shallowReadonly(target) {
- return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
- }
- function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
- if (!isObject(target)) {
- {
- console.warn(`value cannot be made reactive: ${String(target)}`);
- }
- return target;
- }
- // target is already a Proxy, return it.
- // exception: calling readonly() on a reactive object
- if (target["__v_raw" /* RAW */] &&
- !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
- return target;
- }
- // target already has corresponding Proxy
- const existingProxy = proxyMap.get(target);
- if (existingProxy) {
- return existingProxy;
- }
- // only a whitelist of value types can be observed.
- const targetType = getTargetType(target);
- if (targetType === 0 /* INVALID */) {
- return target;
- }
- const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
- proxyMap.set(target, proxy);
- return proxy;
- }
- function isReactive(value) {
- if (isReadonly(value)) {
- return isReactive(value["__v_raw" /* RAW */]);
- }
- return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
- }
- function isReadonly(value) {
- return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
- }
- function isShallow(value) {
- return !!(value && value["__v_isShallow" /* IS_SHALLOW */]);
- }
- function isProxy(value) {
- return isReactive(value) || isReadonly(value);
- }
- function toRaw(observed) {
- const raw = observed && observed["__v_raw" /* RAW */];
- return raw ? toRaw(raw) : observed;
- }
- function markRaw(value) {
- def(value, "__v_skip" /* SKIP */, true);
- return value;
- }
- const toReactive = (value) => isObject(value) ? reactive(value) : value;
- const toReadonly = (value) => isObject(value) ? readonly(value) : value;
- function trackRefValue(ref) {
- if (shouldTrack && activeEffect) {
- ref = toRaw(ref);
- {
- trackEffects(ref.dep || (ref.dep = createDep()), {
- target: ref,
- type: "get" /* GET */,
- key: 'value'
- });
- }
- }
- }
- function triggerRefValue(ref, newVal) {
- ref = toRaw(ref);
- if (ref.dep) {
- {
- triggerEffects(ref.dep, {
- target: ref,
- type: "set" /* SET */,
- key: 'value',
- newValue: newVal
- });
- }
- }
- }
- function isRef(r) {
- return !!(r && r.__v_isRef === true);
- }
- function ref(value) {
- return createRef(value, false);
- }
- function shallowRef(value) {
- return createRef(value, true);
- }
- function createRef(rawValue, shallow) {
- if (isRef(rawValue)) {
- return rawValue;
- }
- return new RefImpl(rawValue, shallow);
- }
- class RefImpl {
- constructor(value, __v_isShallow) {
- this.__v_isShallow = __v_isShallow;
- this.dep = undefined;
- this.__v_isRef = true;
- this._rawValue = __v_isShallow ? value : toRaw(value);
- this._value = __v_isShallow ? value : toReactive(value);
- }
- get value() {
- trackRefValue(this);
- return this._value;
- }
- set value(newVal) {
- newVal = this.__v_isShallow ? newVal : toRaw(newVal);
- if (hasChanged(newVal, this._rawValue)) {
- this._rawValue = newVal;
- this._value = this.__v_isShallow ? newVal : toReactive(newVal);
- triggerRefValue(this, newVal);
- }
- }
- }
- function triggerRef(ref) {
- triggerRefValue(ref, ref.value );
- }
- function unref(ref) {
- return isRef(ref) ? ref.value : ref;
- }
- const shallowUnwrapHandlers = {
- get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
- set: (target, key, value, receiver) => {
- const oldValue = target[key];
- if (isRef(oldValue) && !isRef(value)) {
- oldValue.value = value;
- return true;
- }
- else {
- return Reflect.set(target, key, value, receiver);
- }
- }
- };
- function proxyRefs(objectWithRefs) {
- return isReactive(objectWithRefs)
- ? objectWithRefs
- : new Proxy(objectWithRefs, shallowUnwrapHandlers);
- }
- class CustomRefImpl {
- constructor(factory) {
- this.dep = undefined;
- this.__v_isRef = true;
- const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
- this._get = get;
- this._set = set;
- }
- get value() {
- return this._get();
- }
- set value(newVal) {
- this._set(newVal);
- }
- }
- function customRef(factory) {
- return new CustomRefImpl(factory);
- }
- function toRefs(object) {
- if (!isProxy(object)) {
- console.warn(`toRefs() expects a reactive object but received a plain one.`);
- }
- const ret = isArray(object) ? new Array(object.length) : {};
- for (const key in object) {
- ret[key] = toRef(object, key);
- }
- return ret;
- }
- class ObjectRefImpl {
- constructor(_object, _key, _defaultValue) {
- this._object = _object;
- this._key = _key;
- this._defaultValue = _defaultValue;
- this.__v_isRef = true;
- }
- get value() {
- const val = this._object[this._key];
- return val === undefined ? this._defaultValue : val;
- }
- set value(newVal) {
- this._object[this._key] = newVal;
- }
- }
- function toRef(object, key, defaultValue) {
- const val = object[key];
- return isRef(val)
- ? val
- : new ObjectRefImpl(object, key, defaultValue);
- }
- class ComputedRefImpl {
- constructor(getter, _setter, isReadonly, isSSR) {
- this._setter = _setter;
- this.dep = undefined;
- this.__v_isRef = true;
- this._dirty = true;
- this.effect = new ReactiveEffect(getter, () => {
- if (!this._dirty) {
- this._dirty = true;
- triggerRefValue(this);
- }
- });
- this.effect.computed = this;
- this.effect.active = this._cacheable = !isSSR;
- this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
- }
- get value() {
- // the computed ref may get wrapped by other proxies e.g. readonly() #3376
- const self = toRaw(this);
- trackRefValue(self);
- if (self._dirty || !self._cacheable) {
- self._dirty = false;
- self._value = self.effect.run();
- }
- return self._value;
- }
- set value(newValue) {
- this._setter(newValue);
- }
- }
- function computed(getterOrOptions, debugOp