Showing preview only (1,136K chars total). Download the full file or copy to clipboard to get everything.
Repository: zchengo/crm
Branch: main
Commit: 0e9f2197cdc1
Files: 120
Total size: 1021.8 KB
Directory structure:
gitextract_8rd8nrrh/
├── .gitattributes
├── .github/
│ └── workflows/
│ └── deploy.yaml
├── .gitignore
├── LICENSE
├── README.md
├── docs/
│ ├── docs/
│ │ ├── .vitepress/
│ │ │ ├── cache/
│ │ │ │ └── deps/
│ │ │ │ ├── _metadata.json
│ │ │ │ ├── package.json
│ │ │ │ └── vue.js
│ │ │ ├── config.js
│ │ │ └── theme/
│ │ │ ├── adsense.vue
│ │ │ ├── index.css
│ │ │ └── index.js
│ │ ├── about/
│ │ │ └── about.md
│ │ ├── index.md
│ │ ├── project/
│ │ │ ├── backend/
│ │ │ │ ├── cors-handle.md
│ │ │ │ └── jwt-handle.md
│ │ │ ├── devops/
│ │ │ │ ├── ci-cd.md
│ │ │ │ └── deploy-cloudserver.md
│ │ │ ├── docs/
│ │ │ │ ├── deploy-guide.md
│ │ │ │ ├── detailed-design.md
│ │ │ │ ├── getting-started.md
│ │ │ │ ├── introduction.md
│ │ │ │ ├── problem-feedback.md
│ │ │ │ └── update-log.md
│ │ │ └── frontend/
│ │ │ ├── axios-package.md
│ │ │ ├── env-var-modes.md
│ │ │ └── nprogress.md
│ │ └── sponsor/
│ │ └── sponsor.md
│ └── package.json
├── server/
│ ├── api/
│ │ ├── common.go
│ │ ├── config.go
│ │ ├── contract.go
│ │ ├── customer.go
│ │ ├── dashboard.go
│ │ ├── notice.go
│ │ ├── product.go
│ │ ├── subscribe.go
│ │ └── user.go
│ ├── common/
│ │ ├── alipay.go
│ │ ├── excel.go
│ │ ├── jwt.go
│ │ ├── mail.go
│ │ ├── rand.go
│ │ └── uuid.go
│ ├── config/
│ │ └── config.go
│ ├── config.yaml
│ ├── dao/
│ │ ├── common.go
│ │ ├── config.go
│ │ ├── contract.go
│ │ ├── customer.go
│ │ ├── dashboard.go
│ │ ├── notice.go
│ │ ├── product.go
│ │ ├── subscribe.go
│ │ └── user.go
│ ├── db/
│ │ └── crm.sql
│ ├── global/
│ │ └── global.go
│ ├── go.mod
│ ├── go.sum
│ ├── initialize/
│ │ ├── alipay.go
│ │ ├── gorm.go
│ │ ├── load.go
│ │ ├── redis.go
│ │ ├── router.go
│ │ └── run.go
│ ├── main.go
│ ├── middleware/
│ │ ├── cors.go
│ │ └── jwt.go
│ ├── models/
│ │ ├── common.go
│ │ ├── config.go
│ │ ├── contract.go
│ │ ├── customer.go
│ │ ├── dashboard.go
│ │ ├── notice.go
│ │ ├── product.go
│ │ ├── subscribe.go
│ │ └── user.go
│ ├── response/
│ │ ├── errcode.go
│ │ └── response.go
│ └── service/
│ ├── common.go
│ ├── config.go
│ ├── contract.go
│ ├── customer.go
│ ├── dashboard.go
│ ├── notice.go
│ ├── product.go
│ ├── subscribe.go
│ └── user.go
└── web/
├── index.html
├── package.json
├── src/
│ ├── App.vue
│ ├── api/
│ │ ├── common.js
│ │ ├── config.js
│ │ ├── contract.js
│ │ ├── customer.js
│ │ ├── dashboard.js
│ │ ├── notice.js
│ │ ├── product.js
│ │ ├── subscribe.js
│ │ └── user.js
│ ├── assets/
│ │ └── region.js
│ ├── axios/
│ │ └── index.js
│ ├── components/
│ │ └── Spot.vue
│ ├── main.js
│ ├── router/
│ │ └── index.js
│ ├── store/
│ │ └── index.js
│ └── views/
│ ├── Config.vue
│ ├── Contract.vue
│ ├── Customer.vue
│ ├── Dashboard.vue
│ ├── Error.vue
│ ├── Home.vue
│ ├── Index.vue
│ ├── Login.vue
│ ├── Pass.vue
│ ├── Product.vue
│ ├── Register.vue
│ ├── Result.vue
│ └── Subscribe.vue
└── vite.config.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
region.js linguist-vendored
================================================
FILE: .github/workflows/deploy.yaml
================================================
name: CRM CI
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Use Node.js
uses: actions/setup-node@v3
with:
node-version: '18.12.0'
- name: Build Web
run: cd web && npm install && npm run build
- name: Build Docs
run: cd docs && npm install && npm run docs:build
- name: Use Go
uses: actions/setup-go@v3
with:
go-version: 1.19
- name: Build Server
run: cd server && go mod tidy && go build -o crmserver main.go
- name: Deploy CRM
env:
KEY: ${{ secrets.SSH_PRIVATE_KEY }}
HOST: ${{ secrets.REMOTE_HOST }}
run: |
mkdir -p ~/.ssh/ && echo "$KEY" > ~/.ssh/id_rsa && chmod 600 ~/.ssh/id_rsa
scp -o StrictHostKeyChecking=no -r web/dist ubuntu@${HOST}:/usr/local/nginx/html/
scp -o StrictHostKeyChecking=no -r docs/docs/.vitepress/dist ubuntu@${HOST}:/usr/local/nginx/html/docs/
ssh -o StrictHostKeyChecking=no ubuntu@${HOST} "sudo /usr/local/nginx/sbin/nginx -s reload"
scp -o StrictHostKeyChecking=no -r server/crmserver ubuntu@${HOST}:/home/ubuntu/
ssh -o StrictHostKeyChecking=no ubuntu@${HOST} "sudo /home/ubuntu/crmapi/restart.sh > /dev/null 2>&1 &"
================================================
FILE: .gitignore
================================================
### node
node_modules
/dist
### IDEA ###
.idea
### MacOS ###
.DS_Store
### VS Code ###
.vscode
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2022-present zchengo
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# crm
<a href="https://zocrm.cloud"><img src="https://img.shields.io/badge/在线演示-zocrm.cloud-%230092FF" /></a>
<a href="https://docs.zocrm.cloud"><img src="https://img.shields.io/badge/项目文档-docs.zocrm.cloud-%230092FF" /></a>
## 简介
客户关系管理系统，基于 Vue + Go 实现，主要功能有仪表盘、客户管理、合同管理、产品管理，配置、订阅等功能。
- 在线演示：[zocrm.cloud](https://zocrm.cloud)
- 项目文档：[docs.zocrm.cloud](https://docs.zocrm.cloud)
## 快速开始
系统运行环境：
| 环境 | 版本 | 下载地址 |
|---|---|---|
| go | >= 1.19.2 | https://golang.google.cn/dl |
| mysql | >= 8.0.31 | https://www.mysql.com/downloads |
| redis | >= 7.0.5 | https://redis.io/download |
| node | >= 18.12.0 | https://nodejs.org/en/download |
在终端中，执行如下命令：
```bash
$ cd server
$ go mod tidy
$ go build -o server main.go (windows编译命令为 go build -o server.exe main.go )
# 运行二进制
$ ./server (windows运行命令为 server.exe)
$ cd web
$ npm install
$ npm run dev
```
初始化和启动成功后，打开浏览器访问[http://127.0.0.1:8060](http://127.0.0.1:8060)。
## 项目文档
想要了解有关项目的更多信息，请访问[docs.zocrm.cloud](https://docs.zocrm.cloud)。
## 许可证
[MIT License](https://github.com/zchengo/crm/blob/main/LICENSE)
Copyright (c) 2022-present zchengo
================================================
FILE: docs/docs/.vitepress/cache/deps/_metadata.json
================================================
{
"hash": "ce2e264b",
"browserHash": "e34b92f3",
"optimized": {
"vue": {
"src": "../../../../node_modules/vue/dist/vue.runtime.esm-bundler.js",
"file": "vue.js",
"fileHash": "0c7ec6e0",
"needsInterop": false
}
},
"chunks": {}
}
================================================
FILE: docs/docs/.vitepress/cache/deps/package.json
================================================
{"type":"module"}
================================================
FILE: docs/docs/.vitepress/cache/deps/vue.js
================================================
// node_modules/@vue/shared/dist/shared.esm-bundler.js
function makeMap(str, expectsLowerCase) {
const map2 = /* @__PURE__ */ Object.create(null);
const list = str.split(",");
for (let i = 0; i < list.length; i++) {
map2[list[i]] = true;
}
return expectsLowerCase ? (val) => !!map2[val.toLowerCase()] : (val) => !!map2[val];
}
var 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";
var isGloballyWhitelisted = makeMap(GLOBALS_WHITE_LISTED);
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;
}
}
var listDelimiterRE = /;(?![^(]*\))/g;
var propertyDelimiterRE = /:([^]+)/;
var styleCommentRE = /\/\*.*?\*\//gs;
function parseStringStyle(cssText) {
const ret = {};
cssText.replace(styleCommentRE, "").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;
}
var HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,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";
var SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,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";
var VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
var isHTMLTag = makeMap(HTML_TAGS);
var isSVGTag = makeMap(SVG_TAGS);
var isVoidTag = makeMap(VOID_TAGS);
var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
var isSpecialBooleanAttr = makeMap(specialBooleanAttrs);
var isBooleanAttr = makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
function includeBooleanAttr(value) {
return !!value || value === "";
}
var isKnownHtmlAttr = makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`);
var isKnownSvgAttr = makeMap(`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`);
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 = isSymbol(a);
bValidType = isSymbol(b);
if (aValidType || bValidType) {
return a === b;
}
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) {
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));
}
var 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);
};
var replacer = (_key, val) => {
if (val && val.__v_isRef) {
return replacer(_key, val.value);
} else if (isMap(val)) {
return {
[`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
entries[`${key} =>`] = val2;
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;
};
var EMPTY_OBJ = true ? Object.freeze({}) : {};
var EMPTY_ARR = true ? Object.freeze([]) : [];
var NOOP = () => {
};
var NO = () => false;
var onRE = /^on[^a-z]/;
var isOn = (key) => onRE.test(key);
var isModelListener = (key) => key.startsWith("onUpdate:");
var extend = Object.assign;
var remove = (arr, el) => {
const i = arr.indexOf(el);
if (i > -1) {
arr.splice(i, 1);
}
};
var hasOwnProperty = Object.prototype.hasOwnProperty;
var hasOwn = (val, key) => hasOwnProperty.call(val, key);
var isArray = Array.isArray;
var isMap = (val) => toTypeString(val) === "[object Map]";
var isSet = (val) => toTypeString(val) === "[object Set]";
var isDate = (val) => toTypeString(val) === "[object Date]";
var isRegExp = (val) => toTypeString(val) === "[object RegExp]";
var isFunction = (val) => typeof val === "function";
var isString = (val) => typeof val === "string";
var isSymbol = (val) => typeof val === "symbol";
var isObject = (val) => val !== null && typeof val === "object";
var isPromise = (val) => {
return isObject(val) && isFunction(val.then) && isFunction(val.catch);
};
var objectToString = Object.prototype.toString;
var toTypeString = (value) => objectToString.call(value);
var toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
var isPlainObject = (val) => toTypeString(val) === "[object Object]";
var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
var isReservedProp = makeMap(
// the leading comma is intentional so empty string "" is also included
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
);
var isBuiltInDirective = makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo");
var cacheStringFunction = (fn) => {
const cache = /* @__PURE__ */ Object.create(null);
return (str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
};
};
var camelizeRE = /-(\w)/g;
var camelize = cacheStringFunction((str) => {
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
});
var hyphenateRE = /\B([A-Z])/g;
var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
var invokeArrayFns = (fns, arg) => {
for (let i = 0; i < fns.length; i++) {
fns[i](arg);
}
};
var def = (obj, key, value) => {
Object.defineProperty(obj, key, {
configurable: true,
enumerable: false,
value
});
};
var looseToNumber = (val) => {
const n = parseFloat(val);
return isNaN(n) ? val : n;
};
var toNumber = (val) => {
const n = isString(val) ? Number(val) : NaN;
return isNaN(n) ? val : n;
};
var _globalThis;
var getGlobalThis = () => {
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
};
// node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
function warn(msg, ...args) {
console.warn(`[Vue warn] ${msg}`, ...args);
}
var activeEffectScope;
var EffectScope = class {
constructor(detached = false) {
this.detached = detached;
this._active = true;
this.effects = [];
this.cleanups = [];
this.parent = activeEffectScope;
if (!detached && activeEffectScope) {
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
}
}
get active() {
return this._active;
}
run(fn) {
if (this._active) {
const currentEffectScope = activeEffectScope;
try {
activeEffectScope = this;
return fn();
} finally {
activeEffectScope = currentEffectScope;
}
} else if (true) {
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) {
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);
}
}
if (!this.detached && this.parent && !fromParent) {
const last = this.parent.scopes.pop();
if (last && last !== this) {
this.parent.scopes[this.index] = last;
last.index = this.index;
}
}
this.parent = void 0;
this._active = false;
}
}
};
function effectScope(detached) {
return new EffectScope(detached);
}
function recordEffectScope(effect2, scope = activeEffectScope) {
if (scope && scope.active) {
scope.effects.push(effect2);
}
}
function getCurrentScope() {
return activeEffectScope;
}
function onScopeDispose(fn) {
if (activeEffectScope) {
activeEffectScope.cleanups.push(fn);
} else if (true) {
warn(`onScopeDispose() is called when there is no active effect scope to be associated with.`);
}
}
var createDep = (effects) => {
const dep = new Set(effects);
dep.w = 0;
dep.n = 0;
return dep;
};
var wasTracked = (dep) => (dep.w & trackOpBit) > 0;
var newTracked = (dep) => (dep.n & trackOpBit) > 0;
var initDepMarkers = ({ deps }) => {
if (deps.length) {
for (let i = 0; i < deps.length; i++) {
deps[i].w |= trackOpBit;
}
}
};
var finalizeDepMarkers = (effect2) => {
const { deps } = effect2;
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(effect2);
} else {
deps[ptr++] = dep;
}
dep.w &= ~trackOpBit;
dep.n &= ~trackOpBit;
}
deps.length = ptr;
}
};
var targetMap = /* @__PURE__ */ new WeakMap();
var effectTrackDepth = 0;
var trackOpBit = 1;
var maxMarkerBits = 30;
var activeEffect;
var ITERATE_KEY = Symbol(true ? "iterate" : "");
var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : "");
var ReactiveEffect = class {
constructor(fn, scheduler = null, scope) {
this.fn = fn;
this.scheduler = scheduler;
this.active = true;
this.deps = [];
this.parent = void 0;
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 = void 0;
if (this.deferStop) {
this.stop();
}
}
}
stop() {
if (activeEffect === this) {
this.deferStop = true;
} else if (this.active) {
cleanupEffect(this);
if (this.onStop) {
this.onStop();
}
this.active = false;
}
}
};
function cleanupEffect(effect2) {
const { deps } = effect2;
if (deps.length) {
for (let i = 0; i < deps.length; i++) {
deps[i].delete(effect2);
}
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();
}
var shouldTrack = true;
var trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function resetTracking() {
const last = trackStack.pop();
shouldTrack = last === void 0 ? true : last;
}
function track(target, type, key) {
if (shouldTrack && activeEffect) {
let depsMap = targetMap.get(target);
if (!depsMap) {
targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
}
let dep = depsMap.get(key);
if (!dep) {
depsMap.set(key, dep = createDep());
}
const eventInfo = true ? { effect: activeEffect, target, type, key } : void 0;
trackEffects(dep, eventInfo);
}
}
function trackEffects(dep, debuggerEventExtraInfo) {
let shouldTrack2 = false;
if (effectTrackDepth <= maxMarkerBits) {
if (!newTracked(dep)) {
dep.n |= trackOpBit;
shouldTrack2 = !wasTracked(dep);
}
} else {
shouldTrack2 = !dep.has(activeEffect);
}
if (shouldTrack2) {
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) {
return;
}
let deps = [];
if (type === "clear") {
deps = [...depsMap.values()];
} else if (key === "length" && isArray(target)) {
const newLength = Number(newValue);
depsMap.forEach((dep, key2) => {
if (key2 === "length" || key2 >= newLength) {
deps.push(dep);
}
});
} else {
if (key !== void 0) {
deps.push(depsMap.get(key));
}
switch (type) {
case "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)) {
deps.push(depsMap.get("length"));
}
break;
case "delete":
if (!isArray(target)) {
deps.push(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set":
if (isMap(target)) {
deps.push(depsMap.get(ITERATE_KEY));
}
break;
}
}
const eventInfo = true ? { target, type, key, newValue, oldValue, oldTarget } : void 0;
if (deps.length === 1) {
if (deps[0]) {
if (true) {
triggerEffects(deps[0], eventInfo);
} else {
triggerEffects(deps[0]);
}
}
} else {
const effects = [];
for (const dep of deps) {
if (dep) {
effects.push(...dep);
}
}
if (true) {
triggerEffects(createDep(effects), eventInfo);
} else {
triggerEffects(createDep(effects));
}
}
}
function triggerEffects(dep, debuggerEventExtraInfo) {
const effects = isArray(dep) ? dep : [...dep];
for (const effect2 of effects) {
if (effect2.computed) {
triggerEffect(effect2, debuggerEventExtraInfo);
}
}
for (const effect2 of effects) {
if (!effect2.computed) {
triggerEffect(effect2, debuggerEventExtraInfo);
}
}
}
function triggerEffect(effect2, debuggerEventExtraInfo) {
if (effect2 !== activeEffect || effect2.allowRecurse) {
if (effect2.onTrigger) {
effect2.onTrigger(extend({ effect: effect2 }, debuggerEventExtraInfo));
}
if (effect2.scheduler) {
effect2.scheduler();
} else {
effect2.run();
}
}
}
function getDepFromReactive(object, key) {
var _a2;
return (_a2 = targetMap.get(object)) === null || _a2 === void 0 ? void 0 : _a2.get(key);
}
var isNonTrackableKeys = makeMap(`__proto__,__v_isRef,__isVue`);
var builtInSymbols = new Set(
Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
);
var get$1 = createGetter();
var shallowGet = createGetter(false, true);
var readonlyGet = createGetter(true);
var shallowReadonlyGet = createGetter(true, true);
var arrayInstrumentations = 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", i + "");
}
const res = arr[key](...args);
if (res === -1 || res === false) {
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 hasOwnProperty2(key) {
const obj = toRaw(this);
track(obj, "has", key);
return obj.hasOwnProperty(key);
}
function createGetter(isReadonly2 = false, shallow = false) {
return function get2(target, key, receiver) {
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_isShallow") {
return shallow;
} else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
return target;
}
const targetIsArray = isArray(target);
if (!isReadonly2) {
if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver);
}
if (key === "hasOwnProperty") {
return hasOwnProperty2;
}
}
const res = Reflect.get(target, key, receiver);
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
return res;
}
if (!isReadonly2) {
track(target, "get", key);
}
if (shallow) {
return res;
}
if (isRef(res)) {
return targetIsArray && isIntegerKey(key) ? res : res.value;
}
if (isObject(res)) {
return isReadonly2 ? readonly(res) : reactive(res);
}
return res;
};
}
var set$1 = createSetter();
var shallowSet = createSetter(true);
function createSetter(shallow = false) {
return function set2(target, key, value, receiver) {
let oldValue = target[key];
if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
return false;
}
if (!shallow) {
if (!isShallow(value) && !isReadonly(value)) {
oldValue = toRaw(oldValue);
value = toRaw(value);
}
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);
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "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", key, void 0, oldValue);
}
return result;
}
function has$1(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has", key);
}
return result;
}
function ownKeys(target) {
track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
return Reflect.ownKeys(target);
}
var mutableHandlers = {
get: get$1,
set: set$1,
deleteProperty,
has: has$1,
ownKeys
};
var readonlyHandlers = {
get: readonlyGet,
set(target, key) {
if (true) {
warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
}
return true;
},
deleteProperty(target, key) {
if (true) {
warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
}
return true;
}
};
var shallowReactiveHandlers = extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
});
var shallowReadonlyHandlers = extend({}, readonlyHandlers, {
get: shallowReadonlyGet
});
var toShallow = (value) => value;
var getProto = (v) => Reflect.getPrototypeOf(v);
function get(target, key, isReadonly2 = false, isShallow3 = false) {
target = target[
"__v_raw"
/* ReactiveFlags.RAW */
];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (!isReadonly2) {
if (key !== rawKey) {
track(rawTarget, "get", key);
}
track(rawTarget, "get", rawKey);
}
const { has: has2 } = getProto(rawTarget);
const wrap = isShallow3 ? toShallow : isReadonly2 ? toReadonly : toReactive;
if (has2.call(rawTarget, key)) {
return wrap(target.get(key));
} else if (has2.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
} else if (target !== rawTarget) {
target.get(key);
}
}
function has(key, isReadonly2 = false) {
const target = this[
"__v_raw"
/* ReactiveFlags.RAW */
];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (!isReadonly2) {
if (key !== rawKey) {
track(rawTarget, "has", key);
}
track(rawTarget, "has", rawKey);
}
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target, isReadonly2 = false) {
target = target[
"__v_raw"
/* ReactiveFlags.RAW */
];
!isReadonly2 && track(toRaw(target), "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", value, value);
}
return this;
}
function set(key, value) {
value = toRaw(value);
const target = toRaw(this);
const { has: has2, get: get2 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
} else if (true) {
checkIdentityKeys(target, has2, key);
}
const oldValue = get2.call(target, key);
target.set(key, value);
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value, oldValue);
}
return this;
}
function deleteEntry(key) {
const target = toRaw(this);
const { has: has2, get: get2 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
} else if (true) {
checkIdentityKeys(target, has2, key);
}
const oldValue = get2 ? get2.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) {
trigger(target, "delete", key, void 0, oldValue);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
const result = target.clear();
if (hadItems) {
trigger(target, "clear", void 0, void 0, oldTarget);
}
return result;
}
function createForEach(isReadonly2, isShallow3) {
return function forEach(callback, thisArg) {
const observed = this;
const target = observed[
"__v_raw"
/* ReactiveFlags.RAW */
];
const rawTarget = toRaw(target);
const wrap = isShallow3 ? toShallow : isReadonly2 ? toReadonly : toReactive;
!isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
return target.forEach((value, key) => {
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly2, isShallow3) {
return function(...args) {
const target = this[
"__v_raw"
/* ReactiveFlags.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 = isShallow3 ? toShallow : isReadonly2 ? toReadonly : toReactive;
!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
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) {
if (true) {
const key = args[0] ? `on key "${args[0]}" ` : ``;
console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
}
return type === "delete" ? false : this;
};
}
function createInstrumentations() {
const mutableInstrumentations2 = {
get(key) {
return get(this, key);
},
get size() {
return size(this);
},
has,
add,
set,
delete: deleteEntry,
clear,
forEach: createForEach(false, false)
};
const shallowInstrumentations2 = {
get(key) {
return get(this, key, false, true);
},
get size() {
return size(this);
},
has,
add,
set,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations2 = {
get(key) {
return get(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has.call(this, key, true);
},
add: createReadonlyMethod(
"add"
/* TriggerOpTypes.ADD */
),
set: createReadonlyMethod(
"set"
/* TriggerOpTypes.SET */
),
delete: createReadonlyMethod(
"delete"
/* TriggerOpTypes.DELETE */
),
clear: createReadonlyMethod(
"clear"
/* TriggerOpTypes.CLEAR */
),
forEach: createForEach(true, false)
};
const shallowReadonlyInstrumentations2 = {
get(key) {
return get(this, key, true, true);
},
get size() {
return size(this, true);
},
has(key) {
return has.call(this, key, true);
},
add: createReadonlyMethod(
"add"
/* TriggerOpTypes.ADD */
),
set: createReadonlyMethod(
"set"
/* TriggerOpTypes.SET */
),
delete: createReadonlyMethod(
"delete"
/* TriggerOpTypes.DELETE */
),
clear: createReadonlyMethod(
"clear"
/* TriggerOpTypes.CLEAR */
),
forEach: createForEach(true, true)
};
const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
iteratorMethods.forEach((method) => {
mutableInstrumentations2[method] = createIterableMethod(method, false, false);
readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
shallowInstrumentations2[method] = createIterableMethod(method, false, true);
shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
});
return [
mutableInstrumentations2,
readonlyInstrumentations2,
shallowInstrumentations2,
shallowReadonlyInstrumentations2
];
}
var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = createInstrumentations();
function createInstrumentationGetter(isReadonly2, shallow) {
const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_raw") {
return target;
}
return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
};
}
var mutableCollectionHandlers = {
get: createInstrumentationGetter(false, false)
};
var shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
var readonlyCollectionHandlers = {
get: createInstrumentationGetter(true, false)
};
var shallowReadonlyCollectionHandlers = {
get: createInstrumentationGetter(true, true)
};
function checkIdentityKeys(target, has2, key) {
const rawKey = toRaw(key);
if (rawKey !== key && has2.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.`);
}
}
var reactiveMap = /* @__PURE__ */ new WeakMap();
var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
var readonlyMap = /* @__PURE__ */ new WeakMap();
var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case "Object":
case "Array":
return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2;
default:
return 0;
}
}
function getTargetType(value) {
return value[
"__v_skip"
/* ReactiveFlags.SKIP */
] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
}
function reactive(target) {
if (isReadonly(target)) {
return target;
}
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
}
function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
}
function readonly(target) {
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
}
function shallowReadonly(target) {
return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
}
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
if (!isObject(target)) {
if (true) {
console.warn(`value cannot be made reactive: ${String(target)}`);
}
return target;
}
if (target[
"__v_raw"
/* ReactiveFlags.RAW */
] && !(isReadonly2 && target[
"__v_isReactive"
/* ReactiveFlags.IS_REACTIVE */
])) {
return target;
}
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
const targetType = getTargetType(target);
if (targetType === 0) {
return target;
}
const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value[
"__v_raw"
/* ReactiveFlags.RAW */
]);
}
return !!(value && value[
"__v_isReactive"
/* ReactiveFlags.IS_REACTIVE */
]);
}
function isReadonly(value) {
return !!(value && value[
"__v_isReadonly"
/* ReactiveFlags.IS_READONLY */
]);
}
function isShallow(value) {
return !!(value && value[
"__v_isShallow"
/* ReactiveFlags.IS_SHALLOW */
]);
}
function isProxy(value) {
return isReactive(value) || isReadonly(value);
}
function toRaw(observed) {
const raw = observed && observed[
"__v_raw"
/* ReactiveFlags.RAW */
];
return raw ? toRaw(raw) : observed;
}
function markRaw(value) {
def(value, "__v_skip", true);
return value;
}
var toReactive = (value) => isObject(value) ? reactive(value) : value;
var toReadonly = (value) => isObject(value) ? readonly(value) : value;
function trackRefValue(ref2) {
if (shouldTrack && activeEffect) {
ref2 = toRaw(ref2);
if (true) {
trackEffects(ref2.dep || (ref2.dep = createDep()), {
target: ref2,
type: "get",
key: "value"
});
} else {
trackEffects(ref2.dep || (ref2.dep = createDep()));
}
}
}
function triggerRefValue(ref2, newVal) {
ref2 = toRaw(ref2);
const dep = ref2.dep;
if (dep) {
if (true) {
triggerEffects(dep, {
target: ref2,
type: "set",
key: "value",
newValue: newVal
});
} else {
triggerEffects(dep);
}
}
}
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);
}
var RefImpl = class {
constructor(value, __v_isShallow) {
this.__v_isShallow = __v_isShallow;
this.dep = void 0;
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) {
const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
newVal = useDirectValue ? newVal : toRaw(newVal);
if (hasChanged(newVal, this._rawValue)) {
this._rawValue = newVal;
this._value = useDirectValue ? newVal : toReactive(newVal);
triggerRefValue(this, newVal);
}
}
};
function triggerRef(ref2) {
triggerRefValue(ref2, true ? ref2.value : void 0);
}
function unref(ref2) {
return isRef(ref2) ? ref2.value : ref2;
}
var 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);
}
var CustomRefImpl = class {
constructor(factory) {
this.dep = void 0;
this.__v_isRef = true;
const { get: get2, set: set2 } = factory(() => trackRefValue(this), () => triggerRefValue(this));
this._get = get2;
this._set = set2;
}
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;
}
var ObjectRefImpl = class {
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 === void 0 ? this._defaultValue : val;
}
set value(newVal) {
this._object[this._key] = newVal;
}
get dep() {
return getDepFromReactive(toRaw(this._object), this._key);
}
};
function toRef(object, key, defaultValue) {
const val = object[key];
return isRef(val) ? val : new ObjectRefImpl(object, key, defaultValue);
}
var _a$1;
var ComputedRefImpl = class {
constructor(getter, _setter, isReadonly2, isSSR) {
this._setter = _setter;
this.dep = void 0;
this.__v_isRef = true;
this[_a$1] = false;
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"
/* ReactiveFlags.IS_READONLY */
] = isReadonly2;
}
get value() {
const self2 = toRaw(this);
trackRefValue(self2);
if (self2._dirty || !self2._cacheable) {
self2._dirty = false;
self2._value = self2.effect.run();
}
return self2._value;
}
set value(newValue) {
this._setter(newValue);
}
};
_a$1 = "__v_isReadonly";
function computed(getterOrOptions, debugOptions, isSSR = false) {
let getter;
let setter;
const onlyGetter = isFunction(getterOrOptions);
if (onlyGetter) {
getter = getterOrOptions;
setter = true ? () => {
console.warn("Write operation failed: computed value is readonly");
} : NOOP;
} else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
if (debugOptions && !isSSR) {
cRef.effect.onTrack = debugOptions.onTrack;
cRef.effect.onTrigger = debugOptions.onTrigger;
}
return cRef;
}
var _a;
var tick = Promise.resolve();
_a = "__v_isReadonly";
// node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
var stack = [];
function pushWarningContext(vnode) {
stack.push(vnode);
}
function popWarningContext() {
stack.pop();
}
function warn2(msg, ...args) {
if (false)
return;
pauseTracking();
const instance = stack.length ? stack[stack.length - 1].component : null;
const appWarnHandler = instance && instance.appContext.config.warnHandler;
const trace = getComponentTrace();
if (appWarnHandler) {
callWithErrorHandling(appWarnHandler, instance, 11, [
msg + args.join(""),
instance && instance.proxy,
trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"),
trace
]);
} else {
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
if (trace.length && // avoid spamming console during tests
true) {
warnArgs.push(`
`, ...formatTrace(trace));
}
console.warn(...warnArgs);
}
resetTracking();
}
function getComponentTrace() {
let currentVNode = stack[stack.length - 1];
if (!currentVNode) {
return [];
}
const normalizedStack = [];
while (currentVNode) {
const last = normalizedStack[0];
if (last && last.vnode === currentVNode) {
last.recurseCount++;
} else {
normalizedStack.push({
vnode: currentVNode,
recurseCount: 0
});
}
const parentInstance = currentVNode.component && currentVNode.component.parent;
currentVNode = parentInstance && parentInstance.vnode;
}
return normalizedStack;
}
function formatTrace(trace) {
const logs = [];
trace.forEach((entry, i) => {
logs.push(...i === 0 ? [] : [`
`], ...formatTraceEntry(entry));
});
return logs;
}
function formatTraceEntry({ vnode, recurseCount }) {
const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
const isRoot = vnode.component ? vnode.component.parent == null : false;
const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
const close = `>` + postfix;
return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
}
function formatProps(props) {
const res = [];
const keys = Object.keys(props);
keys.slice(0, 3).forEach((key) => {
res.push(...formatProp(key, props[key]));
});
if (keys.length > 3) {
res.push(` ...`);
}
return res;
}
function formatProp(key, value, raw) {
if (isString(value)) {
value = JSON.stringify(value);
return raw ? value : [`${key}=${value}`];
} else if (typeof value === "number" || typeof value === "boolean" || value == null) {
return raw ? value : [`${key}=${value}`];
} else if (isRef(value)) {
value = formatProp(key, toRaw(value.value), true);
return raw ? value : [`${key}=Ref<`, value, `>`];
} else if (isFunction(value)) {
return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
} else {
value = toRaw(value);
return raw ? value : [`${key}=`, value];
}
}
function assertNumber(val, type) {
if (false)
return;
if (val === void 0) {
return;
} else if (typeof val !== "number") {
warn2(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
} else if (isNaN(val)) {
warn2(`${type} is NaN - the duration expression might be incorrect.`);
}
}
var ErrorTypeStrings = {
[
"sp"
/* LifecycleHooks.SERVER_PREFETCH */
]: "serverPrefetch hook",
[
"bc"
/* LifecycleHooks.BEFORE_CREATE */
]: "beforeCreate hook",
[
"c"
/* LifecycleHooks.CREATED */
]: "created hook",
[
"bm"
/* LifecycleHooks.BEFORE_MOUNT */
]: "beforeMount hook",
[
"m"
/* LifecycleHooks.MOUNTED */
]: "mounted hook",
[
"bu"
/* LifecycleHooks.BEFORE_UPDATE */
]: "beforeUpdate hook",
[
"u"
/* LifecycleHooks.UPDATED */
]: "updated",
[
"bum"
/* LifecycleHooks.BEFORE_UNMOUNT */
]: "beforeUnmount hook",
[
"um"
/* LifecycleHooks.UNMOUNTED */
]: "unmounted hook",
[
"a"
/* LifecycleHooks.ACTIVATED */
]: "activated hook",
[
"da"
/* LifecycleHooks.DEACTIVATED */
]: "deactivated hook",
[
"ec"
/* LifecycleHooks.ERROR_CAPTURED */
]: "errorCaptured hook",
[
"rtc"
/* LifecycleHooks.RENDER_TRACKED */
]: "renderTracked hook",
[
"rtg"
/* LifecycleHooks.RENDER_TRIGGERED */
]: "renderTriggered hook",
[
0
/* ErrorCodes.SETUP_FUNCTION */
]: "setup function",
[
1
/* ErrorCodes.RENDER_FUNCTION */
]: "render function",
[
2
/* ErrorCodes.WATCH_GETTER */
]: "watcher getter",
[
3
/* ErrorCodes.WATCH_CALLBACK */
]: "watcher callback",
[
4
/* ErrorCodes.WATCH_CLEANUP */
]: "watcher cleanup function",
[
5
/* ErrorCodes.NATIVE_EVENT_HANDLER */
]: "native event handler",
[
6
/* ErrorCodes.COMPONENT_EVENT_HANDLER */
]: "component event handler",
[
7
/* ErrorCodes.VNODE_HOOK */
]: "vnode hook",
[
8
/* ErrorCodes.DIRECTIVE_HOOK */
]: "directive hook",
[
9
/* ErrorCodes.TRANSITION_HOOK */
]: "transition hook",
[
10
/* ErrorCodes.APP_ERROR_HANDLER */
]: "app errorHandler",
[
11
/* ErrorCodes.APP_WARN_HANDLER */
]: "app warnHandler",
[
12
/* ErrorCodes.FUNCTION_REF */
]: "ref function",
[
13
/* ErrorCodes.ASYNC_COMPONENT_LOADER */
]: "async component loader",
[
14
/* ErrorCodes.SCHEDULER */
]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
};
function callWithErrorHandling(fn, instance, type, args) {
let res;
try {
res = args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance, type);
}
return res;
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
if (isFunction(fn)) {
const res = callWithErrorHandling(fn, instance, type, args);
if (res && isPromise(res)) {
res.catch((err) => {
handleError(err, instance, type);
});
}
return res;
}
const values = [];
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
}
return values;
}
function handleError(err, instance, type, throwInDev = true) {
const contextVNode = instance ? instance.vnode : null;
if (instance) {
let cur = instance.parent;
const exposedInstance = instance.proxy;
const errorInfo = true ? ErrorTypeStrings[type] : type;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
return;
}
}
}
cur = cur.parent;
}
const appErrorHandler = instance.appContext.config.errorHandler;
if (appErrorHandler) {
callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]);
return;
}
}
logError(err, type, contextVNode, throwInDev);
}
function logError(err, type, contextVNode, throwInDev = true) {
if (true) {
const info = ErrorTypeStrings[type];
if (contextVNode) {
pushWarningContext(contextVNode);
}
warn2(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
if (contextVNode) {
popWarningContext();
}
if (throwInDev) {
throw err;
} else {
console.error(err);
}
} else {
console.error(err);
}
}
var isFlushing = false;
var isFlushPending = false;
var queue = [];
var flushIndex = 0;
var pendingPostFlushCbs = [];
var activePostFlushCbs = null;
var postFlushIndex = 0;
var resolvedPromise = Promise.resolve();
var currentFlushPromise = null;
var RECURSION_LIMIT = 100;
function nextTick(fn) {
const p2 = currentFlushPromise || resolvedPromise;
return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
}
function findInsertionIndex(id) {
let start = flushIndex + 1;
let end = queue.length;
while (start < end) {
const middle = start + end >>> 1;
const middleJobId = getId(queue[middle]);
middleJobId < id ? start = middle + 1 : end = middle;
}
return start;
}
function queueJob(job) {
if (!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) {
if (job.id == null) {
queue.push(job);
} else {
queue.splice(findInsertionIndex(job.id), 0, job);
}
queueFlush();
}
}
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true;
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function invalidateJob(job) {
const i = queue.indexOf(job);
if (i > flushIndex) {
queue.splice(i, 1);
}
}
function queuePostFlushCb(cb) {
if (!isArray(cb)) {
if (!activePostFlushCbs || !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) {
pendingPostFlushCbs.push(cb);
}
} else {
pendingPostFlushCbs.push(...cb);
}
queueFlush();
}
function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
if (true) {
seen = seen || /* @__PURE__ */ new Map();
}
for (; i < queue.length; i++) {
const cb = queue[i];
if (cb && cb.pre) {
if (checkRecursiveUpdates(seen, cb)) {
continue;
}
queue.splice(i, 1);
i--;
cb();
}
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)];
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
if (true) {
seen = seen || /* @__PURE__ */ new Map();
}
activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
continue;
}
activePostFlushCbs[postFlushIndex]();
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
var getId = (job) => job.id == null ? Infinity : job.id;
var comparator = (a, b) => {
const diff = getId(a) - getId(b);
if (diff === 0) {
if (a.pre && !b.pre)
return -1;
if (b.pre && !a.pre)
return 1;
}
return diff;
};
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
if (true) {
seen = seen || /* @__PURE__ */ new Map();
}
queue.sort(comparator);
const check = true ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job && job.active !== false) {
if (check(job)) {
continue;
}
callWithErrorHandling(
job,
null,
14
/* ErrorCodes.SCHEDULER */
);
}
}
} finally {
flushIndex = 0;
queue.length = 0;
flushPostFlushCbs(seen);
isFlushing = false;
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
flushJobs(seen);
}
}
}
function checkRecursiveUpdates(seen, fn) {
if (!seen.has(fn)) {
seen.set(fn, 1);
} else {
const count = seen.get(fn);
if (count > RECURSION_LIMIT) {
const instance = fn.ownerInstance;
const componentName = instance && getComponentName(instance.type);
warn2(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`);
return true;
} else {
seen.set(fn, count + 1);
}
}
}
var isHmrUpdating = false;
var hmrDirtyComponents = /* @__PURE__ */ new Set();
if (true) {
getGlobalThis().__VUE_HMR_RUNTIME__ = {
createRecord: tryWrap(createRecord),
rerender: tryWrap(rerender),
reload: tryWrap(reload)
};
}
var map = /* @__PURE__ */ new Map();
function registerHMR(instance) {
const id = instance.type.__hmrId;
let record = map.get(id);
if (!record) {
createRecord(id, instance.type);
record = map.get(id);
}
record.instances.add(instance);
}
function unregisterHMR(instance) {
map.get(instance.type.__hmrId).instances.delete(instance);
}
function createRecord(id, initialDef) {
if (map.has(id)) {
return false;
}
map.set(id, {
initialDef: normalizeClassComponent(initialDef),
instances: /* @__PURE__ */ new Set()
});
return true;
}
function normalizeClassComponent(component) {
return isClassComponent(component) ? component.__vccOpts : component;
}
function rerender(id, newRender) {
const record = map.get(id);
if (!record) {
return;
}
record.initialDef.render = newRender;
[...record.instances].forEach((instance) => {
if (newRender) {
instance.render = newRender;
normalizeClassComponent(instance.type).render = newRender;
}
instance.renderCache = [];
isHmrUpdating = true;
instance.update();
isHmrUpdating = false;
});
}
function reload(id, newComp) {
const record = map.get(id);
if (!record)
return;
newComp = normalizeClassComponent(newComp);
updateComponentDef(record.initialDef, newComp);
const instances = [...record.instances];
for (const instance of instances) {
const oldComp = normalizeClassComponent(instance.type);
if (!hmrDirtyComponents.has(oldComp)) {
if (oldComp !== record.initialDef) {
updateComponentDef(oldComp, newComp);
}
hmrDirtyComponents.add(oldComp);
}
instance.appContext.optionsCache.delete(instance.type);
if (instance.ceReload) {
hmrDirtyComponents.add(oldComp);
instance.ceReload(newComp.styles);
hmrDirtyComponents.delete(oldComp);
} else if (instance.parent) {
queueJob(instance.parent.update);
} else if (instance.appContext.reload) {
instance.appContext.reload();
} else if (typeof window !== "undefined") {
window.location.reload();
} else {
console.warn("[HMR] Root or manually mounted instance modified. Full reload required.");
}
}
queuePostFlushCb(() => {
for (const instance of instances) {
hmrDirtyComponents.delete(normalizeClassComponent(instance.type));
}
});
}
function updateComponentDef(oldComp, newComp) {
extend(oldComp, newComp);
for (const key in oldComp) {
if (key !== "__file" && !(key in newComp)) {
delete oldComp[key];
}
}
}
function tryWrap(fn) {
return (id, arg) => {
try {
return fn(id, arg);
} catch (e) {
console.error(e);
console.warn(`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`);
}
};
}
var devtools;
var buffer = [];
var devtoolsNotInstalled = false;
function emit$1(event, ...args) {
if (devtools) {
devtools.emit(event, ...args);
} else if (!devtoolsNotInstalled) {
buffer.push({ event, args });
}
}
function setDevtoolsHook(hook, target) {
var _a2, _b;
devtools = hook;
if (devtools) {
devtools.enabled = true;
buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
buffer = [];
} else if (// handle late devtools injection - only do this if we are in an actual
// browser environment to avoid the timer handle stalling test runner exit
// (#4815)
typeof window !== "undefined" && // some envs mock window but not fully
window.HTMLElement && // also exclude jsdom
!((_b = (_a2 = window.navigator) === null || _a2 === void 0 ? void 0 : _a2.userAgent) === null || _b === void 0 ? void 0 : _b.includes("jsdom"))) {
const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
replay.push((newHook) => {
setDevtoolsHook(newHook, target);
});
setTimeout(() => {
if (!devtools) {
target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
devtoolsNotInstalled = true;
buffer = [];
}
}, 3e3);
} else {
devtoolsNotInstalled = true;
buffer = [];
}
}
function devtoolsInitApp(app, version2) {
emit$1("app:init", app, version2, {
Fragment,
Text,
Comment,
Static
});
}
function devtoolsUnmountApp(app) {
emit$1("app:unmount", app);
}
var devtoolsComponentAdded = createDevtoolsComponentHook(
"component:added"
/* DevtoolsHooks.COMPONENT_ADDED */
);
var devtoolsComponentUpdated = createDevtoolsComponentHook(
"component:updated"
/* DevtoolsHooks.COMPONENT_UPDATED */
);
var _devtoolsComponentRemoved = createDevtoolsComponentHook(
"component:removed"
/* DevtoolsHooks.COMPONENT_REMOVED */
);
var devtoolsComponentRemoved = (component) => {
if (devtools && typeof devtools.cleanupBuffer === "function" && // remove the component if it wasn't buffered
!devtools.cleanupBuffer(component)) {
_devtoolsComponentRemoved(component);
}
};
function createDevtoolsComponentHook(hook) {
return (component) => {
emit$1(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : void 0, component);
};
}
var devtoolsPerfStart = createDevtoolsPerformanceHook(
"perf:start"
/* DevtoolsHooks.PERFORMANCE_START */
);
var devtoolsPerfEnd = createDevtoolsPerformanceHook(
"perf:end"
/* DevtoolsHooks.PERFORMANCE_END */
);
function createDevtoolsPerformanceHook(hook) {
return (component, type, time) => {
emit$1(hook, component.appContext.app, component.uid, component, type, time);
};
}
function devtoolsComponentEmit(component, event, params) {
emit$1("component:emit", component.appContext.app, component, event, params);
}
function emit(instance, event, ...rawArgs) {
if (instance.isUnmounted)
return;
const props = instance.vnode.props || EMPTY_OBJ;
if (true) {
const { emitsOptions, propsOptions: [propsOptions] } = instance;
if (emitsOptions) {
if (!(event in emitsOptions) && true) {
if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
warn2(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`);
}
} else {
const validator = emitsOptions[event];
if (isFunction(validator)) {
const isValid = validator(...rawArgs);
if (!isValid) {
warn2(`Invalid event arguments: event validation failed for event "${event}".`);
}
}
}
}
}
let args = rawArgs;
const isModelListener2 = event.startsWith("update:");
const modelArg = isModelListener2 && event.slice(7);
if (modelArg && modelArg in props) {
const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
if (trim) {
args = rawArgs.map((a) => isString(a) ? a.trim() : a);
}
if (number) {
args = rawArgs.map(looseToNumber);
}
}
if (true) {
devtoolsComponentEmit(instance, event, args);
}
if (true) {
const lowerCaseEvent = event.toLowerCase();
if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
warn2(`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(event)}" instead of "${event}".`);
}
}
let handlerName;
let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
props[handlerName = toHandlerKey(camelize(event))];
if (!handler && isModelListener2) {
handler = props[handlerName = toHandlerKey(hyphenate(event))];
}
if (handler) {
callWithAsyncErrorHandling(handler, instance, 6, args);
}
const onceHandler = props[handlerName + `Once`];
if (onceHandler) {
if (!instance.emitted) {
instance.emitted = {};
} else if (instance.emitted[handlerName]) {
return;
}
instance.emitted[handlerName] = true;
callWithAsyncErrorHandling(onceHandler, instance, 6, args);
}
}
function normalizeEmitsOptions(comp, appContext, asMixin = false) {
const cache = appContext.emitsCache;
const cached = cache.get(comp);
if (cached !== void 0) {
return cached;
}
const raw = comp.emits;
let normalized = {};
let hasExtends = false;
if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
const extendEmits = (raw2) => {
const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
if (normalizedFromExtend) {
hasExtends = true;
extend(normalized, normalizedFromExtend);
}
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendEmits);
}
if (comp.extends) {
extendEmits(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendEmits);
}
}
if (!raw && !hasExtends) {
if (isObject(comp)) {
cache.set(comp, null);
}
return null;
}
if (isArray(raw)) {
raw.forEach((key) => normalized[key] = null);
} else {
extend(normalized, raw);
}
if (isObject(comp)) {
cache.set(comp, normalized);
}
return normalized;
}
function isEmitListener(options, key) {
if (!options || !isOn(key)) {
return false;
}
key = key.slice(2).replace(/Once$/, "");
return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
}
var currentRenderingInstance = null;
var currentScopeId = null;
function setCurrentRenderingInstance(instance) {
const prev = currentRenderingInstance;
currentRenderingInstance = instance;
currentScopeId = instance && instance.type.__scopeId || null;
return prev;
}
function pushScopeId(id) {
currentScopeId = id;
}
function popScopeId() {
currentScopeId = null;
}
var withScopeId = (_id) => withCtx;
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
if (!ctx)
return fn;
if (fn._n) {
return fn;
}
const renderFnWithContext = (...args) => {
if (renderFnWithContext._d) {
setBlockTracking(-1);
}
const prevInstance = setCurrentRenderingInstance(ctx);
let res;
try {
res = fn(...args);
} finally {
setCurrentRenderingInstance(prevInstance);
if (renderFnWithContext._d) {
setBlockTracking(1);
}
}
if (true) {
devtoolsComponentUpdated(ctx);
}
return res;
};
renderFnWithContext._n = true;
renderFnWithContext._c = true;
renderFnWithContext._d = true;
return renderFnWithContext;
}
var accessedAttrs = false;
function markAttrsAccessed() {
accessedAttrs = true;
}
function renderComponentRoot(instance) {
const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit: emit2, render: render2, renderCache, data, setupState, ctx, inheritAttrs } = instance;
let result;
let fallthroughAttrs;
const prev = setCurrentRenderingInstance(instance);
if (true) {
accessedAttrs = false;
}
try {
if (vnode.shapeFlag & 4) {
const proxyToUse = withProxy || proxy;
result = normalizeVNode(render2.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));
fallthroughAttrs = attrs;
} else {
const render3 = Component;
if (attrs === props) {
markAttrsAccessed();
}
result = normalizeVNode(render3.length > 1 ? render3(props, true ? {
get attrs() {
markAttrsAccessed();
return attrs;
},
slots,
emit: emit2
} : { attrs, slots, emit: emit2 }) : render3(
props,
null
/* we know it doesn't need it */
));
fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
}
} catch (err) {
blockStack.length = 0;
handleError(
err,
instance,
1
/* ErrorCodes.RENDER_FUNCTION */
);
result = createVNode(Comment);
}
let root = result;
let setRoot = void 0;
if (result.patchFlag > 0 && result.patchFlag & 2048) {
[root, setRoot] = getChildRoot(result);
}
if (fallthroughAttrs && inheritAttrs !== false) {
const keys = Object.keys(fallthroughAttrs);
const { shapeFlag } = root;
if (keys.length) {
if (shapeFlag & (1 | 6)) {
if (propsOptions && keys.some(isModelListener)) {
fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
}
root = cloneVNode(root, fallthroughAttrs);
} else if (!accessedAttrs && root.type !== Comment) {
const allAttrs = Object.keys(attrs);
const eventAttrs = [];
const extraAttrs = [];
for (let i = 0, l = allAttrs.length; i < l; i++) {
const key = allAttrs[i];
if (isOn(key)) {
if (!isModelListener(key)) {
eventAttrs.push(key[2].toLowerCase() + key.slice(3));
}
} else {
extraAttrs.push(key);
}
}
if (extraAttrs.length) {
warn2(`Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`);
}
if (eventAttrs.length) {
warn2(`Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`);
}
}
}
}
if (vnode.dirs) {
if (!isElementRoot(root)) {
warn2(`Runtime directive used on component with non-element root node. The directives will not function as intended.`);
}
root = cloneVNode(root);
root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
}
if (vnode.transition) {
if (!isElementRoot(root)) {
warn2(`Component inside <Transition> renders non-element root node that cannot be animated.`);
}
root.transition = vnode.transition;
}
if (setRoot) {
setRoot(root);
} else {
result = root;
}
setCurrentRenderingInstance(prev);
return result;
}
var getChildRoot = (vnode) => {
const rawChildren = vnode.children;
const dynamicChildren = vnode.dynamicChildren;
const childRoot = filterSingleRoot(rawChildren);
if (!childRoot) {
return [vnode, void 0];
}
const index = rawChildren.indexOf(childRoot);
const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
const setRoot = (updatedRoot) => {
rawChildren[index] = updatedRoot;
if (dynamicChildren) {
if (dynamicIndex > -1) {
dynamicChildren[dynamicIndex] = updatedRoot;
} else if (updatedRoot.patchFlag > 0) {
vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
}
}
};
return [normalizeVNode(childRoot), setRoot];
};
function filterSingleRoot(children) {
let singleRoot;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isVNode(child)) {
if (child.type !== Comment || child.children === "v-if") {
if (singleRoot) {
return;
} else {
singleRoot = child;
}
}
} else {
return;
}
}
return singleRoot;
}
var getFunctionalFallthrough = (attrs) => {
let res;
for (const key in attrs) {
if (key === "class" || key === "style" || isOn(key)) {
(res || (res = {}))[key] = attrs[key];
}
}
return res;
};
var filterModelListeners = (attrs, props) => {
const res = {};
for (const key in attrs) {
if (!isModelListener(key) || !(key.slice(9) in props)) {
res[key] = attrs[key];
}
}
return res;
};
var isElementRoot = (vnode) => {
return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const { props: prevProps, children: prevChildren, component } = prevVNode;
const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
const emits = component.emitsOptions;
if ((prevChildren || nextChildren) && isHmrUpdating) {
return true;
}
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (optimized && patchFlag >= 0) {
if (patchFlag & 1024) {
return true;
}
if (patchFlag & 16) {
if (!prevProps) {
return !!nextProps;
}
return hasPropsChanged(prevProps, nextProps, emits);
} else if (patchFlag & 8) {
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
return true;
}
}
}
} else {
if (prevChildren || nextChildren) {
if (!nextChildren || !nextChildren.$stable) {
return true;
}
}
if (prevProps === nextProps) {
return false;
}
if (!prevProps) {
return !!nextProps;
}
if (!nextProps) {
return true;
}
return hasPropsChanged(prevProps, nextProps, emits);
}
return false;
}
function hasPropsChanged(prevProps, nextProps, emitsOptions) {
const nextKeys = Object.keys(nextProps);
if (nextKeys.length !== Object.keys(prevProps).length) {
return true;
}
for (let i = 0; i < nextKeys.length; i++) {
const key = nextKeys[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
return true;
}
}
return false;
}
function updateHOCHostEl({ vnode, parent }, el) {
while (parent && parent.subTree === vnode) {
(vnode = parent.vnode).el = el;
parent = parent.parent;
}
}
var isSuspense = (type) => type.__isSuspense;
var SuspenseImpl = {
name: "Suspense",
// In order to make Suspense tree-shakable, we need to avoid importing it
// directly in the renderer. The renderer checks for the __isSuspense flag
// on a vnode's type and calls the `process` method, passing in renderer
// internals.
__isSuspense: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
if (n1 == null) {
mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals);
} else {
patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals);
}
},
hydrate: hydrateSuspense,
create: createSuspenseBoundary,
normalize: normalizeSuspenseChildren
};
var Suspense = SuspenseImpl;
function triggerEvent(vnode, name) {
const eventListener = vnode.props && vnode.props[name];
if (isFunction(eventListener)) {
eventListener();
}
}
function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
const { p: patch, o: { createElement } } = rendererInternals;
const hiddenContainer = createElement("div");
const suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals);
patch(null, suspense.pendingBranch = vnode.ssContent, hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds);
if (suspense.deps > 0) {
triggerEvent(vnode, "onPending");
triggerEvent(vnode, "onFallback");
patch(
null,
vnode.ssFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
isSVG,
slotScopeIds
);
setActiveBranch(suspense, vnode.ssFallback);
} else {
suspense.resolve();
}
}
function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
const suspense = n2.suspense = n1.suspense;
suspense.vnode = n2;
n2.el = n1.el;
const newBranch = n2.ssContent;
const newFallback = n2.ssFallback;
const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
if (pendingBranch) {
suspense.pendingBranch = newBranch;
if (isSameVNodeType(newBranch, pendingBranch)) {
patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
if (suspense.deps <= 0) {
suspense.resolve();
} else if (isInFallback) {
patch(
activeBranch,
newFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
isSVG,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newFallback);
}
} else {
suspense.pendingId++;
if (isHydrating) {
suspense.isHydrating = false;
suspense.activeBranch = pendingBranch;
} else {
unmount(pendingBranch, parentComponent, suspense);
}
suspense.deps = 0;
suspense.effects.length = 0;
suspense.hiddenContainer = createElement("div");
if (isInFallback) {
patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
if (suspense.deps <= 0) {
suspense.resolve();
} else {
patch(
activeBranch,
newFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
isSVG,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newFallback);
}
} else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized);
suspense.resolve(true);
} else {
patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
if (suspense.deps <= 0) {
suspense.resolve();
}
}
}
} else {
if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized);
setActiveBranch(suspense, newBranch);
} else {
triggerEvent(n2, "onPending");
suspense.pendingBranch = newBranch;
suspense.pendingId++;
patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized);
if (suspense.deps <= 0) {
suspense.resolve();
} else {
const { timeout, pendingId } = suspense;
if (timeout > 0) {
setTimeout(() => {
if (suspense.pendingId === pendingId) {
suspense.fallback(newFallback);
}
}, timeout);
} else if (timeout === 0) {
suspense.fallback(newFallback);
}
}
}
}
}
var hasWarned = false;
function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
if (!hasWarned) {
hasWarned = true;
console[console.info ? "info" : "log"](`<Suspense> is an experimental feature and its API will likely change.`);
}
const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove: remove2 } } = rendererInternals;
const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
if (true) {
assertNumber(timeout, `Suspense timeout`);
}
const suspense = {
vnode,
parent,
parentComponent,
isSVG,
container,
hiddenContainer,
anchor,
deps: 0,
pendingId: 0,
timeout: typeof timeout === "number" ? timeout : -1,
activeBranch: null,
pendingBranch: null,
isInFallback: true,
isHydrating,
isUnmounted: false,
effects: [],
resolve(resume = false) {
if (true) {
if (!resume && !suspense.pendingBranch) {
throw new Error(`suspense.resolve() is called without a pending branch.`);
}
if (suspense.isUnmounted) {
throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`);
}
}
const { vnode: vnode2, activeBranch, pendingBranch, pendingId, effects, parentComponent: parentComponent2, container: container2 } = suspense;
if (suspense.isHydrating) {
suspense.isHydrating = false;
} else if (!resume) {
const delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
if (delayEnter) {
activeBranch.transition.afterLeave = () => {
if (pendingId === suspense.pendingId) {
move(
pendingBranch,
container2,
anchor2,
0
/* MoveType.ENTER */
);
}
};
}
let { anchor: anchor2 } = suspense;
if (activeBranch) {
anchor2 = next(activeBranch);
unmount(activeBranch, parentComponent2, suspense, true);
}
if (!delayEnter) {
move(
pendingBranch,
container2,
anchor2,
0
/* MoveType.ENTER */
);
}
}
setActiveBranch(suspense, pendingBranch);
suspense.pendingBranch = null;
suspense.isInFallback = false;
let parent2 = suspense.parent;
let hasUnresolvedAncestor = false;
while (parent2) {
if (parent2.pendingBranch) {
parent2.effects.push(...effects);
hasUnresolvedAncestor = true;
break;
}
parent2 = parent2.parent;
}
if (!hasUnresolvedAncestor) {
queuePostFlushCb(effects);
}
suspense.effects = [];
triggerEvent(vnode2, "onResolve");
},
fallback(fallbackVNode) {
if (!suspense.pendingBranch) {
return;
}
const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG2 } = suspense;
triggerEvent(vnode2, "onFallback");
const anchor2 = next(activeBranch);
const mountFallback = () => {
if (!suspense.isInFallback) {
return;
}
patch(
null,
fallbackVNode,
container2,
anchor2,
parentComponent2,
null,
// fallback tree will not have suspense context
isSVG2,
slotScopeIds,
optimized
);
setActiveBranch(suspense, fallbackVNode);
};
const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
if (delayEnter) {
activeBranch.transition.afterLeave = mountFallback;
}
suspense.isInFallback = true;
unmount(
activeBranch,
parentComponent2,
null,
// no suspense so unmount hooks fire now
true
// shouldRemove
);
if (!delayEnter) {
mountFallback();
}
},
move(container2, anchor2, type) {
suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
suspense.container = container2;
},
next() {
return suspense.activeBranch && next(suspense.activeBranch);
},
registerDep(instance, setupRenderEffect) {
const isInPendingSuspense = !!suspense.pendingBranch;
if (isInPendingSuspense) {
suspense.deps++;
}
const hydratedEl = instance.vnode.el;
instance.asyncDep.catch((err) => {
handleError(
err,
instance,
0
/* ErrorCodes.SETUP_FUNCTION */
);
}).then((asyncSetupResult) => {
if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
return;
}
instance.asyncResolved = true;
const { vnode: vnode2 } = instance;
if (true) {
pushWarningContext(vnode2);
}
handleSetupResult(instance, asyncSetupResult, false);
if (hydratedEl) {
vnode2.el = hydratedEl;
}
const placeholder = !hydratedEl && instance.subTree.el;
setupRenderEffect(
instance,
vnode2,
// component may have been moved before resolve.
// if this is not a hydration, instance.subTree will be the comment
// placeholder.
parentNode(hydratedEl || instance.subTree.el),
// anchor will not be used if this is hydration, so only need to
// consider the comment placeholder case.
hydratedEl ? null : next(instance.subTree),
suspense,
isSVG,
optimized
);
if (placeholder) {
remove2(placeholder);
}
updateHOCHostEl(instance, vnode2.el);
if (true) {
popWarningContext();
}
if (isInPendingSuspense && --suspense.deps === 0) {
suspense.resolve();
}
});
},
unmount(parentSuspense, doRemove) {
suspense.isUnmounted = true;
if (suspense.activeBranch) {
unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove);
}
if (suspense.pendingBranch) {
unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove);
}
}
};
return suspense;
}
function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
const suspense = vnode.suspense = createSuspenseBoundary(
vnode,
parentSuspense,
parentComponent,
node.parentNode,
document.createElement("div"),
null,
isSVG,
slotScopeIds,
optimized,
rendererInternals,
true
/* hydrating */
);
const result = hydrateNode(node, suspense.pendingBranch = vnode.ssContent, parentComponent, suspense, slotScopeIds, optimized);
if (suspense.deps === 0) {
suspense.resolve();
}
return result;
}
function normalizeSuspenseChildren(vnode) {
const { shapeFlag, children } = vnode;
const isSlotChildren = shapeFlag & 32;
vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children);
vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
}
function normalizeSuspenseSlot(s) {
let block;
if (isFunction(s)) {
const trackBlock = isBlockTreeEnabled && s._c;
if (trackBlock) {
s._d = false;
openBlock();
}
s = s();
if (trackBlock) {
s._d = true;
block = currentBlock;
closeBlock();
}
}
if (isArray(s)) {
const singleChild = filterSingleRoot(s);
if (!singleChild) {
warn2(`<Suspense> slots expect a single root node.`);
}
s = singleChild;
}
s = normalizeVNode(s);
if (block && !s.dynamicChildren) {
s.dynamicChildren = block.filter((c) => c !== s);
}
return s;
}
function queueEffectWithSuspense(fn, suspense) {
if (suspense && suspense.pendingBranch) {
if (isArray(fn)) {
suspense.effects.push(...fn);
} else {
suspense.effects.push(fn);
}
} else {
queuePostFlushCb(fn);
}
}
function setActiveBranch(suspense, branch) {
suspense.activeBranch = branch;
const { vnode, parentComponent } = suspense;
const el = vnode.el = branch.el;
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
}
function provide(key, value) {
if (!currentInstance) {
if (true) {
warn2(`provide() can only be used inside setup().`);
}
} else {
let provides = currentInstance.provides;
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
provides[key] = value;
}
}
function inject(key, defaultValue, treatDefaultAsFactory = false) {
const instance = currentInstance || currentRenderingInstance;
if (instance) {
const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides;
if (provides && key in provides) {
return provides[key];
} else if (arguments.length > 1) {
return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue;
} else if (true) {
warn2(`injection "${String(key)}" not found.`);
}
} else if (true) {
warn2(`inject() can only be used inside setup() or functional components.`);
}
}
function watchEffect(effect2, options) {
return doWatch(effect2, null, options);
}
function watchPostEffect(effect2, options) {
return doWatch(effect2, null, true ? Object.assign(Object.assign({}, options), { flush: "post" }) : { flush: "post" });
}
function watchSyncEffect(effect2, options) {
return doWatch(effect2, null, true ? Object.assign(Object.assign({}, options), { flush: "sync" }) : { flush: "sync" });
}
var INITIAL_WATCHER_VALUE = {};
function watch(source, cb, options) {
if (!isFunction(cb)) {
warn2(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`);
}
return doWatch(source, cb, options);
}
function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
if (!cb) {
if (immediate !== void 0) {
warn2(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
}
if (deep !== void 0) {
warn2(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
}
}
const warnInvalidSource = (s) => {
warn2(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`);
};
const instance = getCurrentScope() === (currentInstance === null || currentInstance === void 0 ? void 0 : currentInstance.scope) ? currentInstance : null;
let getter;
let forceTrigger = false;
let isMultiSource = false;
if (isRef(source)) {
getter = () => source.value;
forceTrigger = isShallow(source);
} else if (isReactive(source)) {
getter = () => source;
deep = true;
} else if (isArray(source)) {
isMultiSource = true;
forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
getter = () => source.map((s) => {
if (isRef(s)) {
return s.value;
} else if (isReactive(s)) {
return traverse(s);
} else if (isFunction(s)) {
return callWithErrorHandling(
s,
instance,
2
/* ErrorCodes.WATCH_GETTER */
);
} else {
warnInvalidSource(s);
}
});
} else if (isFunction(source)) {
if (cb) {
getter = () => callWithErrorHandling(
source,
instance,
2
/* ErrorCodes.WATCH_GETTER */
);
} else {
getter = () => {
if (instance && instance.isUnmounted) {
return;
}
if (cleanup) {
cleanup();
}
return callWithAsyncErrorHandling(source, instance, 3, [onCleanup]);
};
}
} else {
getter = NOOP;
warnInvalidSource(source);
}
if (cb && deep) {
const baseGetter = getter;
getter = () => traverse(baseGetter());
}
let cleanup;
let onCleanup = (fn) => {
cleanup = effect2.onStop = () => {
callWithErrorHandling(
fn,
instance,
4
/* ErrorCodes.WATCH_CLEANUP */
);
};
};
let ssrCleanup;
if (isInSSRComponentSetup) {
onCleanup = NOOP;
if (!cb) {
getter();
} else if (immediate) {
callWithAsyncErrorHandling(cb, instance, 3, [
getter(),
isMultiSource ? [] : void 0,
onCleanup
]);
}
if (flush === "sync") {
const ctx = useSSRContext();
ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
} else {
return NOOP;
}
}
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
const job = () => {
if (!effect2.active) {
return;
}
if (cb) {
const newValue = effect2.run();
if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
if (cleanup) {
cleanup();
}
callWithAsyncErrorHandling(cb, instance, 3, [
newValue,
// pass undefined as the old value when it's changed for the first time
oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
onCleanup
]);
oldValue = newValue;
}
} else {
effect2.run();
}
};
job.allowRecurse = !!cb;
let scheduler;
if (flush === "sync") {
scheduler = job;
} else if (flush === "post") {
scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
} else {
job.pre = true;
if (instance)
job.id = instance.uid;
scheduler = () => queueJob(job);
}
const effect2 = new ReactiveEffect(getter, scheduler);
if (true) {
effect2.onTrack = onTrack;
effect2.onTrigger = onTrigger;
}
if (cb) {
if (immediate) {
job();
} else {
oldValue = effect2.run();
}
} else if (flush === "post") {
queuePostRenderEffect(effect2.run.bind(effect2), instance && instance.suspense);
} else {
effect2.run();
}
const unwatch = () => {
effect2.stop();
if (instance && instance.scope) {
remove(instance.scope.effects, effect2);
}
};
if (ssrCleanup)
ssrCleanup.push(unwatch);
return unwatch;
}
function instanceWatch(source, value, options) {
const publicThis = this.proxy;
const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
let cb;
if (isFunction(value)) {
cb = value;
} else {
cb = value.handler;
options = value;
}
const cur = currentInstance;
setCurrentInstance(this);
const res = doWatch(getter, cb.bind(publicThis), options);
if (cur) {
setCurrentInstance(cur);
} else {
unsetCurrentInstance();
}
return res;
}
function createPathGetter(ctx, path) {
const segments = path.split(".");
return () => {
let cur = ctx;
for (let i = 0; i < segments.length && cur; i++) {
cur = cur[segments[i]];
}
return cur;
};
}
function traverse(value, seen) {
if (!isObject(value) || value[
"__v_skip"
/* ReactiveFlags.SKIP */
]) {
return value;
}
seen = seen || /* @__PURE__ */ new Set();
if (seen.has(value)) {
return value;
}
seen.add(value);
if (isRef(value)) {
traverse(value.value, seen);
} else if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], seen);
}
} else if (isSet(value) || isMap(value)) {
value.forEach((v) => {
traverse(v, seen);
});
} else if (isPlainObject(value)) {
for (const key in value) {
traverse(value[key], seen);
}
}
return value;
}
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: /* @__PURE__ */ new Map()
};
onMounted(() => {
state.isMounted = true;
});
onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
var TransitionHookValidator = [Function, Array];
var BaseTransitionImpl = {
name: `BaseTransition`,
props: {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: TransitionHookValidator,
onEnter: TransitionHookValidator,
onAfterEnter: TransitionHookValidator,
onEnterCancelled: TransitionHookValidator,
// leave
onBeforeLeave: TransitionHookValidator,
onLeave: TransitionHookValidator,
onAfterLeave: TransitionHookValidator,
onLeaveCancelled: TransitionHookValidator,
// appear
onBeforeAppear: TransitionHookValidator,
onAppear: TransitionHookValidator,
onAfterAppear: TransitionHookValidator,
onAppearCancelled: TransitionHookValidator
},
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
let prevTransitionKey;
return () => {
const children = slots.default && getTransitionRawChildren(slots.default(), true);
if (!children || !children.length) {
return;
}
let child = children[0];
if (children.length > 1) {
let hasFound = false;
for (const c of children) {
if (c.type !== Comment) {
if (hasFound) {
warn2("<transition> can only be used on a single element or component. Use <transition-group> for lists.");
break;
}
child = c;
hasFound = true;
if (false)
break;
}
}
}
const rawProps = toRaw(props);
const { mode } = rawProps;
if (mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
warn2(`invalid <transition> mode: ${mode}`);
}
if (state.isLeaving) {
return emptyPlaceholder(child);
}
const innerChild = getKeepAliveChild(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
const enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance);
setTransitionHooks(innerChild, enterHooks);
const oldChild = instance.subTree;
const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
let transitionKeyChanged = false;
const { getTransitionKey } = innerChild.type;
if (getTransitionKey) {
const key = getTransitionKey();
if (prevTransitionKey === void 0) {
prevTransitionKey = key;
} else if (key !== prevTransitionKey) {
prevTransitionKey = key;
transitionKeyChanged = true;
}
}
if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);
setTransitionHooks(oldInnerChild, leavingHooks);
if (mode === "out-in") {
state.isLeaving = true;
leavingHooks.afterLeave = () => {
state.isLeaving = false;
if (instance.update.active !== false) {
instance.update();
}
};
return emptyPlaceholder(child);
} else if (mode === "in-out" && innerChild.type !== Comment) {
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
el._leaveCb = () => {
earlyRemove();
el._leaveCb = void 0;
delete enterHooks.delayedLeave;
};
enterHooks.delayedLeave = delayedLeave;
};
}
}
return child;
};
}
};
var BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = /* @__PURE__ */ Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
function resolveTransitionHooks(vnode, props, state, instance) {
const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook3 = (hook, args) => {
hook && callWithAsyncErrorHandling(hook, instance, 9, args);
};
const callAsyncHook = (hook, args) => {
const done = args[1];
callHook3(hook, args);
if (isArray(hook)) {
if (hook.every((hook2) => hook2.length <= 1))
done();
} else if (hook.length <= 1) {
done();
}
};
const hooks = {
mode,
persisted,
beforeEnter(el) {
let hook = onBeforeEnter;
if (!state.isMounted) {
if (appear) {
hook = onBeforeAppear || onBeforeEnter;
} else {
return;
}
}
if (el._leaveCb) {
el._leaveCb(
true
/* cancelled */
);
}
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el._leaveCb) {
leavingVNode.el._leaveCb();
}
callHook3(hook, [el]);
},
enter(el) {
let hook = onEnter;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
if (!state.isMounted) {
if (appear) {
hook = onAppear || onEnter;
afterHook = onAfterAppear || onAfterEnter;
cancelHook = onAppearCancelled || onEnterCancelled;
} else {
return;
}
}
let called = false;
const done = el._enterCb = (cancelled) => {
if (called)
return;
called = true;
if (cancelled) {
callHook3(cancelHook, [el]);
} else {
callHook3(afterHook, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el._enterCb = void 0;
};
if (hook) {
callAsyncHook(hook, [el, done]);
} else {
done();
}
},
leave(el, remove2) {
const key2 = String(vnode.key);
if (el._enterCb) {
el._enterCb(
true
/* cancelled */
);
}
if (state.isUnmounting) {
return remove2();
}
callHook3(onBeforeLeave, [el]);
let called = false;
const done = el._leaveCb = (cancelled) => {
if (called)
return;
called = true;
remove2();
if (cancelled) {
callHook3(onLeaveCancelled, [el]);
} else {
callHook3(onAfterLeave, [el]);
}
el._leaveCb = void 0;
if (leavingVNodesCache[key2] === vnode) {
delete leavingVNodesCache[key2];
}
};
leavingVNodesCache[key2] = vnode;
if (onLeave) {
callAsyncHook(onLeave, [el, done]);
} else {
done();
}
},
clone(vnode2) {
return resolveTransitionHooks(vnode2, props, state, instance);
}
};
return hooks;
}
function emptyPlaceholder(vnode) {
if (isKeepAlive(vnode)) {
vnode = cloneVNode(vnode);
vnode.children = null;
return vnode;
}
}
function getKeepAliveChild(vnode) {
return isKeepAlive(vnode) ? vnode.children ? vnode.children[0] : void 0 : vnode;
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 && vnode.component) {
setTransitionHooks(vnode.component.subTree, hooks);
} else if (vnode.shapeFlag & 128) {
vnode.ssContent.transition = hooks.clone(vnode.ssContent);
vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
} else {
vnode.transition = hooks;
}
}
function getTransitionRawChildren(children, keepComment = false, parentKey) {
let ret = [];
let keyedFragmentCount = 0;
for (let i = 0; i < children.length; i++) {
let child = children[i];
const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
if (child.type === Fragment) {
if (child.patchFlag & 128)
keyedFragmentCount++;
ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));
} else if (keepComment || child.type !== Comment) {
ret.push(key != null ? cloneVNode(child, { key }) : child);
}
}
if (keyedFragmentCount > 1) {
for (let i = 0; i < ret.length; i++) {
ret[i].patchFlag = -2;
}
}
return ret;
}
function defineComponent(options) {
return isFunction(options) ? { setup: options, name: options.name } : options;
}
var isAsyncWrapper = (i) => !!i.type.__asyncLoader;
function defineAsyncComponent(source) {
if (isFunction(source)) {
source = { loader: source };
}
const {
loader,
loadingComponent,
errorComponent,
delay = 200,
timeout,
// undefined = never times out
suspensible = true,
onError: userOnError
} = source;
let pendingRequest = null;
let resolvedComp;
let retries = 0;
const retry = () => {
retries++;
pendingRequest = null;
return load();
};
const load = () => {
let thisRequest;
return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
err = err instanceof Error ? err : new Error(String(err));
if (userOnError) {
return new Promise((resolve2, reject) => {
const userRetry = () => resolve2(retry());
const userFail = () => reject(err);
userOnError(err, userRetry, userFail, retries + 1);
});
} else {
throw err;
}
}).then((comp) => {
if (thisRequest !== pendingRequest && pendingRequest) {
return pendingRequest;
}
if (!comp) {
warn2(`Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`);
}
if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
comp = comp.default;
}
if (comp && !isObject(comp) && !isFunction(comp)) {
throw new Error(`Invalid async component load result: ${comp}`);
}
resolvedComp = comp;
return comp;
}));
};
return defineComponent({
name: "AsyncComponentWrapper",
__asyncLoader: load,
get __asyncResolved() {
return resolvedComp;
},
setup() {
const instance = currentInstance;
if (resolvedComp) {
return () => createInnerComp(resolvedComp, instance);
}
const onError = (err) => {
pendingRequest = null;
handleError(
err,
instance,
13,
!errorComponent
/* do not throw in dev if user provided error component */
);
};
if (suspensible && instance.suspense || isInSSRComponentSetup) {
return load().then((comp) => {
return () => createInnerComp(comp, instance);
}).catch((err) => {
onError(err);
return () => errorComponent ? createVNode(errorComponent, {
error: err
}) : null;
});
}
const loaded = ref(false);
const error = ref();
const delayed = ref(!!delay);
if (delay) {
setTimeout(() => {
delayed.value = false;
}, delay);
}
if (timeout != null) {
setTimeout(() => {
if (!loaded.value && !error.value) {
const err = new Error(`Async component timed out after ${timeout}ms.`);
onError(err);
error.value = err;
}
}, timeout);
}
load().then(() => {
loaded.value = true;
if (instance.parent && isKeepAlive(instance.parent.vnode)) {
queueJob(instance.parent.update);
}
}).catch((err) => {
onError(err);
error.value = err;
});
return () => {
if (loaded.value && resolvedComp) {
return createInnerComp(resolvedComp, instance);
} else if (error.value && errorComponent) {
return createVNode(errorComponent, {
error: error.value
});
} else if (loadingComponent && !delayed.value) {
return createVNode(loadingComponent);
}
};
}
});
}
function createInnerComp(comp, parent) {
const { ref: ref2, props, children, ce } = parent.vnode;
const vnode = createVNode(comp, props, children);
vnode.ref = ref2;
vnode.ce = ce;
delete parent.vnode.ce;
return vnode;
}
var isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
var KeepAliveImpl = {
name: `KeepAlive`,
// Marker for special handling inside the renderer. We are not using a ===
// check directly on KeepAlive in the renderer, because importing it directly
// would prevent it from being tree-shaken.
__isKeepAlive: true,
props: {
include: [String, RegExp, Array],
exclude: [String, RegExp, Array],
max: [String, Number]
},
setup(props, { slots }) {
const instance = getCurrentInstance();
const sharedContext = instance.ctx;
if (!sharedContext.renderer) {
return () => {
const children = slots.default && slots.default();
return children && children.length === 1 ? children[0] : children;
};
}
const cache = /* @__PURE__ */ new Map();
const keys = /* @__PURE__ */ new Set();
let current = null;
if (true) {
instance.__v_cache = cache;
}
const parentSuspense = instance.suspense;
const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;
const storageContainer = createElement("div");
sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
const instance2 = vnode.component;
move(vnode, container, anchor, 0, parentSuspense);
patch(instance2.vnode, vnode, container, anchor, instance2, parentSuspense, isSVG, vnode.slotScopeIds, optimized);
queuePostRenderEffect(() => {
instance2.isDeactivated = false;
if (instance2.a) {
invokeArrayFns(instance2.a);
}
const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance2.parent, vnode);
}
}, parentSuspense);
if (true) {
devtoolsComponentAdded(instance2);
}
};
sharedContext.deactivate = (vnode) => {
const instance2 = vnode.component;
move(vnode, storageContainer, null, 1, parentSuspense);
queuePostRenderEffect(() => {
if (instance2.da) {
invokeArrayFns(instance2.da);
}
const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance2.parent, vnode);
}
instance2.isDeactivated = true;
}, parentSuspense);
if (true) {
devtoolsComponentAdded(instance2);
}
};
function unmount(vnode) {
resetShapeFlag(vnode);
_unmount(vnode, instance, parentSuspense, true);
}
function pruneCache(filter) {
cache.forEach((vnode, key) => {
const name = getComponentName(vnode.type);
if (name && (!filter || !filter(name))) {
pruneCacheEntry(key);
}
});
}
function pruneCacheEntry(key) {
const cached = cache.get(key);
if (!current || !isSameVNodeType(cached, current)) {
unmount(cached);
} else if (current) {
resetShapeFlag(current);
}
cache.delete(key);
keys.delete(key);
}
watch(
() => [props.include, props.exclude],
([include, exclude]) => {
include && pruneCache((name) => matches(include, name));
exclude && pruneCache((name) => !matches(exclude, name));
},
// prune post-render after `current` has been updated
{ flush: "post", deep: true }
);
let pendingCacheKey = null;
const cacheSubtree = () => {
if (pendingCacheKey != null) {
cache.set(pendingCacheKey, getInnerChild(instance.subTree));
}
};
onMounted(cacheSubtree);
onUpdated(cacheSubtree);
onBeforeUnmount(() => {
cache.forEach((cached) => {
const { subTree, suspense } = instance;
const vnode = getInnerChild(subTree);
if (cached.type === vnode.type && cached.key === vnode.key) {
resetShapeFlag(vnode);
const da = vnode.component.da;
da && queuePostRenderEffect(da, suspense);
return;
}
unmount(cached);
});
});
return () => {
pendingCacheKey = null;
if (!slots.default) {
return null;
}
const children = slots.default();
const rawVNode = children[0];
if (children.length > 1) {
if (true) {
warn2(`KeepAlive should contain exactly one component child.`);
}
current = null;
return children;
} else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
current = null;
return rawVNode;
}
let vnode = getInnerChild(rawVNode);
const comp = vnode.type;
const name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp);
const { include, exclude, max } = props;
if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
current = vnode;
return rawVNode;
}
const key = vnode.key == null ? comp : vnode.key;
const cachedVNode = cache.get(key);
if (vnode.el) {
vnode = cloneVNode(vnode);
if (rawVNode.shapeFlag & 128) {
rawVNode.ssContent = vnode;
}
}
pendingCacheKey = key;
if (cachedVNode) {
vnode.el = cachedVNode.el;
vnode.component = cachedVNode.component;
if (vnode.transition) {
setTransitionHooks(vnode, vnode.transition);
}
vnode.shapeFlag |= 512;
keys.delete(key);
keys.add(key);
} else {
keys.add(key);
if (max && keys.size > parseInt(max, 10)) {
pruneCacheEntry(keys.values().next().value);
}
}
vnode.shapeFlag |= 256;
current = vnode;
return isSuspense(rawVNode.type) ? rawVNode : vnode;
};
}
};
var KeepAlive = KeepAliveImpl;
function matches(pattern, name) {
if (isArray(pattern)) {
return pattern.some((p2) => matches(p2, name));
} else if (isString(pattern)) {
return pattern.split(",").includes(name);
} else if (isRegExp(pattern)) {
return pattern.test(name);
}
return false;
}
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a", target);
}
function onDeactivated(hook, target) {
registerKeepAliveHook(hook, "da", target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
const wrappedHook = hook.__wdc || (hook.__wdc = () => {
let current = target;
while (current) {
if (current.isDeactivated) {
return;
}
current = current.parent;
}
return hook();
});
injectHook(type, wrappedHook, target);
if (target) {
let current = target.parent;
while (current && current.parent) {
if (isKeepAlive(current.parent.vnode)) {
injectToKeepAliveRoot(wrappedHook, type, target, current);
}
current = current.parent;
}
}
}
function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
const injected = injectHook(
type,
hook,
keepAliveRoot,
true
/* prepend */
);
onUnmounted(() => {
remove(keepAliveRoot[type], injected);
}, target);
}
function resetShapeFlag(vnode) {
vnode.shapeFlag &= ~256;
vnode.shapeFlag &= ~512;
}
function getInnerChild(vnode) {
return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
if (target.isUnmounted) {
return;
}
pauseTracking();
setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
unsetCurrentInstance();
resetTracking();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
} else {
hooks.push(wrappedHook);
}
return wrappedHook;
} else if (true) {
const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ""));
warn2(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
}
}
var createHook = (lifecycle) => (hook, target = currentInstance) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target);
var onBeforeMount = createHook(
"bm"
/* LifecycleHooks.BEFORE_MOUNT */
);
var onMounted = createHook(
"m"
/* LifecycleHooks.MOUNTED */
);
var onBeforeUpdate = createHook(
"bu"
/* LifecycleHooks.BEFORE_UPDATE */
);
var onUpdated = createHook(
"u"
/* LifecycleHooks.UPDATED */
);
var onBeforeUnmount = createHook(
"bum"
/* LifecycleHooks.BEFORE_UNMOUNT */
);
var onUnmounted = createHook(
"um"
/* LifecycleHooks.UNMOUNTED */
);
var onServerPrefetch = createHook(
"sp"
/* LifecycleHooks.SERVER_PREFETCH */
);
var onRenderTriggered = createHook(
"rtg"
/* LifecycleHooks.RENDER_TRIGGERED */
);
var onRenderTracked = createHook(
"rtc"
/* LifecycleHooks.RENDER_TRACKED */
);
function onErrorCaptured(hook, target = currentInstance) {
injectHook("ec", hook, target);
}
function validateDirectiveName(name) {
if (isBuiltInDirective(name)) {
warn2("Do not use built-in directive ids as custom directive id: " + name);
}
}
function withDirectives(vnode, directives) {
const internalInstance = currentRenderingInstance;
if (internalInstance === null) {
warn2(`withDirectives can only be used inside render functions.`);
return vnode;
}
const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
const bindings = vnode.dirs || (vnode.dirs = []);
for (let i = 0; i < directives.length; i++) {
let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
if (dir) {
if (isFunction(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
if (dir.deep) {
traverse(value);
}
bindings.push({
dir,
instance,
value,
oldValue: void 0,
arg,
modifiers
});
}
}
return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
const bindings = vnode.dirs;
const oldBindings = prevVNode && prevVNode.dirs;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
if (oldBindings) {
binding.oldValue = oldBindings[i].value;
}
let hook = binding.dir[name];
if (hook) {
pauseTracking();
callWithAsyncErrorHandling(hook, instance, 8, [
vnode.el,
binding,
vnode,
prevVNode
]);
resetTracking();
}
}
}
var COMPONENTS = "components";
var DIRECTIVES = "directives";
function resolveComponent(name, maybeSelfReference) {
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
}
var NULL_DYNAMIC_COMPONENT = Symbol();
function resolveDynamicComponent(component) {
if (isString(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
} else {
return component || NULL_DYNAMIC_COMPONENT;
}
}
function resolveDirective(name) {
return resolveAsset(DIRECTIVES, name);
}
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
const instance = currentRenderingInstance || currentInstance;
if (instance) {
const Component = instance.type;
if (type === COMPONENTS) {
const selfName = getComponentName(
Component,
false
/* do not include inferred name to avoid breaking existing code */
);
if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
return Component;
}
}
const res = (
// local registration
// check instance[type] first which is resolved for options API
resolve(instance[type] || Component[type], name) || // global registration
resolve(instance.appContext[type], name)
);
if (!res && maybeSelfReference) {
return Component;
}
if (warnMissing && !res) {
const extra = type === COMPONENTS ? `
If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
warn2(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
}
return res;
} else if (true) {
warn2(`resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`);
}
}
function resolve(registry, name) {
return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
}
function renderList(source, renderItem, cache, index) {
let ret;
const cached = cache && cache[index];
if (isArray(source) || isString(source)) {
ret = new Array(source.length);
for (let i = 0, l = source.length; i < l; i++) {
ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
}
} else if (typeof source === "number") {
if (!Number.isInteger(source)) {
warn2(`The v-for range expect an integer value but got ${source}.`);
}
ret = new Array(source);
for (let i = 0; i < source; i++) {
ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
}
} else if (isObject(source)) {
if (source[Symbol.iterator]) {
ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));
} else {
const keys = Object.keys(source);
ret = new Array(keys.length);
for (let i = 0, l = keys.length; i < l; i++) {
const key = keys[i];
ret[i] = renderItem(source[key], key, i, cached && cached[i]);
}
}
} else {
ret = [];
}
if (cache) {
cache[index] = ret;
}
return ret;
}
function createSlots(slots, dynamicSlots) {
for (let i = 0; i < dynamicSlots.length; i++) {
const slot = dynamicSlots[i];
if (isArray(slot)) {
for (let j = 0; j < slot.length; j++) {
slots[slot[j].name] = slot[j].fn;
}
} else if (slot) {
slots[slot.name] = slot.key ? (...args) => {
const res = slot.fn(...args);
if (res)
res.key = slot.key;
return res;
} : slot.fn;
}
}
return slots;
}
function renderSlot(slots, name, props = {}, fallback, noSlotted) {
if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
if (name !== "default")
props.name = name;
return createVNode("slot", props, fallback && fallback());
}
let slot = slots[name];
if (slot && slot.length > 1) {
warn2(`SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`);
slot = () => [];
}
if (slot && slot._c) {
slot._d = false;
}
openBlock();
const validSlotContent = slot && ensureValidVNode(slot(props));
const rendered = createBlock(
Fragment,
{
key: props.key || validSlotContent && validSlotContent.key || `_${name}`
},
validSlotContent || (fallback ? fallback() : []),
validSlotContent && slots._ === 1 ? 64 : -2
/* PatchFlags.BAIL */
);
if (!noSlotted && rendered.scopeId) {
rendered.slotScopeIds = [rendered.scopeId + "-s"];
}
if (slot && slot._c) {
slot._d = true;
}
return rendered;
}
function ensureValidVNode(vnodes) {
return vnodes.some((child) => {
if (!isVNode(child))
return true;
if (child.type === Comment)
return false;
if (child.type === Fragment && !ensureValidVNode(child.children))
return false;
return true;
}) ? vnodes : null;
}
function toHandlers(obj, preserveCaseIfNecessary) {
const ret = {};
if (!isObject(obj)) {
warn2(`v-on with no argument expects an object value.`);
return ret;
}
for (const key in obj) {
ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
}
return ret;
}
var getPublicInstance = (i) => {
if (!i)
return null;
if (isStatefulComponent(i))
return getExposeProxy(i) || i.proxy;
return getPublicInstance(i.parent);
};
var publicPropertiesMap = (
// Move PURE marker to new line to workaround compiler discarding it
// due to type annotation
extend(/* @__PURE__ */ Object.create(null), {
$: (i) => i,
$el: (i) => i.vnode.el,
$data: (i) => i.data,
$props: (i) => true ? shallowReadonly(i.props) : i.props,
$attrs: (i) => true ? shallowReadonly(i.attrs) : i.attrs,
$slots: (i) => true ? shallowReadonly(i.slots) : i.slots,
$refs: (i) => true ? shallowReadonly(i.refs) : i.refs,
$parent: (i) => getPublicInstance(i.parent),
$root: (i) => getPublicInstance(i.root),
$emit: (i) => i.emit,
$options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,
$forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
$watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP
})
);
var isReservedPrefix = (key) => key === "_" || key === "$";
var hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
var PublicInstanceProxyHandlers = {
get({ _: instance }, key) {
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
if (key === "__isVue") {
return true;
}
let normalizedProps;
if (key[0] !== "$") {
const n = accessCache[key];
if (n !== void 0) {
switch (n) {
case 1:
return setupState[key];
case 2:
return data[key];
case 4:
return ctx[key];
case 3:
return props[key];
}
} else if (hasSetupBinding(setupState, key)) {
accessCache[key] = 1;
return setupState[key];
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
accessCache[key] = 2;
return data[key];
} else if ((normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) {
accessCache[key] = 3;
return props[key];
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4;
return ctx[key];
} else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {
accessCache[key] = 0;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
if (publicGetter) {
if (key === "$attrs") {
track(instance, "get", key);
markAttrsAccessed();
}
return publicGetter(instance);
} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {
return cssModule;
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4;
return ctx[key];
} else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {
{
return globalProperties[key];
}
} else if (currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
// to infinite warning loop
key.indexOf("__v") !== 0)) {
if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
warn2(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`);
} else if (instance === currentRenderingInstance) {
warn2(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`);
}
}
},
set({ _: instance }, key, value) {
const { data, setupState, ctx } = instance;
if (hasSetupBinding(setupState, key)) {
setupState[key] = value;
return true;
} else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
warn2(`Cannot mutate <script setup> binding "${key}" from Options API.`);
return false;
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
data[key] = value;
return true;
} else if (hasOwn(instance.props, key)) {
warn2(`Attempting to mutate prop "${key}". Props are readonly.`);
return false;
}
if (key[0] === "$" && key.slice(1) in instance) {
warn2(`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`);
return false;
} else {
if (key in instance.appContext.config.globalProperties) {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
value
});
} else {
ctx[key] = value;
}
}
return true;
},
has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {
let normalizedProps;
return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
},
defineProperty(target, key, descriptor) {
if (descriptor.get != null) {
target._.accessCache[key] = 0;
} else if (hasOwn(descriptor, "value")) {
this.set(target, key, descriptor.value, null);
}
return Reflect.defineProperty(target, key, descriptor);
}
};
if (true) {
PublicInstanceProxyHandlers.ownKeys = (target) => {
warn2(`Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`);
return Reflect.ownKeys(target);
};
}
var RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {
get(target, key) {
if (key === Symbol.unscopables) {
return;
}
return PublicInstanceProxyHandlers.get(target, key, target);
},
has(_, key) {
const has2 = key[0] !== "_" && !isGloballyWhitelisted(key);
if (!has2 && PublicInstanceProxyHandlers.has(_, key)) {
warn2(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);
}
return has2;
}
});
function createDevRenderContext(instance) {
const target = {};
Object.defineProperty(target, `_`, {
configurable: true,
enumerable: false,
get: () => instance
});
Object.keys(publicPropertiesMap).forEach((key) => {
Object.defineProperty(target, key, {
configurable: true,
enumerable: false,
get: () => publicPropertiesMap[key](instance),
// intercepted by the proxy so no need for implementation,
// but needed to prevent set errors
set: NOOP
});
});
return target;
}
function exposePropsOnRenderContext(instance) {
const { ctx, propsOptions: [propsOptions] } = instance;
if (propsOptions) {
Object.keys(propsOptions).forEach((key) => {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => instance.props[key],
set: NOOP
});
});
}
}
function exposeSetupStateOnRenderContext(instance) {
const { ctx, setupState } = instance;
Object.keys(toRaw(setupState)).forEach((key) => {
if (!setupState.__isScriptSetup) {
if (isReservedPrefix(key[0])) {
warn2(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" which are reserved prefixes for Vue internals.`);
return;
}
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => setupState[key],
set: NOOP
});
}
});
}
function createDuplicateChecker() {
const cache = /* @__PURE__ */ Object.create(null);
return (type, key) => {
if (cache[key]) {
warn2(`${type} property "${key}" is already defined in ${cache[key]}.`);
} else {
cache[key] = type;
}
};
}
var shouldCacheAccess = true;
function applyOptions(instance) {
const options = resolveMergedOptions(instance);
const publicThis = instance.proxy;
const ctx = instance.ctx;
shouldCacheAccess = false;
if (options.beforeCreate) {
callHook(
options.beforeCreate,
instance,
"bc"
/* LifecycleHooks.BEFORE_CREATE */
);
}
const {
// state
data: dataOptions,
computed: computedOptions,
methods,
watch: watchOptions,
provide: provideOptions,
inject: injectOptions,
// lifecycle
created,
beforeMount,
mounted,
beforeUpdate,
updated,
activated,
deactivated,
beforeDestroy,
beforeUnmount,
destroyed,
unmounted,
render: render2,
renderTracked,
renderTriggered,
errorCaptured,
serverPrefetch,
// public API
expose,
inheritAttrs,
// assets
components,
directives,
filters
} = options;
const checkDuplicateProperties = true ? createDuplicateChecker() : null;
if (true) {
const [propsOptions] = instance.propsOptions;
if (propsOptions) {
for (const key in propsOptions) {
checkDuplicateProperties("Props", key);
}
}
}
if (injectOptions) {
resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef);
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (isFunction(methodHandler)) {
if (true) {
Object.defineProperty(ctx, key, {
value: methodHandler.bind(publicThis),
configurable: true,
enumerable: true,
writable: true
});
} else {
ctx[key] = methodHandler.bind(publicThis);
}
if (true) {
checkDuplicateProperties("Methods", key);
}
} else if (true) {
warn2(`Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`);
}
}
}
if (dataOptions) {
if (!isFunction(dataOptions)) {
warn2(`The data option must be a function. Plain object usage is no longer supported.`);
}
const data = dataOptions.call(publicThis, publicThis);
if (isPromise(data)) {
warn2(`data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`);
}
if (!isObject(data)) {
warn2(`data() should return an object.`);
} else {
instance.data = reactive(data);
if (true) {
for (const key in data) {
checkDuplicateProperties("Data", key);
if (!isReservedPrefix(key[0])) {
Object.defineProperty(ctx, key, {
configurable: true,
enumerable: true,
get: () => data[key],
set: NOOP
});
}
}
}
}
}
shouldCacheAccess = true;
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get2 = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
if (get2 === NOOP) {
warn2(`Computed property "${key}" has no getter.`);
}
const set2 = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : true ? () => {
warn2(`Write operation failed: computed property "${key}" is readonly.`);
} : NOOP;
const c = computed2({
get: get2,
set: set2
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: (v) => c.value = v
});
if (true) {
checkDuplicateProperties("Computed", key);
}
}
}
if (watchOptions) {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
}
if (provideOptions) {
const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
Reflect.ownKeys(provides).forEach((key) => {
provide(key, provides[key]);
});
}
if (created) {
callHook(
created,
instance,
"c"
/* LifecycleHooks.CREATED */
);
}
function registerLifecycleHook(register, hook) {
if (isArray(hook)) {
hook.forEach((_hook) => register(_hook.bind(publicThis)));
} else if (hook) {
register(hook.bind(publicThis));
}
}
registerLifecycleHook(onBeforeMount, beforeMount);
registerLifecycleHook(onMounted, mounted);
registerLifecycleHook(onBeforeUpdate, beforeUpdate);
registerLifecycleHook(onUpdated, updated);
registerLifecycleHook(onActivated, activated);
registerLifecycleHook(onDeactivated, deactivated);
registerLifecycleHook(onErrorCaptured, errorCaptured);
registerLifecycleHook(onRenderTracked, renderTracked);
registerLifecycleHook(onRenderTriggered, renderTriggered);
registerLifecycleHook(onBeforeUnmount, beforeUnmount);
registerLifecycleHook(onUnmounted, unmounted);
registerLifecycleHook(onServerPrefetch, serverPrefetch);
if (isArray(expose)) {
if (expose.length) {
const exposed = instance.exposed || (instance.exposed = {});
expose.forEach((key) => {
Object.defineProperty(exposed, key, {
get: () => publicThis[key],
set: (val) => publicThis[key] = val
});
});
} else if (!instance.exposed) {
instance.exposed = {};
}
}
if (render2 && instance.render === NOOP) {
instance.render = render2;
}
if (inheritAttrs != null) {
instance.inheritAttrs = inheritAttrs;
}
if (components)
instance.components = components;
if (directives)
instance.directives = directives;
}
function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
if (isArray(injectOptions)) {
injectOptions = normalizeInject(injectOptions);
}
for (const key in injectOptions) {
const opt = injectOptions[key];
let injected;
if (isObject(opt)) {
if ("default" in opt) {
injected = inject(
opt.from || key,
opt.default,
true
/* treat default function as factory */
);
} else {
injected = inject(opt.from || key);
}
} else {
injected = inject(opt);
}
if (isRef(injected)) {
if (unwrapRef) {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => injected.value,
set: (v) => injected.value = v
});
} else {
if (true) {
warn2(`injected property "${key}" is a ref and will be auto-unwrapped and no longer needs \`.value\` in the next minor release. To opt-in to the new behavior now, set \`app.config.unwrapInjectedRef = true\` (this config is temporary and will not be needed in the future.)`);
}
ctx[key] = injected;
}
} else {
ctx[key] = injected;
}
if (true) {
checkDuplicateProperties("Inject", key);
}
}
}
function callHook(hook, instance, type) {
callWithAsyncErrorHandling(isArray(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type);
}
function createWatcher(raw, ctx, publicThis, key) {
const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
if (isString(raw)) {
const handler = ctx[raw];
if (isFunction(handler)) {
watch(getter, handler);
} else if (true) {
warn2(`Invalid watch handler specified by key "${raw}"`, handler);
}
} else if (isFunction(raw)) {
watch(getter, raw.bind(publicThis));
} else if (isObject(raw)) {
if (isArray(raw)) {
raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
} else {
const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
if (isFunction(handler)) {
watch(getter, handler, raw);
} else if (true) {
warn2(`Invalid watch handler specified by key "${raw.handler}"`, handler);
}
}
} else if (true) {
warn2(`Invalid watch option: "${key}"`, raw);
}
}
function resolveMergedOptions(instance) {
const base = instance.type;
const { mixins, extends: extendsOptions } = base;
const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;
const cached = cache.get(base);
let resolved;
if (cached) {
resolved = cached;
} else if (!globalMixins.length && !mixins && !extendsOptions) {
{
resolved = base;
}
} else {
resolved = {};
if (globalMixins.length) {
globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
}
mergeOptions(resolved, base, optionMergeStrategies);
}
if (isObject(base)) {
cache.set(base, resolved);
}
return resolved;
}
function mergeOptions(to, from, strats, asMixin = false) {
const { mixins, extends: extendsOptions } = from;
if (extendsOptions) {
mergeOptions(to, extendsOptions, strats, true);
}
if (mixins) {
mixins.forEach((m) => mergeOptions(to, m, strats, true));
}
for (const key in from) {
if (asMixin && key === "expose") {
warn2(`"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`);
} else {
const strat = internalOptionMergeStrats[key] || strats && strats[key];
to[key] = strat ? strat(to[key], from[key]) : from[key];
}
}
return to;
}
var internalOptionMergeStrats = {
data: mergeDataFn,
props: mergeObjectOptions,
emits: mergeObjectOptions,
// objects
methods: mergeObjectOptions,
computed: mergeObjectOptions,
// lifecycle
beforeCreate: mergeAsArray,
created: mergeAsArray,
beforeMount: mergeAsArray,
mounted: mergeAsArray,
beforeUpdate: mergeAsArray,
updated: mergeAsArray,
beforeDestroy: mergeAsArray,
beforeUnmount: mergeAsArray,
destroyed: mergeAsArray,
unmounted: mergeAsArray,
activated: mergeAsArray,
deactivated: mergeAsArray,
errorCaptured: mergeAsArray,
serverPrefetch: mergeAsArray,
// assets
components: mergeObjectOptions,
directives: mergeObjectOptions,
// watch
watch: mergeWatchOptions,
// provide / inject
provide: mergeDataFn,
inject: mergeInject
};
function mergeDataFn(to, from) {
if (!from) {
return to;
}
if (!to) {
return from;
}
return function mergedDataFn() {
return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
};
}
function mergeInject(to, from) {
return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
}
function normalizeInject(raw) {
if (isArray(raw)) {
const res = {};
for (let i = 0; i < raw.length; i++) {
res[raw[i]] = raw[i];
}
return res;
}
return raw;
}
function mergeAsArray(to, from) {
return to ? [...new Set([].concat(to, from))] : from;
}
function mergeObjectOptions(to, from) {
return to ? extend(extend(/* @__PURE__ */ Object.create(null), to), from) : from;
}
function mergeWatchOptions(to, from) {
if (!to)
return from;
if (!from)
return to;
const merged = extend(/* @__PURE__ */ Object.create(null), to);
for (const key in from) {
merged[key] = mergeAsArray(to[key], from[key]);
}
return merged;
}
function initProps(instance, rawProps, isStateful, isSSR = false) {
const props = {};
const attrs = {};
def(attrs, InternalObjectKey, 1);
instance.propsDefaults = /* @__PURE__ */ Object.create(null);
setFullProps(instance, rawProps, props, attrs);
for (const key in instance.propsOptions[0]) {
if (!(key in props)) {
props[key] = void 0;
}
}
if (true) {
validateProps(rawProps || {}, props, instance);
}
if (isStateful) {
instance.props = isSSR ? props : shallowReactive(props);
} else {
if (!instance.type.props) {
instance.props = attrs;
} else {
instance.props = props;
}
}
instance.attrs = attrs;
}
function isInHmrContext(instance) {
while (instance) {
if (instance.type.__hmrId)
return true;
instance = instance.parent;
}
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const { props, attrs, vnode: { patchFlag } } = instance;
const rawCurrentProps = toRaw(props);
const [options] = instance.propsOptions;
let hasAttrsChanged = false;
if (// always force full diff in dev
// - #1942 if hmr is enabled with sfc component
// - vite#872 non-sfc component used by sfc component
!isInHmrContext(instance) && (optimized || patchFlag > 0) && !(patchFlag & 16)) {
if (patchFlag & 8) {
const propsToUpdate = instance.vnode.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
let key = propsToUpdate[i];
if (isEmitListener(instance.emitsOptions, key)) {
continue;
}
const value = rawProps[key];
if (options) {
if (hasOwn(attrs, key)) {
if (value !== attrs[key]) {
attrs[key] = value;
hasAttrsChanged = true;
}
} else {
const camelizedKey = camelize(key);
props[camelizedKey] = resolvePropValue(
options,
rawCurrentProps,
camelizedKey,
value,
instance,
false
/* isAbsent */
);
}
} else {
if (value !== attrs[key]) {
attrs[key] = value;
hasAttrsChanged = true;
}
}
}
}
} else {
if (setFullProps(instance, rawProps, props, attrs)) {
hasAttrsChanged = true;
}
let kebabKey;
for (const key in rawCurrentProps) {
if (!rawProps || !hasOwn(rawProps, key) && ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
if (options) {
if (rawPrevProps && (rawPrevProps[key] !== void 0 || // for kebab-case
rawPrevProps[kebabKey] !== void 0)) {
props[key] = resolvePropValue(
options,
rawCurrentProps,
key,
void 0,
instance,
true
/* isAbsent */
);
}
} else {
delete props[key];
}
}
}
if (attrs !== rawCurrentProps) {
for (const key in attrs) {
if (!rawProps || !hasOwn(rawProps, key) && true) {
delete attrs[key];
hasAttrsChanged = true;
}
}
}
}
if (hasAttrsChanged) {
trigger(instance, "set", "$attrs");
}
if (true) {
validateProps(rawProps || {}, props, instance);
}
}
function setFullProps(instance, rawProps, props, attrs) {
const [options, needCastKeys] = instance.propsOptions;
let hasAttrsChanged = false;
let rawCastValues;
if (rawProps) {
for (let key in rawProps) {
if (isReservedProp(key)) {
continue;
}
const value = rawProps[key];
let camelKey;
if (options && hasOwn(options, camelKey = camelize(key))) {
if (!needCastKeys || !needCastKeys.includes(camelKey)) {
props[camelKey] = value;
} else {
(rawCastValues || (rawCastValues = {}))[camelKey] = value;
}
} else if (!isEmitListener(instance.emitsOptions, key)) {
if (!(key in attrs) || value !== attrs[key]) {
attrs[key] = value;
hasAttrsChanged = true;
}
}
}
}
if (needCastKeys) {
const rawCurrentProps = toRaw(props);
const castValues = rawCastValues || EMPTY_OBJ;
for (let i = 0; i < needCastKeys.length; i++) {
const key = needCastKeys[i];
props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key));
}
}
return hasAttrsChanged;
}
function resolvePropValue(options, props, key, value, instance, isAbsent) {
const opt = options[key];
if (opt != null) {
const hasDefault = hasOwn(opt, "default");
if (hasDefault && value === void 0) {
const defaultValue = opt.default;
if (opt.type !== Function && isFunction(defaultValue)) {
const { propsDefaults } = instance;
if (key in propsDefaults) {
value = propsDefaults[key];
} else {
setCurrentInstance(instance);
value = propsDefaults[key] = defaultValue.call(null, props);
unsetCurrentInstance();
}
} else {
value = defaultValue;
}
}
if (opt[
0
/* BooleanFlags.shouldCast */
]) {
if (isAbsent && !hasDefault) {
value = false;
} else if (opt[
1
/* BooleanFlags.shouldCastTrue */
] && (value === "" || value === hyphenate(key))) {
value = true;
}
}
}
return value;
}
function normalizePropsOptions(comp, appContext, asMixin = false) {
const cache = appContext.propsCache;
const cached = cache.get(comp);
if (cached) {
return cached;
}
const raw = comp.props;
const normalized = {};
const needCastKeys = [];
let hasExtends = false;
if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
const extendProps = (raw2) => {
hasExtends = true;
const [props, keys] = normalizePropsOptions(raw2, appContext, true);
extend(normalized, props);
if (keys)
needCastKeys.push(...keys);
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendProps);
}
if (comp.extends) {
extendProps(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendProps);
}
}
if (!raw && !hasExtends) {
if (isObject(comp)) {
cache.set(comp, EMPTY_ARR);
}
return EMPTY_ARR;
}
if (isArray(raw)) {
for (let i = 0; i < raw.length; i++) {
if (!isString(raw[i])) {
warn2(`props must be strings when using array syntax.`, raw[i]);
}
const normalizedKey = camelize(raw[i]);
if (validatePropName(normalizedKey)) {
normalized[normalizedKey] = EMPTY_OBJ;
}
}
} else if (raw) {
if (!isObject(raw)) {
warn2(`invalid props options`, raw);
}
for (const key in raw) {
const normalizedKey = camelize(key);
if (validatePropName(normalizedKey)) {
const opt = raw[key];
const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : Object.assign({}, opt);
if (prop) {
const booleanIndex = getTypeIndex(Boolean, prop.type);
const stringIndex = getTypeIndex(String, prop.type);
prop[
0
/* BooleanFlags.shouldCast */
] = booleanIndex > -1;
prop[
1
/* BooleanFlags.shouldCastTrue */
] = stringIndex < 0 || booleanIndex < stringIndex;
if (booleanIndex > -1 || hasOwn(prop, "default")) {
needCastKeys.push(normalizedKey);
}
}
}
}
}
const res = [normalized, needCastKeys];
if (isObject(comp)) {
cache.set(comp, res);
}
return res;
}
function validatePropName(key) {
if (key[0] !== "$") {
return true;
} else if (true) {
warn2(`Invalid prop name: "${key}" is a reserved property.`);
}
return false;
}
function getType(ctor) {
const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
return match ? match[2] : ctor === null ? "null" : "";
}
function isSameType(a, b) {
return getType(a) === getType(b);
}
function getTypeIndex(type, expectedTypes) {
if (isArray(expectedTypes)) {
return expectedTypes.findIndex((t) => isSameType(t, type));
} else if (isFunction(expectedTypes)) {
return isSameType(expectedTypes, type) ? 0 : -1;
}
return -1;
}
function validateProps(rawProps, props, instance) {
const resolvedValues = toRaw(props);
const options = instance.propsOptions[0];
for (const key in options) {
let opt = options[key];
if (opt == null)
continue;
validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key)));
}
}
function validateProp(name, value, prop, isAbsent) {
const { type, required, validator } = prop;
if (required && isAbsent) {
warn2('Missing required prop: "' + name + '"');
return;
}
if (value == null && !prop.required) {
return;
}
if (type != null && type !== true) {
let isValid = false;
const types = isArray(type) ? type : [type];
const expectedTypes = [];
for (let i = 0; i < types.length && !isValid; i++) {
const { valid, expectedType } = assertType(value, types[i]);
expectedTypes.push(expectedType || "");
isValid = valid;
}
if (!isValid) {
warn2(getInvalidTypeMessage(name, value, expectedTypes));
return;
}
}
if (validator && !validator(value)) {
warn2('Invalid prop: custom validator check failed for prop "' + name + '".');
}
}
var isSimpleType = makeMap("String,Number,Boolean,Function,Symbol,BigInt");
function assertType(value, type) {
let valid;
const expectedType = getType(type);
if (isSimpleType(expectedType)) {
const t = typeof value;
valid = t === expectedType.toLowerCase();
if (!valid && t === "object") {
valid = value instanceof type;
}
} else if (expectedType === "Object") {
valid = isObject(value);
} else if (expectedType === "Array") {
valid = isArray(value);
} else if (expectedType === "null") {
valid = value === null;
} else {
valid = value instanceof type;
}
return {
valid,
expectedType
};
}
function getInvalidTypeMessage(name, value, expectedTypes) {
let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
const expectedType = expectedTypes[0];
const receivedType = toRawType(value);
const expectedValue = styleValue(value, expectedType);
const receivedValue = styleValue(value, receivedType);
if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
message += ` with value ${expectedValue}`;
}
message += `, got ${receivedType} `;
if (isExplicable(receivedType)) {
message += `with value ${receivedValue}.`;
}
return message;
}
function styleValue(value, type) {
if (type === "String") {
return `"${value}"`;
} else if (type === "Number") {
return `${Number(value)}`;
} else {
return `${value}`;
}
}
function isExplicable(type) {
const explicitTypes = ["string", "number", "boolean"];
return explicitTypes.some((elem) => type.toLowerCase() === elem);
}
function isBoolean(...args) {
return args.some((elem) => elem.toLowerCase() === "boolean");
}
var isInternalKey = (key) => key[0] === "_" || key === "$stable";
var normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
var normalizeSlot = (key, rawSlot, ctx) => {
if (rawSlot._n) {
return rawSlot;
}
const normalized = withCtx((...args) => {
if (currentInstance) {
warn2(`Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`);
}
return normalizeSlotValue(rawSlot(...args));
}, ctx);
normalized._c = false;
return normalized;
};
var normalizeObjectSlots = (rawSlots, slots, instance) => {
const ctx = rawSlots._ctx;
for (const key in rawSlots) {
if (isInternalKey(key))
continue;
const value = rawSlots[key];
if (isFunction(value)) {
slots[key] = normalizeSlot(key, value, ctx);
} else if (value != null) {
if (true) {
warn2(`Non-function value encountered for slot "${key}". Prefer function slots for better performance.`);
}
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
var normalizeVNodeSlots = (instance, children) => {
if (!isKeepAlive(instance.vnode) && true) {
warn2(`Non-function value encountered for default slot. Prefer function slots for better performance.`);
}
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
var initSlots = (instance, children) => {
if (instance.vnode.shapeFlag & 32) {
const type = children._;
if (type) {
instance.slots = toRaw(children);
def(children, "_", type);
} else {
normalizeObjectSlots(children, instance.slots = {});
}
} else {
instance.slots = {};
if (children) {
normalizeVNodeSlots(instance, children);
}
}
def(instance.slots, InternalObjectKey, 1);
};
var updateSlots = (instance, children, optimized) => {
const { vnode, slots } = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = EMPTY_OBJ;
if (vnode.shapeFlag & 32) {
const type = children._;
if (type) {
if (isHmrUpdating) {
extend(slots, children);
} else if (optimized && type === 1) {
needDeletionCheck = false;
} else {
extend(slots, children);
if (!optimized && type === 1) {
delete slots._;
}
}
} else {
needDeletionCheck = !children.$stable;
normalizeObjectSlots(children, slots);
}
deletionComparisonTarget = children;
} else if (children) {
normalizeVNodeSlots(instance, children);
deletionComparisonTarget = { default: 1 };
}
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
delete slots[key];
}
}
}
};
function createAppContext() {
return {
app: null,
config: {
isNativeTag: NO,
performance: false,
globalProperties: {},
optionMergeStrategies: {},
errorHandler: void 0,
warnHandler: void 0,
compilerOptions: {}
},
mixins: [],
components: {},
directives: {},
provides: /* @__PURE__ */ Object.create(null),
optionsCache: /* @__PURE__ */ new WeakMap(),
propsCache: /* @__PURE__ */ new WeakMap(),
emitsCache: /* @__PURE__ */ new WeakMap()
};
}
var uid$1 = 0;
function createAppAPI(render2, hydrate2) {
return function createApp2(rootComponent, rootProps = null) {
if (!isFunction(rootComponent)) {
rootComponent = Object.assign({}, rootComponent);
}
if (rootProps != null && !isObject(rootProps)) {
warn2(`root props passed to app.mount() must be an object.`);
rootProps = null;
}
const context = createAppContext();
const installedPlugins = /* @__PURE__ */ new Set();
let isMounted = false;
const app = context.app = {
_uid: uid$1++,
_component: rootComponent,
_props: rootProps,
_container: null,
_context: context,
_instance: null,
version,
get config() {
return context.config;
},
set config(v) {
if (true) {
warn2(`app.config cannot be replaced. Modify individual options instead.`);
}
},
use(plugin, ...options) {
if (installedPlugins.has(plugin)) {
warn2(`Plugin has already been applied to target app.`);
} else if (plugin && isFunction(plugin.install)) {
installedPlugins.add(plugin);
plugin.install(app, ...options);
} else if (isFunction(plugin)) {
installedPlugins.add(plugin);
plugin(app, ...options);
} else if (true) {
warn2(`A plugin must either be a function or an object with an "install" function.`);
}
return app;
},
mixin(mixin) {
if (__VUE_OPTIONS_API__) {
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
} else if (true) {
warn2("Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : ""));
}
} else if (true) {
warn2("Mixins are only available in builds supporting Options API");
}
return app;
},
component(name, component) {
if (true) {
validateComponentName(name, context.config);
}
if (!component) {
return context.components[name];
}
if (context.components[name]) {
warn2(`Component "${name}" has already been registered in target app.`);
}
context.components[name] = component;
return app;
},
directive(name, directive) {
if (true) {
validateDirectiveName(name);
}
if (!directive) {
return context.directives[name];
}
if (context.directives[name]) {
warn2(`Directive "${name}" has already been registered in target app.`);
}
context.directives[name] = directive;
return app;
},
mount(rootContainer, isHydrate, isSVG) {
if (!isMounted) {
if (rootContainer.__vue_app__) {
warn2(`There is already an app instance mounted on the host container.
If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`);
}
const vnode = createVNode(rootComponent, rootProps);
vnode.appContext = context;
if (true) {
context.reload = () => {
render2(cloneVNode(vnode), rootContainer, isSVG);
};
}
if (isHydrate && hydrate2) {
hydrate2(vnode, rootContainer);
} else {
render2(vnode, rootContainer, isSVG);
}
isMounted = true;
app._container = rootContainer;
rootContainer.__vue_app__ = app;
if (true) {
app._instance = vnode.component;
devtoolsInitApp(app, version);
}
return getExposeProxy(vnode.component) || vnode.component.proxy;
} else if (true) {
warn2(`App has already been mounted.
If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``);
}
},
unmount() {
if (isMounted) {
render2(null, app._container);
if (true) {
app._instance = null;
devtoolsUnmountApp(app);
}
delete app._container.__vue_app__;
} else if (true) {
warn2(`Cannot unmount an app that is not mounted.`);
}
},
provide(key, value) {
if (key in context.provides) {
warn2(`App already provides property with key "${String(key)}". It will be overwritten with the new value.`);
}
context.provides[key] = value;
return app;
}
};
return app;
};
}
function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
if (isArray(rawRef)) {
rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount));
return;
}
if (isAsyncWrapper(vnode) && !isUnmount) {
return;
}
const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
const value = isUnmount ? null : refValue;
const { i: owner, r: ref2 } = rawRef;
if (!owner) {
warn2(`Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`);
return;
}
const oldRef = oldRawRef && oldRawRef.r;
const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
const setupState = owner.setupState;
if (oldRef != null && oldRef !== ref2) {
if (isString(oldRef)) {
refs[oldRef] = null;
if (hasOwn(setupState, oldRef)) {
setupState[oldRef] = null;
}
} else if (isRef(oldRef)) {
oldRef.value = null;
}
}
if (isFunction(ref2)) {
callWithErrorHandling(ref2, owner, 12, [value, refs]);
} else {
const _isString = isString(ref2);
const _isRef = isRef(ref2);
if (_isString || _isRef) {
const doSet = () => {
if (rawRef.f) {
const existing = _isString ? hasOwn(setupState, ref2) ? setupState[ref2] : refs[ref2] : ref2.value;
if (isUnmount) {
isArray(existing) && remove(existing, refValue);
} else {
if (!isArray(existing)) {
if (_isString) {
refs[ref2] = [refValue];
if (hasOwn(setupState, ref2)) {
setupState[ref2] = refs[ref2];
}
} else {
ref2.value = [refValue];
if (rawRef.k)
refs[rawRef.k] = ref2.value;
}
} else if (!existing.includes(refValue)) {
existing.push(refValue);
}
}
} else if (_isString) {
refs[ref2] = value;
if (hasOwn(setupState, ref2)) {
setupState[ref2] = value;
}
} else if (_isRef) {
ref2.value = value;
if (rawRef.k)
refs[rawRef.k] = value;
} else if (true) {
warn2("Invalid template ref type:", ref2, `(${typeof ref2})`);
}
};
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
} else {
doSet();
}
} else if (true) {
warn2("Invalid template ref type:", ref2, `(${typeof ref2})`);
}
}
}
var hasMismatch = false;
var isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== "foreignObject";
var isComment = (node) => node.nodeType === 8;
function createHydrationFunctions(rendererInternals) {
const { mt: mountComponent, p: patch, o: { patchProp: patchProp2, createText, nextSibling, parentNode, remove: remove2, insert, createComment } } = rendererInternals;
const hydrate2 = (vnode, container) => {
if (!container.hasChildNodes()) {
warn2(`Attempting to hydrate existing markup but container is empty. Performing full mount instead.`);
patch(null, vnode, container);
flushPostFlushCbs();
container._vnode = vnode;
return;
}
hasMismatch = false;
hydrateNode(container.firstChild, vnode, null, null, null);
flushPostFlushCbs();
container._vnode = vnode;
if (hasMismatch && true) {
console.error(`Hydration completed but contains mismatches.`);
}
};
const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
const isFragmentStart = isComment(node) && node.data === "[";
const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart);
const { type, ref: ref2, shapeFlag, patchFlag } = vnode;
let domType = node.nodeType;
vnode.el = node;
if (patchFlag === -2) {
optimized = false;
vnode.dynamicChildren = null;
}
let nextNode = null;
switch (type) {
case Text:
if (domType !== 3) {
if (vnode.children === "") {
insert(vnode.el = createText(""), parentNode(node), node);
nextNode = node;
} else {
nextNode = onMismatch();
}
} else {
if (node.data !== vnode.children) {
hasMismatch = true;
warn2(`Hydration text mismatch:
- Client: ${JSON.stringify(node.data)}
- Server: ${JSON.stringify(vnode.children)}`);
node.data = vnode.children;
}
nextNode = nextSibling(node);
}
break;
case Comment:
if (domType !== 8 || isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = nextSibling(node);
}
break;
case Static:
if (isFragmentStart) {
node = nextSibling(node);
domType = node.nodeType;
}
if (domType === 1 || domType === 3) {
nextNode = node;
const needToAdoptContent = !vnode.children.length;
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode;
}
nextNode = nextSibling(nextNode);
}
return isFragmentStart ? nextSibling(nextNode) : nextNode;
} else {
onMismatch();
}
break;
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
}
break;
default:
if (shapeFlag & 1) {
if (domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) {
nextNode = onMismatch();
} else {
nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
}
} else if (shapeFlag & 6) {
vnode.slotScopeIds = slotScopeIds;
const container = parentNode(node);
mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized);
nextNode = isFragmentStart ? locateClosingAsyncAnchor(node) : nextSibling(node);
if (nextNode && isComment(nextNode) && nextNode.data === "teleport end") {
nextNode = nextSibling(nextNode);
}
if (isAsyncWrapper(vnode)) {
let subTree;
if (isFragmentStart) {
subTree = createVNode(Fragment);
subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
} else {
subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
}
subTree.el = node;
vnode.component.subTree = subTree;
}
} else if (shapeFlag & 64) {
if (domType !== 8) {
nextNode = onMismatch();
} else {
nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren);
}
} else if (shapeFlag & 128) {
nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode);
} else if (true) {
warn2("Invalid HostVNode type:", type, `(${typeof type})`);
}
}
if (ref2 != null) {
setRef(ref2, null, parentSuspense, vnode);
}
return nextNode;
};
const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const { type, props, patchFlag, shapeFlag, dirs } = vnode;
const forcePatchValue = type === "input" && dirs || type === "option";
if (true) {
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
if (props) {
if (forcePatchValue || !optimized || patchFlag & (16 | 32)) {
for (const key in props) {
if (forcePatchValue && key.endsWith("value") || isOn(key) && !isReservedProp(key)) {
patchProp2(el, key, null, props[key], false, void 0, parentComponent);
}
}
} else if (props.onClick) {
patchProp2(el, "onClick", null, props.onClick, false, void 0, parentComponent);
}
}
let vnodeHooks;
if (vnodeHooks = props && props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
if (shapeFlag & 16 && // skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))) {
let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized);
let hasWarned2 = false;
while (next) {
hasMismatch = true;
if (!hasWarned2) {
warn2(`Hydration children mismatch in <${vnode.type}>: server rendered element contains more child nodes than client vdom.`);
hasWarned2 = true;
}
const cur = next;
next = next.nextSibling;
remove2(cur);
}
} else if (shapeFlag & 8) {
if (el.textContent !== vnode.children) {
hasMismatch = true;
warn2(`Hydration text content mismatch in <${vnode.type}>:
- Client: ${el.textContent}
- Server: ${vnode.children}`);
el.textContent = vnode.children;
}
}
}
return el.nextSibling;
};
const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!parentVNode.dynamicChildren;
const children = parentVNode.children;
const l = children.length;
let hasWarned2 = false;
for (let i = 0; i < l; i++) {
const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
if (node) {
node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
} else if (vnode.type === Text && !vnode.children) {
continue;
} else {
hasMismatch = true;
if (!hasWarned2) {
warn2(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: server rendered element contains fewer child nodes than client vdom.`);
hasWarned2 = true;
}
patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds);
}
}
return node;
};
const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
const { slotScopeIds: fragmentSlotScopeIds } = vnode;
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
const container = parentNode(node);
const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized);
if (next && isComment(next) && next.data === "]") {
return nextSibling(vnode.anchor = next);
} else {
hasMismatch = true;
insert(vnode.anchor = createComment(`]`), container, next);
return next;
}
};
const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
hasMismatch = true;
warn2(`Hydration node mismatch:
- Client vnode:`, vnode.type, `
- Server rendered DOM:`, node, node.nodeType === 3 ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``);
vnode.el = null;
if (isFragment) {
const end = locateClosingAsyncAnchor(node);
while (true) {
const next2 = nextSibling(node);
if (next2 && next2 !== end) {
remove2(next2);
} else {
break;
}
}
}
const next = nextSibling(node);
const container = parentNode(node);
remove2(node);
patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds);
return next;
};
const locateClosingAsyncAnchor = (node) => {
let match = 0;
while (node) {
node = nextSibling(node);
if (node && isComment(node)) {
if (node.data === "[")
match++;
if (node.data === "]") {
if (match === 0) {
return nextSibling(node);
} else {
match--;
}
}
}
}
return node;
};
return [hydrate2, hydrateNode];
}
var supported;
var perf;
function startMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
perf.mark(`vue-${type}-${instance.uid}`);
}
if (true) {
devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
}
}
function endMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
const startTag = `vue-${type}-${instance.uid}`;
const endTag = startTag + `:end`;
perf.mark(endTag);
perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag);
perf.clearMarks(startTag);
perf.clearMarks(endTag);
}
if (true) {
devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
}
}
function isSupported() {
if (supported !== void 0) {
return supported;
}
if (typeof window !== "undefined" && window.performance) {
supported = true;
perf = window.performance;
} else {
supported = false;
}
return supported;
}
function initFeatureFlags() {
const needWarn = [];
if (typeof __VUE_OPTIONS_API__ !== "boolean") {
needWarn.push(`__VUE_OPTIONS_API__`);
getGlobalThis().__VUE_OPTIONS_API__ = true;
}
if (typeof __VUE_PROD_DEVTOOLS__ !== "boolean") {
needWarn.push(`__VUE_PROD_DEVTOOLS__`);
getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;
}
if (needWarn.length) {
const multi = needWarn.length > 1;
console.warn(`Feature flag${multi ? `s` : ``} ${needWarn.join(", ")} ${multi ? `are` : `is`} not explicitly defined. You are running the esm-bundler build of Vue, which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.
For more details, see https://link.vuejs.org/feature-flags.`);
}
}
var queuePostRenderEffect = queueEffectWithSuspense;
function createRenderer(options) {
return baseCreateRenderer(options);
}
function createHydrationRenderer(options) {
return baseCreateRenderer(options, createHydrationFunctions);
}
function baseCreateRenderer(options, createHydrationFns) {
{
initFeatureFlags();
}
const target = getGlobalThis();
target.__VUE__ = true;
if (true) {
setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
}
const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, insertStaticContent: hostInsertStaticContent } = options;
const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = isHmrUpdating ? false : !!n2.dynamicChildren) => {
if (n1 === n2) {
return;
}
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
}
if (n2.patchFlag === -2) {
optimized = false;
n2.dynamicChildren = null;
}
const { type, ref: ref2, shapeFlag } = n2;
switch (type) {
case Text:
processText(n1, n2, container, anchor);
break;
case Comment:
processCommentNode(n1, n2, container, anchor);
break;
case Static:
if (n1 == null) {
mountStaticNode(n2, container, anchor, isSVG);
} else if (true) {
patchStaticNode(n1, n2, container, isSVG);
}
break;
case Fragment:
processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
break;
default:
if (shapeFlag & 1) {
processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
} else if (shapeFlag & 6) {
processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
} else if (shapeFlag & 64) {
type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);
} else if (shapeFlag & 128) {
type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);
} else if (true) {
warn2("Invalid VNode type:", type, `(${typeof type})`);
}
}
if (ref2 != null && parentComponent) {
setRef(ref2, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
}
};
const processText = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(n2.el = hostCreateText(n2.children), container, anchor);
} else {
const el = n2.el = n1.el;
if (n2.children !== n1.children) {
hostSetText(el, n2.children);
}
}
};
const processCommentNode = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(n2.el = hostCreateComment(n2.children || ""), container, anchor);
} else {
n2.el = n1.el;
}
};
const mountStaticNode = (n2, container, anchor, isSVG) => {
[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG, n2.el, n2.anchor);
};
const patchStaticNode = (n1, n2, container, isSVG) => {
if (n2.children !== n1.children) {
const anchor = hostNextSibling(n1.anchor);
removeStaticNode(n1);
[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);
} else {
n2.el = n1.el;
n2.anchor = n1.anchor;
}
};
const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostInsert(el, container, nextSibling);
el = next;
}
hostInsert(anchor, container, nextSibling);
};
const removeStaticNode = ({ el, anchor }) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostRemove(el);
el = next;
}
hostRemove(anchor);
};
const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
isSVG = isSVG || n2.type === "svg";
if (n1 == null) {
mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
} else {
patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
}
};
const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
let el;
let vnodeHook;
const { type, props, shapeFlag, transition, dirs } = vnode;
el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is, props);
if (shapeFlag & 8) {
hostSetElementText(el, vnode.children);
} else if (shapeFlag & 16) {
mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== "foreignObject", slotScopeIds, optimized);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
if (props) {
for (const key in props) {
if (key !== "value" && !isReservedProp(key)) {
hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
if ("value" in props) {
hostPatchProp(el, "value", null, props.value);
}
if (vnodeHook = props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
}
if (true) {
Object.defineProperty(el, "__vnode", {
value: vnode,
enumerable: false
});
Object.defineProperty(el, "__vueParentComponent", {
value: parentComponent,
enumerable: false
});
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
const needCallTransitionHooks = (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
if (needCallTransitionHooks) {
transition.beforeEnter(el);
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
};
const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
if (scopeId) {
hostSetScopeId(el, scopeId);
}
if (slotScopeIds) {
for (let i = 0; i < slotScopeIds.length; i++) {
hostSetScopeId(el, slotScopeIds[i]);
}
}
if (parentComponent) {
let subTree = parentComponent.subTree;
if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
subTree = filterSingleRoot(subTree.children) || subTree;
}
if (vnode === subTree) {
const parentVNode = parentComponent.vnode;
setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent);
}
}
};
const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => {
for (let i = start; i < children.length; i++) {
const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
}
};
const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
const el = n2.el = n1.el;
let { patchFlag, dynamicChildren, dirs } = n2;
patchFlag |= n1.patchFlag & 16;
const oldProps = n1.props || EMPTY_OBJ;
const newProps = n2.props || EMPTY_OBJ;
let vnodeHook;
parentComponent && toggleRecurse(parentComponent, false);
if (vnodeHook = newProps.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
}
parentComponent && toggleRecurse(parentComponent, true);
if (isHmrUpdating) {
patchFlag = 0;
optimized = false;
dynamicChildren = null;
}
const areChildrenSVG = isSVG && n2.type !== "foreignObject";
if (dynamicChildren) {
patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds);
if (parentComponent && parentComponent.type.__hmrId) {
traverseStaticChildren(n1, n2);
}
} else if (!optimized) {
patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG, slotScopeIds, false);
}
if (patchFlag > 0) {
if (patchFlag & 16) {
patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
} else {
if (patchFlag & 2) {
if (oldProps.class !== newProps.class) {
hostPatchProp(el, "class", null, newProps.class, isSVG);
}
}
if (patchFlag & 4) {
hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);
}
if (patchFlag & 8) {
const propsToUpdate = n2.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
const prev = oldProps[key];
const next = newProps[key];
if (next !== prev || key === "value") {
hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);
}
}
}
}
if (patchFlag & 1) {
if (n1.children !== n2.children) {
hostSetElementText(el, n2.children);
}
}
} else if (!optimized && dynamicChildren == null) {
patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
}
if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
}, parentSuspense);
}
};
const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {
for (let i = 0; i < newChildren.length; i++) {
const oldVNode = oldChildren[i];
const newVNode = newChildren[i];
const container = (
// oldVNode may be an errored async setup() component inside Suspense
// which will not have a mounted element
oldVNode.el && (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
// which also requires the correct parent container
!isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
// In other cases, the parent container is not actually used so we
// just pass the block element here to avoid a DOM parentNode call.
fallbackContainer
)
);
patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, slotScopeIds, true);
}
};
const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
if (oldProps !== newProps) {
if (oldProps !== EMPTY_OBJ) {
for (const key in oldProps) {
if (!isReservedProp(key) && !(key in newProps)) {
hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
}
for (const key in newProps) {
if (isReservedProp(key))
continue;
const next = newProps[key];
const prev = oldProps[key];
if (next !== prev && key !== "value") {
hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
if ("value" in newProps) {
hostPatchProp(el, "value", oldProps.value, newProps.value);
}
}
};
const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
if (isHmrUpdating || patchFlag & 2048) {
patchFlag = 0;
optimized = false;
dynamicChildren = null;
}
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
} else {
if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
// of renderSlot() with no valid children
n1.dynamicChildren) {
patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG, slotScopeIds);
if (parentComponent && parentComponent.type.__hmrId) {
traverseStaticChildren(n1, n2);
} else if (// #2080 if the stable fragment has a key, it's a <template v-for> that may
// get moved around. Make sure all root level vnodes inherit el.
// #2134 or if it's a component root, it may also get moved around
// as the component is being moved.
n2.key != null || parentComponent && n2 === parentComponent.subTree) {
traverseStaticChildren(
n1,
n2,
true
/* shallow */
);
}
} else {
patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
}
}
};
const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
n2.slotScopeIds = slotScopeIds;
if (n1 == null) {
if (n2.shapeFlag & 512) {
parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);
} else {
mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
} else {
updateComponent(n1, n2, optimized);
}
};
const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
const instance = initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense);
if (instance.type.__hmrId) {
registerHMR(instance);
}
if (true) {
pushWarningContext(initialVNode);
startMeasure(instance, `mount`);
}
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
}
{
if (true) {
startMeasure(instance, `init`);
}
setupComponent(instance);
if (true) {
endMeasure(instance, `init`);
}
}
if (instance.asyncDep) {
parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
if (!initialVNode.el) {
const placeholder = instance.subTree = createVNode(Comment);
processCommentNode(null, placeholder, container, anchor);
}
return;
}
setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized);
gitextract_8rd8nrrh/
├── .gitattributes
├── .github/
│ └── workflows/
│ └── deploy.yaml
├── .gitignore
├── LICENSE
├── README.md
├── docs/
│ ├── docs/
│ │ ├── .vitepress/
│ │ │ ├── cache/
│ │ │ │ └── deps/
│ │ │ │ ├── _metadata.json
│ │ │ │ ├── package.json
│ │ │ │ └── vue.js
│ │ │ ├── config.js
│ │ │ └── theme/
│ │ │ ├── adsense.vue
│ │ │ ├── index.css
│ │ │ └── index.js
│ │ ├── about/
│ │ │ └── about.md
│ │ ├── index.md
│ │ ├── project/
│ │ │ ├── backend/
│ │ │ │ ├── cors-handle.md
│ │ │ │ └── jwt-handle.md
│ │ │ ├── devops/
│ │ │ │ ├── ci-cd.md
│ │ │ │ └── deploy-cloudserver.md
│ │ │ ├── docs/
│ │ │ │ ├── deploy-guide.md
│ │ │ │ ├── detailed-design.md
│ │ │ │ ├── getting-started.md
│ │ │ │ ├── introduction.md
│ │ │ │ ├── problem-feedback.md
│ │ │ │ └── update-log.md
│ │ │ └── frontend/
│ │ │ ├── axios-package.md
│ │ │ ├── env-var-modes.md
│ │ │ └── nprogress.md
│ │ └── sponsor/
│ │ └── sponsor.md
│ └── package.json
├── server/
│ ├── api/
│ │ ├── common.go
│ │ ├── config.go
│ │ ├── contract.go
│ │ ├── customer.go
│ │ ├── dashboard.go
│ │ ├── notice.go
│ │ ├── product.go
│ │ ├── subscribe.go
│ │ └── user.go
│ ├── common/
│ │ ├── alipay.go
│ │ ├── excel.go
│ │ ├── jwt.go
│ │ ├── mail.go
│ │ ├── rand.go
│ │ └── uuid.go
│ ├── config/
│ │ └── config.go
│ ├── config.yaml
│ ├── dao/
│ │ ├── common.go
│ │ ├── config.go
│ │ ├── contract.go
│ │ ├── customer.go
│ │ ├── dashboard.go
│ │ ├── notice.go
│ │ ├── product.go
│ │ ├── subscribe.go
│ │ └── user.go
│ ├── db/
│ │ └── crm.sql
│ ├── global/
│ │ └── global.go
│ ├── go.mod
│ ├── go.sum
│ ├── initialize/
│ │ ├── alipay.go
│ │ ├── gorm.go
│ │ ├── load.go
│ │ ├── redis.go
│ │ ├── router.go
│ │ └── run.go
│ ├── main.go
│ ├── middleware/
│ │ ├── cors.go
│ │ └── jwt.go
│ ├── models/
│ │ ├── common.go
│ │ ├── config.go
│ │ ├── contract.go
│ │ ├── customer.go
│ │ ├── dashboard.go
│ │ ├── notice.go
│ │ ├── product.go
│ │ ├── subscribe.go
│ │ └── user.go
│ ├── response/
│ │ ├── errcode.go
│ │ └── response.go
│ └── service/
│ ├── common.go
│ ├── config.go
│ ├── contract.go
│ ├── customer.go
│ ├── dashboard.go
│ ├── notice.go
│ ├── product.go
│ ├── subscribe.go
│ └── user.go
└── web/
├── index.html
├── package.json
├── src/
│ ├── App.vue
│ ├── api/
│ │ ├── common.js
│ │ ├── config.js
│ │ ├── contract.js
│ │ ├── customer.js
│ │ ├── dashboard.js
│ │ ├── notice.js
│ │ ├── product.js
│ │ ├── subscribe.js
│ │ └── user.js
│ ├── assets/
│ │ └── region.js
│ ├── axios/
│ │ └── index.js
│ ├── components/
│ │ └── Spot.vue
│ ├── main.js
│ ├── router/
│ │ └── index.js
│ ├── store/
│ │ └── index.js
│ └── views/
│ ├── Config.vue
│ ├── Contract.vue
│ ├── Customer.vue
│ ├── Dashboard.vue
│ ├── Error.vue
│ ├── Home.vue
│ ├── Index.vue
│ ├── Login.vue
│ ├── Pass.vue
│ ├── Product.vue
│ ├── Register.vue
│ ├── Result.vue
│ └── Subscribe.vue
└── vite.config.js
SYMBOL INDEX (791 symbols across 65 files)
FILE: docs/docs/.vitepress/cache/deps/vue.js
function makeMap (line 2) | function makeMap(str, expectsLowerCase) {
function normalizeStyle (line 12) | function normalizeStyle(value) {
function parseStringStyle (line 34) | function parseStringStyle(cssText) {
function normalizeClass (line 44) | function normalizeClass(value) {
function normalizeProps (line 64) | function normalizeProps(props) {
function includeBooleanAttr (line 85) | function includeBooleanAttr(value) {
function looseCompareArrays (line 90) | function looseCompareArrays(a, b) {
function looseEqual (line 99) | function looseEqual(a, b) {
function looseIndexOf (line 138) | function looseIndexOf(arr, val) {
function warn (line 246) | function warn(msg, ...args) {
method constructor (line 251) | constructor(detached = false) {
method active (line 261) | get active() {
method run (line 264) | run(fn) {
method on (line 281) | on() {
method off (line 288) | off() {
method stop (line 291) | stop(fromParent) {
function effectScope (line 317) | function effectScope(detached) {
function recordEffectScope (line 320) | function recordEffectScope(effect2, scope = activeEffectScope) {
function getCurrentScope (line 325) | function getCurrentScope() {
function onScopeDispose (line 328) | function onScopeDispose(fn) {
method constructor (line 375) | constructor(fn, scheduler = null, scope) {
method run (line 383) | run() {
method stop (line 419) | stop() {
function cleanupEffect (line 431) | function cleanupEffect(effect2) {
function effect (line 440) | function effect(fn, options) {
function stop (line 457) | function stop(runner) {
function pauseTracking (line 462) | function pauseTracking() {
function resetTracking (line 466) | function resetTracking() {
function track (line 470) | function track(target, type, key) {
function trackEffects (line 484) | function trackEffects(dep, debuggerEventExtraInfo) {
function trigger (line 502) | function trigger(target, type, key, newValue, oldValue, oldTarget) {
function triggerEffects (line 570) | function triggerEffects(dep, debuggerEventExtraInfo) {
function triggerEffect (line 583) | function triggerEffect(effect2, debuggerEventExtraInfo) {
function getDepFromReactive (line 595) | function getDepFromReactive(object, key) {
function createArrayInstrumentations (line 608) | function createArrayInstrumentations() {
function hasOwnProperty2 (line 634) | function hasOwnProperty2(key) {
function createGetter (line 639) | function createGetter(isReadonly2 = false, shallow = false) {
function createSetter (line 680) | function createSetter(shallow = false) {
function deleteProperty (line 708) | function deleteProperty(target, key) {
function has$1 (line 717) | function has$1(target, key) {
function ownKeys (line 724) | function ownKeys(target) {
method set (line 737) | set(target, key) {
method deleteProperty (line 743) | deleteProperty(target, key) {
function get (line 759) | function get(target, key, isReadonly2 = false, isShallow3 = false) {
function has (line 782) | function has(key, isReadonly2 = false) {
function size (line 797) | function size(target, isReadonly2 = false) {
function add (line 805) | function add(value) {
function set (line 816) | function set(key, value) {
function deleteEntry (line 836) | function deleteEntry(key) {
function clear (line 853) | function clear() {
function createForEach (line 863) | function createForEach(isReadonly2, isShallow3) {
function createIterableMethod (line 878) | function createIterableMethod(method, isReadonly2, isShallow3) {
function createReadonlyMethod (line 907) | function createReadonlyMethod(type) {
function createInstrumentations (line 916) | function createInstrumentations() {
function createInstrumentationGetter (line 1016) | function createInstrumentationGetter(isReadonly2, shallow) {
function checkIdentityKeys (line 1041) | function checkIdentityKeys(target, has2, key) {
function targetTypeMap (line 1052) | function targetTypeMap(rawType) {
function getTargetType (line 1066) | function getTargetType(value) {
function reactive (line 1072) | function reactive(target) {
function shallowReactive (line 1078) | function shallowReactive(target) {
function readonly (line 1081) | function readonly(target) {
function shallowReadonly (line 1084) | function shallowReadonly(target) {
function createReactiveObject (line 1087) | function createReactiveObject(target, isReadonly2, baseHandlers, collect...
function isReactive (line 1115) | function isReactive(value) {
function isReadonly (line 1127) | function isReadonly(value) {
function isShallow (line 1133) | function isShallow(value) {
function isProxy (line 1139) | function isProxy(value) {
function toRaw (line 1142) | function toRaw(observed) {
function markRaw (line 1149) | function markRaw(value) {
function trackRefValue (line 1155) | function trackRefValue(ref2) {
function triggerRefValue (line 1169) | function triggerRefValue(ref2, newVal) {
function isRef (line 1185) | function isRef(r) {
function ref (line 1188) | function ref(value) {
function shallowRef (line 1191) | function shallowRef(value) {
function createRef (line 1194) | function createRef(rawValue, shallow) {
method constructor (line 1201) | constructor(value, __v_isShallow) {
method value (line 1208) | get value() {
method value (line 1212) | set value(newVal) {
function triggerRef (line 1222) | function triggerRef(ref2) {
function unref (line 1225) | function unref(ref2) {
function proxyRefs (line 1240) | function proxyRefs(objectWithRefs) {
method constructor (line 1244) | constructor(factory) {
method value (line 1251) | get value() {
method value (line 1254) | set value(newVal) {
function customRef (line 1258) | function customRef(factory) {
function toRefs (line 1261) | function toRefs(object) {
method constructor (line 1272) | constructor(_object, _key, _defaultValue) {
method value (line 1278) | get value() {
method value (line 1282) | set value(newVal) {
method dep (line 1285) | get dep() {
function toRef (line 1289) | function toRef(object, key, defaultValue) {
method constructor (line 1295) | constructor(getter, _setter, isReadonly2, isSSR) {
method value (line 1314) | get value() {
method value (line 1323) | set value(newValue) {
function computed (line 1328) | function computed(getterOrOptions, debugOptions, isSSR = false) {
function pushWarningContext (line 1354) | function pushWarningContext(vnode) {
function popWarningContext (line 1357) | function popWarningContext() {
function warn2 (line 1360) | function warn2(msg, ...args) {
function getComponentTrace (line 1385) | function getComponentTrace() {
function formatTrace (line 1406) | function formatTrace(trace) {
function formatTraceEntry (line 1414) | function formatTraceEntry({ vnode, recurseCount }) {
function formatProps (line 1421) | function formatProps(props) {
function formatProp (line 1432) | function formatProp(key, value, raw) {
function assertNumber (line 1448) | function assertNumber(val, type) {
function callWithErrorHandling (line 1577) | function callWithErrorHandling(fn, instance, type, args) {
function callWithAsyncErrorHandling (line 1586) | function callWithAsyncErrorHandling(fn, instance, type, args) {
function handleError (line 1602) | function handleError(err, instance, type, throwInDev = true) {
function logError (line 1627) | function logError(err, type, contextVNode, throwInDev = true) {
function nextTick (line 1656) | function nextTick(fn) {
function findInsertionIndex (line 1660) | function findInsertionIndex(id) {
function queueJob (line 1670) | function queueJob(job) {
function queueFlush (line 1680) | function queueFlush() {
function invalidateJob (line 1686) | function invalidateJob(job) {
function queuePostFlushCb (line 1692) | function queuePostFlushCb(cb) {
function flushPreFlushCbs (line 1702) | function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
function flushPostFlushCbs (line 1718) | function flushPostFlushCbs(seen) {
function flushJobs (line 1752) | function flushJobs(seen) {
function checkRecursiveUpdates (line 1786) | function checkRecursiveUpdates(seen, fn) {
function registerHMR (line 1811) | function registerHMR(instance) {
function unregisterHMR (line 1820) | function unregisterHMR(instance) {
function createRecord (line 1823) | function createRecord(id, initialDef) {
function normalizeClassComponent (line 1833) | function normalizeClassComponent(component) {
function rerender (line 1836) | function rerender(id, newRender) {
function reload (line 1853) | function reload(id, newComp) {
function updateComponentDef (line 1889) | function updateComponentDef(oldComp, newComp) {
function tryWrap (line 1897) | function tryWrap(fn) {
function emit$1 (line 1910) | function emit$1(event, ...args) {
function setDevtoolsHook (line 1917) | function setDevtoolsHook(hook, target) {
function devtoolsInitApp (line 1946) | function devtoolsInitApp(app, version2) {
function devtoolsUnmountApp (line 1954) | function devtoolsUnmountApp(app) {
function createDevtoolsComponentHook (line 1975) | function createDevtoolsComponentHook(hook) {
function createDevtoolsPerformanceHook (line 1988) | function createDevtoolsPerformanceHook(hook) {
function devtoolsComponentEmit (line 1993) | function devtoolsComponentEmit(component, event, params) {
function emit (line 1996) | function emit(instance, event, ...rawArgs) {
function normalizeEmitsOptions (line 2060) | function normalizeEmitsOptions(comp, appContext, asMixin = false) {
function isEmitListener (line 2103) | function isEmitListener(options, key) {
function setCurrentRenderingInstance (line 2112) | function setCurrentRenderingInstance(instance) {
function pushScopeId (line 2118) | function pushScopeId(id) {
function popScopeId (line 2121) | function popScopeId() {
function withCtx (line 2125) | function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
function markAttrsAccessed (line 2156) | function markAttrsAccessed() {
function renderComponentRoot (line 2159) | function renderComponentRoot(instance) {
function filterSingleRoot (line 2280) | function filterSingleRoot(children) {
function shouldUpdateComponent (line 2319) | function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
function hasPropsChanged (line 2366) | function hasPropsChanged(prevProps, nextProps, emitsOptions) {
function updateHOCHostEl (line 2379) | function updateHOCHostEl({ vnode, parent }, el) {
method process (line 2393) | process(n1, n2, container, anchor, parentComponent, parentSuspense, isSV...
function triggerEvent (line 2405) | function triggerEvent(vnode, name) {
function mountSuspense (line 2411) | function mountSuspense(vnode, container, anchor, parentComponent, parent...
function patchSuspense (line 2435) | function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG...
function createSuspenseBoundary (line 2530) | function createSuspenseBoundary(vnode, parent, parentComponent, containe...
function hydrateSuspense (line 2732) | function hydrateSuspense(node, vnode, parentComponent, parentSuspense, i...
function normalizeSuspenseChildren (line 2753) | function normalizeSuspenseChildren(vnode) {
function normalizeSuspenseSlot (line 2759) | function normalizeSuspenseSlot(s) {
function queueEffectWithSuspense (line 2787) | function queueEffectWithSuspense(fn, suspense) {
function setActiveBranch (line 2798) | function setActiveBranch(suspense, branch) {
function provide (line 2807) | function provide(key, value) {
function inject (line 2821) | function inject(key, defaultValue, treatDefaultAsFactory = false) {
function watchEffect (line 2836) | function watchEffect(effect2, options) {
function watchPostEffect (line 2839) | function watchPostEffect(effect2, options) {
function watchSyncEffect (line 2842) | function watchSyncEffect(effect2, options) {
function watch (line 2846) | function watch(source, cb, options) {
function doWatch (line 2852) | function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigge...
function instanceWatch (line 3011) | function instanceWatch(source, value, options) {
function createPathGetter (line 3031) | function createPathGetter(ctx, path) {
function traverse (line 3041) | function traverse(value, seen) {
function useTransitionState (line 3070) | function useTransitionState() {
method setup (line 3108) | setup(props, { slots }) {
function getLeavingNodesForType (line 3190) | function getLeavingNodesForType(state, vnode) {
function resolveTransitionHooks (line 3199) | function resolveTransitionHooks(vnode, props, state, instance) {
function emptyPlaceholder (line 3315) | function emptyPlaceholder(vnode) {
function getKeepAliveChild (line 3322) | function getKeepAliveChild(vnode) {
function setTransitionHooks (line 3325) | function setTransitionHooks(vnode, hooks) {
function getTransitionRawChildren (line 3335) | function getTransitionRawChildren(children, keepComment = false, parentK...
function defineComponent (line 3356) | function defineComponent(options) {
function defineAsyncComponent (line 3360) | function defineAsyncComponent(source) {
function createInnerComp (line 3483) | function createInnerComp(comp, parent) {
method setup (line 3503) | setup(props, { slots }) {
function matches (line 3664) | function matches(pattern, name) {
function onActivated (line 3674) | function onActivated(hook, target) {
function onDeactivated (line 3677) | function onDeactivated(hook, target) {
function registerKeepAliveHook (line 3680) | function registerKeepAliveHook(hook, type, target = currentInstance) {
function injectToKeepAliveRoot (line 3702) | function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
function resetShapeFlag (line 3714) | function resetShapeFlag(vnode) {
function getInnerChild (line 3718) | function getInnerChild(vnode) {
function injectHook (line 3721) | function injectHook(type, hook, target = currentInstance, prepend = fals...
function onErrorCaptured (line 3783) | function onErrorCaptured(hook, target = currentInstance) {
function validateDirectiveName (line 3786) | function validateDirectiveName(name) {
function withDirectives (line 3791) | function withDirectives(vnode, directives) {
function invokeDirectiveHook (line 3823) | function invokeDirectiveHook(vnode, prevVNode, instance, name) {
function resolveComponent (line 3846) | function resolveComponent(name, maybeSelfReference) {
function resolveDynamicComponent (line 3850) | function resolveDynamicComponent(component) {
function resolveDirective (line 3857) | function resolveDirective(name) {
function resolveAsset (line 3860) | function resolveAsset(type, name, warnMissing = true, maybeSelfReference...
function resolve (line 3893) | function resolve(registry, name) {
function renderList (line 3896) | function renderList(source, renderItem, cache, index) {
function createSlots (line 3931) | function createSlots(slots, dynamicSlots) {
function renderSlot (line 3949) | function renderSlot(slots, name, props = {}, fallback, noSlotted) {
function ensureValidVNode (line 3982) | function ensureValidVNode(vnodes) {
function toHandlers (line 3993) | function toHandlers(obj, preserveCaseIfNecessary) {
method get (line 4034) | get({ _: instance }, key) {
method set (line 4096) | set({ _: instance }, key, value) {
method has (line 4127) | has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions ...
method defineProperty (line 4131) | defineProperty(target, key, descriptor) {
method get (line 4147) | get(target, key) {
method has (line 4153) | has(_, key) {
function createDevRenderContext (line 4161) | function createDevRenderContext(instance) {
function exposePropsOnRenderContext (line 4180) | function exposePropsOnRenderContext(instance) {
function exposeSetupStateOnRenderContext (line 4193) | function exposeSetupStateOnRenderContext(instance) {
function createDuplicateChecker (line 4210) | function createDuplicateChecker() {
function applyOptions (line 4221) | function applyOptions(instance) {
function resolveInjections (line 4416) | function resolveInjections(injectOptions, ctx, checkDuplicateProperties ...
function callHook (line 4459) | function callHook(hook, instance, type) {
function createWatcher (line 4462) | function createWatcher(raw, ctx, publicThis, key) {
function resolveMergedOptions (line 4488) | function resolveMergedOptions(instance) {
function mergeOptions (line 4512) | function mergeOptions(to, from, strats, asMixin = false) {
function mergeDataFn (line 4561) | function mergeDataFn(to, from) {
function mergeInject (line 4572) | function mergeInject(to, from) {
function normalizeInject (line 4575) | function normalizeInject(raw) {
function mergeAsArray (line 4585) | function mergeAsArray(to, from) {
function mergeObjectOptions (line 4588) | function mergeObjectOptions(to, from) {
function mergeWatchOptions (line 4591) | function mergeWatchOptions(to, from) {
function initProps (line 4602) | function initProps(instance, rawProps, isStateful, isSSR = false) {
function isInHmrContext (line 4627) | function isInHmrContext(instance) {
function updateProps (line 4634) | function updateProps(instance, rawProps, rawPrevProps, optimized) {
function setFullProps (line 4718) | function setFullProps(instance, rawProps, props, attrs) {
function resolvePropValue (line 4753) | function resolvePropValue(options, props, key, value, instance, isAbsent) {
function normalizePropsOptions (line 4788) | function normalizePropsOptions(comp, appContext, asMixin = false) {
function validatePropName (line 4865) | function validatePropName(key) {
function getType (line 4873) | function getType(ctor) {
function isSameType (line 4877) | function isSameType(a, b) {
function getTypeIndex (line 4880) | function getTypeIndex(type, expectedTypes) {
function validateProps (line 4888) | function validateProps(rawProps, props, instance) {
function validateProp (line 4898) | function validateProp(name, value, prop, isAbsent) {
function assertType (line 4926) | function assertType(value, type) {
function getInvalidTypeMessage (line 4949) | function getInvalidTypeMessage(name, value, expectedTypes) {
function styleValue (line 4964) | function styleValue(value, type) {
function isExplicable (line 4973) | function isExplicable(type) {
function isBoolean (line 4977) | function isBoolean(...args) {
function createAppContext (line 5070) | function createAppContext() {
function createAppAPI (line 5092) | function createAppAPI(render2, hydrate2) {
function setRef (line 5226) | function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = fa...
function createHydrationFunctions (line 5308) | function createHydrationFunctions(rendererInternals) {
function startMeasure (line 5575) | function startMeasure(instance, type) {
function endMeasure (line 5583) | function endMeasure(instance, type) {
function isSupported (line 5596) | function isSupported() {
function initFeatureFlags (line 5608) | function initFeatureFlags() {
function createRenderer (line 5626) | function createRenderer(options) {
function createHydrationRenderer (line 5629) | function createHydrationRenderer(options) {
function baseCreateRenderer (line 5632) | function baseCreateRenderer(options, createHydrationFns) {
function toggleRecurse (line 6600) | function toggleRecurse({ effect: effect2, update }, allowed) {
function traverseStaticChildren (line 6603) | function traverseStaticChildren(n1, n2, shallow = false) {
function getSequence (line 6627) | function getSequence(arr) {
method process (line 6692) | process(n1, n2, container, anchor, parentComponent, parentSuspense, isSV...
method remove (line 6778) | remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount,...
function moveTeleport (line 6796) | function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m...
function hydrateTeleport (line 6822) | function hydrateTeleport(node, vnode, parentComponent, parentSuspense, s...
function updateCssVars (line 6849) | function updateCssVars(vnode) {
function openBlock (line 6867) | function openBlock(disableTracking = false) {
function closeBlock (line 6870) | function closeBlock() {
function setBlockTracking (line 6875) | function setBlockTracking(value) {
function setupBlock (line 6878) | function setupBlock(vnode) {
function createElementBlock (line 6886) | function createElementBlock(type, props, children, patchFlag, dynamicPro...
function createBlock (line 6898) | function createBlock(type, props, children, patchFlag, dynamicProps) {
function isVNode (line 6909) | function isVNode(value) {
function isSameVNodeType (line 6912) | function isSameVNodeType(n1, n2) {
function transformVNodeArgs (line 6921) | function transformVNodeArgs(transformer) {
function createBaseVNode (line 6932) | function createBaseVNode(type, props = null, children = null, patchFlag ...
function _createVNode (line 6982) | function _createVNode(type, props = null, children = null, patchFlag = 0...
function guardReactiveProps (line 7033) | function guardReactiveProps(props) {
function cloneVNode (line 7038) | function cloneVNode(vnode, extraProps, mergeRef = false) {
function deepCloneVNode (line 7085) | function deepCloneVNode(vnode) {
function createTextVNode (line 7092) | function createTextVNode(text = " ", flag = 0) {
function createStaticVNode (line 7095) | function createStaticVNode(content, numberOfNodes) {
function createCommentVNode (line 7100) | function createCommentVNode(text = "", asBlock = false) {
function normalizeVNode (line 7103) | function normalizeVNode(child) {
function cloneIfMounted (line 7119) | function cloneIfMounted(child) {
function normalizeChildren (line 7122) | function normalizeChildren(vnode, children) {
function mergeProps (line 7167) | function mergeProps(...args) {
function invokeVNodeHook (line 7191) | function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
function createComponentInstance (line 7199) | function createComponentInstance(vnode, parent, suspense) {
function validateComponentName (line 7295) | function validateComponentName(name, config) {
function isStatefulComponent (line 7301) | function isStatefulComponent(instance) {
function setupComponent (line 7305) | function setupComponent(instance, isSSR = false) {
function setupStatefulComponent (line 7315) | function setupStatefulComponent(instance, isSSR) {
function handleSetupResult (line 7378) | function handleSetupResult(instance, setupResult, isSSR) {
function registerRuntimeCompiler (line 7403) | function registerRuntimeCompiler(_compile) {
function finishComponentSetup (line 7412) | function finishComponentSetup(instance, isSSR, skipOptions) {
function createAttrsProxy (line 7456) | function createAttrsProxy(instance) {
function createSetupContext (line 7478) | function createSetupContext(instance) {
function getExposeProxy (line 7525) | function getExposeProxy(instance) {
function getComponentName (line 7543) | function getComponentName(Component, includeInferred = true) {
function formatComponentName (line 7546) | function formatComponentName(instance, Component, isRoot = false) {
function isClassComponent (line 7566) | function isClassComponent(value) {
function defineProps (line 7573) | function defineProps() {
function defineEmits (line 7579) | function defineEmits() {
function defineExpose (line 7585) | function defineExpose(exposed) {
function withDefaults (line 7590) | function withDefaults(props, defaults) {
function useSlots (line 7596) | function useSlots() {
function useAttrs (line 7599) | function useAttrs() {
function getContext (line 7602) | function getContext() {
function mergeDefaults (line 7609) | function mergeDefaults(raw, defaults) {
function createPropsRestProxy (line 7627) | function createPropsRestProxy(props, excludedKeys) {
function withAsyncContext (line 7639) | function withAsyncContext(getAwaitable) {
function h (line 7654) | function h(type, propsOrChildren, children) {
function isShallow2 (line 7684) | function isShallow2(value) {
function initCustomFormatter (line 7690) | function initCustomFormatter() {
function withMemo (line 7865) | function withMemo(memo, render2, cache, index) {
function isMemoSame (line 7874) | function isMemoSame(cached, memo) {
method setScopeId (line 7934) | setScopeId(el, id) {
method insertStaticContent (line 7941) | insertStaticContent(content, parent, anchor, isSVG, start, end) {
function patchClass (line 7969) | function patchClass(el, value, isSVG) {
function patchStyle (line 7982) | function patchStyle(el, prev, next) {
function setStyle (line 8012) | function setStyle(style, name, val) {
function autoPrefix (line 8037) | function autoPrefix(style, rawName) {
function patchAttr (line 8056) | function patchAttr(el, key, value, isSVG, instance) {
function patchDOMProp (line 8072) | function patchDOMProp(el, key, value, prevChildren, parentComponent, par...
function addEventListener (line 8117) | function addEventListener(el, event, handler, options) {
function removeEventListener (line 8120) | function removeEventListener(el, event, handler, options) {
function patchEvent (line 8123) | function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
function parseName (line 8140) | function parseName(name) {
function createInvoker (line 8156) | function createInvoker(initialValue, instance) {
function patchStopImmediatePropagation (line 8169) | function patchStopImmediatePropagation(e, value) {
function shouldSetAsProp (line 8202) | function shouldSetAsProp(el, key, value, isSVG) {
function defineCustomElement (line 8229) | function defineCustomElement(options, hydrate2) {
method constructor (line 8245) | constructor(_def, _props = {}, hydrate2) {
method connectedCallback (line 8265) | connectedCallback() {
method disconnectedCallback (line 8275) | disconnectedCallback() {
method _resolveDef (line 8287) | _resolveDef() {
method _resolveProps (line 8325) | _resolveProps(def2) {
method _setAttr (line 8344) | _setAttr(key) {
method _getProp (line 8355) | _getProp(key) {
method _setProp (line 8361) | _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
method _update (line 8378) | _update() {
method _createVNode (line 8381) | _createVNode() {
method _applyStyles (line 8421) | _applyStyles(styles) {
function useCssModule (line 8434) | function useCssModule(name = "$style") {
function useCssVars (line 8454) | function useCssVars(getter) {
function setVarsOnVNode (line 8475) | function setVarsOnVNode(vnode, vars) {
function setVarsOnNode (line 8502) | function setVarsOnNode(el, vars) {
function resolveTransitionProps (line 8543) | function resolveTransitionProps(rawProps) {
function normalizeDuration (line 8629) | function normalizeDuration(duration) {
function NumberOf (line 8639) | function NumberOf(val) {
function addTransitionClass (line 8646) | function addTransitionClass(el, cls) {
function removeTransitionClass (line 8650) | function removeTransitionClass(el, cls) {
function nextFrame (line 8660) | function nextFrame(cb) {
function whenTransitionEnds (line 8666) | function whenTransitionEnds(el, expectedType, explicitTimeout, resolve2) {
function getTransitionInfo (line 8698) | function getTransitionInfo(el, expectedType) {
function getTimeout (line 8735) | function getTimeout(delays, durations) {
function toMs (line 8741) | function toMs(s) {
function forceReflow (line 8744) | function forceReflow() {
method setup (line 8755) | setup(props, { slots }) {
function callPendingCbs (line 8818) | function callPendingCbs(c) {
function recordPosition (line 8827) | function recordPosition(c) {
function applyTranslation (line 8830) | function applyTranslation(c) {
function hasCSSTransform (line 8842) | function hasCSSTransform(el, root, moveClass) {
function onCompositionStart (line 8861) | function onCompositionStart(e) {
function onCompositionEnd (line 8864) | function onCompositionEnd(e) {
method created (line 8872) | created(el, { modifiers: { lazy, trim, number } }, vnode) {
method mounted (line 8899) | mounted(el, { value }) {
method beforeUpdate (line 8902) | beforeUpdate(el, { value, modifiers: { lazy, trim, number } }, vnode) {
method created (line 8926) | created(el, _, vnode) {
method beforeUpdate (line 8958) | beforeUpdate(el, binding, vnode) {
function setChecked (line 8963) | function setChecked(el, { value, oldValue }, vnode) {
method created (line 8974) | created(el, { value }, vnode) {
method beforeUpdate (line 8981) | beforeUpdate(el, { value, oldValue }, vnode) {
method created (line 8991) | created(el, { value, modifiers: { number } }, vnode) {
method mounted (line 9001) | mounted(el, { value }) {
method beforeUpdate (line 9004) | beforeUpdate(el, _binding, vnode) {
method updated (line 9007) | updated(el, { value }) {
function setSelected (line 9011) | function setSelected(el, value) {
function getValue (line 9038) | function getValue(el) {
function getCheckboxValue (line 9041) | function getCheckboxValue(el, checked) {
method created (line 9046) | created(el, binding, vnode) {
method mounted (line 9049) | mounted(el, binding, vnode) {
method beforeUpdate (line 9052) | beforeUpdate(el, binding, vnode, prevVNode) {
method updated (line 9055) | updated(el, binding, vnode, prevVNode) {
function resolveDynamicModel (line 9059) | function resolveDynamicModel(tagName, type) {
function callModelHook (line 9076) | function callModelHook(el, binding, vnode, prevVNode, hook) {
function initVModelForSSR (line 9081) | function initVModelForSSR() {
method beforeMount (line 9160) | beforeMount(el, { value }, { transition }) {
method mounted (line 9168) | mounted(el, { value }, { transition }) {
method updated (line 9173) | updated(el, { value, oldValue }, { transition }) {
method beforeUnmount (line 9190) | beforeUnmount(el, { value }) {
function setDisplay (line 9194) | function setDisplay(el, value) {
function initVShowForSSR (line 9197) | function initVShowForSSR() {
function ensureRenderer (line 9207) | function ensureRenderer() {
function ensureHydrationRenderer (line 9210) | function ensureHydrationRenderer() {
function injectNativeTagCheck (line 9261) | function injectNativeTagCheck(app) {
function injectCompilerOptionsCheck (line 9267) | function injectCompilerOptionsCheck(app) {
function normalizeContainer (line 9294) | function normalizeContainer(container) {
function initDev (line 9317) | function initDev() {
FILE: server/api/common.go
type CommonApi (line 12) | type CommonApi struct
method InitDatabase (line 23) | func (c *CommonApi) InitDatabase(context *gin.Context) {
method FileUpload (line 29) | func (c *CommonApi) FileUpload(context *gin.Context) {
method FileRemove (line 36) | func (c *CommonApi) FileRemove(context *gin.Context) {
function NewCommonApi (line 16) | func NewCommonApi() *CommonApi {
FILE: server/api/config.go
type MailConfigApi (line 13) | type MailConfigApi struct
method Save (line 24) | func (m *MailConfigApi) Save(context *gin.Context) {
method Delete (line 44) | func (m *MailConfigApi) Delete(context *gin.Context) {
method UpdateStatus (line 56) | func (m *MailConfigApi) UpdateStatus(context *gin.Context) {
method GetInfo (line 71) | func (m *MailConfigApi) GetInfo(context *gin.Context) {
method Check (line 82) | func (m *MailConfigApi) Check(context *gin.Context) {
function NewMailConfigApi (line 17) | func NewMailConfigApi() *MailConfigApi {
FILE: server/api/contract.go
type ContractApi (line 12) | type ContractApi struct
method Create (line 24) | func (c *ContractApi) Create(context *gin.Context) {
method Update (line 38) | func (c *ContractApi) Update(context *gin.Context) {
method Delete (line 49) | func (c *ContractApi) Delete(context *gin.Context) {
method GetList (line 60) | func (c *ContractApi) GetList(context *gin.Context) {
method GetInfo (line 74) | func (c *ContractApi) GetInfo(context *gin.Context) {
method GetProductList (line 85) | func (p *ContractApi) GetProductList(context *gin.Context) {
method Export (line 96) | func (c *ContractApi) Export(context *gin.Context) {
function NewContractApi (line 16) | func NewContractApi() *ContractApi {
FILE: server/api/customer.go
type CustomerApi (line 13) | type CustomerApi struct
method Create (line 25) | func (c *CustomerApi) Create(context *gin.Context) {
method Update (line 39) | func (c *CustomerApi) Update(context *gin.Context) {
method SendMail (line 50) | func (c *CustomerApi) SendMail(context *gin.Context) {
method Delete (line 65) | func (c *CustomerApi) Delete(context *gin.Context) {
method GetList (line 76) | func (c *CustomerApi) GetList(context *gin.Context) {
method GetInfo (line 90) | func (c *CustomerApi) GetInfo(context *gin.Context) {
method GetOption (line 101) | func (c *CustomerApi) GetOption(context *gin.Context) {
method Export (line 112) | func (c *CustomerApi) Export(context *gin.Context) {
function NewCustomerApi (line 17) | func NewCustomerApi() *CustomerApi {
FILE: server/api/dashboard.go
type DashboardApi (line 11) | type DashboardApi struct
method Summary (line 23) | func (d *DashboardApi) Summary(context *gin.Context) {
function NewDashboardApi (line 15) | func NewDashboardApi() *DashboardApi {
FILE: server/api/notice.go
type NoticeApi (line 13) | type NoticeApi struct
method Update (line 24) | func (n *NoticeApi) Update(context *gin.Context) {
method GetUnReadCount (line 35) | func (n *NoticeApi) GetUnReadCount(context *gin.Context) {
method Delete (line 45) | func (n *NoticeApi) Delete(context *gin.Context) {
method GetList (line 55) | func (n *NoticeApi) GetList(context *gin.Context) {
function NewNoticeApi (line 17) | func NewNoticeApi() *NoticeApi {
FILE: server/api/product.go
type ProductApi (line 12) | type ProductApi struct
method Create (line 24) | func (p *ProductApi) Create(context *gin.Context) {
method Update (line 38) | func (p *ProductApi) Update(context *gin.Context) {
method Delete (line 49) | func (p *ProductApi) Delete(context *gin.Context) {
method GetList (line 60) | func (p *ProductApi) GetList(context *gin.Context) {
method GetInfo (line 74) | func (p *ProductApi) GetInfo(context *gin.Context) {
method Export (line 85) | func (p *ProductApi) Export(context *gin.Context) {
function NewProductApi (line 16) | func NewProductApi() *ProductApi {
FILE: server/api/subscribe.go
type SubscribeApi (line 14) | type SubscribeApi struct
method Pay (line 26) | func (s *SubscribeApi) Pay(context *gin.Context) {
method PayBack (line 40) | func (s *SubscribeApi) PayBack(context *gin.Context) {
method GetInfo (line 48) | func (s *SubscribeApi) GetInfo(context *gin.Context) {
function NewSubscribeApi (line 18) | func NewSubscribeApi() *SubscribeApi {
FILE: server/api/user.go
type UserApi (line 13) | type UserApi struct
method Register (line 25) | func (u *UserApi) Register(context *gin.Context) {
method Login (line 37) | func (u *UserApi) Login(context *gin.Context) {
method GetVerifyCode (line 52) | func (u *UserApi) GetVerifyCode(context *gin.Context) {
method ForgotPass (line 63) | func (u *UserApi) ForgotPass(context *gin.Context) {
method Delete (line 74) | func (u *UserApi) Delete(context *gin.Context) {
method GetInfo (line 88) | func (u *UserApi) GetInfo(context *gin.Context) {
function NewUserApi (line 17) | func NewUserApi() *UserApi {
FILE: server/common/alipay.go
type Alipay (line 15) | type Alipay struct
method PagePay (line 22) | func (a *Alipay) PagePay(tradeNo string, totalAmount float64) (string,...
method VerifySign (line 42) | func (a *Alipay) VerifySign(req *http.Request) gopay.BodyMap {
method GenTradeNo (line 57) | func (a *Alipay) GenTradeNo() string {
function GetAlipay (line 18) | func GetAlipay() *Alipay {
FILE: server/common/excel.go
constant letter (line 13) | letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
function GenExcelFile (line 16) | func GenExcelFile[T any](sheet string, columns []string, rowValue []T, f...
FILE: server/common/jwt.go
type Claims (line 10) | type Claims struct
function GenToken (line 16) | func GenToken(uid int64) (string, error) {
function VerifyToken (line 28) | func VerifyToken(tokens string) (int64, error) {
FILE: server/common/mail.go
function SendMail (line 16) | func SendMail(email, content string) error {
function SendMailToCustomer (line 38) | func SendMailToCustomer(mp models.MailParam) error {
function DialMail (line 57) | func DialMail(smtp string, port int, sender, authCode string) error {
FILE: server/common/rand.go
function RandInt (line 8) | func RandInt(min, max int) int {
FILE: server/common/uuid.go
function GenUUID (line 10) | func GenUUID() string {
FILE: server/config/config.go
type Config (line 4) | type Config struct
type Server (line 15) | type Server struct
type Mysql (line 21) | type Mysql struct
type Redis (line 34) | type Redis struct
type Jwt (line 42) | type Jwt struct
type File (line 48) | type File struct
type Mail (line 53) | type Mail struct
type Alipay (line 60) | type Alipay struct
FILE: server/dao/common.go
constant USER (line 19) | USER = "user"
constant CUSTOMER (line 20) | CUSTOMER = "customer"
constant CONTRACT (line 21) | CONTRACT = "contract"
constant PRODUCT (line 22) | PRODUCT = "product"
constant SUBSCRIBE (line 23) | SUBSCRIBE = "subscribe"
constant NOTICE (line 24) | NOTICE = "notice"
constant MAIL_CONFIG (line 25) | MAIL_CONFIG = "mail_config"
constant NumberNull (line 28) | NumberNull = 0
constant StringNull (line 29) | StringNull = ""
constant Dev (line 32) | Dev = "dev"
constant Prod (line 33) | Prod = "prod"
function restPage (line 44) | func restPage(page models.Page, name string, query interface{}, dest int...
type CommonDao (line 53) | type CommonDao struct
method InitDatabase (line 60) | func (c *CommonDao) InitDatabase() error {
method FileUpload (line 85) | func (c *CommonDao) FileUpload(file *multipart.FileHeader) (*models.Fi...
method FileRemove (line 112) | func (c *CommonDao) FileRemove(fileName string) error {
function NewCommonDao (line 56) | func NewCommonDao() *CommonDao {
FILE: server/dao/config.go
constant Closed (line 10) | Closed = 2
type MailConfigDao (line 13) | type MailConfigDao struct
method Save (line 20) | func (m *MailConfigDao) Save(param *models.MailConfigSaveParam) error {
method Delete (line 27) | func (m *MailConfigDao) Delete(param *models.MailConfigDeleteParam) er...
method GetInfo (line 31) | func (m *MailConfigDao) GetInfo(uid int64) (*models.MailConfig, error) {
method UpdateStatus (line 40) | func (m *MailConfigDao) UpdateStatus(param *models.MailConfigStatusPar...
method IsExists (line 52) | func (m *MailConfigDao) IsExists(uid int64) bool {
function NewMailConfigDao (line 16) | func NewMailConfigDao() *MailConfigDao {
function create (line 58) | func create(param *models.MailConfigSaveParam) error {
function update (line 74) | func update(param *models.MailConfigSaveParam) error {
FILE: server/dao/contract.go
type ContractDao (line 9) | type ContractDao struct
method Create (line 16) | func (c *ContractDao) Create(param *models.ContractCreateParam) error {
method Update (line 32) | func (c *ContractDao) Update(param *models.ContractUpdateParam) error {
method Delete (line 49) | func (c *ContractDao) Delete(param *models.ContractDeleteParam) error {
method GetList (line 53) | func (c *ContractDao) GetList(param *models.ContractQueryParam) ([]*mo...
method GetListByUid (line 82) | func (c *ContractDao) GetListByUid(uid int64) ([]*models.ContractList,...
method GetInfo (line 93) | func (c *ContractDao) GetInfo(param *models.ContractQueryParam) (*mode...
method GetAddedPList (line 105) | func (c *ContractDao) GetAddedPList(id int64) (*models.Contract, error) {
function NewContractDao (line 12) | func NewContractDao() *ContractDao {
FILE: server/dao/customer.go
type CustomerDao (line 9) | type CustomerDao struct
method Create (line 16) | func (c *CustomerDao) Create(param *models.CustomerCreateParam) error {
method Update (line 34) | func (c *CustomerDao) Update(param *models.CustomerUpdateParam) error {
method Delete (line 53) | func (c *CustomerDao) Delete(param *models.CustomerDeleteParam) error {
method IsExists (line 57) | func (c *CustomerDao) IsExists(name string, uid int64) bool {
method GetList (line 63) | func (c *CustomerDao) GetList(param *models.CustomerQueryParam) ([]*mo...
method GetInfo (line 80) | func (c *CustomerDao) GetInfo(param *models.CustomerQueryParam) (*mode...
method GetOption (line 92) | func (c *CustomerDao) GetOption(uid int64) ([]*models.CustomerOption, ...
method GetListByUid (line 104) | func (c *CustomerDao) GetListByUid(uid int64) ([]*models.Customer, err...
function NewCustomerDao (line 12) | func NewCustomerDao() *CustomerDao {
FILE: server/dao/dashboard.go
type DashboardDao (line 8) | type DashboardDao struct
method Count (line 15) | func (d *DashboardDao) Count(uid int64, days int) models.DashboardSum {
method AmountSum (line 27) | func (d *DashboardDao) AmountSum(start, end, uid int64) float64 {
function NewDashboardDao (line 11) | func NewDashboardDao() *DashboardDao {
FILE: server/dao/notice.go
constant Read (line 10) | Read = 1
constant UnRead (line 11) | UnRead = 2
type NoticeDao (line 14) | type NoticeDao struct
method Create (line 21) | func (n *NoticeDao) Create(param *models.NoticeCreateParam) error {
method Update (line 31) | func (n *NoticeDao) Update(param *models.NoticeUpdateParam) error {
method GetUnReadCountByUid (line 40) | func (n *NoticeDao) GetUnReadCountByUid(uid int64) (models.UnReadNotic...
method Delete (line 49) | func (n *NoticeDao) Delete(param *models.NoticeDeleteParam) error {
method GetList (line 53) | func (n *NoticeDao) GetList(uid int64) ([]*models.NoticeList, error) {
function NewNoticeDao (line 17) | func NewNoticeDao() *NoticeDao {
FILE: server/dao/product.go
type ProductDao (line 9) | type ProductDao struct
method Create (line 16) | func (p *ProductDao) Create(param *models.ProductCreateParam) error {
method Update (line 31) | func (p *ProductDao) Update(param *models.ProductUpdateParam) error {
method Delete (line 47) | func (p *ProductDao) Delete(param *models.ProductDeleteParam) error {
method IsExists (line 51) | func (p *ProductDao) IsExists(name string, uid int64) bool {
method GetList (line 57) | func (p *ProductDao) GetList(param *models.ProductQueryParam) ([]*mode...
method GetListByIds (line 71) | func (p *ProductDao) GetListByIds(ids []int64) ([]*models.Products, er...
method GetInfo (line 79) | func (p *ProductDao) GetInfo(param *models.ProductQueryParam) (*models...
method GetListByUid (line 91) | func (p *ProductDao) GetListByUid(uid int64) ([]*models.Product, error) {
function NewProductDao (line 12) | func NewProductDao() *ProductDao {
FILE: server/dao/subscribe.go
type SubscribeDao (line 10) | type SubscribeDao struct
method Create (line 17) | func (s *SubscribeDao) Create(param *models.SubscribeCreateParam) error {
method Update (line 27) | func (s *SubscribeDao) Update(param *models.SubscribeUpdateParam) error {
method UpdateVersion (line 36) | func (s *SubscribeDao) UpdateVersion(uid int64, v int) error {
method IsExists (line 40) | func (u *SubscribeDao) IsExists(uid int64) bool {
method GetInfo (line 46) | func (s *SubscribeDao) GetInfo(uid int64) (*models.SubscribeInfo, erro...
method SetOrder (line 54) | func (s *SubscribeDao) SetOrder(tradeNo string, param *models.Subscrib...
method GetOrder (line 59) | func (s *SubscribeDao) GetOrder(tradeNo string) (string, error) {
function NewSubscribeDao (line 13) | func NewSubscribeDao() *SubscribeDao {
FILE: server/dao/user.go
type UserDao (line 13) | type UserDao struct
method Create (line 20) | func (u *UserDao) Create(param *models.UserCreateParam) error {
method UpdatePass (line 30) | func (u *UserDao) UpdatePass(email, password string) error {
method IsExists (line 38) | func (u *UserDao) IsExists(email string) bool {
method GetUid (line 43) | func (u *UserDao) GetUid(email string) (int64, error) {
method GetUser (line 51) | func (u *UserDao) GetUser(email string) (*models.User, error) {
method DeleteData (line 60) | func (u *UserDao) DeleteData(param models.UserDeleteParam) error {
method GetInfo (line 79) | func (u *UserDao) GetInfo(uid int64) (*models.UserPersonInfo, error) {
method SetCode (line 95) | func (u *UserDao) SetCode(code int, email string) error {
method GetCode (line 100) | func (u *UserDao) GetCode(email string) string {
function NewUserDao (line 16) | func NewUserDao() *UserDao {
FILE: server/db/crm.sql
type `contract` (line 24) | CREATE TABLE `contract` (
type `customer` (line 76) | CREATE TABLE `customer` (
type `mail_config` (line 130) | CREATE TABLE `mail_config` (
type `notice` (line 155) | CREATE TABLE `notice` (
type `product` (line 189) | CREATE TABLE `product` (
type `subscribe` (line 221) | CREATE TABLE `subscribe` (
type `user` (line 243) | CREATE TABLE `user` (
FILE: server/initialize/alipay.go
function Alipay (line 11) | func Alipay() {
FILE: server/initialize/gorm.go
function Mysql (line 14) | func Mysql() {
FILE: server/initialize/load.go
function LoadConfig (line 11) | func LoadConfig() {
FILE: server/initialize/redis.go
function Redis (line 11) | func Redis() {
FILE: server/initialize/router.go
function Router (line 12) | func Router() {
FILE: server/initialize/run.go
function Run (line 3) | func Run() {
FILE: server/main.go
function main (line 5) | func main() {
FILE: server/middleware/cors.go
function Cors (line 10) | func Cors() gin.HandlerFunc {
FILE: server/middleware/jwt.go
function JwtAuth (line 12) | func JwtAuth() gin.HandlerFunc {
FILE: server/models/common.go
type Page (line 4) | type Page struct
type MailParam (line 10) | type MailParam struct
type FileParam (line 22) | type FileParam struct
type FileInfo (line 27) | type FileInfo struct
FILE: server/models/config.go
type MailConfig (line 3) | type MailConfig struct
type MailConfigSaveParam (line 15) | type MailConfigSaveParam struct
type MailConfigStatusParam (line 25) | type MailConfigStatusParam struct
type MailConfigDeleteParam (line 31) | type MailConfigDeleteParam struct
type MailConfigInfo (line 35) | type MailConfigInfo struct
FILE: server/models/contract.go
type Contract (line 8) | type Contract struct
type ContractCreateParam (line 23) | type ContractCreateParam struct
type ContractUpdateParam (line 35) | type ContractUpdateParam struct
type ContractDeleteParam (line 47) | type ContractDeleteParam struct
type ContractQueryParam (line 51) | type ContractQueryParam struct
type ContractList (line 60) | type ContractList struct
type ContractInfo (line 73) | type ContractInfo struct
type Products (line 85) | type Products struct
type ContractExcelRow (line 95) | type ContractExcelRow struct
type Productlist (line 107) | type Productlist
method Value (line 109) | func (p *Productlist) Value() (driver.Value, error) {
method Scan (line 114) | func (p *Productlist) Scan(src any) error {
FILE: server/models/customer.go
type Customer (line 3) | type Customer struct
type CustomerCreateParam (line 20) | type CustomerCreateParam struct
type CustomerUpdateParam (line 34) | type CustomerUpdateParam struct
type CustomerSendMailParam (line 48) | type CustomerSendMailParam struct
type CustomerDeleteParam (line 56) | type CustomerDeleteParam struct
type CustomerQueryParam (line 60) | type CustomerQueryParam struct
type CustomerList (line 71) | type CustomerList struct
type CustomerInfo (line 87) | type CustomerInfo struct
type CustomerOption (line 101) | type CustomerOption struct
type CustomerExcelRow (line 106) | type CustomerExcelRow struct
FILE: server/models/dashboard.go
type DashboardSum (line 3) | type DashboardSum struct
type CustomerIndustry (line 13) | type CustomerIndustry struct
FILE: server/models/notice.go
type Notice (line 3) | type Notice struct
type NoticeCreateParam (line 12) | type NoticeCreateParam struct
type NoticeUpdateParam (line 17) | type NoticeUpdateParam struct
type NoticeDeleteParam (line 21) | type NoticeDeleteParam struct
type UnReadNotice (line 25) | type UnReadNotice struct
type NoticeList (line 29) | type NoticeList struct
FILE: server/models/product.go
type Product (line 3) | type Product struct
type ProductCreateParam (line 17) | type ProductCreateParam struct
type ProductUpdateParam (line 28) | type ProductUpdateParam struct
type ProductDeleteParam (line 40) | type ProductDeleteParam struct
type ProductQueryParam (line 44) | type ProductQueryParam struct
type ProductList (line 53) | type ProductList struct
type ProductInfo (line 66) | type ProductInfo struct
type ProductExcelRow (line 77) | type ProductExcelRow struct
FILE: server/models/subscribe.go
type Subscribe (line 3) | type Subscribe struct
type SubscribeCreateParam (line 12) | type SubscribeCreateParam struct
type SubscribeUpdateParam (line 18) | type SubscribeUpdateParam struct
type SubscribePayParam (line 25) | type SubscribePayParam struct
type SubscribePayOrder (line 30) | type SubscribePayOrder struct
type SubscribePayUrl (line 36) | type SubscribePayUrl struct
type SubscribeInfo (line 40) | type SubscribeInfo struct
FILE: server/models/user.go
type User (line 3) | type User struct
type UserCreateParam (line 13) | type UserCreateParam struct
type UserDeleteParam (line 19) | type UserDeleteParam struct
type UserLoginParam (line 25) | type UserLoginParam struct
type UserVerifyCodeParam (line 30) | type UserVerifyCodeParam struct
type UserPassParam (line 34) | type UserPassParam struct
type UserInfo (line 40) | type UserInfo struct
type UserPersonInfo (line 45) | type UserPersonInfo struct
FILE: server/response/errcode.go
constant ErrCodeSuccess (line 4) | ErrCodeSuccess = 0
constant ErrCodeFailed (line 5) | ErrCodeFailed = 1
constant ErrCodeParamInvalid (line 6) | ErrCodeParamInvalid = 2
constant ErrCodeNoLogin (line 7) | ErrCodeNoLogin = 3
constant ErrCodeTokenExpire (line 8) | ErrCodeTokenExpire = 4
constant ErrCodeInitDataFailed (line 10) | ErrCodeInitDataFailed = 10
constant ErrCodeFileUploadFailed (line 11) | ErrCodeFileUploadFailed = 11
constant ErrCodeFileRemoveFailed (line 12) | ErrCodeFileRemoveFailed = 12
constant ErrCodeUserHasExist (line 14) | ErrCodeUserHasExist = 10001
constant ErrCodeUserNotExist (line 15) | ErrCodeUserNotExist = 10002
constant ErrCOdeUserEmailOrPass (line 16) | ErrCOdeUserEmailOrPass = 10003
constant ErrCodeVerityCodeSendFailed (line 17) | ErrCodeVerityCodeSendFailed = 10004
constant ErrCodeVerityCodeInvalid (line 18) | ErrCodeVerityCodeInvalid = 10005
constant ErrCodeEmailFormatInvalid (line 19) | ErrCodeEmailFormatInvalid = 10008
constant ErrCodeUserPassResetFailed (line 20) | ErrCodeUserPassResetFailed = 10009
constant ErrCodeCustomerHasExist (line 22) | ErrCodeCustomerHasExist = 20001
constant ErrCodePayFailed (line 24) | ErrCodePayFailed = 20001
constant ErrCodeFileExportFailed (line 26) | ErrCodeFileExportFailed = 30001
constant ErrCodeProductHasExist (line 28) | ErrCodeProductHasExist = 40001
constant ErrCodeMailConfigInvalid (line 30) | ErrCodeMailConfigInvalid = 50001
constant ErrCodeMailSendFailed (line 31) | ErrCodeMailSendFailed = 50002
constant ErrCodeMailSendUnEnable (line 32) | ErrCodeMailSendUnEnable = 50003
constant ErrCodeMailConfigUnSet (line 33) | ErrCodeMailConfigUnSet = 50004
FILE: server/response/response.go
type Response (line 9) | type Response struct
type Page (line 15) | type Page struct
function Result (line 21) | func Result(code int, data interface{}, c *gin.Context) {
function PageResult (line 27) | func PageResult(code int, data interface{}, rows int64, c *gin.Context) {
FILE: server/service/common.go
constant USER (line 13) | USER = "user"
constant CUSTOMER (line 14) | CUSTOMER = "customer"
constant CONTRACT (line 15) | CONTRACT = "contract"
constant PRODUCT (line 16) | PRODUCT = "product"
constant SUBSCRIBE (line 17) | SUBSCRIBE = "subscribe"
constant NOTICE (line 18) | NOTICE = "notice"
constant NumberNull (line 22) | NumberNull = 0
constant StringNull (line 23) | StringNull = ""
constant Dev (line 27) | Dev = "dev"
constant Prod (line 28) | Prod = "prod"
constant REGISTER_NOTICE_TEMPLATE (line 32) | REGISTER_NOTICE_TEMPLATE = "你注册了账号"
constant LOGIN_NOTICE_TEMPLATE (line 33) | LOGIN_NOTICE_TEMPLATE = "你登录了账号"
constant SUBSCRIBE_NOTICE_TEMPLATE1 (line 34) | SUBSCRIBE_NOTICE_TEMPLATE1 = "你订阅了专业版"
constant SUBSCRIBE_NOTICE_TEMPLATE2 (line 35) | SUBSCRIBE_NOTICE_TEMPLATE2 = "你订阅了高级版"
type CommonService (line 38) | type CommonService struct
method InitDatabase (line 49) | func (c *CommonService) InitDatabase() int {
method FileUpload (line 57) | func (c *CommonService) FileUpload(file *multipart.FileHeader) (*model...
method FileRemove (line 66) | func (c *CommonService) FileRemove(param *models.FileParam) int {
function NewCommonService (line 42) | func NewCommonService() *CommonService {
FILE: server/service/config.go
type MailConfigService (line 10) | type MailConfigService struct
method Save (line 21) | func (m *MailConfigService) Save(param *models.MailConfigSaveParam) int {
method Delete (line 29) | func (m *MailConfigService) Delete(param *models.MailConfigDeleteParam...
method UpdateStatus (line 37) | func (m *MailConfigService) UpdateStatus(param *models.MailConfigStatu...
method GetInfo (line 48) | func (m *MailConfigService) GetInfo(uid int64) (*models.MailConfigInfo...
method Check (line 68) | func (m *MailConfigService) Check(uid int64) int {
function NewMailConfigService (line 14) | func NewMailConfigService() *MailConfigService {
FILE: server/service/contract.go
type ContractService (line 13) | type ContractService struct
method Create (line 26) | func (c *ContractService) Create(param *models.ContractCreateParam) int {
method Update (line 34) | func (c *ContractService) Update(param *models.ContractUpdateParam) int {
method Delete (line 42) | func (c *ContractService) Delete(param *models.ContractDeleteParam) int {
method GetList (line 50) | func (c *ContractService) GetList(param *models.ContractQueryParam) ([...
method GetInfo (line 59) | func (c *ContractService) GetInfo(param *models.ContractQueryParam) (*...
method GetProductList (line 68) | func (c *ContractService) GetProductList(param *models.ContractQueryPa...
method Export (line 113) | func (c *ContractService) Export(uid int64) (string, int) {
function NewContractService (line 18) | func NewContractService() *ContractService {
FILE: server/service/customer.go
constant Open (line 13) | Open = 1
constant Close (line 14) | Close = 2
type CustomerService (line 17) | type CustomerService struct
method Create (line 30) | func (c *CustomerService) Create(param *models.CustomerCreateParam) int {
method Update (line 41) | func (c *CustomerService) Update(param *models.CustomerUpdateParam) int {
method SendMail (line 49) | func (c *CustomerService) SendMail(param *models.CustomerSendMailParam...
method Delete (line 74) | func (c *CustomerService) Delete(param *models.CustomerDeleteParam) int {
method GetList (line 82) | func (c *CustomerService) GetList(param *models.CustomerQueryParam) ([...
method GetInfo (line 91) | func (c *CustomerService) GetInfo(param *models.CustomerQueryParam) (*...
method GetOption (line 100) | func (c *CustomerService) GetOption(uid int64) ([]*models.CustomerOpti...
method Export (line 109) | func (c *CustomerService) Export(uid int64) (string, int) {
function NewCustomerService (line 22) | func NewCustomerService() *CustomerService {
FILE: server/service/dashboard.go
type DashboardService (line 9) | type DashboardService struct
method Summary (line 20) | func (d *DashboardService) Summary(uid int64, days int) models.Dashboa...
function NewDashboardService (line 13) | func NewDashboardService() *DashboardService {
function dayRange (line 36) | func dayRange(day int64) (int64, int64) {
FILE: server/service/notice.go
type NoticeService (line 9) | type NoticeService struct
method Create (line 20) | func (n *NoticeService) Create(param *models.NoticeCreateParam) int {
method Update (line 28) | func (n *NoticeService) Update(param *models.NoticeUpdateParam) int {
method GetUnReadCount (line 36) | func (n *NoticeService) GetUnReadCount(uid int64) (models.UnReadNotice...
method Delete (line 45) | func (n *NoticeService) Delete(param *models.NoticeDeleteParam) int {
method GetList (line 53) | func (n *NoticeService) GetList(uid int64) ([]*models.NoticeList, int) {
function NewNoticeService (line 13) | func NewNoticeService() *NoticeService {
FILE: server/service/product.go
type ProductService (line 12) | type ProductService struct
method Create (line 23) | func (p *ProductService) Create(param *models.ProductCreateParam) int {
method Update (line 34) | func (p *ProductService) Update(param *models.ProductUpdateParam) int {
method Delete (line 42) | func (p *ProductService) Delete(param *models.ProductDeleteParam) int {
method GetList (line 50) | func (p *ProductService) GetList(param *models.ProductQueryParam) ([]*...
method GetInfo (line 59) | func (p *ProductService) GetInfo(param *models.ProductQueryParam) (*mo...
method Export (line 68) | func (p *ProductService) Export(uid int64) (string, int) {
function NewProductService (line 16) | func NewProductService() *ProductService {
FILE: server/service/subscribe.go
type SubscribeService (line 12) | type SubscribeService struct
method Pay (line 26) | func (s *SubscribeService) Pay(param models.SubscribePayParam) (*model...
method PayBack (line 53) | func (s *SubscribeService) PayBack(outTradeNo string) int {
method GetInfo (line 101) | func (s *SubscribeService) GetInfo(uid int64) (*models.SubscribeInfo, ...
function NewSubscribeService (line 17) | func NewSubscribeService() *SubscribeService {
FILE: server/service/user.go
constant TOKEN_MAX_EXPIRE_TIME (line 15) | TOKEN_MAX_EXPIRE_TIME = 7 * 24
type UserService (line 18) | type UserService struct
method Register (line 34) | func (u *UserService) Register(param *models.UserCreateParam) int {
method Login (line 93) | func (u *UserService) Login(param *models.UserLoginParam) (*models.Use...
method GetVerifyCode (line 134) | func (u *UserService) GetVerifyCode(email string) int {
method ForgotPass (line 153) | func (u *UserService) ForgotPass(param *models.UserPassParam) int {
method Delete (line 177) | func (u *UserService) Delete(param models.UserDeleteParam) int {
method GetInfo (line 191) | func (u *UserService) GetInfo(uid int64) (*models.UserPersonInfo, int) {
function NewUserService (line 24) | func NewUserService() *UserService {
FILE: web/src/api/common.js
function initDatabase (line 4) | function initDatabase(param) {
function fileRemove (line 13) | function fileRemove(param) {
FILE: web/src/api/config.js
function saveMailConfig (line 4) | function saveMailConfig(param) {
function deleteMailConfig (line 13) | function deleteMailConfig(param) {
function updateMailConfigStmpStatus (line 22) | function updateMailConfigStmpStatus(param) {
function getMailConfig (line 31) | function getMailConfig(param) {
function checkMailConfig (line 40) | function checkMailConfig(param) {
FILE: web/src/api/contract.js
function createContract (line 4) | function createContract(param) {
function updateContract (line 13) | function updateContract(param) {
function deleteContract (line 22) | function deleteContract(param) {
function queryContractList (line 31) | function queryContractList(param) {
function queryContractInfo (line 40) | function queryContractInfo(param) {
function queryContractPlist (line 49) | function queryContractPlist(param) {
function contractExport (line 58) | function contractExport(param) {
FILE: web/src/api/customer.js
function createCustomer (line 4) | function createCustomer(param) {
function updateCustomer (line 13) | function updateCustomer(param) {
function sendMailToCustomer (line 22) | function sendMailToCustomer(param) {
function deleteCustomer (line 31) | function deleteCustomer(param) {
function queryCustomerList (line 40) | function queryCustomerList(param) {
function queryCustomerInfo (line 49) | function queryCustomerInfo(param) {
function queryCustomerOption (line 58) | function queryCustomerOption(param) {
function customerExport (line 67) | function customerExport(param) {
FILE: web/src/api/dashboard.js
function getSummary (line 4) | function getSummary(param) {
FILE: web/src/api/notice.js
function updateNotice (line 4) | function updateNotice(param) {
function getNoticeCount (line 13) | function getNoticeCount(param) {
function deleteNotice (line 22) | function deleteNotice(param) {
function getNoticeList (line 31) | function getNoticeList(param) {
FILE: web/src/api/product.js
function createProduct (line 4) | function createProduct(param) {
function updateProduct (line 13) | function updateProduct(param) {
function deleteProduct (line 22) | function deleteProduct(param) {
function queryProductInfo (line 31) | function queryProductInfo(param) {
function queryProductList (line 40) | function queryProductList(param) {
function productExport (line 49) | function productExport(param) {
FILE: web/src/api/subscribe.js
function subscribePay (line 4) | function subscribePay(param) {
function getSubscribeInfo (line 13) | function getSubscribeInfo(param) {
FILE: web/src/api/user.js
function userLogin (line 4) | function userLogin(param) {
function userRegister (line 13) | function userRegister(param) {
function getVerifyCode (line 22) | function getVerifyCode(param) {
function userForgotPass (line 31) | function userForgotPass(param) {
function userDelete (line 40) | function userDelete(param) {
function getUserInfo (line 49) | function getUserInfo(param) {
Condensed preview — 120 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,208K chars).
[
{
"path": ".gitattributes",
"chars": 27,
"preview": "region.js linguist-vendored"
},
{
"path": ".github/workflows/deploy.yaml",
"chars": 1363,
"preview": "name: CRM CI\n\non:\n push:\n branches: [ \"main\" ]\n pull_request:\n branches: [ \"main\" ]\njobs:\n build:\n runs-on: "
},
{
"path": ".gitignore",
"chars": 97,
"preview": "### node\nnode_modules\n/dist\n\n### IDEA ###\n.idea\n\n### MacOS ###\n.DS_Store\n\n### VS Code ###\n.vscode"
},
{
"path": "LICENSE",
"chars": 1072,
"preview": "MIT License\n\nCopyright (c) 2022-present zchengo\n\nPermission is hereby granted, free of charge, to any person obtaining a"
},
{
"path": "README.md",
"chars": 1110,
"preview": "# crm\n\n<a href=\"https://zocrm.cloud\"><img src=\"https://img.shields.io/badge/在线演示-zocrm.cloud-%230092FF\" /></a>\n<a href=\""
},
{
"path": "docs/docs/.vitepress/cache/deps/_metadata.json",
"chars": 269,
"preview": "{\n \"hash\": \"ce2e264b\",\n \"browserHash\": \"e34b92f3\",\n \"optimized\": {\n \"vue\": {\n \"src\": \"../../../../node_module"
},
{
"path": "docs/docs/.vitepress/cache/deps/package.json",
"chars": 17,
"preview": "{\"type\":\"module\"}"
},
{
"path": "docs/docs/.vitepress/cache/deps/vue.js",
"chars": 301626,
"preview": "// node_modules/@vue/shared/dist/shared.esm-bundler.js\nfunction makeMap(str, expectsLowerCase) {\n const map2 = /* @__PU"
},
{
"path": "docs/docs/.vitepress/config.js",
"chars": 2612,
"preview": "export default {\n title: 'CrmDocs',\n description: 'CrmDocs',\n themeConfig: {\n logo: '/logo.svg',\n "
},
{
"path": "docs/docs/.vitepress/theme/adsense.vue",
"chars": 752,
"preview": "<script setup>\nimport DefaultTheme from 'vitepress/theme'\nconst { Layout } = DefaultTheme\n\n</script>\n\n<template>\n <Layo"
},
{
"path": "docs/docs/.vitepress/theme/index.css",
"chars": 774,
"preview": ":root {\n /* 标题 */\n --vp-home-hero-name-color: transparent;\n --vp-home-hero-name-background: linear-gradient( 135deg, "
},
{
"path": "docs/docs/.vitepress/theme/index.js",
"chars": 142,
"preview": "import Theme from 'vitepress/theme'\nimport './index.css'\nimport adsense from './adsense.vue'\n\nexport default {\n ...Them"
},
{
"path": "docs/docs/about/about.md",
"chars": 455,
"preview": "# 关于\n\nCrm（英文全称 Customer relationship management ）是一个免费、开源的客户关系管理系统，主要功能有仪表盘、客户管理、合同管理、产品管理、配置、订阅等功能。\n\n项目基于 Vue + Golang "
},
{
"path": "docs/docs/index.md",
"chars": 601,
"preview": "---\nlayout: home\n\nhero:\n name: CRM DOCS\n text: 客户关系管理系统\n tagline: 基于 Vue3 和 Golang 实现，适用于新手学习参考。\n image:\n src: /l"
},
{
"path": "docs/docs/project/backend/cors-handle.md",
"chars": 2716,
"preview": "# 跨域请求处理\n\n您可以在前端、服务端或者 Nginx 服务器上处理跨域请求。\n\n## 什么是跨域请求？\n\n当您在浏览器中从一个域名的网页去请求另一个域名的资源时，域名、端口、协议中的任一不同，就会出现请求跨域。只要协议、域名和端口中的任"
},
{
"path": "docs/docs/project/backend/jwt-handle.md",
"chars": 2614,
"preview": "# 用户授权与认证\n\nCrm 系统采用 JWT 来完成用户授权与认证。\n\n## 什么是 JWT ？\n\nJSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑和自包含的方式，用于作为JSON对象在各方之间安"
},
{
"path": "docs/docs/project/devops/ci-cd.md",
"chars": 4374,
"preview": "# 持续集成与交付 (CI/CD)\n\nCrm 系统使用 GitHub Actions 作为持续集成和持续交付 (CI/CD) 平台，自动执行生成、测试和部署，通过创建工作流程来自动构建和部署项目到生产环境。\n\n想要了解有关 GitHub A"
},
{
"path": "docs/docs/project/devops/deploy-cloudserver.md",
"chars": 13983,
"preview": "# 部署到云服务器\n\n如果您打算将 Crm 系统部署到您自己的云服务器上，您需要先注册一个域名和购买一台云服务器，然后在云服务器上进行环境安装、服务启动与配置、项目的构建与部署。\n\n## 注册域名\n\n您可以选择以下任意云厂商提供的域名注册，"
},
{
"path": "docs/docs/project/docs/deploy-guide.md",
"chars": 2644,
"preview": "# 部署指南\n\n::: tip 提示\n请先安装运行环境，再运行服务端和Web端。\n:::\n\n## 环境安装\n\n你需要在你的系统中，安装如下运行环境：\n\n| 环境 | 版本 | 下载地址 |\n|---|---|---|\n| go | >= 1"
},
{
"path": "docs/docs/project/docs/detailed-design.md",
"chars": 17,
"preview": "# 详细设计\n\n文档即将发布..."
},
{
"path": "docs/docs/project/docs/getting-started.md",
"chars": 849,
"preview": "# 快速开始\n\n## 安装\n\n如果你的系统中已经安装了 ```Git```，你可以使用如下方式安装：\n\n```bash\ngit clone https://github.com/zchengo/crm.git\n```\n\n你也可以通过下载压缩"
},
{
"path": "docs/docs/project/docs/introduction.md",
"chars": 3282,
"preview": "# 简介\n\n::: tip 提示\n你正在阅读的是 Crm 最新版的[项目文档](https://docs.zocrm.cloud)。\n:::\n\n## 什么是 Crm ？\n\nCrm（英文全称 Customer relationship man"
},
{
"path": "docs/docs/project/docs/problem-feedback.md",
"chars": 97,
"preview": "# 问题反馈\n\n在使用过程中遇到了问题，您可以通过以下方式反馈：\n\n- [New Issues In Github](https://github.com/zchengo/crm/issues)"
},
{
"path": "docs/docs/project/docs/update-log.md",
"chars": 86,
"preview": "# 更新日志\n\n### 2023-01-15\n\n- 项目文档优化。\n- 新增前端、后端以及运维相关的文档。\n\n### 2023-01-10\n\n- CRM 项目文档正式发布。"
},
{
"path": "docs/docs/project/frontend/axios-package.md",
"chars": 1932,
"preview": "# 网络请求库封装\n\nCrm 系统采用 axios 作为网络请求库。\n\n## 什么是 axios ？\n\naxios 是浏览器和 node.js 的一个简单的基于 promise 的 HTTP 客户端。axios 在一个具有非常可扩展界面的小"
},
{
"path": "docs/docs/project/frontend/env-var-modes.md",
"chars": 1826,
"preview": "# 环境变量和模式\n\nCrm 采用 Vite 提供的环境变量与模式，来设置应用的环境变量与运行模式。\n\n了解有关 Vite 环境变量与模式的更多信息，请参考文档[Vite 环境变量与模式](https://vitejs.dev/guide/"
},
{
"path": "docs/docs/project/frontend/nprogress.md",
"chars": 964,
"preview": "# 页面中的加载进度条\n\nCrm 系统使用 NProgress 作为页面中的加载进度条。\n\n## 什么是 NProgress？\n\nNProgress 是一个适用于应用程序的超薄进度条，灵感来自谷歌、YouTube和媒体。了解有关 NProg"
},
{
"path": "docs/docs/sponsor/sponsor.md",
"chars": 257,
"preview": "# 赞赏\n\n打开微信扫一扫，扫描下方赞赏码，请作者喝咖啡！\n\n<img src=\"/sponsor.png\" style=\"width: 240px; height: 240px;border-radius: 8px;border: 1px"
},
{
"path": "docs/package.json",
"chars": 364,
"preview": "{\n \"name\": \"docs\",\n \"version\": \"1.0.0\",\n \"description\": \"crm docs\",\n \"main\": \"index.js\",\n \"scripts\": {\n \"docs:de"
},
{
"path": "server/api/common.go",
"chars": 956,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"log\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntype CommonApi"
},
{
"path": "server/api/config.go",
"chars": 2332,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"log\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntyp"
},
{
"path": "server/api/contract.go",
"chars": 2941,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntype Contr"
},
{
"path": "server/api/customer.go",
"chars": 3312,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"log\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntyp"
},
{
"path": "server/api/dashboard.go",
"chars": 706,
"preview": "package api\n\nimport (\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntype DashboardApi struct"
},
{
"path": "server/api/notice.go",
"chars": 1562,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"fmt\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntyp"
},
{
"path": "server/api/product.go",
"chars": 2502,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntype Produ"
},
{
"path": "server/api/subscribe.go",
"chars": 1415,
"preview": "package api\n\nimport (\n\t\"crm/common\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"net/http\"\n\t\"strconv\"\n\n\t\"github.com/gi"
},
{
"path": "server/api/user.go",
"chars": 2367,
"preview": "package api\n\nimport (\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"crm/service\"\n\t\"log\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntyp"
},
{
"path": "server/common/alipay.go",
"chars": 1244,
"preview": "package common\n\nimport (\n\t\"context\"\n\t\"crm/global\"\n\t\"net/http\"\n\t\"strconv\"\n\t\"time\"\n\n\t\"github.com/go-pay/gopay\"\n\t\"github.co"
},
{
"path": "server/common/excel.go",
"chars": 879,
"preview": "package common\n\nimport (\n\t\"crm/global\"\n\t\"log\"\n\t\"reflect\"\n\t\"strconv\"\n\n\t\"github.com/xuri/excelize/v2\"\n)\n\nconst (\n\tletter ="
},
{
"path": "server/common/jwt.go",
"chars": 909,
"preview": "package common\n\nimport (\n\t\"crm/global\"\n\t\"time\"\n\n\t\"github.com/golang-jwt/jwt/v4\"\n)\n\ntype Claims struct {\n\tUid int64 `json"
},
{
"path": "server/common/mail.go",
"chars": 1662,
"preview": "package common\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"crypto/tls\"\n\t\"fmt\"\n\t\"log\"\n\n\t\"gopkg.in/gomail.v2\"\n)\n\n// 发送邮件（系统级别）"
},
{
"path": "server/common/rand.go",
"chars": 209,
"preview": "package common\n\nimport (\n\t\"math/rand\"\n\t\"time\"\n)\n\nfunc RandInt(min, max int) int {\n\trand.Seed(time.Now().UnixNano())\n\tif "
},
{
"path": "server/common/uuid.go",
"chars": 208,
"preview": "package common\n\nimport (\n\t\"log\"\n\n\t\"github.com/gofrs/uuid\"\n)\n\n// 生成UUID\nfunc GenUUID() string {\n\tu, err := uuid.NewV4()\n\t"
},
{
"path": "server/config/config.go",
"chars": 1876,
"preview": "package config\n\n// 组合全部配置模型\ntype Config struct {\n\tServer Server `mapstructure:\"server\"`\n\tMysql Mysql `mapstructure:\"my"
},
{
"path": "server/config.yaml",
"chars": 955,
"preview": "# 服务端启动配置\nserver:\n port: 8000\n runenv: dev\n\n# MySQL数据库配置\nmysql:\n host: 127.0.0.1\n port: 3306\n username: root\n pass"
},
{
"path": "server/dao/common.go",
"chars": 2257,
"preview": "package dao\n\nimport (\n\t\"context\"\n\t\"crm/common\"\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"io\"\n\t\"log\"\n\t\"mime/multipart\"\n\t\"os\"\n\t\"path\"\n"
},
{
"path": "server/dao/config.go",
"chars": 2091,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"time\"\n)\n\nconst (\n\tClosed = 2\n)\n\ntype MailConfigDao struct {\n}\n\nfunc "
},
{
"path": "server/dao/contract.go",
"chars": 3666,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"time\"\n)\n\ntype ContractDao struct {\n}\n\nfunc NewContractDao() *Contrac"
},
{
"path": "server/dao/customer.go",
"chars": 2908,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"time\"\n)\n\ntype CustomerDao struct {\n}\n\nfunc NewCustomerDao() *Custome"
},
{
"path": "server/dao/dashboard.go",
"chars": 1036,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n)\n\ntype DashboardDao struct {\n}\n\nfunc NewDashboardDao() *DashboardDao "
},
{
"path": "server/dao/notice.go",
"chars": 1410,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"time\"\n)\n\nconst (\n\tRead = 1 // 已读\n\tUnRead = 2 // 未读\n)\n\ntype NoticeD"
},
{
"path": "server/dao/product.go",
"chars": 2613,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"time\"\n)\n\ntype ProductDao struct {\n}\n\nfunc NewProductDao() *ProductDa"
},
{
"path": "server/dao/subscribe.go",
"chars": 1723,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"encoding/json\"\n\t\"time\"\n)\n\ntype SubscribeDao struct {\n}\n\nfunc NewSubs"
},
{
"path": "server/dao/user.go",
"chars": 2504,
"preview": "package dao\n\nimport (\n\t\"crm/global\"\n\t\"crm/models\"\n\t\"fmt\"\n\t\"strconv\"\n\t\"time\"\n\n\t\"gorm.io/gorm\"\n)\n\ntype UserDao struct {\n}\n"
},
{
"path": "server/db/crm.sql",
"chars": 32424,
"preview": "/*\n Navicat Premium Data Transfer\n\n Source Server : mysql\n Source Server Type : MySQL\n Source Server Version "
},
{
"path": "server/global/global.go",
"chars": 217,
"preview": "package global\n\nimport (\n\t\"crm/config\"\n\n\t\"github.com/go-pay/gopay/alipay\"\n\t\"github.com/go-redis/redis/v9\"\n\t\"gorm.io/gorm"
},
{
"path": "server/go.mod",
"chars": 2564,
"preview": "module crm\n\ngo 1.19\n\nrequire (\n\tgithub.com/gin-gonic/gin v1.8.1\n\tgithub.com/go-pay/gopay v1.5.88\n\tgithub.com/go-redis/re"
},
{
"path": "server/go.sum",
"chars": 60850,
"preview": "cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=\ncloud.google.com/go v0.34.0/go.mod h1"
},
{
"path": "server/initialize/alipay.go",
"chars": 561,
"preview": "package initialize\n\nimport (\n\t\"crm/global\"\n\t\"log\"\n\n\t\"github.com/go-pay/gopay/alipay\"\n\t\"github.com/go-pay/gopay/pkg/xlog\""
},
{
"path": "server/initialize/gorm.go",
"chars": 744,
"preview": "package initialize\n\nimport (\n\t\"crm/global\"\n\t\"fmt\"\n\t\"time\"\n\n\t\"gorm.io/driver/mysql\"\n\t\"gorm.io/gorm\"\n\t\"gorm.io/gorm/schema"
},
{
"path": "server/initialize/load.go",
"chars": 435,
"preview": "package initialize\n\nimport (\n\t\"crm/global\"\n\t\"fmt\"\n\n\t\"github.com/spf13/viper\"\n)\n\n// 加载配置文件\nfunc LoadConfig() {\n\tviper.Add"
},
{
"path": "server/initialize/redis.go",
"chars": 304,
"preview": "package initialize\n\nimport (\n\t\"crm/global\"\n\t\"fmt\"\n\n\t\"github.com/go-redis/redis/v9\"\n)\n\n// 初始化Redis数据库\nfunc Redis() {\n\tr :"
},
{
"path": "server/initialize/router.go",
"chars": 3084,
"preview": "package initialize\n\nimport (\n\t\"crm/api\"\n\t\"crm/global\"\n\t\"crm/middleware\"\n\t\"fmt\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc Rout"
},
{
"path": "server/initialize/run.go",
"chars": 87,
"preview": "package initialize\n\nfunc Run() {\n\tLoadConfig()\n\tMysql()\n\tRedis()\n\tAlipay()\n\tRouter()\n}"
},
{
"path": "server/main.go",
"chars": 73,
"preview": "package main\n\nimport \"crm/initialize\"\n\nfunc main() {\n\tinitialize.Run()\n}\n"
},
{
"path": "server/middleware/cors.go",
"chars": 791,
"preview": "package middleware\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\n// Cors 处理跨域请求\nfunc Cors() gin.HandlerFunc {\n\tr"
},
{
"path": "server/middleware/jwt.go",
"chars": 555,
"preview": "package middleware\n\nimport (\n\t\"crm/common\"\n\t\"crm/response\"\n\t\"strconv\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\n// JWT认证中间件\nfunc J"
},
{
"path": "server/models/common.go",
"chars": 505,
"preview": "package models\n\n// 分页参数模型\ntype Page struct {\n\tPageNum int `form:\"pageNum\" json:\"pageNum\"`\n\tPageSize int `form:\"pageSiz"
},
{
"path": "server/models/config.go",
"chars": 1340,
"preview": "package models\n\ntype MailConfig struct {\n\tId int64 `gorm:\"primaryKey\"`\n\tStmp string `gorm:\"stmp\"`\n\tPort i"
},
{
"path": "server/models/contract.go",
"chars": 3762,
"preview": "package models\n\nimport (\n\t\"database/sql/driver\"\n\t\"encoding/json\"\n)\n\ntype Contract struct {\n\tId int64 `go"
},
{
"path": "server/models/customer.go",
"chars": 3910,
"preview": "package models\n\ntype Customer struct {\n\tId int64 `gorm:\"primaryKey\"`\n\tName string `gorm:\"name\"`\n\tSource str"
},
{
"path": "server/models/dashboard.go",
"chars": 538,
"preview": "package models\n\ntype DashboardSum struct {\n\tCustomers int `json:\"customers\"`\n\tContracts in"
},
{
"path": "server/models/notice.go",
"chars": 711,
"preview": "package models\n\ntype Notice struct {\n\tId int64 `gorm:\"primaryKey\"`\n\tContent string `gorm:\"content\"`\n\tStatus int "
},
{
"path": "server/models/product.go",
"chars": 2948,
"preview": "package models\n\ntype Product struct {\n\tId int64 `gorm:\"primaryKey\"`\n\tName string `gorm:\"name\"`\n\tType "
},
{
"path": "server/models/subscribe.go",
"chars": 966,
"preview": "package models\n\ntype Subscribe struct {\n\tId int64 `gorm:\"primaryKey\"`\n\tUid int64 `gorm:\"uid\"`\n\tVersion int `g"
},
{
"path": "server/models/user.go",
"chars": 1301,
"preview": "package models\n\ntype User struct {\n\tId int64 `gorm:\"primaryKey\"`\n\tEmail string `gorm:\"email\"`\n\tPassword string"
},
{
"path": "server/response/errcode.go",
"chars": 2054,
"preview": "package response\n\nconst (\n\tErrCodeSuccess = 0 // 成功\n\tErrCodeFailed = 1 // 失败\n\tErrCodeParamInvalid = 2 // 请求参数"
},
{
"path": "server/response/response.go",
"chars": 651,
"preview": "package response\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/gin-gonic/gin\"\n)\n\ntype Response struct {\n\tCode int `json"
},
{
"path": "server/service/common.go",
"chars": 1316,
"preview": "package service\n\nimport (\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"mime/multipart\"\n)\n\nconst (\n\n\t// 数据库表名\n\tUSER = "
},
{
"path": "server/service/config.go",
"chars": 1845,
"preview": "package service\n\nimport (\n\t\"crm/common\"\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n)\n\ntype MailConfigService struct {\n\tmai"
},
{
"path": "server/service/contract.go",
"chars": 3751,
"preview": "package service\n\nimport (\n\t\"crm/common\"\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"strconv\"\n\n\t\"time\"\n)\n\ntype ContractSer"
},
{
"path": "server/service/customer.go",
"chars": 3707,
"preview": "package service\n\nimport (\n\t\"crm/common\"\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"strconv\"\n\t\"time\"\n)\n\nconst (\n\tOpen = "
},
{
"path": "server/service/dashboard.go",
"chars": 930,
"preview": "package service\n\nimport (\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"time\"\n)\n\ntype DashboardService struct {\n\tdashboardDao *dao.Dashboar"
},
{
"path": "server/service/notice.go",
"chars": 1321,
"preview": "package service\n\nimport (\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n)\n\ntype NoticeService struct {\n\tnoticeDao *dao.Notice"
},
{
"path": "server/service/product.go",
"chars": 2611,
"preview": "package service\n\nimport (\n\t\"crm/common\"\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"strconv\"\n\t\"time\"\n)\n\ntype ProductServi"
},
{
"path": "server/service/subscribe.go",
"chars": 2738,
"preview": "package service\n\nimport (\n\t\"crm/common\"\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"encoding/json\"\n\t\"time\"\n)\n\ntype Subscr"
},
{
"path": "server/service/user.go",
"chars": 4225,
"preview": "package service\n\nimport (\n\t\"crm/common\"\n\t\"crm/dao\"\n\t\"crm/models\"\n\t\"crm/response\"\n\t\"fmt\"\n\t\"log\"\n\n\t\"golang.org/x/crypto/bc"
},
{
"path": "web/index.html",
"chars": 421,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"UTF-8\" />\n <link rel=\"icon\" type=\"image/svg+xml\" href=\"."
},
{
"path": "web/package.json",
"chars": 538,
"preview": "{\n \"name\": \"web\",\n \"private\": true,\n \"version\": \"0.0.0\",\n \"type\": \"module\",\n \"scripts\": {\n \"dev\": \"vite --mode d"
},
{
"path": "web/src/App.vue",
"chars": 390,
"preview": "<template>\n <transition name=\"fade\">\n <router-view v-slot=\"{ Component }\">\n <component :is=\"Component\" />\n <"
},
{
"path": "web/src/api/common.js",
"chars": 315,
"preview": "import request from '../axios/index'\n\n// 初始化数据库\nexport function initDatabase(param) {\n return request({\n\t\turl: '/comm"
},
{
"path": "web/src/api/config.js",
"chars": 738,
"preview": "import request from '../axios/index'\n\n// 保存邮件服务配置\nexport function saveMailConfig(param) {\n return request({\n\t\turl: '/"
},
{
"path": "web/src/api/contract.js",
"chars": 1035,
"preview": "import request from '../axios/index'\n\n// 新建合同\nexport function createContract(param) {\n return request({\n\t\turl: '/cont"
},
{
"path": "web/src/api/customer.js",
"chars": 1176,
"preview": "import request from '../axios/index'\n\n// 新建客户\nexport function createCustomer(param) {\n return request({\n\t\turl: '/cust"
},
{
"path": "web/src/api/dashboard.js",
"chars": 170,
"preview": "import request from '../axios/index'\n\n// 获取数据汇总\nexport function getSummary(param) {\n return request({\n\t\turl: '/dashbo"
},
{
"path": "web/src/api/notice.js",
"chars": 575,
"preview": "import request from '../axios/index'\n\n// 获取通知列表\nexport function updateNotice(param) {\n return request({\n\t\turl: '/noti"
},
{
"path": "web/src/api/product.js",
"chars": 879,
"preview": "import request from '../axios/index'\n\n// 新建产品\nexport function createProduct(param) {\n return request({\n\t\turl: '/produ"
},
{
"path": "web/src/api/subscribe.js",
"chars": 311,
"preview": "import request from '../axios/index'\n\n// 订阅专业版\nexport function subscribePay(param) {\n return request({\n\t\turl: '/subsc"
},
{
"path": "web/src/api/user.js",
"chars": 821,
"preview": "import request from '../axios/index'\n\n// 用户登录\nexport function userLogin(param) {\n return request({\n\t\turl: '/user/logi"
},
{
"path": "web/src/assets/region.js",
"chars": 386954,
"preview": "const regionData = [\n {\n \"code\": \"110000\",\n \"value\": \"北京市\",\n \"label\": \"北京市\",\n \"children\": [\n "
},
{
"path": "web/src/axios/index.js",
"chars": 714,
"preview": "import axios from 'axios';\nimport { message } from 'ant-design-vue';\n\naxios.defaults.baseURL = import.meta.env.VITE_API_"
},
{
"path": "web/src/components/Spot.vue",
"chars": 763,
"preview": "<script setup>\nimport { ref } from 'vue';\nconst spotType = ref('spot-' + props.type)\nconst props = defineProps({\n typ"
},
{
"path": "web/src/main.js",
"chars": 316,
"preview": "import { createApp } from 'vue'\nimport App from './App.vue'\nimport Antd from 'ant-design-vue';\nimport 'ant-design-vue/di"
},
{
"path": "web/src/router/index.js",
"chars": 2162,
"preview": "import { createRouter, createWebHashHistory } from 'vue-router';\nimport NProgress from 'nprogress';\nimport 'nprogress/np"
},
{
"path": "web/src/store/index.js",
"chars": 183,
"preview": "import { defineStore } from 'pinia'\nimport { ref } from 'vue'\n\nexport const useStore = defineStore('main', () => {\n con"
},
{
"path": "web/src/views/Config.vue",
"chars": 10167,
"preview": "<template>\n <div :style=\"{ padding: '0 20px 12px 20px' }\">\n <a-tabs v-model:activeKey=\"activeKey\">\n "
},
{
"path": "web/src/views/Contract.vue",
"chars": 22959,
"preview": "<template>\n <div :style=\"{ padding: '20px 20px 12px 20px' }\">\n <div style=\"display: flex;justify-content: spac"
},
{
"path": "web/src/views/Customer.vue",
"chars": 21096,
"preview": "<template>\n <div :style=\"{ padding: '20px 20px 12px 20px' }\">\n <div style=\"display: flex;justify-content: spac"
},
{
"path": "web/src/views/Dashboard.vue",
"chars": 8521,
"preview": "<template>\n <div :style=\"{ padding: '20px 20px 12px 20px' }\">\n <a-row :gutter=\"16\">\n <a-col :span=\""
},
{
"path": "web/src/views/Error.vue",
"chars": 540,
"preview": "<template>\n <div class=\"container\">\n <a-result status=\"404\" title=\"404\" sub-title=\"抱歉，您访问的页面不存在。\">\n "
},
{
"path": "web/src/views/Home.vue",
"chars": 12507,
"preview": "<template>\n <a-layout has-sider>\n <a-layout-sider class=\"layout-sider\" width=\"150\">\n <div class=\"lo"
},
{
"path": "web/src/views/Index.vue",
"chars": 1891,
"preview": "<template>\n <div class=\"container\">\n <a-row>\n <a-col :span=\"14\">\n <div class=\"back\">"
},
{
"path": "web/src/views/Login.vue",
"chars": 3366,
"preview": "<template>\n <a-form :model=\"formData\" @finish=\"onLogin\" @finishFailed=\"onLoginFailed\" style=\"width: 65%;\">\n <a"
},
{
"path": "web/src/views/Pass.vue",
"chars": 3379,
"preview": "<template>\n <a-form ref=\"passFormRef\" :model=\"formData\" layout=\"vertical\" style=\"width: 65%;\" @finish=\"onSubmit\" :rul"
},
{
"path": "web/src/views/Product.vue",
"chars": 12945,
"preview": "<template>\n <div :style=\"{ padding: '20px 20px 12px 20px' }\">\n <div style=\"display: flex;justify-content: spac"
},
{
"path": "web/src/views/Register.vue",
"chars": 3630,
"preview": "<template>\n <a-form ref=\"registerFormRef\" :model=\"formData\" style=\"width: 65%;\" layout=\"vertical\" @finish=\"onRegister"
},
{
"path": "web/src/views/Result.vue",
"chars": 553,
"preview": "<template>\n <div style=\"margin-top: 50px;\">\n <a-result status=\"403\" sub-title=\"您需要订阅专业版或高级版才能使用该功能哦！\">\n "
},
{
"path": "web/src/views/Subscribe.vue",
"chars": 8831,
"preview": "<template>\n <div :style=\"{ padding: '20px 20px 12px 20px' }\">\n <a-row :gutter=\"30\">\n <a-col :span=\""
},
{
"path": "web/vite.config.js",
"chars": 509,
"preview": "import { defineConfig } from 'vite'\nimport vue from '@vitejs/plugin-vue'\n\n// https://vitejs.dev/config/\nexport default d"
}
]
About this extraction
This page contains the full source code of the zchengo/crm GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 120 files (1021.8 KB), approximately 297.3k tokens, and a symbol index with 791 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.