code
stringlengths 2
1.05M
| repo_name
stringlengths 5
114
| path
stringlengths 4
991
| language
stringclasses 1
value | license
stringclasses 15
values | size
int32 2
1.05M
|
|---|---|---|---|---|---|
c['969']=[['970',"ChargeId Property","topic_000000000000038C.html",0],['971',"CreatedUtc Property","topic_0000000000000390.html",0],['972',"Currency Property","topic_000000000000038D.html",0],['973',"EndPeriod Property","topic_000000000000038F.html",0],['974',"Id Property","topic_000000000000038A.html",0],['975',"InvoiceNumber Property","topic_0000000000000393.html",0],['976',"Sequence Property","topic_0000000000000392.html",0],['977',"SiteId Property","topic_000000000000038B.html",0],['978',"StartPeriod Property","topic_000000000000038E.html",0],['979',"Status Property","topic_0000000000000391.html",0]]; | asiboro/asiboro.github.io | vsdoc/toc--/t_969.js | JavaScript | mit | 612 |
//var cv = require('../lib/opencv');
var cv = require('opencv');
cv.readImage("./files/cdl_group.jpg", function(err, im) {
if (err) throw err;
if (im.width() < 1 || im.height() < 1) throw new Error('Image has no size');
im.detectObject("./node_modules/opencv/data//haarcascade_frontalface_alt.xml", {}, function(err, faces) {
if (err) throw err;
for (var i = 0; i < faces.length; i++) {
var face = faces[i];
im.ellipse(face.x + face.width / 2, face.y + face.height / 2, face.width / 2, face.height / 2);
}
im.save('./tmp/face-detection.png');
console.log('Image saved to ./tmp/face-detection.png');
});
}); | jimmyliao/opencvtest | face-detection.js | JavaScript | mit | 690 |
var Vue = (function (exports) {
'use strict';
/**
* Make a map and return a function for checking if a key
* is in that map.
* IMPORTANT: all calls of this function must be prefixed with
* \/\*#\_\_PURE\_\_\*\/
* So that rollup can tree-shake them if necessary.
*/
function makeMap(str, expectsLowerCase) {
const map = Object.create(null);
const list = str.split(',');
for (let i = 0; i < list.length; i++) {
map[list[i]] = true;
}
return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
}
// Patch flags are optimization hints generated by the compiler.
// when a block with dynamicChildren is encountered during diff, the algorithm
// enters "optimized mode". In this mode, we know that the vdom is produced by
// a render function generated by the compiler, so the algorithm only needs to
// handle updates explicitly marked by these patch flags.
// dev only flag -> name mapping
const PatchFlagNames = {
[1 /* TEXT */]: `TEXT`,
[2 /* CLASS */]: `CLASS`,
[4 /* STYLE */]: `STYLE`,
[8 /* PROPS */]: `PROPS`,
[16 /* FULL_PROPS */]: `FULL_PROPS`,
[32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,
[64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,
[128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,
[256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,
[1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,
[512 /* NEED_PATCH */]: `NEED_PATCH`,
[-1 /* HOISTED */]: `HOISTED`,
[-2 /* BAIL */]: `BAIL`
};
const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +
'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +
'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';
const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);
const range = 2;
function generateCodeFrame(source, start = 0, end = source.length) {
const lines = source.split(/\r?\n/);
let count = 0;
const res = [];
for (let i = 0; i < lines.length; i++) {
count += lines[i].length + 1;
if (count >= start) {
for (let j = i - range; j <= i + range || end > count; j++) {
if (j < 0 || j >= lines.length)
continue;
const line = j + 1;
res.push(`${line}${' '.repeat(3 - String(line).length)}| ${lines[j]}`);
const lineLength = lines[j].length;
if (j === i) {
// push underline
const pad = start - (count - lineLength) + 1;
const length = Math.max(1, end > count ? lineLength - pad : end - start);
res.push(` | ` + ' '.repeat(pad) + '^'.repeat(length));
}
else if (j > i) {
if (end > count) {
const length = Math.max(Math.min(end - count, lineLength), 1);
res.push(` | ` + '^'.repeat(length));
}
count += lineLength + 1;
}
}
break;
}
}
return res.join('\n');
}
/**
* On the client we only need to offer special cases for boolean attributes that
* have different names from their corresponding dom properties:
* - itemscope -> N/A
* - allowfullscreen -> allowFullscreen
* - formnovalidate -> formNoValidate
* - ismap -> isMap
* - nomodule -> noModule
* - novalidate -> noValidate
* - readonly -> readOnly
*/
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);
function normalizeStyle(value) {
if (isArray(value)) {
const res = {};
for (let i = 0; i < value.length; i++) {
const item = value[i];
const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);
if (normalized) {
for (const key in normalized) {
res[key] = normalized[key];
}
}
}
return res;
}
else if (isObject(value)) {
return value;
}
}
const listDelimiterRE = /;(?![^(]*\))/g;
const propertyDelimiterRE = /:(.+)/;
function parseStringStyle(cssText) {
const ret = {};
cssText.split(listDelimiterRE).forEach(item => {
if (item) {
const tmp = item.split(propertyDelimiterRE);
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
}
});
return ret;
}
function normalizeClass(value) {
let res = '';
if (isString(value)) {
res = value;
}
else if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
res += normalizeClass(value[i]) + ' ';
}
}
else if (isObject(value)) {
for (const name in value) {
if (value[name]) {
res += name + ' ';
}
}
}
return res.trim();
}
// These tag configs are shared between compiler-dom and runtime-dom, so they
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element
const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +
'header,h1,h2,h3,h4,h5,h6,hgroup,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,rtc,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,menuitem,' +
'summary,content,element,shadow,template,blockquote,iframe,tfoot';
// https://developer.mozilla.org/en-US/docs/Web/SVG/Element
const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +
'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +
'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +
'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +
'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +
'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +
'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +
'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +
'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +
'text,textPath,title,tspan,unknown,use,view';
const VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';
const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);
const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);
const isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);
function looseEqual(a, b) {
if (a === b)
return true;
const isObjectA = isObject(a);
const isObjectB = isObject(b);
if (isObjectA && isObjectB) {
try {
const isArrayA = isArray(a);
const isArrayB = isArray(b);
if (isArrayA && isArrayB) {
return (a.length === b.length &&
a.every((e, i) => looseEqual(e, b[i])));
}
else if (a instanceof Date && b instanceof Date) {
return a.getTime() === b.getTime();
}
else if (!isArrayA && !isArrayB) {
const keysA = Object.keys(a);
const keysB = Object.keys(b);
return (keysA.length === keysB.length &&
keysA.every(key => looseEqual(a[key], b[key])));
}
else {
/* istanbul ignore next */
return false;
}
}
catch (e) {
/* istanbul ignore next */
return false;
}
}
else if (!isObjectA && !isObjectB) {
return String(a) === String(b);
}
else {
return false;
}
}
function looseIndexOf(arr, val) {
return arr.findIndex(item => looseEqual(item, val));
}
// For converting {{ interpolation }} values to displayed strings.
const toDisplayString = (val) => {
return val == null
? ''
: isObject(val)
? JSON.stringify(val, replacer, 2)
: String(val);
};
const replacer = (_key, val) => {
if (val instanceof Map) {
return {
[`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {
entries[`${key} =>`] = val;
return entries;
}, {})
};
}
else if (val instanceof Set) {
return {
[`Set(${val.size})`]: [...val.values()]
};
}
else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
return String(val);
}
return val;
};
const EMPTY_OBJ = Object.freeze({})
;
const EMPTY_ARR = [];
const NOOP = () => { };
/**
* Always return false.
*/
const NO = () => false;
const onRE = /^on[^a-z]/;
const isOn = (key) => onRE.test(key);
const extend = Object.assign;
const remove = (arr, el) => {
const i = arr.indexOf(el);
if (i > -1) {
arr.splice(i, 1);
}
};
const hasOwnProperty = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
const isArray = Array.isArray;
const isFunction = (val) => typeof val === 'function';
const isString = (val) => typeof val === 'string';
const isSymbol = (val) => typeof val === 'symbol';
const isObject = (val) => val !== null && typeof val === 'object';
const isPromise = (val) => {
return isObject(val) && isFunction(val.then) && isFunction(val.catch);
};
const objectToString = Object.prototype.toString;
const toTypeString = (value) => objectToString.call(value);
const toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
const isPlainObject = (val) => toTypeString(val) === '[object Object]';
const isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +
'onVnodeBeforeMount,onVnodeMounted,' +
'onVnodeBeforeUpdate,onVnodeUpdated,' +
'onVnodeBeforeUnmount,onVnodeUnmounted');
const cacheStringFunction = (fn) => {
const cache = Object.create(null);
return ((str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
});
};
const camelizeRE = /-(\w)/g;
const camelize = cacheStringFunction((str) => {
return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
});
const hyphenateRE = /\B([A-Z])/g;
const hyphenate = cacheStringFunction((str) => {
return str.replace(hyphenateRE, '-$1').toLowerCase();
});
const capitalize = cacheStringFunction((str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
});
// compare whether a value has changed, accounting for NaN.
const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
const invokeArrayFns = (fns, arg) => {
for (let i = 0; i < fns.length; i++) {
fns[i](arg);
}
};
const def = (obj, key, value) => {
Object.defineProperty(obj, key, {
configurable: true,
value
});
};
const toNumber = (val) => {
const n = parseFloat(val);
return isNaN(n) ? val : n;
};
function defaultOnError(error) {
throw error;
}
function createCompilerError(code, loc, messages, additionalMessage) {
const msg = (messages || errorMessages)[code] + (additionalMessage || ``)
;
const error = new SyntaxError(String(msg));
error.code = code;
error.loc = loc;
return error;
}
const errorMessages = {
// parse errors
[0 /* ABRUPT_CLOSING_OF_EMPTY_COMMENT */]: 'Illegal comment.',
[1 /* CDATA_IN_HTML_CONTENT */]: 'CDATA section is allowed only in XML context.',
[2 /* DUPLICATE_ATTRIBUTE */]: 'Duplicate attribute.',
[3 /* END_TAG_WITH_ATTRIBUTES */]: 'End tag cannot have attributes.',
[4 /* END_TAG_WITH_TRAILING_SOLIDUS */]: "Illegal '/' in tags.",
[5 /* EOF_BEFORE_TAG_NAME */]: 'Unexpected EOF in tag.',
[6 /* EOF_IN_CDATA */]: 'Unexpected EOF in CDATA section.',
[7 /* EOF_IN_COMMENT */]: 'Unexpected EOF in comment.',
[8 /* EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */]: 'Unexpected EOF in script.',
[9 /* EOF_IN_TAG */]: 'Unexpected EOF in tag.',
[10 /* INCORRECTLY_CLOSED_COMMENT */]: 'Incorrectly closed comment.',
[11 /* INCORRECTLY_OPENED_COMMENT */]: 'Incorrectly opened comment.',
[12 /* INVALID_FIRST_CHARACTER_OF_TAG_NAME */]: "Illegal tag name. Use '<' to print '<'.",
[13 /* MISSING_ATTRIBUTE_VALUE */]: 'Attribute value was expected.',
[14 /* MISSING_END_TAG_NAME */]: 'End tag name was expected.',
[15 /* MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */]: 'Whitespace was expected.',
[16 /* NESTED_COMMENT */]: "Unexpected '<!--' in comment.",
[17 /* UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */]: 'Attribute name cannot contain U+0022 ("), U+0027 (\'), and U+003C (<).',
[18 /* UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */]: 'Unquoted attribute value cannot contain U+0022 ("), U+0027 (\'), U+003C (<), U+003D (=), and U+0060 (`).',
[19 /* UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */]: "Attribute name cannot start with '='.",
[21 /* UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */]: "'<?' is allowed only in XML context.",
[22 /* UNEXPECTED_SOLIDUS_IN_TAG */]: "Illegal '/' in tags.",
// Vue-specific parse errors
[23 /* X_INVALID_END_TAG */]: 'Invalid end tag.',
[24 /* X_MISSING_END_TAG */]: 'Element is missing end tag.',
[25 /* X_MISSING_INTERPOLATION_END */]: 'Interpolation end sign was not found.',
[26 /* X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */]: 'End bracket for dynamic directive argument was not found. ' +
'Note that dynamic directive argument cannot contain spaces.',
// transform errors
[27 /* X_V_IF_NO_EXPRESSION */]: `v-if/v-else-if is missing expression.`,
[28 /* X_V_ELSE_NO_ADJACENT_IF */]: `v-else/v-else-if has no adjacent v-if.`,
[29 /* X_V_FOR_NO_EXPRESSION */]: `v-for is missing expression.`,
[30 /* X_V_FOR_MALFORMED_EXPRESSION */]: `v-for has invalid expression.`,
[31 /* X_V_BIND_NO_EXPRESSION */]: `v-bind is missing expression.`,
[32 /* X_V_ON_NO_EXPRESSION */]: `v-on is missing expression.`,
[33 /* X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */]: `Unexpected custom directive on <slot> outlet.`,
[34 /* X_V_SLOT_MIXED_SLOT_USAGE */]: `Mixed v-slot usage on both the component and nested <template>.` +
`When there are multiple named slots, all slots should use <template> ` +
`syntax to avoid scope ambiguity.`,
[35 /* X_V_SLOT_DUPLICATE_SLOT_NAMES */]: `Duplicate slot names found. `,
[36 /* X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */]: `Extraneous children found when component already has explicitly named ` +
`default slot. These children will be ignored.`,
[37 /* X_V_SLOT_MISPLACED */]: `v-slot can only be used on components or <template> tags.`,
[38 /* X_V_MODEL_NO_EXPRESSION */]: `v-model is missing expression.`,
[39 /* X_V_MODEL_MALFORMED_EXPRESSION */]: `v-model value must be a valid JavaScript member expression.`,
[40 /* X_V_MODEL_ON_SCOPE_VARIABLE */]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
[41 /* X_INVALID_EXPRESSION */]: `Error parsing JavaScript expression: `,
[42 /* X_KEEP_ALIVE_INVALID_CHILDREN */]: `<KeepAlive> expects exactly one child component.`,
// generic errors
[43 /* X_PREFIX_ID_NOT_SUPPORTED */]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
[44 /* X_MODULE_MODE_NOT_SUPPORTED */]: `ES module mode is not supported in this build of compiler.`,
[45 /* X_CACHE_HANDLER_NOT_SUPPORTED */]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
[46 /* X_SCOPE_ID_NOT_SUPPORTED */]: `"scopeId" option is only supported in module mode.`
};
const FRAGMENT = Symbol( `Fragment` );
const TELEPORT = Symbol( `Teleport` );
const SUSPENSE = Symbol( `Suspense` );
const KEEP_ALIVE = Symbol( `KeepAlive` );
const BASE_TRANSITION = Symbol( `BaseTransition` );
const OPEN_BLOCK = Symbol( `openBlock` );
const CREATE_BLOCK = Symbol( `createBlock` );
const CREATE_VNODE = Symbol( `createVNode` );
const CREATE_COMMENT = Symbol( `createCommentVNode` );
const CREATE_TEXT = Symbol( `createTextVNode` );
const CREATE_STATIC = Symbol( `createStaticVNode` );
const RESOLVE_COMPONENT = Symbol( `resolveComponent` );
const RESOLVE_DYNAMIC_COMPONENT = Symbol( `resolveDynamicComponent` );
const RESOLVE_DIRECTIVE = Symbol( `resolveDirective` );
const WITH_DIRECTIVES = Symbol( `withDirectives` );
const RENDER_LIST = Symbol( `renderList` );
const RENDER_SLOT = Symbol( `renderSlot` );
const CREATE_SLOTS = Symbol( `createSlots` );
const TO_DISPLAY_STRING = Symbol( `toDisplayString` );
const MERGE_PROPS = Symbol( `mergeProps` );
const TO_HANDLERS = Symbol( `toHandlers` );
const CAMELIZE = Symbol( `camelize` );
const SET_BLOCK_TRACKING = Symbol( `setBlockTracking` );
const PUSH_SCOPE_ID = Symbol( `pushScopeId` );
const POP_SCOPE_ID = Symbol( `popScopeId` );
const WITH_SCOPE_ID = Symbol( `withScopeId` );
const WITH_CTX = Symbol( `withCtx` );
// Name mapping for runtime helpers that need to be imported from 'vue' in
// generated code. Make sure these are correctly exported in the runtime!
// Using `any` here because TS doesn't allow symbols as index type.
const helperNameMap = {
[FRAGMENT]: `Fragment`,
[TELEPORT]: `Teleport`,
[SUSPENSE]: `Suspense`,
[KEEP_ALIVE]: `KeepAlive`,
[BASE_TRANSITION]: `BaseTransition`,
[OPEN_BLOCK]: `openBlock`,
[CREATE_BLOCK]: `createBlock`,
[CREATE_VNODE]: `createVNode`,
[CREATE_COMMENT]: `createCommentVNode`,
[CREATE_TEXT]: `createTextVNode`,
[CREATE_STATIC]: `createStaticVNode`,
[RESOLVE_COMPONENT]: `resolveComponent`,
[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
[RESOLVE_DIRECTIVE]: `resolveDirective`,
[WITH_DIRECTIVES]: `withDirectives`,
[RENDER_LIST]: `renderList`,
[RENDER_SLOT]: `renderSlot`,
[CREATE_SLOTS]: `createSlots`,
[TO_DISPLAY_STRING]: `toDisplayString`,
[MERGE_PROPS]: `mergeProps`,
[TO_HANDLERS]: `toHandlers`,
[CAMELIZE]: `camelize`,
[SET_BLOCK_TRACKING]: `setBlockTracking`,
[PUSH_SCOPE_ID]: `pushScopeId`,
[POP_SCOPE_ID]: `popScopeId`,
[WITH_SCOPE_ID]: `withScopeId`,
[WITH_CTX]: `withCtx`
};
function registerRuntimeHelpers(helpers) {
Object.getOwnPropertySymbols(helpers).forEach(s => {
helperNameMap[s] = helpers[s];
});
}
// AST Utilities ---------------------------------------------------------------
// Some expressions, e.g. sequence and conditional expressions, are never
// associated with template nodes, so their source locations are just a stub.
// Container types like CompoundExpression also don't need a real location.
const locStub = {
source: '',
start: { line: 1, column: 1, offset: 0 },
end: { line: 1, column: 1, offset: 0 }
};
function createRoot(children, loc = locStub) {
return {
type: 0 /* ROOT */,
children,
helpers: [],
components: [],
directives: [],
hoists: [],
imports: [],
cached: 0,
temps: 0,
codegenNode: undefined,
loc
};
}
function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, isForBlock = false, loc = locStub) {
if (context) {
if (isBlock) {
context.helper(OPEN_BLOCK);
context.helper(CREATE_BLOCK);
}
else {
context.helper(CREATE_VNODE);
}
if (directives) {
context.helper(WITH_DIRECTIVES);
}
}
return {
type: 13 /* VNODE_CALL */,
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
isForBlock,
loc
};
}
function createArrayExpression(elements, loc = locStub) {
return {
type: 17 /* JS_ARRAY_EXPRESSION */,
loc,
elements
};
}
function createObjectExpression(properties, loc = locStub) {
return {
type: 15 /* JS_OBJECT_EXPRESSION */,
loc,
properties
};
}
function createObjectProperty(key, value) {
return {
type: 16 /* JS_PROPERTY */,
loc: locStub,
key: isString(key) ? createSimpleExpression(key, true) : key,
value
};
}
function createSimpleExpression(content, isStatic, loc = locStub, isConstant = false) {
return {
type: 4 /* SIMPLE_EXPRESSION */,
loc,
isConstant,
content,
isStatic
};
}
function createCompoundExpression(children, loc = locStub) {
return {
type: 8 /* COMPOUND_EXPRESSION */,
loc,
children
};
}
function createCallExpression(callee, args = [], loc = locStub) {
return {
type: 14 /* JS_CALL_EXPRESSION */,
loc,
callee,
arguments: args
};
}
function createFunctionExpression(params, returns = undefined, newline = false, isSlot = false, loc = locStub) {
return {
type: 18 /* JS_FUNCTION_EXPRESSION */,
params,
returns,
newline,
isSlot,
loc
};
}
function createConditionalExpression(test, consequent, alternate, newline = true) {
return {
type: 19 /* JS_CONDITIONAL_EXPRESSION */,
test,
consequent,
alternate,
newline,
loc: locStub
};
}
function createCacheExpression(index, value, isVNode = false) {
return {
type: 20 /* JS_CACHE_EXPRESSION */,
index,
value,
isVNode,
loc: locStub
};
}
const isBuiltInType = (tag, expected) => tag === expected || tag === hyphenate(expected);
function isCoreComponent(tag) {
if (isBuiltInType(tag, 'Teleport')) {
return TELEPORT;
}
else if (isBuiltInType(tag, 'Suspense')) {
return SUSPENSE;
}
else if (isBuiltInType(tag, 'KeepAlive')) {
return KEEP_ALIVE;
}
else if (isBuiltInType(tag, 'BaseTransition')) {
return BASE_TRANSITION;
}
}
const nonIdentifierRE = /^\d|[^\$\w]/;
const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
const memberExpRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[^\]]+\])*$/;
const isMemberExpression = (path) => {
if (!path)
return false;
return memberExpRE.test(path.trim());
};
function getInnerRange(loc, offset, length) {
const source = loc.source.substr(offset, length);
const newLoc = {
source,
start: advancePositionWithClone(loc.start, loc.source, offset),
end: loc.end
};
if (length != null) {
newLoc.end = advancePositionWithClone(loc.start, loc.source, offset + length);
}
return newLoc;
}
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
return advancePositionWithMutation(extend({}, pos), source, numberOfCharacters);
}
// advance by mutation without cloning (for performance reasons), since this
// gets called a lot in the parser
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
let linesCount = 0;
let lastNewLinePos = -1;
for (let i = 0; i < numberOfCharacters; i++) {
if (source.charCodeAt(i) === 10 /* newline char code */) {
linesCount++;
lastNewLinePos = i;
}
}
pos.offset += numberOfCharacters;
pos.line += linesCount;
pos.column =
lastNewLinePos === -1
? pos.column + numberOfCharacters
: numberOfCharacters - lastNewLinePos;
return pos;
}
function assert(condition, msg) {
/* istanbul ignore if */
if (!condition) {
throw new Error(msg || `unexpected compiler condition`);
}
}
function findDir(node, name, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 /* DIRECTIVE */ &&
(allowEmpty || p.exp) &&
(isString(name) ? p.name === name : name.test(p.name))) {
return p;
}
}
}
function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6 /* ATTRIBUTE */) {
if (dynamicOnly)
continue;
if (p.name === name && (p.value || allowEmpty)) {
return p;
}
}
else if (p.name === 'bind' && p.exp && isBindKey(p.arg, name)) {
return p;
}
}
}
function isBindKey(arg, name) {
return !!(arg &&
arg.type === 4 /* SIMPLE_EXPRESSION */ &&
arg.isStatic &&
arg.content === name);
}
function hasDynamicKeyVBind(node) {
return node.props.some(p => p.type === 7 /* DIRECTIVE */ &&
p.name === 'bind' &&
(!p.arg || // v-bind="obj"
p.arg.type !== 4 /* SIMPLE_EXPRESSION */ || // v-bind:[_ctx.foo]
!p.arg.isStatic) // v-bind:[foo]
);
}
function isText(node) {
return node.type === 5 /* INTERPOLATION */ || node.type === 2 /* TEXT */;
}
function isVSlot(p) {
return p.type === 7 /* DIRECTIVE */ && p.name === 'slot';
}
function isTemplateNode(node) {
return (node.type === 1 /* ELEMENT */ && node.tagType === 3 /* TEMPLATE */);
}
function isSlotOutlet(node) {
return node.type === 1 /* ELEMENT */ && node.tagType === 2 /* SLOT */;
}
function injectProp(node, prop, context) {
let propsWithInjection;
const props = node.type === 13 /* VNODE_CALL */ ? node.props : node.arguments[2];
if (props == null || isString(props)) {
propsWithInjection = createObjectExpression([prop]);
}
else if (props.type === 14 /* JS_CALL_EXPRESSION */) {
// merged props... add ours
// only inject key to object literal if it's the first argument so that
// if doesn't override user provided keys
const first = props.arguments[0];
if (!isString(first) && first.type === 15 /* JS_OBJECT_EXPRESSION */) {
first.properties.unshift(prop);
}
else {
props.arguments.unshift(createObjectExpression([prop]));
}
propsWithInjection = props;
}
else if (props.type === 15 /* JS_OBJECT_EXPRESSION */) {
let alreadyExists = false;
// check existing key to avoid overriding user provided keys
if (prop.key.type === 4 /* SIMPLE_EXPRESSION */) {
const propKeyName = prop.key.content;
alreadyExists = props.properties.some(p => p.key.type === 4 /* SIMPLE_EXPRESSION */ &&
p.key.content === propKeyName);
}
if (!alreadyExists) {
props.properties.unshift(prop);
}
propsWithInjection = props;
}
else {
// single v-bind with expression, return a merged replacement
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
createObjectExpression([prop]),
props
]);
}
if (node.type === 13 /* VNODE_CALL */) {
node.props = propsWithInjection;
}
else {
node.arguments[2] = propsWithInjection;
}
}
function toValidAssetId(name, type) {
return `_${type}_${name.replace(/[^\w]/g, '_')}`;
}
// The default decoder only provides escapes for characters reserved as part of
// the template syntax, and is only used if the custom renderer did not provide
// a platform-specific decoder.
const decodeRE = /&(gt|lt|amp|apos|quot);/g;
const decodeMap = {
gt: '>',
lt: '<',
amp: '&',
apos: "'",
quot: '"'
};
const defaultParserOptions = {
delimiters: [`{{`, `}}`],
getNamespace: () => 0 /* HTML */,
getTextMode: () => 0 /* DATA */,
isVoidTag: NO,
isPreTag: NO,
isCustomElement: NO,
decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),
onError: defaultOnError
};
function baseParse(content, options = {}) {
const context = createParserContext(content, options);
const start = getCursor(context);
return createRoot(parseChildren(context, 0 /* DATA */, []), getSelection(context, start));
}
function createParserContext(content, options) {
return {
options: extend({}, defaultParserOptions, options),
column: 1,
line: 1,
offset: 0,
originalSource: content,
source: content,
inPre: false,
inVPre: false
};
}
function parseChildren(context, mode, ancestors) {
const parent = last(ancestors);
const ns = parent ? parent.ns : 0 /* HTML */;
const nodes = [];
while (!isEnd(context, mode, ancestors)) {
const s = context.source;
let node = undefined;
if (mode === 0 /* DATA */ || mode === 1 /* RCDATA */) {
if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {
// '{{'
node = parseInterpolation(context, mode);
}
else if (mode === 0 /* DATA */ && s[0] === '<') {
// https://html.spec.whatwg.org/multipage/parsing.html#tag-open-state
if (s.length === 1) {
emitError(context, 5 /* EOF_BEFORE_TAG_NAME */, 1);
}
else if (s[1] === '!') {
// https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state
if (startsWith(s, '<!--')) {
node = parseComment(context);
}
else if (startsWith(s, '<!DOCTYPE')) {
// Ignore DOCTYPE by a limitation.
node = parseBogusComment(context);
}
else if (startsWith(s, '<![CDATA[')) {
if (ns !== 0 /* HTML */) {
node = parseCDATA(context, ancestors);
}
else {
emitError(context, 1 /* CDATA_IN_HTML_CONTENT */);
node = parseBogusComment(context);
}
}
else {
emitError(context, 11 /* INCORRECTLY_OPENED_COMMENT */);
node = parseBogusComment(context);
}
}
else if (s[1] === '/') {
// https://html.spec.whatwg.org/multipage/parsing.html#end-tag-open-state
if (s.length === 2) {
emitError(context, 5 /* EOF_BEFORE_TAG_NAME */, 2);
}
else if (s[2] === '>') {
emitError(context, 14 /* MISSING_END_TAG_NAME */, 2);
advanceBy(context, 3);
continue;
}
else if (/[a-z]/i.test(s[2])) {
emitError(context, 23 /* X_INVALID_END_TAG */);
parseTag(context, 1 /* End */, parent);
continue;
}
else {
emitError(context, 12 /* INVALID_FIRST_CHARACTER_OF_TAG_NAME */, 2);
node = parseBogusComment(context);
}
}
else if (/[a-z]/i.test(s[1])) {
node = parseElement(context, ancestors);
}
else if (s[1] === '?') {
emitError(context, 21 /* UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */, 1);
node = parseBogusComment(context);
}
else {
emitError(context, 12 /* INVALID_FIRST_CHARACTER_OF_TAG_NAME */, 1);
}
}
}
if (!node) {
node = parseText(context, mode);
}
if (isArray(node)) {
for (let i = 0; i < node.length; i++) {
pushNode(nodes, node[i]);
}
}
else {
pushNode(nodes, node);
}
}
// Whitespace management for more efficient output
// (same as v2 whitespace: 'condense')
let removedWhitespace = false;
if (mode !== 2 /* RAWTEXT */) {
if (!context.inPre) {
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (node.type === 2 /* TEXT */) {
if (!/[^\t\r\n\f ]/.test(node.content)) {
const prev = nodes[i - 1];
const next = nodes[i + 1];
// If:
// - the whitespace is the first or last node, or:
// - the whitespace is adjacent to a comment, or:
// - the whitespace is between two elements AND contains newline
// Then the whitespace is ignored.
if (!prev ||
!next ||
prev.type === 3 /* COMMENT */ ||
next.type === 3 /* COMMENT */ ||
(prev.type === 1 /* ELEMENT */ &&
next.type === 1 /* ELEMENT */ &&
/[\r\n]/.test(node.content))) {
removedWhitespace = true;
nodes[i] = null;
}
else {
// Otherwise, condensed consecutive whitespace inside the text
// down to a single space
node.content = ' ';
}
}
else {
node.content = node.content.replace(/[\t\r\n\f ]+/g, ' ');
}
}
}
}
else if (parent && context.options.isPreTag(parent.tag)) {
// remove leading newline per html spec
// https://html.spec.whatwg.org/multipage/grouping-content.html#the-pre-element
const first = nodes[0];
if (first && first.type === 2 /* TEXT */) {
first.content = first.content.replace(/^\r?\n/, '');
}
}
}
return removedWhitespace ? nodes.filter(Boolean) : nodes;
}
function pushNode(nodes, node) {
if (node.type === 2 /* TEXT */) {
const prev = last(nodes);
// Merge if both this and the previous node are text and those are
// consecutive. This happens for cases like "a < b".
if (prev &&
prev.type === 2 /* TEXT */ &&
prev.loc.end.offset === node.loc.start.offset) {
prev.content += node.content;
prev.loc.end = node.loc.end;
prev.loc.source += node.loc.source;
return;
}
}
nodes.push(node);
}
function parseCDATA(context, ancestors) {
advanceBy(context, 9);
const nodes = parseChildren(context, 3 /* CDATA */, ancestors);
if (context.source.length === 0) {
emitError(context, 6 /* EOF_IN_CDATA */);
}
else {
advanceBy(context, 3);
}
return nodes;
}
function parseComment(context) {
const start = getCursor(context);
let content;
// Regular comment.
const match = /--(\!)?>/.exec(context.source);
if (!match) {
content = context.source.slice(4);
advanceBy(context, context.source.length);
emitError(context, 7 /* EOF_IN_COMMENT */);
}
else {
if (match.index <= 3) {
emitError(context, 0 /* ABRUPT_CLOSING_OF_EMPTY_COMMENT */);
}
if (match[1]) {
emitError(context, 10 /* INCORRECTLY_CLOSED_COMMENT */);
}
content = context.source.slice(4, match.index);
// Advancing with reporting nested comments.
const s = context.source.slice(0, match.index);
let prevIndex = 1, nestedIndex = 0;
while ((nestedIndex = s.indexOf('<!--', prevIndex)) !== -1) {
advanceBy(context, nestedIndex - prevIndex + 1);
if (nestedIndex + 4 < s.length) {
emitError(context, 16 /* NESTED_COMMENT */);
}
prevIndex = nestedIndex + 1;
}
advanceBy(context, match.index + match[0].length - prevIndex + 1);
}
return {
type: 3 /* COMMENT */,
content,
loc: getSelection(context, start)
};
}
function parseBogusComment(context) {
const start = getCursor(context);
const contentStart = context.source[1] === '?' ? 1 : 2;
let content;
const closeIndex = context.source.indexOf('>');
if (closeIndex === -1) {
content = context.source.slice(contentStart);
advanceBy(context, context.source.length);
}
else {
content = context.source.slice(contentStart, closeIndex);
advanceBy(context, closeIndex + 1);
}
return {
type: 3 /* COMMENT */,
content,
loc: getSelection(context, start)
};
}
function parseElement(context, ancestors) {
// Start tag.
const wasInPre = context.inPre;
const wasInVPre = context.inVPre;
const parent = last(ancestors);
const element = parseTag(context, 0 /* Start */, parent);
const isPreBoundary = context.inPre && !wasInPre;
const isVPreBoundary = context.inVPre && !wasInVPre;
if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
return element;
}
// Children.
ancestors.push(element);
const mode = context.options.getTextMode(element, parent);
const children = parseChildren(context, mode, ancestors);
ancestors.pop();
element.children = children;
// End tag.
if (startsWithEndTagOpen(context.source, element.tag)) {
parseTag(context, 1 /* End */, parent);
}
else {
emitError(context, 24 /* X_MISSING_END_TAG */, 0, element.loc.start);
if (context.source.length === 0 && element.tag.toLowerCase() === 'script') {
const first = children[0];
if (first && startsWith(first.loc.source, '<!--')) {
emitError(context, 8 /* EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */);
}
}
}
element.loc = getSelection(context, element.loc.start);
if (isPreBoundary) {
context.inPre = false;
}
if (isVPreBoundary) {
context.inVPre = false;
}
return element;
}
const isSpecialTemplateDirective = /*#__PURE__*/ makeMap(`if,else,else-if,for,slot`);
/**
* Parse a tag (E.g. `<div id=a>`) with that type (start tag or end tag).
*/
function parseTag(context, type, parent) {
// Tag open.
const start = getCursor(context);
const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source);
const tag = match[1];
const ns = context.options.getNamespace(tag, parent);
advanceBy(context, match[0].length);
advanceSpaces(context);
// save current state in case we need to re-parse attributes with v-pre
const cursor = getCursor(context);
const currentSource = context.source;
// Attributes.
let props = parseAttributes(context, type);
// check <pre> tag
if (context.options.isPreTag(tag)) {
context.inPre = true;
}
// check v-pre
if (!context.inVPre &&
props.some(p => p.type === 7 /* DIRECTIVE */ && p.name === 'pre')) {
context.inVPre = true;
// reset context
extend(context, cursor);
context.source = currentSource;
// re-parse attrs and filter out v-pre itself
props = parseAttributes(context, type).filter(p => p.name !== 'v-pre');
}
// Tag close.
let isSelfClosing = false;
if (context.source.length === 0) {
emitError(context, 9 /* EOF_IN_TAG */);
}
else {
isSelfClosing = startsWith(context.source, '/>');
if (type === 1 /* End */ && isSelfClosing) {
emitError(context, 4 /* END_TAG_WITH_TRAILING_SOLIDUS */);
}
advanceBy(context, isSelfClosing ? 2 : 1);
}
let tagType = 0 /* ELEMENT */;
const options = context.options;
if (!context.inVPre && !options.isCustomElement(tag)) {
const hasVIs = props.some(p => p.type === 7 /* DIRECTIVE */ && p.name === 'is');
if (options.isNativeTag && !hasVIs) {
if (!options.isNativeTag(tag))
tagType = 1 /* COMPONENT */;
}
else if (hasVIs ||
isCoreComponent(tag) ||
(options.isBuiltInComponent && options.isBuiltInComponent(tag)) ||
/^[A-Z]/.test(tag) ||
tag === 'component') {
tagType = 1 /* COMPONENT */;
}
if (tag === 'slot') {
tagType = 2 /* SLOT */;
}
else if (tag === 'template' &&
props.some(p => {
return (p.type === 7 /* DIRECTIVE */ && isSpecialTemplateDirective(p.name));
})) {
tagType = 3 /* TEMPLATE */;
}
}
return {
type: 1 /* ELEMENT */,
ns,
tag,
tagType,
props,
isSelfClosing,
children: [],
loc: getSelection(context, start),
codegenNode: undefined // to be created during transform phase
};
}
function parseAttributes(context, type) {
const props = [];
const attributeNames = new Set();
while (context.source.length > 0 &&
!startsWith(context.source, '>') &&
!startsWith(context.source, '/>')) {
if (startsWith(context.source, '/')) {
emitError(context, 22 /* UNEXPECTED_SOLIDUS_IN_TAG */);
advanceBy(context, 1);
advanceSpaces(context);
continue;
}
if (type === 1 /* End */) {
emitError(context, 3 /* END_TAG_WITH_ATTRIBUTES */);
}
const attr = parseAttribute(context, attributeNames);
if (type === 0 /* Start */) {
props.push(attr);
}
if (/^[^\t\r\n\f />]/.test(context.source)) {
emitError(context, 15 /* MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */);
}
advanceSpaces(context);
}
return props;
}
function parseAttribute(context, nameSet) {
// Name.
const start = getCursor(context);
const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source);
const name = match[0];
if (nameSet.has(name)) {
emitError(context, 2 /* DUPLICATE_ATTRIBUTE */);
}
nameSet.add(name);
if (name[0] === '=') {
emitError(context, 19 /* UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */);
}
{
const pattern = /["'<]/g;
let m;
while ((m = pattern.exec(name))) {
emitError(context, 17 /* UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */, m.index);
}
}
advanceBy(context, name.length);
// Value
let value = undefined;
if (/^[\t\r\n\f ]*=/.test(context.source)) {
advanceSpaces(context);
advanceBy(context, 1);
advanceSpaces(context);
value = parseAttributeValue(context);
if (!value) {
emitError(context, 13 /* MISSING_ATTRIBUTE_VALUE */);
}
}
const loc = getSelection(context, start);
if (!context.inVPre && /^(v-|:|@|#)/.test(name)) {
const match = /(?:^v-([a-z0-9-]+))?(?:(?::|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(name);
const dirName = match[1] ||
(startsWith(name, ':') ? 'bind' : startsWith(name, '@') ? 'on' : 'slot');
let arg;
if (match[2]) {
const isSlot = dirName === 'slot';
const startOffset = name.indexOf(match[2]);
const loc = getSelection(context, getNewPosition(context, start, startOffset), getNewPosition(context, start, startOffset + match[2].length + ((isSlot && match[3]) || '').length));
let content = match[2];
let isStatic = true;
if (content.startsWith('[')) {
isStatic = false;
if (!content.endsWith(']')) {
emitError(context, 26 /* X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */);
}
content = content.substr(1, content.length - 2);
}
else if (isSlot) {
// #1241 special case for v-slot: vuetify relies extensively on slot
// names containing dots. v-slot doesn't have any modifiers and Vue 2.x
// supports such usage so we are keeping it consistent with 2.x.
content += match[3] || '';
}
arg = {
type: 4 /* SIMPLE_EXPRESSION */,
content,
isStatic,
isConstant: isStatic,
loc
};
}
if (value && value.isQuoted) {
const valueLoc = value.loc;
valueLoc.start.offset++;
valueLoc.start.column++;
valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);
valueLoc.source = valueLoc.source.slice(1, -1);
}
return {
type: 7 /* DIRECTIVE */,
name: dirName,
exp: value && {
type: 4 /* SIMPLE_EXPRESSION */,
content: value.content,
isStatic: false,
// Treat as non-constant by default. This can be potentially set to
// true by `transformExpression` to make it eligible for hoisting.
isConstant: false,
loc: value.loc
},
arg,
modifiers: match[3] ? match[3].substr(1).split('.') : [],
loc
};
}
return {
type: 6 /* ATTRIBUTE */,
name,
value: value && {
type: 2 /* TEXT */,
content: value.content,
loc: value.loc
},
loc
};
}
function parseAttributeValue(context) {
const start = getCursor(context);
let content;
const quote = context.source[0];
const isQuoted = quote === `"` || quote === `'`;
if (isQuoted) {
// Quoted value.
advanceBy(context, 1);
const endIndex = context.source.indexOf(quote);
if (endIndex === -1) {
content = parseTextData(context, context.source.length, 4 /* ATTRIBUTE_VALUE */);
}
else {
content = parseTextData(context, endIndex, 4 /* ATTRIBUTE_VALUE */);
advanceBy(context, 1);
}
}
else {
// Unquoted
const match = /^[^\t\r\n\f >]+/.exec(context.source);
if (!match) {
return undefined;
}
const unexpectedChars = /["'<=`]/g;
let m;
while ((m = unexpectedChars.exec(match[0]))) {
emitError(context, 18 /* UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */, m.index);
}
content = parseTextData(context, match[0].length, 4 /* ATTRIBUTE_VALUE */);
}
return { content, isQuoted, loc: getSelection(context, start) };
}
function parseInterpolation(context, mode) {
const [open, close] = context.options.delimiters;
const closeIndex = context.source.indexOf(close, open.length);
if (closeIndex === -1) {
emitError(context, 25 /* X_MISSING_INTERPOLATION_END */);
return undefined;
}
const start = getCursor(context);
advanceBy(context, open.length);
const innerStart = getCursor(context);
const innerEnd = getCursor(context);
const rawContentLength = closeIndex - open.length;
const rawContent = context.source.slice(0, rawContentLength);
const preTrimContent = parseTextData(context, rawContentLength, mode);
const content = preTrimContent.trim();
const startOffset = preTrimContent.indexOf(content);
if (startOffset > 0) {
advancePositionWithMutation(innerStart, rawContent, startOffset);
}
const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);
advancePositionWithMutation(innerEnd, rawContent, endOffset);
advanceBy(context, close.length);
return {
type: 5 /* INTERPOLATION */,
content: {
type: 4 /* SIMPLE_EXPRESSION */,
isStatic: false,
// Set `isConstant` to false by default and will decide in transformExpression
isConstant: false,
content,
loc: getSelection(context, innerStart, innerEnd)
},
loc: getSelection(context, start)
};
}
function parseText(context, mode) {
const endTokens = ['<', context.options.delimiters[0]];
if (mode === 3 /* CDATA */) {
endTokens.push(']]>');
}
let endIndex = context.source.length;
for (let i = 0; i < endTokens.length; i++) {
const index = context.source.indexOf(endTokens[i], 1);
if (index !== -1 && endIndex > index) {
endIndex = index;
}
}
const start = getCursor(context);
const content = parseTextData(context, endIndex, mode);
return {
type: 2 /* TEXT */,
content,
loc: getSelection(context, start)
};
}
/**
* Get text data with a given length from the current location.
* This translates HTML entities in the text data.
*/
function parseTextData(context, length, mode) {
const rawText = context.source.slice(0, length);
advanceBy(context, length);
if (mode === 2 /* RAWTEXT */ ||
mode === 3 /* CDATA */ ||
rawText.indexOf('&') === -1) {
return rawText;
}
else {
// DATA or RCDATA containing "&"". Entity decoding required.
return context.options.decodeEntities(rawText, mode === 4 /* ATTRIBUTE_VALUE */);
}
}
function getCursor(context) {
const { column, line, offset } = context;
return { column, line, offset };
}
function getSelection(context, start, end) {
end = end || getCursor(context);
return {
start,
end,
source: context.originalSource.slice(start.offset, end.offset)
};
}
function last(xs) {
return xs[xs.length - 1];
}
function startsWith(source, searchString) {
return source.startsWith(searchString);
}
function advanceBy(context, numberOfCharacters) {
const { source } = context;
advancePositionWithMutation(context, source, numberOfCharacters);
context.source = source.slice(numberOfCharacters);
}
function advanceSpaces(context) {
const match = /^[\t\r\n\f ]+/.exec(context.source);
if (match) {
advanceBy(context, match[0].length);
}
}
function getNewPosition(context, start, numberOfCharacters) {
return advancePositionWithClone(start, context.originalSource.slice(start.offset, numberOfCharacters), numberOfCharacters);
}
function emitError(context, code, offset, loc = getCursor(context)) {
if (offset) {
loc.offset += offset;
loc.column += offset;
}
context.options.onError(createCompilerError(code, {
start: loc,
end: loc,
source: ''
}));
}
function isEnd(context, mode, ancestors) {
const s = context.source;
switch (mode) {
case 0 /* DATA */:
if (startsWith(s, '</')) {
//TODO: probably bad performance
for (let i = ancestors.length - 1; i >= 0; --i) {
if (startsWithEndTagOpen(s, ancestors[i].tag)) {
return true;
}
}
}
break;
case 1 /* RCDATA */:
case 2 /* RAWTEXT */: {
const parent = last(ancestors);
if (parent && startsWithEndTagOpen(s, parent.tag)) {
return true;
}
break;
}
case 3 /* CDATA */:
if (startsWith(s, ']]>')) {
return true;
}
break;
}
return !s;
}
function startsWithEndTagOpen(source, tag) {
return (startsWith(source, '</') &&
source.substr(2, tag.length).toLowerCase() === tag.toLowerCase() &&
/[\t\n\f />]/.test(source[2 + tag.length] || '>'));
}
function hoistStatic(root, context) {
walk(root, context, new Map(),
// Root node is unfortunately non-hoistable due to potential parent
// fallthrough attributes.
isSingleElementRoot(root, root.children[0]));
}
function isSingleElementRoot(root, child) {
const { children } = root;
return (children.length === 1 &&
child.type === 1 /* ELEMENT */ &&
!isSlotOutlet(child));
}
function walk(node, context, resultCache, doNotHoistNode = false) {
let hasHoistedNode = false;
// Some transforms, e.g. trasnformAssetUrls from @vue/compiler-sfc, replaces
// static bindings with expressions. These expressions are guaranteed to be
// constant so they are still eligible for hoisting, but they are only
// available at runtime and therefore cannot be evaluated ahead of time.
// This is only a concern for pre-stringification (via transformHoist by
// @vue/compiler-dom), but doing it here allows us to perform only one full
// walk of the AST and allow `stringifyStatic` to stop walking as soon as its
// stringficiation threshold is met.
let hasRuntimeConstant = false;
const { children } = node;
for (let i = 0; i < children.length; i++) {
const child = children[i];
// only plain elements & text calls are eligible for hoisting.
if (child.type === 1 /* ELEMENT */ &&
child.tagType === 0 /* ELEMENT */) {
let staticType;
if (!doNotHoistNode &&
(staticType = getStaticType(child, resultCache)) > 0) {
if (staticType === 2 /* HAS_RUNTIME_CONSTANT */) {
hasRuntimeConstant = true;
}
child.codegenNode.patchFlag =
-1 /* HOISTED */ + ( ` /* HOISTED */` );
child.codegenNode = context.hoist(child.codegenNode);
hasHoistedNode = true;
continue;
}
else {
// node may contain dynamic children, but its props may be eligible for
// hoisting.
const codegenNode = child.codegenNode;
if (codegenNode.type === 13 /* VNODE_CALL */) {
const flag = getPatchFlag(codegenNode);
if ((!flag ||
flag === 512 /* NEED_PATCH */ ||
flag === 1 /* TEXT */) &&
!hasDynamicKeyOrRef(child) &&
!hasCachedProps()) {
const props = getNodeProps(child);
if (props) {
codegenNode.props = context.hoist(props);
}
}
}
}
}
else if (child.type === 12 /* TEXT_CALL */) {
const staticType = getStaticType(child.content, resultCache);
if (staticType > 0) {
if (staticType === 2 /* HAS_RUNTIME_CONSTANT */) {
hasRuntimeConstant = true;
}
child.codegenNode = context.hoist(child.codegenNode);
hasHoistedNode = true;
}
}
// walk further
if (child.type === 1 /* ELEMENT */) {
walk(child, context, resultCache);
}
else if (child.type === 11 /* FOR */) {
// Do not hoist v-for single child because it has to be a block
walk(child, context, resultCache, child.children.length === 1);
}
else if (child.type === 9 /* IF */) {
for (let i = 0; i < child.branches.length; i++) {
// Do not hoist v-if single child because it has to be a block
walk(child.branches[i], context, resultCache, child.branches[i].children.length === 1);
}
}
}
if (!hasRuntimeConstant && hasHoistedNode && context.transformHoist) {
context.transformHoist(children, context, node);
}
}
function getStaticType(node, resultCache = new Map()) {
switch (node.type) {
case 1 /* ELEMENT */:
if (node.tagType !== 0 /* ELEMENT */) {
return 0 /* NOT_STATIC */;
}
const cached = resultCache.get(node);
if (cached !== undefined) {
return cached;
}
const codegenNode = node.codegenNode;
if (codegenNode.type !== 13 /* VNODE_CALL */) {
return 0 /* NOT_STATIC */;
}
const flag = getPatchFlag(codegenNode);
if (!flag && !hasDynamicKeyOrRef(node) && !hasCachedProps()) {
// element self is static. check its children.
let returnType = 1 /* FULL_STATIC */;
for (let i = 0; i < node.children.length; i++) {
const childType = getStaticType(node.children[i], resultCache);
if (childType === 0 /* NOT_STATIC */) {
resultCache.set(node, 0 /* NOT_STATIC */);
return 0 /* NOT_STATIC */;
}
else if (childType === 2 /* HAS_RUNTIME_CONSTANT */) {
returnType = 2 /* HAS_RUNTIME_CONSTANT */;
}
}
// check if any of the props contain runtime constants
if (returnType !== 2 /* HAS_RUNTIME_CONSTANT */) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 /* DIRECTIVE */ &&
p.name === 'bind' &&
p.exp &&
(p.exp.type === 8 /* COMPOUND_EXPRESSION */ ||
p.exp.isRuntimeConstant)) {
returnType = 2 /* HAS_RUNTIME_CONSTANT */;
}
}
}
// only svg/foreignObject could be block here, however if they are
// stati then they don't need to be blocks since there will be no
// nested updates.
if (codegenNode.isBlock) {
codegenNode.isBlock = false;
}
resultCache.set(node, returnType);
return returnType;
}
else {
resultCache.set(node, 0 /* NOT_STATIC */);
return 0 /* NOT_STATIC */;
}
case 2 /* TEXT */:
case 3 /* COMMENT */:
return 1 /* FULL_STATIC */;
case 9 /* IF */:
case 11 /* FOR */:
case 10 /* IF_BRANCH */:
return 0 /* NOT_STATIC */;
case 5 /* INTERPOLATION */:
case 12 /* TEXT_CALL */:
return getStaticType(node.content, resultCache);
case 4 /* SIMPLE_EXPRESSION */:
return node.isConstant
? node.isRuntimeConstant
? 2 /* HAS_RUNTIME_CONSTANT */
: 1 /* FULL_STATIC */
: 0 /* NOT_STATIC */;
case 8 /* COMPOUND_EXPRESSION */:
let returnType = 1 /* FULL_STATIC */;
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (isString(child) || isSymbol(child)) {
continue;
}
const childType = getStaticType(child, resultCache);
if (childType === 0 /* NOT_STATIC */) {
return 0 /* NOT_STATIC */;
}
else if (childType === 2 /* HAS_RUNTIME_CONSTANT */) {
returnType = 2 /* HAS_RUNTIME_CONSTANT */;
}
}
return returnType;
default:
return 0 /* NOT_STATIC */;
}
}
function hasDynamicKeyOrRef(node) {
return !!(findProp(node, 'key', true) || findProp(node, 'ref', true));
}
function hasCachedProps(node) {
{
return false;
}
}
function getNodeProps(node) {
const codegenNode = node.codegenNode;
if (codegenNode.type === 13 /* VNODE_CALL */) {
return codegenNode.props;
}
}
function getPatchFlag(node) {
const flag = node.patchFlag;
return flag ? parseInt(flag, 10) : undefined;
}
function createTransformContext(root, { prefixIdentifiers = false, hoistStatic = false, cacheHandlers = false, nodeTransforms = [], directiveTransforms = {}, transformHoist = null, isBuiltInComponent = NOOP, expressionPlugins = [], scopeId = null, ssr = false, onError = defaultOnError }) {
const context = {
// options
prefixIdentifiers,
hoistStatic,
cacheHandlers,
nodeTransforms,
directiveTransforms,
transformHoist,
isBuiltInComponent,
expressionPlugins,
scopeId,
ssr,
onError,
// state
root,
helpers: new Set(),
components: new Set(),
directives: new Set(),
hoists: [],
imports: new Set(),
temps: 0,
cached: 0,
identifiers: {},
scopes: {
vFor: 0,
vSlot: 0,
vPre: 0,
vOnce: 0
},
parent: null,
currentNode: root,
childIndex: 0,
// methods
helper(name) {
context.helpers.add(name);
return name;
},
helperString(name) {
return `_${helperNameMap[context.helper(name)]}`;
},
replaceNode(node) {
/* istanbul ignore if */
{
if (!context.currentNode) {
throw new Error(`Node being replaced is already removed.`);
}
if (!context.parent) {
throw new Error(`Cannot replace root node.`);
}
}
context.parent.children[context.childIndex] = context.currentNode = node;
},
removeNode(node) {
if ( !context.parent) {
throw new Error(`Cannot remove root node.`);
}
const list = context.parent.children;
const removalIndex = node
? list.indexOf(node)
: context.currentNode
? context.childIndex
: -1;
/* istanbul ignore if */
if ( removalIndex < 0) {
throw new Error(`node being removed is not a child of current parent`);
}
if (!node || node === context.currentNode) {
// current node removed
context.currentNode = null;
context.onNodeRemoved();
}
else {
// sibling node removed
if (context.childIndex > removalIndex) {
context.childIndex--;
context.onNodeRemoved();
}
}
context.parent.children.splice(removalIndex, 1);
},
onNodeRemoved: () => { },
addIdentifiers(exp) {
},
removeIdentifiers(exp) {
},
hoist(exp) {
context.hoists.push(exp);
const identifier = createSimpleExpression(`_hoisted_${context.hoists.length}`, false, exp.loc, true);
identifier.hoisted = exp;
return identifier;
},
cache(exp, isVNode = false) {
return createCacheExpression(++context.cached, exp, isVNode);
}
};
return context;
}
function transform(root, options) {
const context = createTransformContext(root, options);
traverseNode(root, context);
if (options.hoistStatic) {
hoistStatic(root, context);
}
if (!options.ssr) {
createRootCodegen(root, context);
}
// finalize meta information
root.helpers = [...context.helpers];
root.components = [...context.components];
root.directives = [...context.directives];
root.imports = [...context.imports];
root.hoists = context.hoists;
root.temps = context.temps;
root.cached = context.cached;
}
function createRootCodegen(root, context) {
const { helper } = context;
const { children } = root;
const child = children[0];
if (children.length === 1) {
// if the single child is an element, turn it into a block.
if (isSingleElementRoot(root, child) && child.codegenNode) {
// single element root is never hoisted so codegenNode will never be
// SimpleExpressionNode
const codegenNode = child.codegenNode;
if (codegenNode.type === 13 /* VNODE_CALL */) {
codegenNode.isBlock = true;
helper(OPEN_BLOCK);
helper(CREATE_BLOCK);
}
root.codegenNode = codegenNode;
}
else {
// - single <slot/>, IfNode, ForNode: already blocks.
// - single text node: always patched.
// root codegen falls through via genNode()
root.codegenNode = child;
}
}
else if (children.length > 1) {
// root has multiple nodes - return a fragment block.
root.codegenNode = createVNodeCall(context, helper(FRAGMENT), undefined, root.children, `${64 /* STABLE_FRAGMENT */} /* ${PatchFlagNames[64 /* STABLE_FRAGMENT */]} */`, undefined, undefined, true);
}
}
function traverseChildren(parent, context) {
let i = 0;
const nodeRemoved = () => {
i--;
};
for (; i < parent.children.length; i++) {
const child = parent.children[i];
if (isString(child))
continue;
context.parent = parent;
context.childIndex = i;
context.onNodeRemoved = nodeRemoved;
traverseNode(child, context);
}
}
function traverseNode(node, context) {
context.currentNode = node;
// apply transform plugins
const { nodeTransforms } = context;
const exitFns = [];
for (let i = 0; i < nodeTransforms.length; i++) {
const onExit = nodeTransforms[i](node, context);
if (onExit) {
if (isArray(onExit)) {
exitFns.push(...onExit);
}
else {
exitFns.push(onExit);
}
}
if (!context.currentNode) {
// node was removed
return;
}
else {
// node may have been replaced
node = context.currentNode;
}
}
switch (node.type) {
case 3 /* COMMENT */:
if (!context.ssr) {
// inject import for the Comment symbol, which is needed for creating
// comment nodes with `createVNode`
context.helper(CREATE_COMMENT);
}
break;
case 5 /* INTERPOLATION */:
// no need to traverse, but we need to inject toString helper
if (!context.ssr) {
context.helper(TO_DISPLAY_STRING);
}
break;
// for container types, further traverse downwards
case 9 /* IF */:
for (let i = 0; i < node.branches.length; i++) {
traverseNode(node.branches[i], context);
}
break;
case 10 /* IF_BRANCH */:
case 11 /* FOR */:
case 1 /* ELEMENT */:
case 0 /* ROOT */:
traverseChildren(node, context);
break;
}
// exit transforms
let i = exitFns.length;
while (i--) {
exitFns[i]();
}
}
function createStructuralDirectiveTransform(name, fn) {
const matches = isString(name)
? (n) => n === name
: (n) => name.test(n);
return (node, context) => {
if (node.type === 1 /* ELEMENT */) {
const { props } = node;
// structural directive transforms are not concerned with slots
// as they are handled separately in vSlot.ts
if (node.tagType === 3 /* TEMPLATE */ && props.some(isVSlot)) {
return;
}
const exitFns = [];
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 7 /* DIRECTIVE */ && matches(prop.name)) {
// structural directives are removed to avoid infinite recursion
// also we remove them *before* applying so that it can further
// traverse itself in case it moves the node around
props.splice(i, 1);
i--;
const onExit = fn(node, prop, context);
if (onExit)
exitFns.push(onExit);
}
}
return exitFns;
}
};
}
const PURE_ANNOTATION = `/*#__PURE__*/`;
function createCodegenContext(ast, { mode = 'function', prefixIdentifiers = mode === 'module', sourceMap = false, filename = `template.vue.html`, scopeId = null, optimizeBindings = false, runtimeGlobalName = `Vue`, runtimeModuleName = `vue`, ssr = false }) {
const context = {
mode,
prefixIdentifiers,
sourceMap,
filename,
scopeId,
optimizeBindings,
runtimeGlobalName,
runtimeModuleName,
ssr,
source: ast.loc.source,
code: ``,
column: 1,
line: 1,
offset: 0,
indentLevel: 0,
pure: false,
map: undefined,
helper(key) {
return `_${helperNameMap[key]}`;
},
push(code, node) {
context.code += code;
},
indent() {
newline(++context.indentLevel);
},
deindent(withoutNewLine = false) {
if (withoutNewLine) {
--context.indentLevel;
}
else {
newline(--context.indentLevel);
}
},
newline() {
newline(context.indentLevel);
}
};
function newline(n) {
context.push('\n' + ` `.repeat(n));
}
return context;
}
function generate(ast, options = {}) {
const context = createCodegenContext(ast, options);
const { mode, push, prefixIdentifiers, indent, deindent, newline, scopeId, ssr } = context;
const hasHelpers = ast.helpers.length > 0;
const useWithBlock = !prefixIdentifiers && mode !== 'module';
// preambles
{
genFunctionPreamble(ast, context);
}
if (!ssr) {
push(`function render(_ctx, _cache) {`);
}
else {
push(`function ssrRender(_ctx, _push, _parent) {`);
}
indent();
if (useWithBlock) {
push(`with (_ctx) {`);
indent();
// function mode const declarations should be inside with block
// also they should be renamed to avoid collision with user properties
if (hasHelpers) {
push(`const { ${ast.helpers
.map(s => `${helperNameMap[s]}: _${helperNameMap[s]}`)
.join(', ')} } = _Vue`);
push(`\n`);
newline();
}
}
// generate asset resolution statements
if (ast.components.length) {
genAssets(ast.components, 'component', context);
if (ast.directives.length || ast.temps > 0) {
newline();
}
}
if (ast.directives.length) {
genAssets(ast.directives, 'directive', context);
if (ast.temps > 0) {
newline();
}
}
if (ast.temps > 0) {
push(`let `);
for (let i = 0; i < ast.temps; i++) {
push(`${i > 0 ? `, ` : ``}_temp${i}`);
}
}
if (ast.components.length || ast.directives.length || ast.temps) {
push(`\n`);
newline();
}
// generate the VNode tree expression
if (!ssr) {
push(`return `);
}
if (ast.codegenNode) {
genNode(ast.codegenNode, context);
}
else {
push(`null`);
}
if (useWithBlock) {
deindent();
push(`}`);
}
deindent();
push(`}`);
return {
ast,
code: context.code,
// SourceMapGenerator does have toJSON() method but it's not in the types
map: context.map ? context.map.toJSON() : undefined
};
}
function genFunctionPreamble(ast, context) {
const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName } = context;
const VueBinding = runtimeGlobalName;
const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
// Generate const declaration for helpers
// In prefix mode, we place the const declaration at top so it's done
// only once; But if we not prefixing, we place the declaration inside the
// with block so it doesn't incur the `in` check cost for every helper access.
if (ast.helpers.length > 0) {
{
// "with" mode.
// save Vue in a separate variable to avoid collision
push(`const _Vue = ${VueBinding}\n`);
// in "with" mode, helpers are declared inside the with block to avoid
// has check cost, but hoists are lifted out of the function - we need
// to provide the helper here.
if (ast.hoists.length) {
const staticHelpers = [
CREATE_VNODE,
CREATE_COMMENT,
CREATE_TEXT,
CREATE_STATIC
]
.filter(helper => ast.helpers.includes(helper))
.map(aliasHelper)
.join(', ');
push(`const { ${staticHelpers} } = _Vue\n`);
}
}
}
genHoists(ast.hoists, context);
newline();
push(`return `);
}
function genAssets(assets, type, { helper, push, newline }) {
const resolver = helper(type === 'component' ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE);
for (let i = 0; i < assets.length; i++) {
const id = assets[i];
push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)})`);
if (i < assets.length - 1) {
newline();
}
}
}
function genHoists(hoists, context) {
if (!hoists.length) {
return;
}
context.pure = true;
const { push, newline, helper, scopeId, mode } = context;
newline();
hoists.forEach((exp, i) => {
if (exp) {
push(`const _hoisted_${i + 1} = `);
genNode(exp, context);
newline();
}
});
context.pure = false;
}
function isText$1(n) {
return (isString(n) ||
n.type === 4 /* SIMPLE_EXPRESSION */ ||
n.type === 2 /* TEXT */ ||
n.type === 5 /* INTERPOLATION */ ||
n.type === 8 /* COMPOUND_EXPRESSION */);
}
function genNodeListAsArray(nodes, context) {
const multilines = nodes.length > 3 ||
( nodes.some(n => isArray(n) || !isText$1(n)));
context.push(`[`);
multilines && context.indent();
genNodeList(nodes, context, multilines);
multilines && context.deindent();
context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
const { push, newline } = context;
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (isString(node)) {
push(node);
}
else if (isArray(node)) {
genNodeListAsArray(node, context);
}
else {
genNode(node, context);
}
if (i < nodes.length - 1) {
if (multilines) {
comma && push(',');
newline();
}
else {
comma && push(', ');
}
}
}
}
function genNode(node, context) {
if (isString(node)) {
context.push(node);
return;
}
if (isSymbol(node)) {
context.push(context.helper(node));
return;
}
switch (node.type) {
case 1 /* ELEMENT */:
case 9 /* IF */:
case 11 /* FOR */:
assert(node.codegenNode != null, `Codegen node is missing for element/if/for node. ` +
`Apply appropriate transforms first.`);
genNode(node.codegenNode, context);
break;
case 2 /* TEXT */:
genText(node, context);
break;
case 4 /* SIMPLE_EXPRESSION */:
genExpression(node, context);
break;
case 5 /* INTERPOLATION */:
genInterpolation(node, context);
break;
case 12 /* TEXT_CALL */:
genNode(node.codegenNode, context);
break;
case 8 /* COMPOUND_EXPRESSION */:
genCompoundExpression(node, context);
break;
case 3 /* COMMENT */:
genComment(node, context);
break;
case 13 /* VNODE_CALL */:
genVNodeCall(node, context);
break;
case 14 /* JS_CALL_EXPRESSION */:
genCallExpression(node, context);
break;
case 15 /* JS_OBJECT_EXPRESSION */:
genObjectExpression(node, context);
break;
case 17 /* JS_ARRAY_EXPRESSION */:
genArrayExpression(node, context);
break;
case 18 /* JS_FUNCTION_EXPRESSION */:
genFunctionExpression(node, context);
break;
case 19 /* JS_CONDITIONAL_EXPRESSION */:
genConditionalExpression(node, context);
break;
case 20 /* JS_CACHE_EXPRESSION */:
genCacheExpression(node, context);
break;
// SSR only types
case 21 /* JS_BLOCK_STATEMENT */:
break;
case 22 /* JS_TEMPLATE_LITERAL */:
break;
case 23 /* JS_IF_STATEMENT */:
break;
case 24 /* JS_ASSIGNMENT_EXPRESSION */:
break;
case 25 /* JS_SEQUENCE_EXPRESSION */:
break;
case 26 /* JS_RETURN_STATEMENT */:
break;
/* istanbul ignore next */
case 10 /* IF_BRANCH */:
// noop
break;
default:
{
assert(false, `unhandled codegen node type: ${node.type}`);
// make sure we exhaust all possible types
const exhaustiveCheck = node;
return exhaustiveCheck;
}
}
}
function genText(node, context) {
context.push(JSON.stringify(node.content), node);
}
function genExpression(node, context) {
const { content, isStatic } = node;
context.push(isStatic ? JSON.stringify(content) : content, node);
}
function genInterpolation(node, context) {
const { push, helper, pure } = context;
if (pure)
push(PURE_ANNOTATION);
push(`${helper(TO_DISPLAY_STRING)}(`);
genNode(node.content, context);
push(`)`);
}
function genCompoundExpression(node, context) {
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (isString(child)) {
context.push(child);
}
else {
genNode(child, context);
}
}
}
function genExpressionAsPropertyKey(node, context) {
const { push } = context;
if (node.type === 8 /* COMPOUND_EXPRESSION */) {
push(`[`);
genCompoundExpression(node, context);
push(`]`);
}
else if (node.isStatic) {
// only quote keys if necessary
const text = isSimpleIdentifier(node.content)
? node.content
: JSON.stringify(node.content);
push(text, node);
}
else {
push(`[${node.content}]`, node);
}
}
function genComment(node, context) {
{
const { push, helper, pure } = context;
if (pure) {
push(PURE_ANNOTATION);
}
push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
}
}
function genVNodeCall(node, context) {
const { push, helper, pure } = context;
const { tag, props, children, patchFlag, dynamicProps, directives, isBlock, isForBlock } = node;
if (directives) {
push(helper(WITH_DIRECTIVES) + `(`);
}
if (isBlock) {
push(`(${helper(OPEN_BLOCK)}(${isForBlock ? `true` : ``}), `);
}
if (pure) {
push(PURE_ANNOTATION);
}
push(helper(isBlock ? CREATE_BLOCK : CREATE_VNODE) + `(`, node);
genNodeList(genNullableArgs([tag, props, children, patchFlag, dynamicProps]), context);
push(`)`);
if (isBlock) {
push(`)`);
}
if (directives) {
push(`, `);
genNode(directives, context);
push(`)`);
}
}
function genNullableArgs(args) {
let i = args.length;
while (i--) {
if (args[i] != null)
break;
}
return args.slice(0, i + 1).map(arg => arg || `null`);
}
// JavaScript
function genCallExpression(node, context) {
const { push, helper, pure } = context;
const callee = isString(node.callee) ? node.callee : helper(node.callee);
if (pure) {
push(PURE_ANNOTATION);
}
push(callee + `(`, node);
genNodeList(node.arguments, context);
push(`)`);
}
function genObjectExpression(node, context) {
const { push, indent, deindent, newline } = context;
const { properties } = node;
if (!properties.length) {
push(`{}`, node);
return;
}
const multilines = properties.length > 1 ||
(
properties.some(p => p.value.type !== 4 /* SIMPLE_EXPRESSION */));
push(multilines ? `{` : `{ `);
multilines && indent();
for (let i = 0; i < properties.length; i++) {
const { key, value } = properties[i];
// key
genExpressionAsPropertyKey(key, context);
push(`: `);
// value
genNode(value, context);
if (i < properties.length - 1) {
// will only reach this if it's multilines
push(`,`);
newline();
}
}
multilines && deindent();
push(multilines ? `}` : ` }`);
}
function genArrayExpression(node, context) {
genNodeListAsArray(node.elements, context);
}
function genFunctionExpression(node, context) {
const { push, indent, deindent, scopeId, mode } = context;
const { params, returns, body, newline, isSlot } = node;
if (isSlot) {
push(`_${helperNameMap[WITH_CTX]}(`);
}
push(`(`, node);
if (isArray(params)) {
genNodeList(params, context);
}
else if (params) {
genNode(params, context);
}
push(`) => `);
if (newline || body) {
push(`{`);
indent();
}
if (returns) {
if (newline) {
push(`return `);
}
if (isArray(returns)) {
genNodeListAsArray(returns, context);
}
else {
genNode(returns, context);
}
}
else if (body) {
genNode(body, context);
}
if (newline || body) {
deindent();
push(`}`);
}
if ( isSlot) {
push(`)`);
}
}
function genConditionalExpression(node, context) {
const { test, consequent, alternate, newline: needNewline } = node;
const { push, indent, deindent, newline } = context;
if (test.type === 4 /* SIMPLE_EXPRESSION */) {
const needsParens = !isSimpleIdentifier(test.content);
needsParens && push(`(`);
genExpression(test, context);
needsParens && push(`)`);
}
else {
push(`(`);
genNode(test, context);
push(`)`);
}
needNewline && indent();
context.indentLevel++;
needNewline || push(` `);
push(`? `);
genNode(consequent, context);
context.indentLevel--;
needNewline && newline();
needNewline || push(` `);
push(`: `);
const isNested = alternate.type === 19 /* JS_CONDITIONAL_EXPRESSION */;
if (!isNested) {
context.indentLevel++;
}
genNode(alternate, context);
if (!isNested) {
context.indentLevel--;
}
needNewline && deindent(true /* without newline */);
}
function genCacheExpression(node, context) {
const { push, helper, indent, deindent, newline } = context;
push(`_cache[${node.index}] || (`);
if (node.isVNode) {
indent();
push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
newline();
}
push(`_cache[${node.index}] = `);
genNode(node.value, context);
if (node.isVNode) {
push(`,`);
newline();
push(`${helper(SET_BLOCK_TRACKING)}(1),`);
newline();
push(`_cache[${node.index}]`);
deindent();
}
push(`)`);
}
// these keywords should not appear inside expressions, but operators like
// typeof, instanceof and in are allowed
const prohibitedKeywordRE = new RegExp('\\b' +
('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
'super,throw,while,yield,delete,export,import,return,switch,default,' +
'extends,finally,continue,debugger,function,arguments,typeof,void')
.split(',')
.join('\\b|\\b') +
'\\b');
// strip strings in expressions
const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
/**
* Validate a non-prefixed expression.
* This is only called when using the in-browser runtime compiler since it
* doesn't prefix expressions.
*/
function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {
const exp = node.content;
try {
new Function(asRawStatements
? ` ${exp} `
: `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`);
}
catch (e) {
let message = e.message;
const keywordMatch = exp
.replace(stripStringRE, '')
.match(prohibitedKeywordRE);
if (keywordMatch) {
message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`;
}
context.onError(createCompilerError(41 /* X_INVALID_EXPRESSION */, node.loc, undefined, message));
}
}
const transformExpression = (node, context) => {
if (node.type === 5 /* INTERPOLATION */) {
node.content = processExpression(node.content, context);
}
else if (node.type === 1 /* ELEMENT */) {
// handle directives on element
for (let i = 0; i < node.props.length; i++) {
const dir = node.props[i];
// do not process for v-on & v-for since they are special handled
if (dir.type === 7 /* DIRECTIVE */ && dir.name !== 'for') {
const exp = dir.exp;
const arg = dir.arg;
// do not process exp if this is v-on:arg - we need special handling
// for wrapping inline statements.
if (exp &&
exp.type === 4 /* SIMPLE_EXPRESSION */ &&
!(dir.name === 'on' && arg)) {
dir.exp = processExpression(exp, context,
// slot args must be processed as function params
dir.name === 'slot');
}
if (arg && arg.type === 4 /* SIMPLE_EXPRESSION */ && !arg.isStatic) {
dir.arg = processExpression(arg, context);
}
}
}
}
};
// Important: since this function uses Node.js only dependencies, it should
// always be used with a leading !true check so that it can be
// tree-shaken from the browser build.
function processExpression(node, context,
// some expressions like v-slot props & v-for aliases should be parsed as
// function params
asParams = false,
// v-on handler values may contain multiple statements
asRawStatements = false) {
{
// simple in-browser validation (same logic in 2.x)
validateBrowserExpression(node, context, asParams, asRawStatements);
return node;
}
}
const transformIf = createStructuralDirectiveTransform(/^(if|else|else-if)$/, (node, dir, context) => {
return processIf(node, dir, context, (ifNode, branch, isRoot) => {
// Exit callback. Complete the codegenNode when all children have been
// transformed.
return () => {
if (isRoot) {
ifNode.codegenNode = createCodegenNodeForBranch(branch, 0, context);
}
else {
// attach this branch's codegen node to the v-if root.
let parentCondition = ifNode.codegenNode;
while (parentCondition.alternate.type ===
19 /* JS_CONDITIONAL_EXPRESSION */) {
parentCondition = parentCondition.alternate;
}
parentCondition.alternate = createCodegenNodeForBranch(branch, ifNode.branches.length - 1, context);
}
};
});
});
// target-agnostic transform used for both Client and SSR
function processIf(node, dir, context, processCodegen) {
if (dir.name !== 'else' &&
(!dir.exp || !dir.exp.content.trim())) {
const loc = dir.exp ? dir.exp.loc : node.loc;
context.onError(createCompilerError(27 /* X_V_IF_NO_EXPRESSION */, dir.loc));
dir.exp = createSimpleExpression(`true`, false, loc);
}
if ( dir.exp) {
validateBrowserExpression(dir.exp, context);
}
if (dir.name === 'if') {
const branch = createIfBranch(node, dir);
const ifNode = {
type: 9 /* IF */,
loc: node.loc,
branches: [branch]
};
context.replaceNode(ifNode);
if (processCodegen) {
return processCodegen(ifNode, branch, true);
}
}
else {
// locate the adjacent v-if
const siblings = context.parent.children;
const comments = [];
let i = siblings.indexOf(node);
while (i-- >= -1) {
const sibling = siblings[i];
if ( sibling && sibling.type === 3 /* COMMENT */) {
context.removeNode(sibling);
comments.unshift(sibling);
continue;
}
if (sibling && sibling.type === 9 /* IF */) {
// move the node to the if node's branches
context.removeNode();
const branch = createIfBranch(node, dir);
if ( comments.length) {
branch.children = [...comments, ...branch.children];
}
sibling.branches.push(branch);
const onExit = processCodegen && processCodegen(sibling, branch, false);
// since the branch was removed, it will not be traversed.
// make sure to traverse here.
traverseNode(branch, context);
// call on exit
if (onExit)
onExit();
// make sure to reset currentNode after traversal to indicate this
// node has been removed.
context.currentNode = null;
}
else {
context.onError(createCompilerError(28 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc));
}
break;
}
}
}
function createIfBranch(node, dir) {
return {
type: 10 /* IF_BRANCH */,
loc: node.loc,
condition: dir.name === 'else' ? undefined : dir.exp,
children: node.tagType === 3 /* TEMPLATE */ ? node.children : [node]
};
}
function createCodegenNodeForBranch(branch, index, context) {
if (branch.condition) {
return createConditionalExpression(branch.condition, createChildrenCodegenNode(branch, index, context),
// make sure to pass in asBlock: true so that the comment node call
// closes the current block.
createCallExpression(context.helper(CREATE_COMMENT), [
'"v-if"' ,
'true'
]));
}
else {
return createChildrenCodegenNode(branch, index, context);
}
}
function createChildrenCodegenNode(branch, index, context) {
const { helper } = context;
const keyProperty = createObjectProperty(`key`, createSimpleExpression(index + '', false));
const { children } = branch;
const firstChild = children[0];
const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1 /* ELEMENT */;
if (needFragmentWrapper) {
if (children.length === 1 && firstChild.type === 11 /* FOR */) {
// optimize away nested fragments when child is a ForNode
const vnodeCall = firstChild.codegenNode;
injectProp(vnodeCall, keyProperty, context);
return vnodeCall;
}
else {
return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, `${64 /* STABLE_FRAGMENT */} /* ${PatchFlagNames[64 /* STABLE_FRAGMENT */]} */`, undefined, undefined, true, false, branch.loc);
}
}
else {
const vnodeCall = firstChild
.codegenNode;
// Change createVNode to createBlock.
if (vnodeCall.type === 13 /* VNODE_CALL */ &&
// component vnodes are always tracked and its children are
// compiled into slots so no need to make it a block
(firstChild.tagType !== 1 /* COMPONENT */ ||
// teleport has component type but isn't always tracked
vnodeCall.tag === TELEPORT)) {
vnodeCall.isBlock = true;
helper(OPEN_BLOCK);
helper(CREATE_BLOCK);
}
// inject branch key
injectProp(vnodeCall, keyProperty, context);
return vnodeCall;
}
}
const transformFor = createStructuralDirectiveTransform('for', (node, dir, context) => {
const { helper } = context;
return processFor(node, dir, context, forNode => {
// create the loop render function expression now, and add the
// iterator on exit after all children have been traversed
const renderExp = createCallExpression(helper(RENDER_LIST), [
forNode.source
]);
const keyProp = findProp(node, `key`);
const fragmentFlag = keyProp
? 128 /* KEYED_FRAGMENT */
: 256 /* UNKEYED_FRAGMENT */;
forNode.codegenNode = createVNodeCall(context, helper(FRAGMENT), undefined, renderExp, `${fragmentFlag} /* ${PatchFlagNames[fragmentFlag]} */`, undefined, undefined, true /* isBlock */, true /* isForBlock */, node.loc);
return () => {
// finish the codegen now that all children have been traversed
let childBlock;
const isTemplate = isTemplateNode(node);
const { children } = forNode;
const needFragmentWrapper = children.length > 1 || children[0].type !== 1 /* ELEMENT */;
const slotOutlet = isSlotOutlet(node)
? node
: isTemplate &&
node.children.length === 1 &&
isSlotOutlet(node.children[0])
? node.children[0] // api-extractor somehow fails to infer this
: null;
const keyProperty = keyProp
? createObjectProperty(`key`, keyProp.type === 6 /* ATTRIBUTE */
? createSimpleExpression(keyProp.value.content, true)
: keyProp.exp)
: null;
if (slotOutlet) {
// <slot v-for="..."> or <template v-for="..."><slot/></template>
childBlock = slotOutlet.codegenNode;
if (isTemplate && keyProperty) {
// <template v-for="..." :key="..."><slot/></template>
// we need to inject the key to the renderSlot() call.
// the props for renderSlot is passed as the 3rd argument.
injectProp(childBlock, keyProperty, context);
}
}
else if (needFragmentWrapper) {
// <template v-for="..."> with text or multi-elements
// should generate a fragment block for each loop
childBlock = createVNodeCall(context, helper(FRAGMENT), keyProperty ? createObjectExpression([keyProperty]) : undefined, node.children, `${64 /* STABLE_FRAGMENT */} /* ${PatchFlagNames[64 /* STABLE_FRAGMENT */]} */`, undefined, undefined, true);
}
else {
// Normal element v-for. Directly use the child's codegenNode
// but mark it as a block.
childBlock = children[0]
.codegenNode;
childBlock.isBlock = true;
helper(OPEN_BLOCK);
helper(CREATE_BLOCK);
}
renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true /* force newline */));
};
});
});
// target-agnostic transform used for both Client and SSR
function processFor(node, dir, context, processCodegen) {
if (!dir.exp) {
context.onError(createCompilerError(29 /* X_V_FOR_NO_EXPRESSION */, dir.loc));
return;
}
const parseResult = parseForExpression(
// can only be simple expression because vFor transform is applied
// before expression transform.
dir.exp, context);
if (!parseResult) {
context.onError(createCompilerError(30 /* X_V_FOR_MALFORMED_EXPRESSION */, dir.loc));
return;
}
const { addIdentifiers, removeIdentifiers, scopes } = context;
const { source, value, key, index } = parseResult;
const forNode = {
type: 11 /* FOR */,
loc: dir.loc,
source,
valueAlias: value,
keyAlias: key,
objectIndexAlias: index,
parseResult,
children: node.tagType === 3 /* TEMPLATE */ ? node.children : [node]
};
context.replaceNode(forNode);
// bookkeeping
scopes.vFor++;
const onExit = processCodegen && processCodegen(forNode);
return () => {
scopes.vFor--;
if (onExit)
onExit();
};
}
const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
// This regex doesn't cover the case if key or index aliases have destructuring,
// but those do not make sense in the first place, so this works in practice.
const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
const stripParensRE = /^\(|\)$/g;
function parseForExpression(input, context) {
const loc = input.loc;
const exp = input.content;
const inMatch = exp.match(forAliasRE);
if (!inMatch)
return;
const [, LHS, RHS] = inMatch;
const result = {
source: createAliasExpression(loc, RHS.trim(), exp.indexOf(RHS, LHS.length)),
value: undefined,
key: undefined,
index: undefined
};
{
validateBrowserExpression(result.source, context);
}
let valueContent = LHS.trim()
.replace(stripParensRE, '')
.trim();
const trimmedOffset = LHS.indexOf(valueContent);
const iteratorMatch = valueContent.match(forIteratorRE);
if (iteratorMatch) {
valueContent = valueContent.replace(forIteratorRE, '').trim();
const keyContent = iteratorMatch[1].trim();
let keyOffset;
if (keyContent) {
keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
result.key = createAliasExpression(loc, keyContent, keyOffset);
{
validateBrowserExpression(result.key, context, true);
}
}
if (iteratorMatch[2]) {
const indexContent = iteratorMatch[2].trim();
if (indexContent) {
result.index = createAliasExpression(loc, indexContent, exp.indexOf(indexContent, result.key
? keyOffset + keyContent.length
: trimmedOffset + valueContent.length));
{
validateBrowserExpression(result.index, context, true);
}
}
}
}
if (valueContent) {
result.value = createAliasExpression(loc, valueContent, trimmedOffset);
{
validateBrowserExpression(result.value, context, true);
}
}
return result;
}
function createAliasExpression(range, content, offset) {
return createSimpleExpression(content, false, getInnerRange(range, offset, content.length));
}
function createForLoopParams({ value, key, index }) {
const params = [];
if (value) {
params.push(value);
}
if (key) {
if (!value) {
params.push(createSimpleExpression(`_`, false));
}
params.push(key);
}
if (index) {
if (!key) {
if (!value) {
params.push(createSimpleExpression(`_`, false));
}
params.push(createSimpleExpression(`__`, false));
}
params.push(index);
}
return params;
}
const isStaticExp = (p) => p.type === 4 /* SIMPLE_EXPRESSION */ && p.isStatic;
const defaultFallback = createSimpleExpression(`undefined`, false);
// A NodeTransform that:
// 1. Tracks scope identifiers for scoped slots so that they don't get prefixed
// by transformExpression. This is only applied in non-browser builds with
// { prefixIdentifiers: true }.
// 2. Track v-slot depths so that we know a slot is inside another slot.
// Note the exit callback is executed before buildSlots() on the same node,
// so only nested slots see positive numbers.
const trackSlotScopes = (node, context) => {
if (node.type === 1 /* ELEMENT */ &&
(node.tagType === 1 /* COMPONENT */ ||
node.tagType === 3 /* TEMPLATE */)) {
// We are only checking non-empty v-slot here
// since we only care about slots that introduce scope variables.
const vSlot = findDir(node, 'slot');
if (vSlot) {
const slotProps = vSlot.exp;
context.scopes.vSlot++;
return () => {
context.scopes.vSlot--;
};
}
}
};
const buildClientSlotFn = (props, children, loc) => createFunctionExpression(props, children, false /* newline */, true /* isSlot */, children.length ? children[0].loc : loc);
// Instead of being a DirectiveTransform, v-slot processing is called during
// transformElement to build the slots object for a component.
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
context.helper(WITH_CTX);
const { children, loc } = node;
const slotsProperties = [];
const dynamicSlots = [];
const buildDefaultSlotProperty = (props, children) => createObjectProperty(`default`, buildSlotFn(props, children, loc));
// If the slot is inside a v-for or another v-slot, force it to be dynamic
// since it likely uses a scope variable.
let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
// 1. Check for slot with slotProps on component itself.
// <Comp v-slot="{ prop }"/>
const onComponentSlot = findDir(node, 'slot', true);
if (onComponentSlot) {
const { arg, exp } = onComponentSlot;
slotsProperties.push(createObjectProperty(arg || createSimpleExpression('default', true), buildSlotFn(exp, children, loc)));
}
// 2. Iterate through children and check for template slots
// <template v-slot:foo="{ prop }">
let hasTemplateSlots = false;
let hasNamedDefaultSlot = false;
const implicitDefaultChildren = [];
const seenSlotNames = new Set();
for (let i = 0; i < children.length; i++) {
const slotElement = children[i];
let slotDir;
if (!isTemplateNode(slotElement) ||
!(slotDir = findDir(slotElement, 'slot', true))) {
// not a <template v-slot>, skip.
if (slotElement.type !== 3 /* COMMENT */) {
implicitDefaultChildren.push(slotElement);
}
continue;
}
if (onComponentSlot) {
// already has on-component slot - this is incorrect usage.
context.onError(createCompilerError(34 /* X_V_SLOT_MIXED_SLOT_USAGE */, slotDir.loc));
break;
}
hasTemplateSlots = true;
const { children: slotChildren, loc: slotLoc } = slotElement;
const { arg: slotName = createSimpleExpression(`default`, true), exp: slotProps, loc: dirLoc } = slotDir;
// check if name is dynamic.
let staticSlotName;
if (isStaticExp(slotName)) {
staticSlotName = slotName ? slotName.content : `default`;
}
else {
hasDynamicSlots = true;
}
const slotFunction = buildSlotFn(slotProps, slotChildren, slotLoc);
// check if this slot is conditional (v-if/v-for)
let vIf;
let vElse;
let vFor;
if ((vIf = findDir(slotElement, 'if'))) {
hasDynamicSlots = true;
dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction), defaultFallback));
}
else if ((vElse = findDir(slotElement, /^else(-if)?$/, true /* allowEmpty */))) {
// find adjacent v-if
let j = i;
let prev;
while (j--) {
prev = children[j];
if (prev.type !== 3 /* COMMENT */) {
break;
}
}
if (prev && isTemplateNode(prev) && findDir(prev, 'if')) {
// remove node
children.splice(i, 1);
i--;
// attach this slot to previous conditional
let conditional = dynamicSlots[dynamicSlots.length - 1];
while (conditional.alternate.type === 19 /* JS_CONDITIONAL_EXPRESSION */) {
conditional = conditional.alternate;
}
conditional.alternate = vElse.exp
? createConditionalExpression(vElse.exp, buildDynamicSlot(slotName, slotFunction), defaultFallback)
: buildDynamicSlot(slotName, slotFunction);
}
else {
context.onError(createCompilerError(28 /* X_V_ELSE_NO_ADJACENT_IF */, vElse.loc));
}
}
else if ((vFor = findDir(slotElement, 'for'))) {
hasDynamicSlots = true;
const parseResult = vFor.parseResult ||
parseForExpression(vFor.exp, context);
if (parseResult) {
// Render the dynamic slots as an array and add it to the createSlot()
// args. The runtime knows how to handle it appropriately.
dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [
parseResult.source,
createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true /* force newline */)
]));
}
else {
context.onError(createCompilerError(30 /* X_V_FOR_MALFORMED_EXPRESSION */, vFor.loc));
}
}
else {
// check duplicate static names
if (staticSlotName) {
if (seenSlotNames.has(staticSlotName)) {
context.onError(createCompilerError(35 /* X_V_SLOT_DUPLICATE_SLOT_NAMES */, dirLoc));
continue;
}
seenSlotNames.add(staticSlotName);
if (staticSlotName === 'default') {
hasNamedDefaultSlot = true;
}
}
slotsProperties.push(createObjectProperty(slotName, slotFunction));
}
}
if (!onComponentSlot) {
if (!hasTemplateSlots) {
// implicit default slot (on component)
slotsProperties.push(buildDefaultSlotProperty(undefined, children));
}
else if (implicitDefaultChildren.length) {
// implicit default slot (mixed with named slots)
if (hasNamedDefaultSlot) {
context.onError(createCompilerError(36 /* X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */, implicitDefaultChildren[0].loc));
}
else {
slotsProperties.push(buildDefaultSlotProperty(undefined, implicitDefaultChildren));
}
}
}
let slots = createObjectExpression(slotsProperties.concat(createObjectProperty(`_`, createSimpleExpression(`1`, false))), loc);
if (dynamicSlots.length) {
slots = createCallExpression(context.helper(CREATE_SLOTS), [
slots,
createArrayExpression(dynamicSlots)
]);
}
return {
slots,
hasDynamicSlots
};
}
function buildDynamicSlot(name, fn) {
return createObjectExpression([
createObjectProperty(`name`, name),
createObjectProperty(`fn`, fn)
]);
}
// some directive transforms (e.g. v-model) may return a symbol for runtime
// import, which should be used instead of a resolveDirective call.
const directiveImportMap = new WeakMap();
// generate a JavaScript AST for this element's codegen
const transformElement = (node, context) => {
if (!(node.type === 1 /* ELEMENT */ &&
(node.tagType === 0 /* ELEMENT */ ||
node.tagType === 1 /* COMPONENT */))) {
return;
}
// perform the work on exit, after all child expressions have been
// processed and merged.
return function postTransformElement() {
const { tag, props } = node;
const isComponent = node.tagType === 1 /* COMPONENT */;
// The goal of the transform is to create a codegenNode implementing the
// VNodeCall interface.
const vnodeTag = isComponent
? resolveComponentType(node, context)
: `"${tag}"`;
const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
let vnodeProps;
let vnodeChildren;
let vnodePatchFlag;
let patchFlag = 0;
let vnodeDynamicProps;
let dynamicPropNames;
let vnodeDirectives;
let shouldUseBlock =
// dynamic component may resolve to plain elements
isDynamicComponent ||
(!isComponent &&
// <svg> and <foreignObject> must be forced into blocks so that block
// updates inside get proper isSVG flag at runtime. (#639, #643)
// This is technically web-specific, but splitting the logic out of core
// leads to too much unnecessary complexity.
(tag === 'svg' ||
tag === 'foreignObject' ||
// #938: elements with dynamic keys should be forced into blocks
findProp(node, 'key', true)));
// props
if (props.length > 0) {
const propsBuildResult = buildProps(node, context);
vnodeProps = propsBuildResult.props;
patchFlag = propsBuildResult.patchFlag;
dynamicPropNames = propsBuildResult.dynamicPropNames;
const directives = propsBuildResult.directives;
vnodeDirectives =
directives && directives.length
? createArrayExpression(directives.map(dir => buildDirectiveArgs(dir, context)))
: undefined;
}
// children
if (node.children.length > 0) {
if (vnodeTag === KEEP_ALIVE) {
// Although a built-in component, we compile KeepAlive with raw children
// instead of slot functions so that it can be used inside Transition
// or other Transition-wrapping HOCs.
// To ensure correct updates with block optimizations, we need to:
// 1. Force keep-alive into a block. This avoids its children being
// collected by a parent block.
shouldUseBlock = true;
// 2. Force keep-alive to always be updated, since it uses raw children.
patchFlag |= 1024 /* DYNAMIC_SLOTS */;
if ( node.children.length > 1) {
context.onError(createCompilerError(42 /* X_KEEP_ALIVE_INVALID_CHILDREN */, {
start: node.children[0].loc.start,
end: node.children[node.children.length - 1].loc.end,
source: ''
}));
}
}
const shouldBuildAsSlots = isComponent &&
// Teleport is not a real component and has dedicated runtime handling
vnodeTag !== TELEPORT &&
// explained above.
vnodeTag !== KEEP_ALIVE;
if (shouldBuildAsSlots) {
const { slots, hasDynamicSlots } = buildSlots(node, context);
vnodeChildren = slots;
if (hasDynamicSlots) {
patchFlag |= 1024 /* DYNAMIC_SLOTS */;
}
}
else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
const child = node.children[0];
const type = child.type;
// check for dynamic text children
const hasDynamicTextChild = type === 5 /* INTERPOLATION */ ||
type === 8 /* COMPOUND_EXPRESSION */;
if (hasDynamicTextChild && !getStaticType(child)) {
patchFlag |= 1 /* TEXT */;
}
// pass directly if the only child is a text node
// (plain / interpolation / expression)
if (hasDynamicTextChild || type === 2 /* TEXT */) {
vnodeChildren = child;
}
else {
vnodeChildren = node.children;
}
}
else {
vnodeChildren = node.children;
}
}
// patchFlag & dynamicPropNames
if (patchFlag !== 0) {
{
if (patchFlag < 0) {
// special flags (negative and mutually exclusive)
vnodePatchFlag = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
}
else {
// bitwise flags
const flagNames = Object.keys(PatchFlagNames)
.map(Number)
.filter(n => n > 0 && patchFlag & n)
.map(n => PatchFlagNames[n])
.join(`, `);
vnodePatchFlag = patchFlag + ` /* ${flagNames} */`;
}
}
if (dynamicPropNames && dynamicPropNames.length) {
vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
}
}
node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, vnodePatchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false /* isForBlock */, node.loc);
};
};
function resolveComponentType(node, context, ssr = false) {
const { tag } = node;
// 1. dynamic component
const isProp = node.tag === 'component' ? findProp(node, 'is') : findDir(node, 'is');
if (isProp) {
const exp = isProp.type === 6 /* ATTRIBUTE */
? isProp.value && createSimpleExpression(isProp.value.content, true)
: isProp.exp;
if (exp) {
return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
exp
]);
}
}
// 2. built-in components (Teleport, Transition, KeepAlive, Suspense...)
const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
if (builtIn) {
// built-ins are simply fallthroughs / have special handling during ssr
// no we don't need to import their runtime equivalents
if (!ssr)
context.helper(builtIn);
return builtIn;
}
// 3. user component (resolve)
context.helper(RESOLVE_COMPONENT);
context.components.add(tag);
return toValidAssetId(tag, `component`);
}
function buildProps(node, context, props = node.props, ssr = false) {
const { tag, loc: elementLoc } = node;
const isComponent = node.tagType === 1 /* COMPONENT */;
let properties = [];
const mergeArgs = [];
const runtimeDirectives = [];
// patchFlag analysis
let patchFlag = 0;
let hasRef = false;
let hasClassBinding = false;
let hasStyleBinding = false;
let hasHydrationEventBinding = false;
let hasDynamicKeys = false;
const dynamicPropNames = [];
const analyzePatchFlag = ({ key, value }) => {
if (key.type === 4 /* SIMPLE_EXPRESSION */ && key.isStatic) {
const name = key.content;
if (!isComponent &&
isOn(name) &&
// omit the flag for click handlers becaues hydration gives click
// dedicated fast path.
name.toLowerCase() !== 'onclick' &&
// omit v-model handlers
name !== 'onUpdate:modelValue') {
hasHydrationEventBinding = true;
}
if (value.type === 20 /* JS_CACHE_EXPRESSION */ ||
((value.type === 4 /* SIMPLE_EXPRESSION */ ||
value.type === 8 /* COMPOUND_EXPRESSION */) &&
getStaticType(value) > 0)) {
// skip if the prop is a cached handler or has constant value
return;
}
if (name === 'ref') {
hasRef = true;
}
else if (name === 'class' && !isComponent) {
hasClassBinding = true;
}
else if (name === 'style' && !isComponent) {
hasStyleBinding = true;
}
else if (name !== 'key' && !dynamicPropNames.includes(name)) {
dynamicPropNames.push(name);
}
}
else {
hasDynamicKeys = true;
}
};
for (let i = 0; i < props.length; i++) {
// static attribute
const prop = props[i];
if (prop.type === 6 /* ATTRIBUTE */) {
const { loc, name, value } = prop;
if (name === 'ref') {
hasRef = true;
}
// skip :is on <component>
if (name === 'is' && tag === 'component') {
continue;
}
properties.push(createObjectProperty(createSimpleExpression(name, true, getInnerRange(loc, 0, name.length)), createSimpleExpression(value ? value.content : '', true, value ? value.loc : loc)));
}
else {
// directives
const { name, arg, exp, loc } = prop;
const isBind = name === 'bind';
const isOn = name === 'on';
// skip v-slot - it is handled by its dedicated transform.
if (name === 'slot') {
if (!isComponent) {
context.onError(createCompilerError(37 /* X_V_SLOT_MISPLACED */, loc));
}
continue;
}
// skip v-once - it is handled by its dedicated transform.
if (name === 'once') {
continue;
}
// skip v-is and :is on <component>
if (name === 'is' ||
(isBind && tag === 'component' && isBindKey(arg, 'is'))) {
continue;
}
// skip v-on in SSR compilation
if (isOn && ssr) {
continue;
}
// special case for v-bind and v-on with no argument
if (!arg && (isBind || isOn)) {
hasDynamicKeys = true;
if (exp) {
if (properties.length) {
mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc));
properties = [];
}
if (isBind) {
mergeArgs.push(exp);
}
else {
// v-on="obj" -> toHandlers(obj)
mergeArgs.push({
type: 14 /* JS_CALL_EXPRESSION */,
loc,
callee: context.helper(TO_HANDLERS),
arguments: [exp]
});
}
}
else {
context.onError(createCompilerError(isBind
? 31 /* X_V_BIND_NO_EXPRESSION */
: 32 /* X_V_ON_NO_EXPRESSION */, loc));
}
continue;
}
const directiveTransform = context.directiveTransforms[name];
if (directiveTransform) {
// has built-in directive transform.
const { props, needRuntime } = directiveTransform(prop, node, context);
!ssr && props.forEach(analyzePatchFlag);
properties.push(...props);
if (needRuntime) {
runtimeDirectives.push(prop);
if (isSymbol(needRuntime)) {
directiveImportMap.set(prop, needRuntime);
}
}
}
else {
// no built-in transform, this is a user custom directive.
runtimeDirectives.push(prop);
}
}
}
let propsExpression = undefined;
// has v-bind="object" or v-on="object", wrap with mergeProps
if (mergeArgs.length) {
if (properties.length) {
mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc));
}
if (mergeArgs.length > 1) {
propsExpression = createCallExpression(context.helper(MERGE_PROPS), mergeArgs, elementLoc);
}
else {
// single v-bind with nothing else - no need for a mergeProps call
propsExpression = mergeArgs[0];
}
}
else if (properties.length) {
propsExpression = createObjectExpression(dedupeProperties(properties), elementLoc);
}
// patchFlag analysis
if (hasDynamicKeys) {
patchFlag |= 16 /* FULL_PROPS */;
}
else {
if (hasClassBinding) {
patchFlag |= 2 /* CLASS */;
}
if (hasStyleBinding) {
patchFlag |= 4 /* STYLE */;
}
if (dynamicPropNames.length) {
patchFlag |= 8 /* PROPS */;
}
if (hasHydrationEventBinding) {
patchFlag |= 32 /* HYDRATE_EVENTS */;
}
}
if ((patchFlag === 0 || patchFlag === 32 /* HYDRATE_EVENTS */) &&
(hasRef || runtimeDirectives.length > 0)) {
patchFlag |= 512 /* NEED_PATCH */;
}
return {
props: propsExpression,
directives: runtimeDirectives,
patchFlag,
dynamicPropNames
};
}
// Dedupe props in an object literal.
// Literal duplicated attributes would have been warned during the parse phase,
// however, it's possible to encounter duplicated `onXXX` handlers with different
// modifiers. We also need to merge static and dynamic class / style attributes.
// - onXXX handlers / style: merge into array
// - class: merge into single expression with concatenation
function dedupeProperties(properties) {
const knownProps = new Map();
const deduped = [];
for (let i = 0; i < properties.length; i++) {
const prop = properties[i];
// dynamic keys are always allowed
if (prop.key.type === 8 /* COMPOUND_EXPRESSION */ || !prop.key.isStatic) {
deduped.push(prop);
continue;
}
const name = prop.key.content;
const existing = knownProps.get(name);
if (existing) {
if (name === 'style' || name === 'class' || name.startsWith('on')) {
mergeAsArray(existing, prop);
}
// unexpected duplicate, should have emitted error during parse
}
else {
knownProps.set(name, prop);
deduped.push(prop);
}
}
return deduped;
}
function mergeAsArray(existing, incoming) {
if (existing.value.type === 17 /* JS_ARRAY_EXPRESSION */) {
existing.value.elements.push(incoming.value);
}
else {
existing.value = createArrayExpression([existing.value, incoming.value], existing.loc);
}
}
function buildDirectiveArgs(dir, context) {
const dirArgs = [];
const runtime = directiveImportMap.get(dir);
if (runtime) {
dirArgs.push(context.helperString(runtime));
}
else {
// inject statement for resolving directive
context.helper(RESOLVE_DIRECTIVE);
context.directives.add(dir.name);
dirArgs.push(toValidAssetId(dir.name, `directive`));
}
const { loc } = dir;
if (dir.exp)
dirArgs.push(dir.exp);
if (dir.arg) {
if (!dir.exp) {
dirArgs.push(`void 0`);
}
dirArgs.push(dir.arg);
}
if (Object.keys(dir.modifiers).length) {
if (!dir.arg) {
if (!dir.exp) {
dirArgs.push(`void 0`);
}
dirArgs.push(`void 0`);
}
const trueExpression = createSimpleExpression(`true`, false, loc);
dirArgs.push(createObjectExpression(dir.modifiers.map(modifier => createObjectProperty(modifier, trueExpression)), loc));
}
return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props) {
let propsNamesString = `[`;
for (let i = 0, l = props.length; i < l; i++) {
propsNamesString += JSON.stringify(props[i]);
if (i < l - 1)
propsNamesString += ', ';
}
return propsNamesString + `]`;
}
const transformSlotOutlet = (node, context) => {
if (isSlotOutlet(node)) {
const { children, loc } = node;
const { slotName, slotProps } = processSlotOutlet(node, context);
const slotArgs = [
context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
slotName
];
if (slotProps) {
slotArgs.push(slotProps);
}
if (children.length) {
if (!slotProps) {
slotArgs.push(`{}`);
}
slotArgs.push(createFunctionExpression([], children, false, false, loc));
}
node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc);
}
};
function processSlotOutlet(node, context) {
let slotName = `"default"`;
let slotProps = undefined;
// check for <slot name="xxx" OR :name="xxx" />
const name = findProp(node, 'name');
if (name) {
if (name.type === 6 /* ATTRIBUTE */ && name.value) {
// static name
slotName = JSON.stringify(name.value.content);
}
else if (name.type === 7 /* DIRECTIVE */ && name.exp) {
// dynamic name
slotName = name.exp;
}
}
const propsWithoutName = name
? node.props.filter(p => p !== name)
: node.props;
if (propsWithoutName.length > 0) {
const { props, directives } = buildProps(node, context, propsWithoutName);
slotProps = props;
if (directives.length) {
context.onError(createCompilerError(33 /* X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, directives[0].loc));
}
}
return {
slotName,
slotProps
};
}
const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
const transformOn = (dir, node, context, augmentor) => {
const { loc, modifiers, arg } = dir;
if (!dir.exp && !modifiers.length) {
context.onError(createCompilerError(32 /* X_V_ON_NO_EXPRESSION */, loc));
}
let eventName;
if (arg.type === 4 /* SIMPLE_EXPRESSION */) {
if (arg.isStatic) {
const rawName = arg.content;
// for @vnode-xxx event listeners, auto convert it to camelCase
const normalizedName = rawName.startsWith(`vnode`)
? capitalize(camelize(rawName))
: capitalize(rawName);
eventName = createSimpleExpression(`on${normalizedName}`, true, arg.loc);
}
else {
eventName = createCompoundExpression([`"on" + (`, arg, `)`]);
}
}
else {
// already a compound expression.
eventName = arg;
eventName.children.unshift(`"on" + (`);
eventName.children.push(`)`);
}
// handler processing
let exp = dir.exp;
if (exp && !exp.content.trim()) {
exp = undefined;
}
let isCacheable = !exp;
if (exp) {
const isMemberExp = isMemberExpression(exp.content);
const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
const hasMultipleStatements = exp.content.includes(`;`);
{
validateBrowserExpression(exp, context, false, hasMultipleStatements);
}
if (isInlineStatement || (isCacheable && isMemberExp)) {
// wrap inline statement in a function expression
exp = createCompoundExpression([
`$event => ${hasMultipleStatements ? `{` : `(`}`,
exp,
hasMultipleStatements ? `}` : `)`
]);
}
}
let ret = {
props: [
createObjectProperty(eventName, exp || createSimpleExpression(`() => {}`, false, loc))
]
};
// apply extended compiler augmentor
if (augmentor) {
ret = augmentor(ret);
}
if (isCacheable) {
// cache handlers so that it's always the same handler being passed down.
// this avoids unnecessary re-renders when users use inline handlers on
// components.
ret.props[0].value = context.cache(ret.props[0].value);
}
return ret;
};
// v-bind without arg is handled directly in ./transformElements.ts due to it affecting
// codegen for the entire props object. This transform here is only for v-bind
// *with* args.
const transformBind = (dir, node, context) => {
const { exp, modifiers, loc } = dir;
const arg = dir.arg;
if (!exp || (exp.type === 4 /* SIMPLE_EXPRESSION */ && !exp.content)) {
context.onError(createCompilerError(31 /* X_V_BIND_NO_EXPRESSION */, loc));
}
// .prop is no longer necessary due to new patch behavior
// .sync is replaced by v-model:arg
if (modifiers.includes('camel')) {
if (arg.type === 4 /* SIMPLE_EXPRESSION */) {
if (arg.isStatic) {
arg.content = camelize(arg.content);
}
else {
arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
}
}
else {
arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
arg.children.push(`)`);
}
}
return {
props: [
createObjectProperty(arg, exp || createSimpleExpression('', true, loc))
]
};
};
// Merge adjacent text nodes and expressions into a single expression
// e.g. <div>abc {{ d }} {{ e }}</div> should have a single expression node as child.
const transformText = (node, context) => {
if (node.type === 0 /* ROOT */ ||
node.type === 1 /* ELEMENT */ ||
node.type === 11 /* FOR */ ||
node.type === 10 /* IF_BRANCH */) {
// perform the transform on node exit so that all expressions have already
// been processed.
return () => {
const children = node.children;
let currentContainer = undefined;
let hasText = false;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText(child)) {
hasText = true;
for (let j = i + 1; j < children.length; j++) {
const next = children[j];
if (isText(next)) {
if (!currentContainer) {
currentContainer = children[i] = {
type: 8 /* COMPOUND_EXPRESSION */,
loc: child.loc,
children: [child]
};
}
// merge adjacent text node into current
currentContainer.children.push(` + `, next);
children.splice(j, 1);
j--;
}
else {
currentContainer = undefined;
break;
}
}
}
}
if (!hasText ||
// if this is a plain element with a single text child, leave it
// as-is since the runtime has dedicated fast path for this by directly
// setting textContent of the element.
// for component root it's always normalized anyway.
(children.length === 1 &&
(node.type === 0 /* ROOT */ ||
(node.type === 1 /* ELEMENT */ &&
node.tagType === 0 /* ELEMENT */)))) {
return;
}
// pre-convert text nodes into createTextVNode(text) calls to avoid
// runtime normalization.
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText(child) || child.type === 8 /* COMPOUND_EXPRESSION */) {
const callArgs = [];
// createTextVNode defaults to single whitespace, so if it is a
// single space the code could be an empty call to save bytes.
if (child.type !== 2 /* TEXT */ || child.content !== ' ') {
callArgs.push(child);
}
// mark dynamic text with flag so it gets patched inside a block
if (!context.ssr && child.type !== 2 /* TEXT */) {
callArgs.push(`${1 /* TEXT */} /* ${PatchFlagNames[1 /* TEXT */]} */`);
}
children[i] = {
type: 12 /* TEXT_CALL */,
content: child,
loc: child.loc,
codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs)
};
}
}
};
}
};
const transformOnce = (node, context) => {
if (node.type === 1 /* ELEMENT */ && findDir(node, 'once', true)) {
context.helper(SET_BLOCK_TRACKING);
return () => {
if (node.codegenNode) {
node.codegenNode = context.cache(node.codegenNode, true /* isVNode */);
}
};
}
};
const transformModel = (dir, node, context) => {
const { exp, arg } = dir;
if (!exp) {
context.onError(createCompilerError(38 /* X_V_MODEL_NO_EXPRESSION */, dir.loc));
return createTransformProps();
}
const expString = exp.type === 4 /* SIMPLE_EXPRESSION */ ? exp.content : exp.loc.source;
if (!isMemberExpression(expString)) {
context.onError(createCompilerError(39 /* X_V_MODEL_MALFORMED_EXPRESSION */, exp.loc));
return createTransformProps();
}
const propName = arg ? arg : createSimpleExpression('modelValue', true);
const eventName = arg
? arg.type === 4 /* SIMPLE_EXPRESSION */ && arg.isStatic
? `onUpdate:${arg.content}`
: createCompoundExpression(['"onUpdate:" + ', arg])
: `onUpdate:modelValue`;
const props = [
// modelValue: foo
createObjectProperty(propName, dir.exp),
// "onUpdate:modelValue": $event => (foo = $event)
createObjectProperty(eventName, createCompoundExpression([`$event => (`, exp, ` = $event)`]))
];
// modelModifiers: { foo: true, "bar-baz": true }
if (dir.modifiers.length && node.tagType === 1 /* COMPONENT */) {
const modifiers = dir.modifiers
.map(m => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`)
.join(`, `);
const modifiersKey = arg
? arg.type === 4 /* SIMPLE_EXPRESSION */ && arg.isStatic
? `${arg.content}Modifiers`
: createCompoundExpression([arg, ' + "Modifiers"'])
: `modelModifiers`;
props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, true)));
}
return createTransformProps(props);
};
function createTransformProps(props = []) {
return { props };
}
function getBaseTransformPreset(prefixIdentifiers) {
return [
[
transformOnce,
transformIf,
transformFor,
...( [transformExpression]
),
transformSlotOutlet,
transformElement,
trackSlotScopes,
transformText
],
{
on: transformOn,
bind: transformBind,
model: transformModel
}
];
}
// we name it `baseCompile` so that higher order compilers like
// @vue/compiler-dom can export `compile` while re-exporting everything else.
function baseCompile(template, options = {}) {
const onError = options.onError || defaultOnError;
const isModuleMode = options.mode === 'module';
/* istanbul ignore if */
{
if (options.prefixIdentifiers === true) {
onError(createCompilerError(43 /* X_PREFIX_ID_NOT_SUPPORTED */));
}
else if (isModuleMode) {
onError(createCompilerError(44 /* X_MODULE_MODE_NOT_SUPPORTED */));
}
}
const prefixIdentifiers = !true ;
if ( options.cacheHandlers) {
onError(createCompilerError(45 /* X_CACHE_HANDLER_NOT_SUPPORTED */));
}
if (options.scopeId && !isModuleMode) {
onError(createCompilerError(46 /* X_SCOPE_ID_NOT_SUPPORTED */));
}
const ast = isString(template) ? baseParse(template, options) : template;
const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
transform(ast, extend({}, options, {
prefixIdentifiers,
nodeTransforms: [
...nodeTransforms,
...(options.nodeTransforms || []) // user transforms
],
directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {} // user transforms
)
}));
return generate(ast, extend({}, options, {
prefixIdentifiers
}));
}
const noopDirectiveTransform = () => ({ props: [] });
const V_MODEL_RADIO = Symbol( `vModelRadio` );
const V_MODEL_CHECKBOX = Symbol( `vModelCheckbox` );
const V_MODEL_TEXT = Symbol( `vModelText` );
const V_MODEL_SELECT = Symbol( `vModelSelect` );
const V_MODEL_DYNAMIC = Symbol( `vModelDynamic` );
const V_ON_WITH_MODIFIERS = Symbol( `vOnModifiersGuard` );
const V_ON_WITH_KEYS = Symbol( `vOnKeysGuard` );
const V_SHOW = Symbol( `vShow` );
const TRANSITION = Symbol( `Transition` );
const TRANSITION_GROUP = Symbol( `TransitionGroup` );
registerRuntimeHelpers({
[V_MODEL_RADIO]: `vModelRadio`,
[V_MODEL_CHECKBOX]: `vModelCheckbox`,
[V_MODEL_TEXT]: `vModelText`,
[V_MODEL_SELECT]: `vModelSelect`,
[V_MODEL_DYNAMIC]: `vModelDynamic`,
[V_ON_WITH_MODIFIERS]: `withModifiers`,
[V_ON_WITH_KEYS]: `withKeys`,
[V_SHOW]: `vShow`,
[TRANSITION]: `Transition`,
[TRANSITION_GROUP]: `TransitionGroup`
});
/* eslint-disable no-restricted-globals */
let decoder;
function decodeHtmlBrowser(raw) {
(decoder || (decoder = document.createElement('div'))).innerHTML = raw;
return decoder.textContent;
}
const isRawTextContainer = /*#__PURE__*/ makeMap('style,iframe,script,noscript', true);
const parserOptions = {
isVoidTag,
isNativeTag: tag => isHTMLTag(tag) || isSVGTag(tag),
isPreTag: tag => tag === 'pre',
decodeEntities: decodeHtmlBrowser ,
isBuiltInComponent: (tag) => {
if (isBuiltInType(tag, `Transition`)) {
return TRANSITION;
}
else if (isBuiltInType(tag, `TransitionGroup`)) {
return TRANSITION_GROUP;
}
},
// https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
getNamespace(tag, parent) {
let ns = parent ? parent.ns : 0 /* HTML */;
if (parent && ns === 2 /* MATH_ML */) {
if (parent.tag === 'annotation-xml') {
if (tag === 'svg') {
return 1 /* SVG */;
}
if (parent.props.some(a => a.type === 6 /* ATTRIBUTE */ &&
a.name === 'encoding' &&
a.value != null &&
(a.value.content === 'text/html' ||
a.value.content === 'application/xhtml+xml'))) {
ns = 0 /* HTML */;
}
}
else if (/^m(?:[ions]|text)$/.test(parent.tag) &&
tag !== 'mglyph' &&
tag !== 'malignmark') {
ns = 0 /* HTML */;
}
}
else if (parent && ns === 1 /* SVG */) {
if (parent.tag === 'foreignObject' ||
parent.tag === 'desc' ||
parent.tag === 'title') {
ns = 0 /* HTML */;
}
}
if (ns === 0 /* HTML */) {
if (tag === 'svg') {
return 1 /* SVG */;
}
if (tag === 'math') {
return 2 /* MATH_ML */;
}
}
return ns;
},
// https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
getTextMode({ tag, ns }) {
if (ns === 0 /* HTML */) {
if (tag === 'textarea' || tag === 'title') {
return 1 /* RCDATA */;
}
if (isRawTextContainer(tag)) {
return 2 /* RAWTEXT */;
}
}
return 0 /* DATA */;
}
};
// Parse inline CSS strings for static style attributes into an object.
// This is a NodeTransform since it works on the static `style` attribute and
// converts it into a dynamic equivalent:
// style="color: red" -> :style='{ "color": "red" }'
// It is then processed by `transformElement` and included in the generated
// props.
const transformStyle = node => {
if (node.type === 1 /* ELEMENT */) {
node.props.forEach((p, i) => {
if (p.type === 6 /* ATTRIBUTE */ && p.name === 'style' && p.value) {
// replace p with an expression node
node.props[i] = {
type: 7 /* DIRECTIVE */,
name: `bind`,
arg: createSimpleExpression(`style`, true, p.loc),
exp: parseInlineCSS(p.value.content, p.loc),
modifiers: [],
loc: p.loc
};
}
});
}
};
const parseInlineCSS = (cssText, loc) => {
const normalized = parseStringStyle(cssText);
return createSimpleExpression(JSON.stringify(normalized), false, loc, true);
};
function createDOMCompilerError(code, loc) {
return createCompilerError(code, loc, DOMErrorMessages );
}
const DOMErrorMessages = {
[47 /* X_V_HTML_NO_EXPRESSION */]: `v-html is missing expression.`,
[48 /* X_V_HTML_WITH_CHILDREN */]: `v-html will override element children.`,
[49 /* X_V_TEXT_NO_EXPRESSION */]: `v-text is missing expression.`,
[50 /* X_V_TEXT_WITH_CHILDREN */]: `v-text will override element children.`,
[51 /* X_V_MODEL_ON_INVALID_ELEMENT */]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
[52 /* X_V_MODEL_ARG_ON_ELEMENT */]: `v-model argument is not supported on plain elements.`,
[53 /* X_V_MODEL_ON_FILE_INPUT_ELEMENT */]: `v-model cannot used on file inputs since they are read-only. Use a v-on:change listener instead.`,
[54 /* X_V_MODEL_UNNECESSARY_VALUE */]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
[55 /* X_V_SHOW_NO_EXPRESSION */]: `v-show is missing expression.`,
[56 /* X_TRANSITION_INVALID_CHILDREN */]: `<Transition> expects exactly one child element or component.`
};
const transformVHtml = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(createDOMCompilerError(47 /* X_V_HTML_NO_EXPRESSION */, loc));
}
if (node.children.length) {
context.onError(createDOMCompilerError(48 /* X_V_HTML_WITH_CHILDREN */, loc));
node.children.length = 0;
}
return {
props: [
createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression('', true))
]
};
};
const transformVText = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(createDOMCompilerError(49 /* X_V_TEXT_NO_EXPRESSION */, loc));
}
if (node.children.length) {
context.onError(createDOMCompilerError(50 /* X_V_TEXT_WITH_CHILDREN */, loc));
node.children.length = 0;
}
return {
props: [
createObjectProperty(createSimpleExpression(`textContent`, true, loc), exp || createSimpleExpression('', true))
]
};
};
const transformModel$1 = (dir, node, context) => {
const baseResult = transformModel(dir, node, context);
// base transform has errors OR component v-model (only need props)
if (!baseResult.props.length || node.tagType === 1 /* COMPONENT */) {
return baseResult;
}
if (dir.arg) {
context.onError(createDOMCompilerError(52 /* X_V_MODEL_ARG_ON_ELEMENT */, dir.arg.loc));
}
function checkDuplicatedValue() {
const value = findProp(node, 'value');
if (value) {
context.onError(createDOMCompilerError(54 /* X_V_MODEL_UNNECESSARY_VALUE */, value.loc));
}
}
const { tag } = node;
if (tag === 'input' || tag === 'textarea' || tag === 'select') {
let directiveToUse = V_MODEL_TEXT;
let isInvalidType = false;
if (tag === 'input') {
const type = findProp(node, `type`);
if (type) {
if (type.type === 7 /* DIRECTIVE */) {
// :type="foo"
directiveToUse = V_MODEL_DYNAMIC;
}
else if (type.value) {
switch (type.value.content) {
case 'radio':
directiveToUse = V_MODEL_RADIO;
break;
case 'checkbox':
directiveToUse = V_MODEL_CHECKBOX;
break;
case 'file':
isInvalidType = true;
context.onError(createDOMCompilerError(53 /* X_V_MODEL_ON_FILE_INPUT_ELEMENT */, dir.loc));
break;
default:
// text type
checkDuplicatedValue();
break;
}
}
}
else if (hasDynamicKeyVBind(node)) {
// element has bindings with dynamic keys, which can possibly contain
// "type".
directiveToUse = V_MODEL_DYNAMIC;
}
else {
// text type
checkDuplicatedValue();
}
}
else if (tag === 'select') {
directiveToUse = V_MODEL_SELECT;
}
else if (tag === 'textarea') {
checkDuplicatedValue();
}
// inject runtime directive
// by returning the helper symbol via needRuntime
// the import will replaced a resolveDirective call.
if (!isInvalidType) {
baseResult.needRuntime = context.helper(directiveToUse);
}
}
else {
context.onError(createDOMCompilerError(51 /* X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc));
}
// native vmodel doesn't need the `modelValue` props since they are also
// passed to the runtime as `binding.value`. removing it reduces code size.
baseResult.props = baseResult.props.filter(p => {
if (p.key.type === 4 /* SIMPLE_EXPRESSION */ &&
p.key.content === 'modelValue') {
return false;
}
return true;
});
return baseResult;
};
const isEventOptionModifier = /*#__PURE__*/ makeMap(`passive,once,capture`);
const isNonKeyModifier = /*#__PURE__*/ makeMap(
// event propagation management
`stop,prevent,self,` +
// system modifiers + exact
`ctrl,shift,alt,meta,exact,` +
// mouse
`left,middle,right`);
const isKeyboardEvent = /*#__PURE__*/ makeMap(`onkeyup,onkeydown,onkeypress`, true);
const generateModifiers = (modifiers) => {
const keyModifiers = [];
const nonKeyModifiers = [];
const eventOptionModifiers = [];
for (let i = 0; i < modifiers.length; i++) {
const modifier = modifiers[i];
if (isEventOptionModifier(modifier)) {
// eventOptionModifiers: modifiers for addEventListener() options, e.g. .passive & .capture
eventOptionModifiers.push(modifier);
}
else {
// runtimeModifiers: modifiers that needs runtime guards
if (isNonKeyModifier(modifier)) {
nonKeyModifiers.push(modifier);
}
else {
keyModifiers.push(modifier);
}
}
}
return {
keyModifiers,
nonKeyModifiers,
eventOptionModifiers
};
};
const transformClick = (key, event) => {
const isStaticClick = key.type === 4 /* SIMPLE_EXPRESSION */ &&
key.isStatic &&
key.content.toLowerCase() === 'onclick';
return isStaticClick
? createSimpleExpression(event, true)
: key.type !== 4 /* SIMPLE_EXPRESSION */
? createCompoundExpression([
`(`,
key,
`).toLowerCase() === "onclick" ? "${event}" : (`,
key,
`)`
])
: key;
};
const transformOn$1 = (dir, node, context) => {
return transformOn(dir, node, context, baseResult => {
const { modifiers } = dir;
if (!modifiers.length)
return baseResult;
let { key, value: handlerExp } = baseResult.props[0];
const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = generateModifiers(modifiers);
// normalize click.right and click.middle since they don't actually fire
if (nonKeyModifiers.includes('right')) {
key = transformClick(key, `onContextmenu`);
}
if (nonKeyModifiers.includes('middle')) {
key = transformClick(key, `onMouseup`);
}
if (nonKeyModifiers.length) {
handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
handlerExp,
JSON.stringify(nonKeyModifiers)
]);
}
if (keyModifiers.length &&
// if event name is dynamic, always wrap with keys guard
(key.type === 8 /* COMPOUND_EXPRESSION */ ||
!key.isStatic ||
isKeyboardEvent(key.content))) {
handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
handlerExp,
JSON.stringify(keyModifiers)
]);
}
if (eventOptionModifiers.length) {
handlerExp = createObjectExpression([
createObjectProperty('handler', handlerExp),
createObjectProperty('options', createObjectExpression(eventOptionModifiers.map(modifier => createObjectProperty(modifier, createSimpleExpression('true', false)))))
]);
}
return {
props: [createObjectProperty(key, handlerExp)]
};
});
};
const transformShow = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(createDOMCompilerError(55 /* X_V_SHOW_NO_EXPRESSION */, loc));
}
return {
props: [],
needRuntime: context.helper(V_SHOW)
};
};
const warnTransitionChildren = (node, context) => {
if (node.type === 1 /* ELEMENT */ &&
node.tagType === 1 /* COMPONENT */) {
const component = context.isBuiltInComponent(node.tag);
if (component === TRANSITION) {
return () => {
if (node.children.length && hasMultipleChildren(node)) {
context.onError(createDOMCompilerError(56 /* X_TRANSITION_INVALID_CHILDREN */, {
start: node.children[0].loc.start,
end: node.children[node.children.length - 1].loc.end,
source: ''
}));
}
};
}
}
};
function hasMultipleChildren(node) {
const child = node.children[0];
return (node.children.length !== 1 ||
child.type === 11 /* FOR */ ||
(child.type === 9 /* IF */ && child.branches.some(hasMultipleChildren)));
}
const DOMNodeTransforms = [
transformStyle,
...( [warnTransitionChildren] )
];
const DOMDirectiveTransforms = {
cloak: noopDirectiveTransform,
html: transformVHtml,
text: transformVText,
model: transformModel$1,
on: transformOn$1,
show: transformShow
};
function compile(template, options = {}) {
return baseCompile(template, extend({}, parserOptions, options, {
nodeTransforms: [...DOMNodeTransforms, ...(options.nodeTransforms || [])],
directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
transformHoist: null
}));
}
const targetMap = new WeakMap();
const effectStack = [];
let activeEffect;
const ITERATE_KEY = Symbol( 'iterate' );
const MAP_KEY_ITERATE_KEY = Symbol( 'Map key iterate' );
function isEffect(fn) {
return fn && fn._isEffect === true;
}
function effect(fn, options = EMPTY_OBJ) {
if (isEffect(fn)) {
fn = fn.raw;
}
const effect = createReactiveEffect(fn, options);
if (!options.lazy) {
effect();
}
return effect;
}
function stop(effect) {
if (effect.active) {
cleanup(effect);
if (effect.options.onStop) {
effect.options.onStop();
}
effect.active = false;
}
}
let uid = 0;
function createReactiveEffect(fn, options) {
const effect = function reactiveEffect(...args) {
if (!effect.active) {
return options.scheduler ? undefined : fn(...args);
}
if (!effectStack.includes(effect)) {
cleanup(effect);
try {
enableTracking();
effectStack.push(effect);
activeEffect = effect;
return fn(...args);
}
finally {
effectStack.pop();
resetTracking();
activeEffect = effectStack[effectStack.length - 1];
}
}
};
effect.id = uid++;
effect._isEffect = true;
effect.active = true;
effect.raw = fn;
effect.deps = [];
effect.options = options;
return effect;
}
function cleanup(effect) {
const { deps } = effect;
if (deps.length) {
for (let i = 0; i < deps.length; i++) {
deps[i].delete(effect);
}
deps.length = 0;
}
}
let shouldTrack = true;
const trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function enableTracking() {
trackStack.push(shouldTrack);
shouldTrack = true;
}
function resetTracking() {
const last = trackStack.pop();
shouldTrack = last === undefined ? true : last;
}
function track(target, type, key) {
if (!shouldTrack || activeEffect === undefined) {
return;
}
let depsMap = targetMap.get(target);
if (!depsMap) {
targetMap.set(target, (depsMap = new Map()));
}
let dep = depsMap.get(key);
if (!dep) {
depsMap.set(key, (dep = new Set()));
}
if (!dep.has(activeEffect)) {
dep.add(activeEffect);
activeEffect.deps.push(dep);
if ( activeEffect.options.onTrack) {
activeEffect.options.onTrack({
effect: activeEffect,
target,
type,
key
});
}
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
// never been tracked
return;
}
const effects = new Set();
const computedRunners = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect || !shouldTrack) {
if (effect.options.computed) {
computedRunners.add(effect);
}
else {
effects.add(effect);
}
}
});
}
};
if (type === "clear" /* CLEAR */) {
// collection being cleared
// trigger all effects for target
depsMap.forEach(add);
}
else if (key === 'length' && isArray(target)) {
depsMap.forEach((dep, key) => {
if (key === 'length' || key >= newValue) {
add(dep);
}
});
}
else {
// schedule runs for SET | ADD | DELETE
if (key !== void 0) {
add(depsMap.get(key));
}
// also run for iteration key on ADD | DELETE | Map.SET
const isAddOrDelete = type === "add" /* ADD */ ||
(type === "delete" /* DELETE */ && !isArray(target));
if (isAddOrDelete ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));
}
if (isAddOrDelete && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
const run = (effect) => {
if ( effect.options.onTrigger) {
effect.options.onTrigger({
effect,
target,
key,
type,
newValue,
oldValue,
oldTarget
});
}
if (effect.options.scheduler) {
effect.options.scheduler(effect);
}
else {
effect();
}
};
// Important: computed effects must be run first so that computed getters
// can be invalidated before any normal effects that depend on them are run.
computedRunners.forEach(run);
effects.forEach(run);
}
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
.map(key => Symbol[key])
.filter(isSymbol));
const get = /*#__PURE__*/ createGetter();
const shallowGet = /*#__PURE__*/ createGetter(false, true);
const readonlyGet = /*#__PURE__*/ createGetter(true);
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
const arrayInstrumentations = {};
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
arrayInstrumentations[key] = function (...args) {
const arr = toRaw(this);
for (let i = 0, l = this.length; i < l; i++) {
track(arr, "get" /* GET */, i + '');
}
// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
}
else {
return res;
}
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* isReactive */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */ &&
receiver ===
(isReadonly
? target.__v_readonly
: target.__v_reactive)) {
return target;
}
const targetIsArray = isArray(target);
if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver);
}
const res = Reflect.get(target, key, receiver);
if ((isSymbol(key) && builtInSymbols.has(key)) || key === '__proto__') {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
return res;
}
if (isRef(res)) {
// ref unwrapping, only for Objects, not for Arrays.
return targetIsArray ? res : res.value;
}
if (isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};
}
const set = /*#__PURE__*/ createSetter();
const shallowSet = /*#__PURE__*/ createSetter(true);
function createSetter(shallow = false) {
return function set(target, key, value, receiver) {
const oldValue = target[key];
if (!shallow) {
value = toRaw(value);
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
}
const hadKey = hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);
// don't trigger if target is something up in the prototype chain of original
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add" /* ADD */, key, value);
}
else if (hasChanged(value, oldValue)) {
trigger(target, "set" /* SET */, key, value, oldValue);
}
}
return result;
};
}
function deleteProperty(target, key) {
const hadKey = hasOwn(target, key);
const oldValue = target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
}
return result;
}
function has(target, key) {
const result = Reflect.has(target, key);
track(target, "has" /* HAS */, key);
return result;
}
function ownKeys(target) {
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.ownKeys(target);
}
const mutableHandlers = {
get,
set,
deleteProperty,
has,
ownKeys
};
const readonlyHandlers = {
get: readonlyGet,
has,
ownKeys,
set(target, key) {
{
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
}
return true;
},
deleteProperty(target, key) {
{
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
}
return true;
}
};
const shallowReactiveHandlers = extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = extend({}, readonlyHandlers, {
get: shallowReadonlyGet
});
const toReactive = (value) => isObject(value) ? reactive(value) : value;
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, wrap) {
target = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "get" /* GET */, key);
}
track(target, "get" /* GET */, rawKey);
const { has, get } = getProto(target);
if (has.call(target, key)) {
return wrap(get.call(target, key));
}
else if (has.call(target, rawKey)) {
return wrap(get.call(target, rawKey));
}
}
function has$1(key) {
const target = toRaw(this);
const rawKey = toRaw(key);
if (key !== rawKey) {
track(target, "has" /* HAS */, key);
}
track(target, "has" /* HAS */, rawKey);
const has = getProto(target).has;
return has.call(target, key) || has.call(target, rawKey);
}
function size(target) {
target = toRaw(target);
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(getProto(target), 'size', target);
}
function add(value) {
value = toRaw(value);
const target = toRaw(this);
const proto = getProto(target);
const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
if (!hadKey) {
trigger(target, "add" /* ADD */, value, value);
}
return result;
}
function set$1(key, value) {
value = toRaw(value);
const target = toRaw(this);
const { has, get, set } = getProto(target);
let hadKey = has.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has.call(target, key);
}
else {
checkIdentityKeys(target, has, key);
}
const oldValue = get.call(target, key);
const result = set.call(target, key, value);
if (!hadKey) {
trigger(target, "add" /* ADD */, key, value);
}
else if (hasChanged(value, oldValue)) {
trigger(target, "set" /* SET */, key, value, oldValue);
}
return result;
}
function deleteEntry(key) {
const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
let hadKey = has.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has.call(target, key);
}
else {
checkIdentityKeys(target, has, key);
}
const oldValue = get ? get.call(target, key) : undefined;
// forward the operation before queueing reactions
const result = del.call(target, key);
if (hadKey) {
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const oldTarget = target instanceof Map
? new Map(target)
: new Set(target)
;
// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
if (hadItems) {
trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
}
return result;
}
function createForEach(isReadonly, shallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = toRaw(observed);
const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;
!isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
// important: create sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
function wrappedCallback(value, key) {
return callback.call(thisArg, wrap(value), wrap(key), observed);
}
return getProto(target).forEach.call(target, wrappedCallback);
};
}
function createIterableMethod(method, isReadonly, shallow) {
return function (...args) {
const target = toRaw(this);
const isMap = target instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = getProto(target)[method].apply(target, args);
const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;
!isReadonly &&
track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the
// values emitted from the real iterator
return {
// iterator protocol
next() {
const { value, done } = innerIterator.next();
return done
? { value, done }
: {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
// iterable protocol
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function (...args) {
{
const key = args[0] ? `on key "${args[0]}" ` : ``;
console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
}
return type === "delete" /* DELETE */ ? false : this;
};
}
const mutableInstrumentations = {
get(key) {
return get$1(this, key, toReactive);
},
get size() {
return size(this);
},
has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, false)
};
const shallowInstrumentations = {
get(key) {
return get$1(this, key, toShallow);
},
get size() {
return size(this);
},
has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, toReadonly);
},
get size() {
return size(this);
},
has: has$1,
add: createReadonlyMethod("add" /* ADD */),
set: createReadonlyMethod("set" /* SET */),
delete: createReadonlyMethod("delete" /* DELETE */),
clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* isReactive */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* isReadonly */) {
return isReadonly;
}
else if (key === "__v_raw" /* raw */) {
return target;
}
return Reflect.get(hasOwn(instrumentations, key) && key in target
? instrumentations
: target, key, receiver);
};
}
const mutableCollectionHandlers = {
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true, false)
};
function checkIdentityKeys(target, has, key) {
const rawKey = toRaw(key);
if (rawKey !== key && has.call(target, rawKey)) {
const type = toRawType(target);
console.warn(`Reactive ${type} contains both the raw and reactive ` +
`versions of the same object${type === `Map` ? `as keys` : ``}, ` +
`which can lead to inconsistencies. ` +
`Avoid differentiating between the raw and reactive versions ` +
`of an object and only use the reactive version if possible.`);
}
}
const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
const isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
const canObserve = (value) => {
return (!value["__v_skip" /* skip */] &&
isObservableType(toRawType(value)) &&
!Object.isFrozen(value));
};
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target["__v_isReadonly" /* isReadonly */]) {
return target;
}
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);
}
// Return a reactive-copy of the original object, where only the root level
// properties are reactive, and does NOT unwrap refs nor recursively convert
// returned properties.
function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}
function readonly(target) {
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);
}
// Return a reactive-copy of the original object, where only the root level
// properties are readonly, and does NOT unwrap refs nor recursively convert
// returned properties.
// This is used for creating the props proxy object for stateful components.
function shallowReadonly(target) {
return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);
}
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {
if (!isObject(target)) {
{
console.warn(`value cannot be made reactive: ${String(target)}`);
}
return target;
}
// target is already a Proxy, return it.
// exception: calling readonly() on a reactive object
if (target["__v_raw" /* raw */] &&
!(isReadonly && target["__v_isReactive" /* isReactive */])) {
return target;
}
// target already has corresponding Proxy
if (hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) {
return isReadonly
? target["__v_readonly" /* readonly */]
: target["__v_reactive" /* reactive */];
}
// only a whitelist of value types can be observed.
if (!canObserve(target)) {
return target;
}
const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed);
return observed;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value["__v_raw" /* raw */]);
}
return !!(value && value["__v_isReactive" /* isReactive */]);
}
function isReadonly(value) {
return !!(value && value["__v_isReadonly" /* isReadonly */]);
}
function isProxy(value) {
return isReactive(value) || isReadonly(value);
}
function toRaw(observed) {
return ((observed && toRaw(observed["__v_raw" /* raw */])) || observed);
}
function markRaw(value) {
def(value, "__v_skip" /* skip */, true);
return value;
}
const convert = (val) => isObject(val) ? reactive(val) : val;
function isRef(r) {
return r ? r.__v_isRef === true : false;
}
function ref(value) {
return createRef(value);
}
function shallowRef(value) {
return createRef(value, true);
}
function createRef(rawValue, shallow = false) {
if (isRef(rawValue)) {
return rawValue;
}
let value = shallow ? rawValue : convert(rawValue);
const r = {
__v_isRef: true,
get value() {
track(r, "get" /* GET */, 'value');
return value;
},
set value(newVal) {
if (hasChanged(toRaw(newVal), rawValue)) {
rawValue = newVal;
value = shallow ? newVal : convert(newVal);
trigger(r, "set" /* SET */, 'value', { newValue: newVal } );
}
}
};
return r;
}
function triggerRef(ref) {
trigger(ref, "set" /* SET */, 'value', { newValue: ref.value } );
}
function unref(ref) {
return isRef(ref) ? ref.value : ref;
}
function customRef(factory) {
const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
const r = {
__v_isRef: true,
get value() {
return get();
},
set value(v) {
set(v);
}
};
return r;
}
function toRefs(object) {
if ( !isProxy(object)) {
console.warn(`toRefs() expects a reactive object but received a plain one.`);
}
const ret = {};
for (const key in object) {
ret[key] = toRef(object, key);
}
return ret;
}
function toRef(object, key) {
return {
__v_isRef: true,
get value() {
return object[key];
},
set value(newVal) {
object[key] = newVal;
}
};
}
function computed(getterOrOptions) {
let getter;
let setter;
if (isFunction(getterOrOptions)) {
getter = getterOrOptions;
setter = () => {
console.warn('Write operation failed: computed value is readonly');
}
;
}
else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
let dirty = true;
let value;
let computed;
const runner = effect(getter, {
lazy: true,
// mark effect as computed so that it gets priority during trigger
computed: true,
scheduler: () => {
if (!dirty) {
dirty = true;
trigger(computed, "set" /* SET */, 'value');
}
}
});
computed = {
__v_isRef: true,
// expose effect so computed can be stopped
effect: runner,
get value() {
if (dirty) {
value = runner();
dirty = false;
}
track(computed, "get" /* GET */, 'value');
return value;
},
set value(newValue) {
setter(newValue);
}
};
return computed;
}
const stack = [];
function pushWarningContext(vnode) {
stack.push(vnode);
}
function popWarningContext() {
stack.pop();
}
function warn(msg, ...args) {
// avoid props formatting or warn handler tracking deps that might be mutated
// during patch, leading to infinite recursion.
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 /* APP_WARN_HANDLER */, [
msg + args.join(''),
instance && instance.proxy,
trace
.map(({ vnode }) => `at <${formatComponentName(vnode.type)}>`)
.join('\n'),
trace
]);
}
else {
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
if (trace.length &&
// avoid spamming console during tests
!false) {
warnArgs.push(`\n`, ...formatTrace(trace));
}
console.warn(...warnArgs);
}
resetTracking();
}
function getComponentTrace() {
let currentVNode = stack[stack.length - 1];
if (!currentVNode) {
return [];
}
// we can't just use the stack because it will be incomplete during updates
// that did not start from the root. Re-construct the parent chain using
// instance parent pointers.
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 ? [] : [`\n`]), ...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.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];
}
}
const ErrorTypeStrings = {
["bc" /* BEFORE_CREATE */]: 'beforeCreate hook',
["c" /* CREATED */]: 'created hook',
["bm" /* BEFORE_MOUNT */]: 'beforeMount hook',
["m" /* MOUNTED */]: 'mounted hook',
["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook',
["u" /* UPDATED */]: 'updated',
["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',
["um" /* UNMOUNTED */]: 'unmounted hook',
["a" /* ACTIVATED */]: 'activated hook',
["da" /* DEACTIVATED */]: 'deactivated hook',
["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook',
["rtc" /* RENDER_TRACKED */]: 'renderTracked hook',
["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook',
[0 /* SETUP_FUNCTION */]: 'setup function',
[1 /* RENDER_FUNCTION */]: 'render function',
[2 /* WATCH_GETTER */]: 'watcher getter',
[3 /* WATCH_CALLBACK */]: 'watcher callback',
[4 /* WATCH_CLEANUP */]: 'watcher cleanup function',
[5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',
[6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',
[7 /* VNODE_HOOK */]: 'vnode hook',
[8 /* DIRECTIVE_HOOK */]: 'directive hook',
[9 /* TRANSITION_HOOK */]: 'transition hook',
[10 /* APP_ERROR_HANDLER */]: 'app errorHandler',
[11 /* APP_WARN_HANDLER */]: 'app warnHandler',
[12 /* FUNCTION_REF */]: 'ref function',
[13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',
[14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'
};
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) {
const contextVNode = instance ? instance.vnode : null;
if (instance) {
let cur = instance.parent;
// the exposed instance is the render proxy to keep it consistent with 2.x
const exposedInstance = instance.proxy;
// in production the hook receives only the error code
const errorInfo = ErrorTypeStrings[type] ;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {
return;
}
}
}
cur = cur.parent;
}
// app-level handling
const appErrorHandler = instance.appContext.config.errorHandler;
if (appErrorHandler) {
callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
return;
}
}
logError(err, type, contextVNode);
}
function logError(err, type, contextVNode) {
// default behavior is crash in prod & test, recover in dev.
{
const info = ErrorTypeStrings[type];
if (contextVNode) {
pushWarningContext(contextVNode);
}
warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
console.error(err);
if (contextVNode) {
popWarningContext();
}
}
}
const queue = [];
const postFlushCbs = [];
const p = Promise.resolve();
let isFlushing = false;
let isFlushPending = false;
const RECURSION_LIMIT = 100;
function nextTick(fn) {
return fn ? p.then(fn) : p;
}
function queueJob(job) {
if (!queue.includes(job)) {
queue.push(job);
queueFlush();
}
}
function invalidateJob(job) {
const i = queue.indexOf(job);
if (i > -1) {
queue[i] = null;
}
}
function queuePostFlushCb(cb) {
if (!isArray(cb)) {
postFlushCbs.push(cb);
}
else {
postFlushCbs.push(...cb);
}
queueFlush();
}
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true;
nextTick(flushJobs);
}
}
function flushPostFlushCbs(seen) {
if (postFlushCbs.length) {
const cbs = [...new Set(postFlushCbs)];
postFlushCbs.length = 0;
{
seen = seen || new Map();
}
for (let i = 0; i < cbs.length; i++) {
{
checkRecursiveUpdates(seen, cbs[i]);
}
cbs[i]();
}
}
}
const getId = (job) => (job.id == null ? Infinity : job.id);
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
let job;
{
seen = seen || new Map();
}
// Sort queue before flush.
// This ensures that:
// 1. Components are updated from parent to child. (because parent is always
// created before the child so its render effect will have smaller
// priority number)
// 2. If a component is unmounted during a parent component's update,
// its update can be skipped.
// Jobs can never be null before flush starts, since they are only invalidated
// during execution of another flushed job.
queue.sort((a, b) => getId(a) - getId(b));
while ((job = queue.shift()) !== undefined) {
if (job === null) {
continue;
}
{
checkRecursiveUpdates(seen, job);
}
callWithErrorHandling(job, null, 14 /* SCHEDULER */);
}
flushPostFlushCbs(seen);
isFlushing = false;
// some postFlushCb queued jobs!
// keep flushing until it drains.
if (queue.length || postFlushCbs.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) {
throw new Error('Maximum recursive updates exceeded. ' +
"You may have code that is mutating state in your component's " +
'render function or updated hook or watcher source function.');
}
else {
seen.set(fn, count + 1);
}
}
}
let isHmrUpdating = false;
const hmrDirtyComponents = new Set();
// Expose the HMR runtime on the global object
// This makes it entirely tree-shakable without polluting the exports and makes
// it easier to be used in toolings like vue-loader
// Note: for a component to be eligible for HMR it also needs the __hmrId option
// to be set so that its instances can be registered / removed.
{
const globalObject = typeof global !== 'undefined'
? global
: typeof self !== 'undefined'
? self
: typeof window !== 'undefined'
? window
: {};
globalObject.__VUE_HMR_RUNTIME__ = {
createRecord: tryWrap(createRecord),
rerender: tryWrap(rerender),
reload: tryWrap(reload)
};
}
const map = new Map();
function registerHMR(instance) {
const id = instance.type.__hmrId;
let record = map.get(id);
if (!record) {
createRecord(id);
record = map.get(id);
}
record.add(instance);
}
function unregisterHMR(instance) {
map.get(instance.type.__hmrId).delete(instance);
}
function createRecord(id) {
if (map.has(id)) {
return false;
}
map.set(id, new Set());
return true;
}
function rerender(id, newRender) {
const record = map.get(id);
if (!record)
return;
// Array.from creates a snapshot which avoids the set being mutated during
// updates
Array.from(record).forEach(instance => {
if (newRender) {
instance.render = newRender;
}
instance.renderCache = [];
// this flag forces child components with slot content to update
isHmrUpdating = true;
instance.update();
isHmrUpdating = false;
});
}
function reload(id, newComp) {
const record = map.get(id);
if (!record)
return;
// Array.from creates a snapshot which avoids the set being mutated during
// updates
Array.from(record).forEach(instance => {
const comp = instance.type;
if (!hmrDirtyComponents.has(comp)) {
// 1. Update existing comp definition to match new one
extend(comp, newComp);
for (const key in comp) {
if (!(key in newComp)) {
delete comp[key];
}
}
// 2. Mark component dirty. This forces the renderer to replace the component
// on patch.
hmrDirtyComponents.add(comp);
// 3. Make sure to unmark the component after the reload.
queuePostFlushCb(() => {
hmrDirtyComponents.delete(comp);
});
}
if (instance.parent) {
// 4. Force the parent instance to re-render. This will cause all updated
// components to be unmounted and re-mounted. Queue the update so that we
// don't end up forcing the same parent to re-render multiple times.
queueJob(instance.parent.update);
}
else if (instance.appContext.reload) {
// root instance mounted via createApp() has a reload method
instance.appContext.reload();
}
else if (typeof window !== 'undefined') {
// root instance inside tree created via raw render(). Force reload.
window.location.reload();
}
else {
console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');
}
});
}
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.`);
}
};
}
// mark the current rendering instance for asset resolution (e.g.
// resolveComponent, resolveDirective) during render
let currentRenderingInstance = null;
function setCurrentRenderingInstance(instance) {
currentRenderingInstance = instance;
}
// dev only flag to track whether $attrs was used during render.
// If $attrs was used during render then the warning for failed attrs
// fallthrough can be suppressed.
let accessedAttrs = false;
function markAttrsAccessed() {
accessedAttrs = true;
}
function renderComponentRoot(instance) {
const { type: Component, parent, vnode, proxy, withProxy, props, slots, attrs, emit, renderCache } = instance;
let result;
currentRenderingInstance = instance;
{
accessedAttrs = false;
}
try {
let fallthroughAttrs;
if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {
// withProxy is a proxy with a different `has` trap only for
// runtime-compiled render functions using `with` block.
const proxyToUse = withProxy || proxy;
result = normalizeVNode(instance.render.call(proxyToUse, proxyToUse, renderCache));
fallthroughAttrs = attrs;
}
else {
// functional
const render = Component;
// in dev, mark attrs accessed if optional props (attrs === props)
if (true && attrs === props) {
markAttrsAccessed();
}
result = normalizeVNode(render.length > 1
? render(props, true
? {
get attrs() {
markAttrsAccessed();
return attrs;
},
slots,
emit
}
: { attrs, slots, emit })
: render(props, null /* we know it doesn't need it */));
fallthroughAttrs = Component.props ? attrs : getFallthroughAttrs(attrs);
}
// attr merging
// in dev mode, comments are preserved, and it's possible for a template
// to have comments along side the root element which makes it a fragment
let root = result;
let setRoot = undefined;
if (true) {
;
[root, setRoot] = getChildRoot(result);
}
if (Component.inheritAttrs !== false &&
fallthroughAttrs &&
Object.keys(fallthroughAttrs).length) {
if (root.shapeFlag & 1 /* ELEMENT */ ||
root.shapeFlag & 6 /* COMPONENT */) {
root = cloneVNode(root, fallthroughAttrs);
}
else if (true && !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)) {
// remove `on`, lowercase first letter to reflect event casing accurately
eventAttrs.push(key[2].toLowerCase() + key.slice(3));
}
else {
extraAttrs.push(key);
}
}
if (extraAttrs.length) {
warn(`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) {
warn(`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.`);
}
}
}
// inherit scopeId
const parentScopeId = parent && parent.type.__scopeId;
if (parentScopeId) {
root = cloneVNode(root, { [parentScopeId]: '' });
}
// inherit directives
if (vnode.dirs) {
if (true && !isElementRoot(root)) {
warn(`Runtime directive used on component with non-element root node. ` +
`The directives will not function as intended.`);
}
root.dirs = vnode.dirs;
}
// inherit transition data
if (vnode.transition) {
if (true && !isElementRoot(root)) {
warn(`Component inside <Transition> renders non-element root node ` +
`that cannot be animated.`);
}
root.transition = vnode.transition;
}
// inherit ref
if (Component.inheritRef && vnode.ref != null) {
root.ref = vnode.ref;
}
if (true && setRoot) {
setRoot(root);
}
else {
result = root;
}
}
catch (err) {
handleError(err, instance, 1 /* RENDER_FUNCTION */);
result = createVNode(Comment);
}
currentRenderingInstance = null;
return result;
}
const getChildRoot = (vnode) => {
if (vnode.type !== Fragment) {
return [vnode, undefined];
}
const rawChildren = vnode.children;
const dynamicChildren = vnode.dynamicChildren;
const children = rawChildren.filter(child => {
return !(isVNode(child) && child.type === Comment);
});
if (children.length !== 1) {
return [vnode, undefined];
}
const childRoot = children[0];
const index = rawChildren.indexOf(childRoot);
const dynamicIndex = dynamicChildren
? dynamicChildren.indexOf(childRoot)
: null;
const setRoot = (updatedRoot) => {
rawChildren[index] = updatedRoot;
if (dynamicIndex !== null)
dynamicChildren[dynamicIndex] = updatedRoot;
};
return [normalizeVNode(childRoot), setRoot];
};
const getFallthroughAttrs = (attrs) => {
let res;
for (const key in attrs) {
if (key === 'class' || key === 'style' || isOn(key)) {
(res || (res = {}))[key] = attrs[key];
}
}
return res;
};
const isElementRoot = (vnode) => {
return (vnode.shapeFlag & 6 /* COMPONENT */ ||
vnode.shapeFlag & 1 /* ELEMENT */ ||
vnode.type === Comment // potential v-if branch switch
);
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const { props: prevProps, children: prevChildren } = prevVNode;
const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
// Parent component's render function was hot-updated. Since this may have
// caused the child component's slots content to have changed, we need to
// force the child to update as well.
if ( (prevChildren || nextChildren) && isHmrUpdating) {
return true;
}
// force child update for runtime directive or transition on component vnode.
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (patchFlag > 0) {
if (patchFlag & 1024 /* DYNAMIC_SLOTS */) {
// slot content that references values that might have changed,
// e.g. in a v-for
return true;
}
if (patchFlag & 16 /* FULL_PROPS */) {
if (!prevProps) {
return !!nextProps;
}
// presence of this flag indicates props are always non-null
return hasPropsChanged(prevProps, nextProps);
}
else if (patchFlag & 8 /* PROPS */) {
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
if (nextProps[key] !== prevProps[key]) {
return true;
}
}
}
}
else if (!optimized) {
// this path is only taken by manually written render functions
// so presence of any children leads to a forced update
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);
}
return false;
}
function hasPropsChanged(prevProps, nextProps) {
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]) {
return true;
}
}
return false;
}
function updateHOCHostEl({ vnode, parent }, el // HostNode
) {
while (parent && parent.subTree === vnode) {
(vnode = parent.vnode).el = el;
parent = parent.parent;
}
}
const isSuspense = (type) => type.__isSuspense;
// Suspense exposes a component-like API, and is treated like a component
// in the compiler, but internally it's a special built-in type that hooks
// directly into the renderer.
const SuspenseImpl = {
// 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, optimized,
// platform-specific impl passed from renderer
rendererInternals) {
if (n1 == null) {
mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals);
}
else {
patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, rendererInternals);
}
},
hydrate: hydrateSuspense
};
// Force-casted public typing for h and TSX props inference
const Suspense = ( SuspenseImpl
);
function mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals) {
const { p: patch, o: { createElement } } = rendererInternals;
const hiddenContainer = createElement('div');
const suspense = (n2.suspense = createSuspenseBoundary(n2, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals));
// start mounting the content subtree in an off-dom container
patch(null, suspense.subTree, hiddenContainer, null, parentComponent, suspense, isSVG, optimized);
// now check if we have encountered any async deps
if (suspense.deps > 0) {
// mount the fallback tree
patch(null, suspense.fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context
isSVG, optimized);
n2.el = suspense.fallbackTree.el;
}
else {
// Suspense has no async deps. Just resolve.
suspense.resolve();
}
}
function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, { p: patch }) {
const suspense = (n2.suspense = n1.suspense);
suspense.vnode = n2;
const { content, fallback } = normalizeSuspenseChildren(n2);
const oldSubTree = suspense.subTree;
const oldFallbackTree = suspense.fallbackTree;
if (!suspense.isResolved) {
patch(oldSubTree, content, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, optimized);
if (suspense.deps > 0) {
// still pending. patch the fallback tree.
patch(oldFallbackTree, fallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context
isSVG, optimized);
n2.el = fallback.el;
}
// If deps somehow becomes 0 after the patch it means the patch caused an
// async dep component to unmount and removed its dep. It will cause the
// suspense to resolve and we don't need to do anything here.
}
else {
// just normal patch inner content as a fragment
patch(oldSubTree, content, container, anchor, parentComponent, suspense, isSVG, optimized);
n2.el = content.el;
}
suspense.subTree = content;
suspense.fallbackTree = fallback;
}
let hasWarned = false;
function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals, isHydrating = false) {
/* istanbul ignore if */
if ( !hasWarned) {
hasWarned = true;
// @ts-ignore `console.info` cannot be null error
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 } } = rendererInternals;
const getCurrentTree = () => suspense.isResolved || suspense.isHydrating
? suspense.subTree
: suspense.fallbackTree;
const { content, fallback } = normalizeSuspenseChildren(vnode);
const suspense = {
vnode,
parent,
parentComponent,
isSVG,
optimized,
container,
hiddenContainer,
anchor,
deps: 0,
subTree: content,
fallbackTree: fallback,
isHydrating,
isResolved: false,
isUnmounted: false,
effects: [],
resolve() {
{
if (suspense.isResolved) {
throw new Error(`resolveSuspense() is called on an already resolved suspense boundary.`);
}
if (suspense.isUnmounted) {
throw new Error(`resolveSuspense() is called on an already unmounted suspense boundary.`);
}
}
const { vnode, subTree, fallbackTree, effects, parentComponent, container } = suspense;
if (suspense.isHydrating) {
suspense.isHydrating = false;
}
else {
// this is initial anchor on mount
let { anchor } = suspense;
// unmount fallback tree
if (fallbackTree.el) {
// if the fallback tree was mounted, it may have been moved
// as part of a parent suspense. get the latest anchor for insertion
anchor = next(fallbackTree);
unmount(fallbackTree, parentComponent, suspense, true);
}
// move content from off-dom container to actual container
move(subTree, container, anchor, 0 /* ENTER */);
}
const el = (vnode.el = subTree.el);
// suspense as the root node of a component...
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
// check if there is a pending parent suspense
let parent = suspense.parent;
let hasUnresolvedAncestor = false;
while (parent) {
if (!parent.isResolved) {
// found a pending parent suspense, merge buffered post jobs
// into that parent
parent.effects.push(...effects);
hasUnresolvedAncestor = true;
break;
}
parent = parent.parent;
}
// no pending parent suspense, flush all jobs
if (!hasUnresolvedAncestor) {
queuePostFlushCb(effects);
}
suspense.isResolved = true;
suspense.effects = [];
// invoke @resolve event
const onResolve = vnode.props && vnode.props.onResolve;
if (isFunction(onResolve)) {
onResolve();
}
},
recede() {
suspense.isResolved = false;
const { vnode, subTree, fallbackTree, parentComponent, container, hiddenContainer, isSVG, optimized } = suspense;
// move content tree back to the off-dom container
const anchor = next(subTree);
move(subTree, hiddenContainer, null, 1 /* LEAVE */);
// remount the fallback tree
patch(null, fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context
isSVG, optimized);
const el = (vnode.el = fallbackTree.el);
// suspense as the root node of a component...
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
// invoke @recede event
const onRecede = vnode.props && vnode.props.onRecede;
if (isFunction(onRecede)) {
onRecede();
}
},
move(container, anchor, type) {
move(getCurrentTree(), container, anchor, type);
suspense.container = container;
},
next() {
return next(getCurrentTree());
},
registerDep(instance, setupRenderEffect) {
// suspense is already resolved, need to recede.
// use queueJob so it's handled synchronously after patching the current
// suspense tree
if (suspense.isResolved) {
queueJob(() => {
suspense.recede();
});
}
const hydratedEl = instance.vnode.el;
suspense.deps++;
instance
.asyncDep.catch(err => {
handleError(err, instance, 0 /* SETUP_FUNCTION */);
})
.then(asyncSetupResult => {
// retry when the setup() promise resolves.
// component may have been unmounted before resolve.
if (instance.isUnmounted || suspense.isUnmounted) {
return;
}
suspense.deps--;
// retry from this component
instance.asyncResolved = true;
const { vnode } = instance;
{
pushWarningContext(vnode);
}
handleSetupResult(instance, asyncSetupResult);
if (hydratedEl) {
// vnode may have been replaced if an update happened before the
// async dep is resolved.
vnode.el = hydratedEl;
}
setupRenderEffect(instance, vnode,
// component may have been moved before resolve.
// if this is not a hydration, instance.subTree will be the comment
// placeholder.
hydratedEl
? parentNode(hydratedEl)
: parentNode(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);
updateHOCHostEl(instance, vnode.el);
{
popWarningContext();
}
if (suspense.deps === 0) {
suspense.resolve();
}
});
},
unmount(parentSuspense, doRemove) {
suspense.isUnmounted = true;
unmount(suspense.subTree, parentComponent, parentSuspense, doRemove);
if (!suspense.isResolved) {
unmount(suspense.fallbackTree, parentComponent, parentSuspense, doRemove);
}
}
};
return suspense;
}
function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, optimized, rendererInternals, hydrateNode) {
/* eslint-disable no-restricted-globals */
const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, optimized, rendererInternals, true /* hydrating */));
// there are two possible scenarios for server-rendered suspense:
// - success: ssr content should be fully resolved
// - failure: ssr content should be the fallback branch.
// however, on the client we don't really know if it has failed or not
// attempt to hydrate the DOM assuming it has succeeded, but we still
// need to construct a suspense boundary first
const result = hydrateNode(node, suspense.subTree, parentComponent, suspense, optimized);
if (suspense.deps === 0) {
suspense.resolve();
}
return result;
/* eslint-enable no-restricted-globals */
}
function normalizeSuspenseChildren(vnode) {
const { shapeFlag, children } = vnode;
if (shapeFlag & 32 /* SLOTS_CHILDREN */) {
const { default: d, fallback } = children;
return {
content: normalizeVNode(isFunction(d) ? d() : d),
fallback: normalizeVNode(isFunction(fallback) ? fallback() : fallback)
};
}
else {
return {
content: normalizeVNode(children),
fallback: normalizeVNode(null)
};
}
}
function queueEffectWithSuspense(fn, suspense) {
if (suspense && !suspense.isResolved) {
if (isArray(fn)) {
suspense.effects.push(...fn);
}
else {
suspense.effects.push(fn);
}
}
else {
queuePostFlushCb(fn);
}
}
/**
* Wrap a slot function to memoize current rendering instance
* @private
*/
function withCtx(fn, ctx = currentRenderingInstance) {
if (!ctx)
return fn;
return function renderFnWithContext() {
const owner = currentRenderingInstance;
setCurrentRenderingInstance(ctx);
const res = fn.apply(null, arguments);
setCurrentRenderingInstance(owner);
return res;
};
}
// SFC scoped style ID management.
let currentScopeId = null;
const scopeIdStack = [];
/**
* @private
*/
function pushScopeId(id) {
scopeIdStack.push((currentScopeId = id));
}
/**
* @private
*/
function popScopeId() {
scopeIdStack.pop();
currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;
}
/**
* @private
*/
function withScopeId(id) {
return ((fn) => withCtx(function () {
pushScopeId(id);
const res = fn.apply(this, arguments);
popScopeId();
return res;
}));
}
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === '');
const resolveTarget = (props, select) => {
const targetSelector = props && props.to;
if (isString(targetSelector)) {
if (!select) {
warn(`Current renderer does not support string target for Teleports. ` +
`(missing querySelector renderer option)`);
return null;
}
else {
const target = select(targetSelector);
if (!target) {
warn(`Failed to locate Teleport target with selector "${targetSelector}".`);
}
return target;
}
}
else {
if ( !targetSelector) {
warn(`Invalid Teleport target: ${targetSelector}`);
}
return targetSelector;
}
};
const TeleportImpl = {
__isTeleport: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals) {
const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals;
const disabled = isTeleportDisabled(n2.props);
const { shapeFlag, children } = n2;
if (n1 == null) {
// insert anchors in the main view
const placeholder = (n2.el = createComment('teleport start')
);
const mainAnchor = (n2.anchor = createComment('teleport end')
);
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
const target = (n2.target = resolveTarget(n2.props, querySelector));
const targetAnchor = (n2.targetAnchor = createText(''));
if (target) {
insert(targetAnchor, target);
}
else {
warn('Invalid Teleport target on mount:', target, `(${typeof target})`);
}
const mount = (container, anchor) => {
// Teleport *always* has Array children. This is enforced in both the
// compiler and vnode children normalization.
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
};
if (disabled) {
mount(container, mainAnchor);
}
else if (target) {
mount(target, targetAnchor);
}
}
else {
// update content
n2.el = n1.el;
const mainAnchor = (n2.anchor = n1.anchor);
const target = (n2.target = n1.target);
const targetAnchor = (n2.targetAnchor = n1.targetAnchor);
const wasDisabled = isTeleportDisabled(n1.props);
const currentContainer = wasDisabled ? container : target;
const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
if (n2.dynamicChildren) {
// fast path when the teleport happens to be a block root
patchBlockChildren(n1.dynamicChildren, n2.dynamicChildren, currentContainer, parentComponent, parentSuspense, isSVG);
}
else if (!optimized) {
patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, isSVG);
}
if (disabled) {
if (!wasDisabled) {
// enabled -> disabled
// move into main container
moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */);
}
}
else {
// target changed
if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
const nextTarget = (n2.target = resolveTarget(n2.props, querySelector));
if (nextTarget) {
moveTeleport(n2, nextTarget, null, internals, 0 /* TARGET_CHANGE */);
}
else {
warn('Invalid Teleport target on update:', target, `(${typeof target})`);
}
}
else if (wasDisabled) {
// disabled -> enabled
// move into teleport target
moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */);
}
}
}
},
remove(vnode, { r: remove, o: { remove: hostRemove } }) {
const { shapeFlag, children, anchor } = vnode;
hostRemove(anchor);
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
for (let i = 0; i < children.length; i++) {
remove(children[i]);
}
}
},
move: moveTeleport,
hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* REORDER */) {
// move target anchor if this is a target change.
if (moveType === 0 /* TARGET_CHANGE */) {
insert(vnode.targetAnchor, container, parentAnchor);
}
const { el, anchor, shapeFlag, children, props } = vnode;
const isReorder = moveType === 2 /* REORDER */;
// move main view anchor if this is a re-order.
if (isReorder) {
insert(el, container, parentAnchor);
}
// if this is a re-order and teleport is enabled (content is in target)
// do not move children. So the opposite is: only move children if this
// is not a reorder, or the teleport is disabled
if (!isReorder || isTeleportDisabled(props)) {
// Teleport has either Array children or no children.
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
for (let i = 0; i < children.length; i++) {
move(children[i], container, parentAnchor, 2 /* REORDER */);
}
}
}
// move main view anchor if this is a re-order.
if (isReorder) {
insert(anchor, container, parentAnchor);
}
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, optimized, { o: { nextSibling, parentNode, querySelector } }, hydrateChildren) {
const target = (vnode.target = resolveTarget(vnode.props, querySelector));
if (target) {
// if multiple teleports rendered to the same target element, we need to
// pick up from where the last teleport finished instead of the first node
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {
if (isTeleportDisabled(vnode.props)) {
vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, optimized);
vnode.targetAnchor = targetNode;
}
else {
vnode.anchor = nextSibling(node);
vnode.targetAnchor = hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, optimized);
}
target._lpa =
vnode.targetAnchor && nextSibling(vnode.targetAnchor);
}
}
return vnode.anchor && nextSibling(vnode.anchor);
}
// Force-casted public typing for h and TSX props inference
const Teleport = TeleportImpl;
const COMPONENTS = 'components';
const DIRECTIVES = 'directives';
/**
* @private
*/
function resolveComponent(name) {
return resolveAsset(COMPONENTS, name) || name;
}
const NULL_DYNAMIC_COMPONENT = Symbol();
/**
* @private
*/
function resolveDynamicComponent(component) {
if (isString(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
}
else {
// invalid types will fallthrough to createVNode and raise warning
return component || NULL_DYNAMIC_COMPONENT;
}
}
/**
* @private
*/
function resolveDirective(name) {
return resolveAsset(DIRECTIVES, name);
}
// implementation
function resolveAsset(type, name, warnMissing = true) {
const instance = currentRenderingInstance || currentInstance;
if (instance) {
let camelized, capitalized;
const registry = instance[type];
let res = registry[name] ||
registry[(camelized = camelize(name))] ||
registry[(capitalized = capitalize(camelized))];
if (!res && type === COMPONENTS) {
const self = instance.type;
const selfName = self.displayName || self.name;
if (selfName &&
(selfName === name ||
selfName === camelized ||
selfName === capitalized)) {
res = self;
}
}
{
if (res) {
// in dev, infer anonymous component's name based on registered name
if (type === COMPONENTS &&
isObject(res) &&
!res.name) {
res.name = name;
}
}
else if (warnMissing) {
warn(`Failed to resolve ${type.slice(0, -1)}: ${name}`);
}
}
return res;
}
else {
warn(`resolve${capitalize(type.slice(0, -1))} ` +
`can only be used in render() or setup().`);
}
}
const Fragment = Symbol( 'Fragment' );
const Text = Symbol( 'Text' );
const Comment = Symbol( 'Comment' );
const Static = Symbol( 'Static' );
// Since v-if and v-for are the two possible ways node structure can dynamically
// change, once we consider v-if branches and each v-for fragment a block, we
// can divide a template into nested blocks, and within each block the node
// structure would be stable. This allows us to skip most children diffing
// and only worry about the dynamic nodes (indicated by patch flags).
const blockStack = [];
let currentBlock = null;
/**
* Open a block.
* This must be called before `createBlock`. It cannot be part of `createBlock`
* because the children of the block are evaluated before `createBlock` itself
* is called. The generated code typically looks like this:
*
* ```js
* function render() {
* return (openBlock(),createBlock('div', null, [...]))
* }
* ```
* disableTracking is true when creating a v-for fragment block, since a v-for
* fragment always diffs its children.
*
* @private
*/
function openBlock(disableTracking = false) {
blockStack.push((currentBlock = disableTracking ? null : []));
}
// Whether we should be tracking dynamic child nodes inside a block.
// Only tracks when this value is > 0
// We are not using a simple boolean because this value may need to be
// incremented/decremented by nested usage of v-once (see below)
let shouldTrack$1 = 1;
/**
* Block tracking sometimes needs to be disabled, for example during the
* creation of a tree that needs to be cached by v-once. The compiler generates
* code like this:
*
* ``` js
* _cache[1] || (
* setBlockTracking(-1),
* _cache[1] = createVNode(...),
* setBlockTracking(1),
* _cache[1]
* )
* ```
*
* @private
*/
function setBlockTracking(value) {
shouldTrack$1 += value;
}
/**
* Create a block root vnode. Takes the same exact arguments as `createVNode`.
* A block root keeps track of dynamic nodes within the block in the
* `dynamicChildren` array.
*
* @private
*/
function createBlock(type, props, children, patchFlag, dynamicProps) {
const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);
// save current block children on the block vnode
vnode.dynamicChildren = currentBlock || EMPTY_ARR;
// close block
blockStack.pop();
currentBlock = blockStack[blockStack.length - 1] || null;
// a block is always going to be patched, so track it as a child of its
// parent block
if (currentBlock) {
currentBlock.push(vnode);
}
return vnode;
}
function isVNode(value) {
return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
if (
n2.shapeFlag & 6 /* COMPONENT */ &&
hmrDirtyComponents.has(n2.type)) {
// HMR only: if the component has been hot-updated, force a reload.
return false;
}
return n1.type === n2.type && n1.key === n2.key;
}
let vnodeArgsTransformer;
/**
* Internal API for registering an arguments transform for createVNode
* used for creating stubs in the test-utils
* It is *internal* but needs to be exposed for test-utils to pick up proper
* typings
*/
function transformVNodeArgs(transformer) {
vnodeArgsTransformer = transformer;
}
const createVNodeWithArgsTransform = (...args) => {
return _createVNode(...(vnodeArgsTransformer
? vnodeArgsTransformer(args, currentRenderingInstance)
: args));
};
const InternalObjectKey = `__vInternal`;
const normalizeKey = ({ key }) => key != null ? key : null;
const normalizeRef = ({ ref }) => (ref != null
? isArray(ref)
? ref
: [currentRenderingInstance, ref]
: null);
const createVNode = ( createVNodeWithArgsTransform
);
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
if (!type || type === NULL_DYNAMIC_COMPONENT) {
if ( !type) {
warn(`Invalid vnode type when creating vnode: ${type}.`);
}
type = Comment;
}
// class component normalization.
if (isFunction(type) && '__vccOpts' in type) {
type = type.__vccOpts;
}
// class & style normalization.
if (props) {
// for reactive or proxy objects, we need to clone it to enable mutation.
if (isProxy(props) || InternalObjectKey in props) {
props = extend({}, props);
}
let { class: klass, style } = props;
if (klass && !isString(klass)) {
props.class = normalizeClass(klass);
}
if (isObject(style)) {
// reactive state objects need to be cloned since they are likely to be
// mutated
if (isProxy(style) && !isArray(style)) {
style = extend({}, style);
}
props.style = normalizeStyle(style);
}
}
// encode the vnode type information into a bitmap
const shapeFlag = isString(type)
? 1 /* ELEMENT */
: isSuspense(type)
? 128 /* SUSPENSE */
: isTeleport(type)
? 64 /* TELEPORT */
: isObject(type)
? 4 /* STATEFUL_COMPONENT */
: isFunction(type)
? 2 /* FUNCTIONAL_COMPONENT */
: 0;
if ( shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {
type = toRaw(type);
warn(`Vue received a Component which was made a reactive object. This can ` +
`lead to unnecessary performance overhead, and should be avoided by ` +
`marking the component with \`markRaw\` or using \`shallowRef\` ` +
`instead of \`ref\`.`, `\nComponent that was made reactive: `, type);
}
const vnode = {
__v_isVNode: true,
__v_skip: true,
type,
props,
key: props && normalizeKey(props),
ref: props && normalizeRef(props),
scopeId: currentScopeId,
children: null,
component: null,
suspense: null,
dirs: null,
transition: null,
el: null,
anchor: null,
target: null,
targetAnchor: null,
staticCount: 0,
shapeFlag,
patchFlag,
dynamicProps,
dynamicChildren: null,
appContext: null
};
normalizeChildren(vnode, children);
// presence of a patch flag indicates this node needs patching on updates.
// component nodes also should always be patched, because even if the
// component doesn't need to update, it needs to persist the instance on to
// the next vnode so that it can be properly unmounted later.
if (shouldTrack$1 > 0 &&
!isBlockNode &&
currentBlock &&
// the EVENTS flag is only for hydration and if it is the only flag, the
// vnode should not be considered dynamic due to handler caching.
patchFlag !== 32 /* HYDRATE_EVENTS */ &&
(patchFlag > 0 ||
shapeFlag & 128 /* SUSPENSE */ ||
shapeFlag & 64 /* TELEPORT */ ||
shapeFlag & 4 /* STATEFUL_COMPONENT */ ||
shapeFlag & 2 /* FUNCTIONAL_COMPONENT */)) {
currentBlock.push(vnode);
}
return vnode;
}
function cloneVNode(vnode, extraProps) {
const props = (extraProps
? vnode.props
? mergeProps(vnode.props, extraProps)
: extend({}, extraProps)
: vnode.props);
// This is intentionally NOT using spread or extend to avoid the runtime
// key enumeration cost.
return {
__v_isVNode: true,
__v_skip: true,
type: vnode.type,
props,
key: props && normalizeKey(props),
ref: props && normalizeRef(props),
scopeId: vnode.scopeId,
children: vnode.children,
target: vnode.target,
targetAnchor: vnode.targetAnchor,
staticCount: vnode.staticCount,
shapeFlag: vnode.shapeFlag,
// if the vnode is cloned with extra props, we can no longer assume its
// existing patch flag to be reliable and need to bail out of optimized mode.
// however we don't want block nodes to de-opt their children, so if the
// vnode is a block node, we only add the FULL_PROPS flag to it.
patchFlag: extraProps
? vnode.dynamicChildren
? vnode.patchFlag | 16 /* FULL_PROPS */
: -2 /* BAIL */
: vnode.patchFlag,
dynamicProps: vnode.dynamicProps,
dynamicChildren: vnode.dynamicChildren,
appContext: vnode.appContext,
dirs: vnode.dirs,
transition: vnode.transition,
// These should technically only be non-null on mounted VNodes. However,
// they *should* be copied for kept-alive vnodes. So we just always copy
// them since them being non-null during a mount doesn't affect the logic as
// they will simply be overwritten.
component: vnode.component,
suspense: vnode.suspense,
el: vnode.el,
anchor: vnode.anchor
};
}
/**
* @private
*/
function createTextVNode(text = ' ', flag = 0) {
return createVNode(Text, null, text, flag);
}
/**
* @private
*/
function createStaticVNode(content, numberOfNodes) {
// A static vnode can contain multiple stringified elements, and the number
// of elements is necessary for hydration.
const vnode = createVNode(Static, null, content);
vnode.staticCount = numberOfNodes;
return vnode;
}
/**
* @private
*/
function createCommentVNode(text = '',
// when used as the v-else branch, the comment node must be created as a
// block to ensure correct updates.
asBlock = false) {
return asBlock
? (openBlock(), createBlock(Comment, null, text))
: createVNode(Comment, null, text);
}
function normalizeVNode(child) {
if (child == null || typeof child === 'boolean') {
// empty placeholder
return createVNode(Comment);
}
else if (isArray(child)) {
// fragment
return createVNode(Fragment, null, child);
}
else if (typeof child === 'object') {
// already vnode, this should be the most common since compiled templates
// always produce all-vnode children arrays
return child.el === null ? child : cloneVNode(child);
}
else {
// strings and numbers
return createVNode(Text, null, String(child));
}
}
// optimized normalization for template-compiled render fns
function cloneIfMounted(child) {
return child.el === null ? child : cloneVNode(child);
}
function normalizeChildren(vnode, children) {
let type = 0;
const { shapeFlag } = vnode;
if (children == null) {
children = null;
}
else if (isArray(children)) {
type = 16 /* ARRAY_CHILDREN */;
}
else if (typeof children === 'object') {
// Normalize slot to plain children
if ((shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) &&
children.default) {
normalizeChildren(vnode, children.default());
return;
}
else {
type = 32 /* SLOTS_CHILDREN */;
if (!children._ && !(InternalObjectKey in children)) {
children._ctx = currentRenderingInstance;
}
}
}
else if (isFunction(children)) {
children = { default: children, _ctx: currentRenderingInstance };
type = 32 /* SLOTS_CHILDREN */;
}
else {
children = String(children);
// force teleport children to array so it can be moved around
if (shapeFlag & 64 /* TELEPORT */) {
type = 16 /* ARRAY_CHILDREN */;
children = [createTextVNode(children)];
}
else {
type = 8 /* TEXT_CHILDREN */;
}
}
vnode.children = children;
vnode.shapeFlag |= type;
}
const handlersRE = /^on|^vnode/;
function mergeProps(...args) {
const ret = {};
extend(ret, args[0]);
for (let i = 1; i < args.length; i++) {
const toMerge = args[i];
for (const key in toMerge) {
if (key === 'class') {
if (ret.class !== toMerge.class) {
ret.class = normalizeClass([ret.class, toMerge.class]);
}
}
else if (key === 'style') {
ret.style = normalizeStyle([ret.style, toMerge.style]);
}
else if (handlersRE.test(key)) {
// on*, vnode*
const existing = ret[key];
const incoming = toMerge[key];
if (existing !== incoming) {
ret[key] = existing
? [].concat(existing, toMerge[key])
: incoming;
}
}
else {
ret[key] = toMerge[key];
}
}
}
return ret;
}
function emit(instance, event, ...args) {
const props = instance.vnode.props || EMPTY_OBJ;
{
const options = normalizeEmitsOptions(instance.type.emits);
if (options) {
if (!(event in options)) {
const propsOptions = normalizePropsOptions(instance.type)[0];
if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) {
warn(`Component emitted event "${event}" but it is neither declared in ` +
`the emits option nor as an "on${capitalize(event)}" prop.`);
}
}
else {
const validator = options[event];
if (isFunction(validator)) {
const isValid = validator(...args);
if (!isValid) {
warn(`Invalid event arguments: event validation failed for event "${event}".`);
}
}
}
}
}
let handler = props[`on${capitalize(event)}`];
// for v-model update:xxx events, also trigger kebab-case equivalent
// for props passed via kebab-case
if (!handler && event.startsWith('update:')) {
event = hyphenate(event);
handler = props[`on${capitalize(event)}`];
}
if (handler) {
callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
}
}
function normalizeEmitsOptions(options) {
if (!options) {
return;
}
else if (isArray(options)) {
if (options._n) {
return options._n;
}
const normalized = {};
options.forEach(key => (normalized[key] = null));
def(options, '_n', normalized);
return normalized;
}
else {
return options;
}
}
// Check if an incoming prop key is a declared emit event listener.
// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are
// both considered matched listeners.
function isEmitListener(emits, key) {
return (isOn(key) &&
(hasOwn((emits = normalizeEmitsOptions(emits)), key[2].toLowerCase() + key.slice(3)) ||
hasOwn(emits, key.slice(2))));
}
function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison
isSSR = false) {
const props = {};
const attrs = {};
def(attrs, InternalObjectKey, 1);
setFullProps(instance, rawProps, props, attrs);
// validation
{
validateProps(props, instance.type);
}
if (isStateful) {
// stateful
instance.props = isSSR ? props : shallowReactive(props);
}
else {
if (!instance.type.props) {
// functional w/ optional props, props === attrs
instance.props = attrs;
}
else {
// functional w/ declared props
instance.props = props;
}
}
instance.attrs = attrs;
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const { props, attrs, vnode: { patchFlag } } = instance;
const rawCurrentProps = toRaw(props);
const [options] = normalizePropsOptions(instance.type);
if ((optimized || patchFlag > 0) && !(patchFlag & 16 /* FULL_PROPS */)) {
if (patchFlag & 8 /* PROPS */) {
// Compiler-generated props & no keys change, just set the updated
// the props.
const propsToUpdate = instance.vnode.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
// PROPS flag guarantees rawProps to be non-null
const value = rawProps[key];
if (options) {
// attr / props separation was done on init and will be consistent
// in this code path, so just check if attrs have it.
if (hasOwn(attrs, key)) {
attrs[key] = value;
}
else {
const camelizedKey = camelize(key);
props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value);
}
}
else {
attrs[key] = value;
}
}
}
}
else {
// full props update.
setFullProps(instance, rawProps, props, attrs);
// in case of dynamic props, check if we need to delete keys from
// the props object
let kebabKey;
for (const key in rawCurrentProps) {
if (!rawProps ||
(!hasOwn(rawProps, key) &&
// it's possible the original props was passed in as kebab-case
// and converted to camelCase (#955)
((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey)))) {
if (options) {
if (rawPrevProps && rawPrevProps[kebabKey] !== undefined) {
props[key] = resolvePropValue(options, rawProps || EMPTY_OBJ, key, undefined);
}
}
else {
delete props[key];
}
}
}
// in the case of functional component w/o props declaration, props and
// attrs point to the same object so it should already have been updated.
if (attrs !== rawCurrentProps) {
for (const key in attrs) {
if (!rawProps || !hasOwn(rawProps, key)) {
delete attrs[key];
}
}
}
}
// trigger updates for $attrs in case it's used in component slots
trigger(instance, "set" /* SET */, '$attrs');
if ( rawProps) {
validateProps(props, instance.type);
}
}
function setFullProps(instance, rawProps, props, attrs) {
const [options, needCastKeys] = normalizePropsOptions(instance.type);
const emits = instance.type.emits;
if (rawProps) {
for (const key in rawProps) {
const value = rawProps[key];
// key, ref are reserved and never passed down
if (isReservedProp(key)) {
continue;
}
// prop option names are camelized during normalization, so to support
// kebab -> camel conversion here we need to camelize the key.
let camelKey;
if (options && hasOwn(options, (camelKey = camelize(key)))) {
props[camelKey] = value;
}
else if (!emits || !isEmitListener(emits, key)) {
// Any non-declared (either as a prop or an emitted event) props are put
// into a separate `attrs` object for spreading. Make sure to preserve
// original key casing
attrs[key] = value;
}
}
}
if (needCastKeys) {
const rawCurrentProps = toRaw(props);
for (let i = 0; i < needCastKeys.length; i++) {
const key = needCastKeys[i];
props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key]);
}
}
}
function resolvePropValue(options, props, key, value) {
const opt = options[key];
if (opt != null) {
const hasDefault = hasOwn(opt, 'default');
// default values
if (hasDefault && value === undefined) {
const defaultValue = opt.default;
value =
opt.type !== Function && isFunction(defaultValue)
? defaultValue()
: defaultValue;
}
// boolean casting
if (opt[0 /* shouldCast */]) {
if (!hasOwn(props, key) && !hasDefault) {
value = false;
}
else if (opt[1 /* shouldCastTrue */] &&
(value === '' || value === hyphenate(key))) {
value = true;
}
}
}
return value;
}
function normalizePropsOptions(comp) {
if (comp.__props) {
return comp.__props;
}
const raw = comp.props;
const normalized = {};
const needCastKeys = [];
// apply mixin/extends props
let hasExtends = false;
if ( !isFunction(comp)) {
const extendProps = (raw) => {
const [props, keys] = normalizePropsOptions(raw);
extend(normalized, props);
if (keys)
needCastKeys.push(...keys);
};
if (comp.extends) {
hasExtends = true;
extendProps(comp.extends);
}
if (comp.mixins) {
hasExtends = true;
comp.mixins.forEach(extendProps);
}
}
if (!raw && !hasExtends) {
return (comp.__props = EMPTY_ARR);
}
if (isArray(raw)) {
for (let i = 0; i < raw.length; i++) {
if ( !isString(raw[i])) {
warn(`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)) {
warn(`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 } : opt);
if (prop) {
const booleanIndex = getTypeIndex(Boolean, prop.type);
const stringIndex = getTypeIndex(String, prop.type);
prop[0 /* shouldCast */] = booleanIndex > -1;
prop[1 /* shouldCastTrue */] =
stringIndex < 0 || booleanIndex < stringIndex;
// if the prop needs boolean casting or default value
if (booleanIndex > -1 || hasOwn(prop, 'default')) {
needCastKeys.push(normalizedKey);
}
}
}
}
}
const normalizedEntry = [normalized, needCastKeys];
comp.__props = normalizedEntry;
return normalizedEntry;
}
// use function string name to check type constructors
// so that it works across vms / iframes.
function getType(ctor) {
const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
return match ? match[1] : '';
}
function isSameType(a, b) {
return getType(a) === getType(b);
}
function getTypeIndex(type, expectedTypes) {
if (isArray(expectedTypes)) {
for (let i = 0, len = expectedTypes.length; i < len; i++) {
if (isSameType(expectedTypes[i], type)) {
return i;
}
}
}
else if (isFunction(expectedTypes)) {
return isSameType(expectedTypes, type) ? 0 : -1;
}
return -1;
}
/**
* dev only
*/
function validateProps(props, comp) {
const rawValues = toRaw(props);
const options = normalizePropsOptions(comp)[0];
for (const key in options) {
let opt = options[key];
if (opt == null)
continue;
validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key));
}
}
/**
* dev only
*/
function validatePropName(key) {
if (key[0] !== '$') {
return true;
}
else {
warn(`Invalid prop name: "${key}" is a reserved property.`);
}
return false;
}
/**
* dev only
*/
function validateProp(name, value, prop, isAbsent) {
const { type, required, validator } = prop;
// required!
if (required && isAbsent) {
warn('Missing required prop: "' + name + '"');
return;
}
// missing but optional
if (value == null && !prop.required) {
return;
}
// type check
if (type != null && type !== true) {
let isValid = false;
const types = isArray(type) ? type : [type];
const expectedTypes = [];
// value is valid as long as one of the specified types match
for (let i = 0; i < types.length && !isValid; i++) {
const { valid, expectedType } = assertType(value, types[i]);
expectedTypes.push(expectedType || '');
isValid = valid;
}
if (!isValid) {
warn(getInvalidTypeMessage(name, value, expectedTypes));
return;
}
}
// custom validator
if (validator && !validator(value)) {
warn('Invalid prop: custom validator check failed for prop "' + name + '".');
}
}
const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');
/**
* dev only
*/
function assertType(value, type) {
let valid;
const expectedType = getType(type);
if (isSimpleType(expectedType)) {
const t = typeof value;
valid = t === expectedType.toLowerCase();
// for primitive wrapper objects
if (!valid && t === 'object') {
valid = value instanceof type;
}
}
else if (expectedType === 'Object') {
valid = toRawType(value) === 'Object';
}
else if (expectedType === 'Array') {
valid = isArray(value);
}
else {
valid = value instanceof type;
}
return {
valid,
expectedType
};
}
/**
* dev only
*/
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);
// check if we need to specify expected value
if (expectedTypes.length === 1 &&
isExplicable(expectedType) &&
!isBoolean(expectedType, receivedType)) {
message += ` with value ${expectedValue}`;
}
message += `, got ${receivedType} `;
// check if we need to specify received value
if (isExplicable(receivedType)) {
message += `with value ${receivedValue}.`;
}
return message;
}
/**
* dev only
*/
function styleValue(value, type) {
if (type === 'String') {
return `"${value}"`;
}
else if (type === 'Number') {
return `${Number(value)}`;
}
else {
return `${value}`;
}
}
/**
* dev only
*/
function isExplicable(type) {
const explicitTypes = ['string', 'number', 'boolean'];
return explicitTypes.some(elem => type.toLowerCase() === elem);
}
/**
* dev only
*/
function isBoolean(...args) {
return args.some(elem => elem.toLowerCase() === 'boolean');
}
const isInternalKey = (key) => key[0] === '_' || key === '$stable';
const normalizeSlotValue = (value) => isArray(value)
? value.map(normalizeVNode)
: [normalizeVNode(value)];
const normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => {
if ( currentInstance) {
warn(`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(props));
}, ctx);
const normalizeObjectSlots = (rawSlots, slots) => {
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) {
{
warn(`Non-function value encountered for slot "${key}". ` +
`Prefer function slots for better performance.`);
}
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
const normalizeVNodeSlots = (instance, children) => {
if ( !isKeepAlive(instance.vnode)) {
warn(`Non-function value encountered for default slot. ` +
`Prefer function slots for better performance.`);
}
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
const initSlots = (instance, children) => {
if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
if (children._ === 1) {
instance.slots = children;
}
else {
normalizeObjectSlots(children, (instance.slots = {}));
}
}
else {
instance.slots = {};
if (children) {
normalizeVNodeSlots(instance, children);
}
}
def(instance.slots, InternalObjectKey, 1);
};
const updateSlots = (instance, children) => {
const { vnode, slots } = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = EMPTY_OBJ;
if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
if (children._ === 1) {
// compiled slots.
if ( isHmrUpdating) {
// Parent was HMR updated so slot content may have changed.
// force update slots and mark instance for hmr as well
extend(slots, children);
}
else if (
// bail on dynamic slots (v-if, v-for, reference of scope variables)
!(vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */)) {
// compiled AND static.
// no need to update, and skip stale slots removal.
needDeletionCheck = false;
}
else {
// compiled but dynamic - update slots, but skip normalization.
extend(slots, children);
}
}
else {
needDeletionCheck = !children.$stable;
normalizeObjectSlots(children, slots);
}
deletionComparisonTarget = children;
}
else if (children) {
// non slot object children (direct value) passed to a component
normalizeVNodeSlots(instance, children);
deletionComparisonTarget = { default: 1 };
}
// delete stale slots
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
delete slots[key];
}
}
}
};
/**
Runtime helper for applying directives to a vnode. Example usage:
const comp = resolveComponent('comp')
const foo = resolveDirective('foo')
const bar = resolveDirective('bar')
return withDirectives(h(comp), [
[foo, this.x],
[bar, this.y]
])
*/
const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');
function validateDirectiveName(name) {
if (isBuiltInDirective(name)) {
warn('Do not use built-in directive ids as custom directive id: ' + name);
}
}
/**
* Adds directives to a VNode.
*/
function withDirectives(vnode, directives) {
const internalInstance = currentRenderingInstance;
if (internalInstance === null) {
warn(`withDirectives can only be used inside render functions.`);
return vnode;
}
const instance = 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 (isFunction(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
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;
}
const hook = binding.dir[name];
if (hook) {
callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [
vnode.el,
binding,
vnode,
prevVNode
]);
}
}
}
function createAppContext() {
return {
config: {
isNativeTag: NO,
devtools: true,
performance: false,
globalProperties: {},
optionMergeStrategies: {},
isCustomElement: NO,
errorHandler: undefined,
warnHandler: undefined
},
mixins: [],
components: {},
directives: {},
provides: Object.create(null)
};
}
function createAppAPI(render, hydrate) {
return function createApp(rootComponent, rootProps = null) {
if (rootProps != null && !isObject(rootProps)) {
warn(`root props passed to app.mount() must be an object.`);
rootProps = null;
}
const context = createAppContext();
const installedPlugins = new Set();
let isMounted = false;
const app = {
_component: rootComponent,
_props: rootProps,
_container: null,
_context: context,
get config() {
return context.config;
},
set config(v) {
{
warn(`app.config cannot be replaced. Modify individual options instead.`);
}
},
use(plugin, ...options) {
if (installedPlugins.has(plugin)) {
warn(`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 {
warn(`A plugin must either be a function or an object with an "install" ` +
`function.`);
}
return app;
},
mixin(mixin) {
{
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
}
else {
warn('Mixin has already been applied to target app' +
(mixin.name ? `: ${mixin.name}` : ''));
}
}
return app;
},
component(name, component) {
{
validateComponentName(name, context.config);
}
if (!component) {
return context.components[name];
}
if ( context.components[name]) {
warn(`Component "${name}" has already been registered in target app.`);
}
context.components[name] = component;
return app;
},
directive(name, directive) {
{
validateDirectiveName(name);
}
if (!directive) {
return context.directives[name];
}
if ( context.directives[name]) {
warn(`Directive "${name}" has already been registered in target app.`);
}
context.directives[name] = directive;
return app;
},
mount(rootContainer, isHydrate) {
if (!isMounted) {
const vnode = createVNode(rootComponent, rootProps);
// store app context on the root VNode.
// this will be set on the root instance on initial mount.
vnode.appContext = context;
// HMR root reload
{
context.reload = () => {
render(cloneVNode(vnode), rootContainer);
};
}
if (isHydrate && hydrate) {
hydrate(vnode, rootContainer);
}
else {
render(vnode, rootContainer);
}
isMounted = true;
app._container = rootContainer;
return vnode.component.proxy;
}
else {
warn(`App has already been mounted.\n` +
`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) {
render(null, app._container);
}
else {
warn(`Cannot unmount an app that is not mounted.`);
}
},
provide(key, value) {
if ( key in context.provides) {
warn(`App already provides property with key "${String(key)}". ` +
`It will be overwritten with the new value.`);
}
// TypeScript doesn't allow symbols as index type
// https://github.com/Microsoft/TypeScript/issues/24587
context.provides[key] = value;
return app;
}
};
return app;
};
}
let hasMismatch = false;
const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject';
const isComment = (node) => node.nodeType === 8 /* COMMENT */;
// Note: hydration is DOM-specific
// But we have to place it in core due to tight coupling with core - splitting
// it out creates a ton of unnecessary complexity.
// Hydration also depends on some renderer internal logic which needs to be
// passed in via arguments.
function createHydrationFunctions(rendererInternals) {
const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;
const hydrate = (vnode, container) => {
if ( !container.hasChildNodes()) {
warn(`Attempting to hydrate existing markup but container is empty. ` +
`Performing full mount instead.`);
patch(null, vnode, container);
return;
}
hasMismatch = false;
hydrateNode(container.firstChild, vnode, null, null);
flushPostFlushCbs();
if (hasMismatch && !false) {
// this error should show up in production
console.error(`Hydration completed but contains mismatches.`);
}
};
const hydrateNode = (node, vnode, parentComponent, parentSuspense, optimized = false) => {
const isFragmentStart = isComment(node) && node.data === '[';
const onMismatch = () => handleMismtach(node, vnode, parentComponent, parentSuspense, isFragmentStart);
const { type, ref, shapeFlag } = vnode;
const domType = node.nodeType;
vnode.el = node;
let nextNode = null;
switch (type) {
case Text:
if (domType !== 3 /* TEXT */) {
nextNode = onMismatch();
}
else {
if (node.data !== vnode.children) {
hasMismatch = true;
warn(`Hydration text mismatch:` +
`\n- Client: ${JSON.stringify(node.data)}` +
`\n- Server: ${JSON.stringify(vnode.children)}`);
node.data = vnode.children;
}
nextNode = nextSibling(node);
}
break;
case Comment:
if (domType !== 8 /* COMMENT */ || isFragmentStart) {
nextNode = onMismatch();
}
else {
nextNode = nextSibling(node);
}
break;
case Static:
if (domType !== 1 /* ELEMENT */) {
nextNode = onMismatch();
}
else {
// determine anchor, adopt content
nextNode = node;
// if the static vnode has its content stripped during build,
// adopt it from the server-rendered HTML.
const needToAdoptContent = !vnode.children.length;
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += nextNode.outerHTML;
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode;
}
nextNode = nextSibling(nextNode);
}
return nextNode;
}
break;
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch();
}
else {
nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, optimized);
}
break;
default:
if (shapeFlag & 1 /* ELEMENT */) {
if (domType !== 1 /* ELEMENT */ ||
vnode.type !== node.tagName.toLowerCase()) {
nextNode = onMismatch();
}
else {
nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, optimized);
}
}
else if (shapeFlag & 6 /* COMPONENT */) {
// when setting up the render effect, if the initial vnode already
// has .el set, the component will perform hydration instead of mount
// on its sub-tree.
const container = parentNode(node);
const hydrateComponent = () => {
mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized);
};
// async component
const loadAsync = vnode.type.__asyncLoader;
if (loadAsync) {
loadAsync().then(hydrateComponent);
}
else {
hydrateComponent();
}
// component may be async, so in the case of fragments we cannot rely
// on component's rendered output to determine the end of the fragment
// instead, we do a lookahead to find the end anchor node.
nextNode = isFragmentStart
? locateClosingAsyncAnchor(node)
: nextSibling(node);
}
else if (shapeFlag & 64 /* TELEPORT */) {
if (domType !== 8 /* COMMENT */) {
nextNode = onMismatch();
}
else {
nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, optimized, rendererInternals, hydrateChildren);
}
}
else if ( shapeFlag & 128 /* SUSPENSE */) {
nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), optimized, rendererInternals, hydrateNode);
}
else {
warn('Invalid HostVNode type:', type, `(${typeof type})`);
}
}
if (ref != null && parentComponent) {
setRef(ref, null, parentComponent, vnode);
}
return nextNode;
};
const hydrateElement = (el, vnode, parentComponent, parentSuspense, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const { props, patchFlag, shapeFlag, dirs } = vnode;
// skip props & children if this is hoisted static nodes
if (patchFlag !== -1 /* HOISTED */) {
// props
if (props) {
if (!optimized ||
(patchFlag & 16 /* FULL_PROPS */ ||
patchFlag & 32 /* HYDRATE_EVENTS */)) {
for (const key in props) {
if (!isReservedProp(key) && isOn(key)) {
patchProp(el, key, null, props[key]);
}
}
}
else if (props.onClick) {
// Fast path for click listeners (which is most often) to avoid
// iterating through props.
patchProp(el, 'onClick', null, props.onClick);
}
}
// vnode / directive hooks
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);
}
// children
if (shapeFlag & 16 /* ARRAY_CHILDREN */ &&
// skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))) {
let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, optimized);
let hasWarned = false;
while (next) {
hasMismatch = true;
if ( !hasWarned) {
warn(`Hydration children mismatch in <${vnode.type}>: ` +
`server rendered element contains more child nodes than client vdom.`);
hasWarned = true;
}
// The SSRed DOM contains more nodes than it should. Remove them.
const cur = next;
next = next.nextSibling;
remove(cur);
}
}
else if (shapeFlag & 8 /* TEXT_CHILDREN */) {
if (el.textContent !== vnode.children) {
hasMismatch = true;
warn(`Hydration text content mismatch in <${vnode.type}>:\n` +
`- Client: ${el.textContent}\n` +
`- Server: ${vnode.children}`);
el.textContent = vnode.children;
}
}
}
return el.nextSibling;
};
const hydrateChildren = (node, vnode, container, parentComponent, parentSuspense, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const children = vnode.children;
const l = children.length;
let hasWarned = 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, optimized);
}
else {
hasMismatch = true;
if ( !hasWarned) {
warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` +
`server rendered element contains fewer child nodes than client vdom.`);
hasWarned = true;
}
// the SSRed DOM didn't contain enough nodes. Mount the missing ones.
patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container));
}
}
return node;
};
const hydrateFragment = (node, vnode, parentComponent, parentSuspense, optimized) => {
const container = parentNode(node);
const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, optimized);
if (next && isComment(next) && next.data === ']') {
return nextSibling((vnode.anchor = next));
}
else {
// fragment didn't hydrate successfully, since we didn't get a end anchor
// back. This should have led to node/children mismatch warnings.
hasMismatch = true;
// since the anchor is missing, we need to create one and insert it
insert((vnode.anchor = createComment(`]`)), container, next);
return next;
}
};
const handleMismtach = (node, vnode, parentComponent, parentSuspense, isFragment) => {
hasMismatch = true;
warn(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */
? `(text)`
: isComment(node) && node.data === '['
? `(start of fragment)`
: ``);
vnode.el = null;
if (isFragment) {
// remove excessive fragment nodes
const end = locateClosingAsyncAnchor(node);
while (true) {
const next = nextSibling(node);
if (next && next !== end) {
remove(next);
}
else {
break;
}
}
}
const next = nextSibling(node);
const container = parentNode(node);
remove(node);
patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container));
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 [hydrate, hydrateNode];
}
let supported;
let perf;
function startMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
perf.mark(`vue-${type}-${instance.uid}`);
}
}
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.type)}> ${type}`, startTag, endTag);
perf.clearMarks(startTag);
perf.clearMarks(endTag);
}
}
function isSupported() {
if (supported !== undefined) {
return supported;
}
/* eslint-disable no-restricted-globals */
if (typeof window !== 'undefined' && window.performance) {
supported = true;
perf = window.performance;
}
else {
supported = false;
}
/* eslint-enable no-restricted-globals */
return supported;
}
function createDevEffectOptions(instance) {
return {
scheduler: queueJob,
onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0,
onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0
};
}
const queuePostRenderEffect = queueEffectWithSuspense
;
const setRef = (rawRef, oldRawRef, parent, vnode) => {
let value;
if (!vnode) {
value = null;
}
else {
const { el, component, shapeFlag, type } = vnode;
if (shapeFlag & 6 /* COMPONENT */ && type.inheritRef) {
return;
}
if (shapeFlag & 4 /* STATEFUL_COMPONENT */) {
value = component.proxy;
}
else {
value = el;
}
}
const [owner, ref] = rawRef;
if ( !owner) {
warn(`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[1];
const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs;
const setupState = owner.setupState;
// unset old ref
if (oldRef != null && oldRef !== ref) {
if (isString(oldRef)) {
refs[oldRef] = null;
if (hasOwn(setupState, oldRef)) {
setupState[oldRef] = null;
}
}
else if (isRef(oldRef)) {
oldRef.value = null;
}
}
if (isString(ref)) {
refs[ref] = value;
if (hasOwn(setupState, ref)) {
setupState[ref] = value;
}
}
else if (isRef(ref)) {
ref.value = value;
}
else if (isFunction(ref)) {
callWithErrorHandling(ref, parent, 12 /* FUNCTION_REF */, [value, refs]);
}
else {
warn('Invalid template ref type:', value, `(${typeof value})`);
}
};
/**
* The createRenderer function accepts two generic arguments:
* HostNode and HostElement, corresponding to Node and Element types in the
* host environment. For example, for runtime-dom, HostNode would be the DOM
* `Node` interface and HostElement would be the DOM `Element` interface.
*
* Custom renderers can pass in the platform specific types like this:
*
* ``` js
* const { render, createApp } = createRenderer<Node, Element>({
* patchProp,
* ...nodeOps
* })
* ```
*/
function createRenderer(options) {
return baseCreateRenderer(options);
}
// Separate API for creating hydration-enabled renderer.
// Hydration logic is only used when calling this function, making it
// tree-shakable.
function createHydrationRenderer(options) {
return baseCreateRenderer(options, createHydrationFunctions);
}
// implementation
function baseCreateRenderer(options, createHydrationFns) {
const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options;
// Note: functions inside this closure should use `const xxx = () => {}`
// style in order to prevent being inlined by minifiers.
const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) => {
// patching & not same type, unmount old tree
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
}
if (n2.patchFlag === -2 /* BAIL */) {
optimized = false;
n2.dynamicChildren = null;
}
const { type, ref, 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 {
patchStaticNode(n1, n2, container, isSVG);
}
break;
case Fragment:
processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
break;
default:
if (shapeFlag & 1 /* ELEMENT */) {
processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else if (shapeFlag & 6 /* COMPONENT */) {
processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else if (shapeFlag & 64 /* TELEPORT */) {
type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);
}
else if ( shapeFlag & 128 /* SUSPENSE */) {
type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);
}
else {
warn('Invalid VNode type:', type, `(${typeof type})`);
}
}
// set ref
if (ref != null && parentComponent) {
setRef(ref, n1 && n1.ref, parentComponent, 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 {
// there's no support for dynamic comments
n2.el = n1.el;
}
};
const mountStaticNode = (n2, container, anchor, isSVG) => {
[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);
};
/**
* Dev / HMR only
*/
const patchStaticNode = (n1, n2, container, isSVG) => {
// static nodes are only patched during dev for HMR
if (n2.children !== n1.children) {
const anchor = hostNextSibling(n1.anchor);
// remove existing
removeStaticNode(n1);
[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);
}
else {
n2.el = n1.el;
n2.anchor = n1.anchor;
}
};
/**
* Dev / HMR only
*/
const moveStaticNode = (vnode, container, anchor) => {
let cur = vnode.el;
const end = vnode.anchor;
while (cur && cur !== end) {
const next = hostNextSibling(cur);
hostInsert(cur, container, anchor);
cur = next;
}
hostInsert(end, container, anchor);
};
/**
* Dev / HMR only
*/
const removeStaticNode = (vnode) => {
let cur = vnode.el;
while (cur && cur !== vnode.anchor) {
const next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(vnode.anchor);
};
const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
isSVG = isSVG || n2.type === 'svg';
if (n1 == null) {
mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else {
patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized);
}
};
const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
let el;
let vnodeHook;
const { type, props, shapeFlag, transition, scopeId, patchFlag, dirs } = vnode;
if (vnode.el &&
hostCloneNode !== undefined &&
patchFlag === -1 /* HOISTED */) {
// If a vnode has non-null el, it means it's being reused.
// Only static vnodes can be reused, so its mounted DOM nodes should be
// exactly the same, and we can simply do a clone here.
el = vnode.el = hostCloneNode(vnode.el);
}
else {
el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is);
// mount children first, since some props may rely on child content
// being already rendered, e.g. `<select value>`
if (shapeFlag & 8 /* TEXT_CHILDREN */) {
hostSetElementText(el, vnode.children);
}
else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== 'foreignObject', optimized || !!vnode.dynamicChildren);
}
// props
if (props) {
for (const key in props) {
if (!isReservedProp(key)) {
hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense);
}
}
if ((vnodeHook = props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');
}
// scopeId
if (scopeId) {
hostSetScopeId(el, scopeId);
}
const treeOwnerId = parentComponent && parentComponent.type.__scopeId;
// vnode's own scopeId and the current patched component's scopeId is
// different - this is a slot content node.
if (treeOwnerId && treeOwnerId !== scopeId) {
hostSetScopeId(el, treeOwnerId + '-s');
}
if (transition && !transition.persisted) {
transition.beforeEnter(el);
}
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) ||
(transition && !transition.persisted) ||
dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
transition && !transition.persisted && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');
}, parentSuspense);
}
};
const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, 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, optimized);
}
};
const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, optimized) => {
const el = (n2.el = n1.el);
let { patchFlag, dynamicChildren, dirs } = n2;
const oldProps = (n1 && n1.props) || EMPTY_OBJ;
const newProps = n2.props || EMPTY_OBJ;
let vnodeHook;
if ((vnodeHook = newProps.onVnodeBeforeUpdate)) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate');
}
if ( isHmrUpdating) {
// HMR updated, force full diff
patchFlag = 0;
optimized = false;
dynamicChildren = null;
}
if (patchFlag > 0) {
// the presence of a patchFlag means this element's render code was
// generated by the compiler and can take the fast path.
// in this path old node and new node are guaranteed to have the same shape
// (i.e. at the exact same position in the source template)
if (patchFlag & 16 /* FULL_PROPS */) {
// element props contain dynamic keys, full diff needed
patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
}
else {
// class
// this flag is matched when the element has dynamic class bindings.
if (patchFlag & 2 /* CLASS */) {
if (oldProps.class !== newProps.class) {
hostPatchProp(el, 'class', null, newProps.class, isSVG);
}
}
// style
// this flag is matched when the element has dynamic style bindings
if (patchFlag & 4 /* STYLE */) {
hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG);
}
// props
// This flag is matched when the element has dynamic prop/attr bindings
// other than class and style. The keys of dynamic prop/attrs are saved for
// faster iteration.
// Note dynamic keys like :[foo]="bar" will cause this optimization to
// bail out and go through a full diff because we need to unset the old key
if (patchFlag & 8 /* PROPS */) {
// if the flag is present then dynamicProps must be non-null
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 (prev !== next) {
hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);
}
}
}
}
// text
// This flag is matched when the element has only dynamic text children.
if (patchFlag & 1 /* TEXT */) {
if (n1.children !== n2.children) {
hostSetElementText(el, n2.children);
}
}
}
else if (!optimized && dynamicChildren == null) {
// unoptimized, full diff
patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
}
const areChildrenSVG = isSVG && n2.type !== 'foreignObject';
if (dynamicChildren) {
patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG);
if ( parentComponent && parentComponent.type.__hmrId) {
traverseStaticChildren(n1, n2);
}
}
else if (!optimized) {
// full diff
patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG);
}
if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated');
}, parentSuspense);
}
};
// The fast path for blocks.
const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG) => {
for (let i = 0; i < newChildren.length; i++) {
const oldVNode = oldChildren[i];
const newVNode = newChildren[i];
// Determine the container (parent element) for the patch.
const container =
// - In the case of a Fragment, we need to provide the actual parent
// of the Fragment itself so it can move its children.
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 /* COMPONENT */
? 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, true);
}
};
const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
if (oldProps !== newProps) {
for (const key in newProps) {
if (isReservedProp(key))
continue;
const next = newProps[key];
const prev = oldProps[key];
if (next !== prev) {
hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
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);
}
}
}
}
};
const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText(''));
const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText(''));
let { patchFlag, dynamicChildren } = n2;
if (patchFlag > 0) {
optimized = true;
}
if ( isHmrUpdating) {
// HMR updated, force full diff
patchFlag = 0;
optimized = false;
dynamicChildren = null;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
// a fragment can only have array children
// since they are either generated by the compiler, or implicitly created
// from arrays.
mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);
}
else {
if (patchFlag > 0 &&
patchFlag & 64 /* STABLE_FRAGMENT */ &&
dynamicChildren) {
// a stable fragment (template root or <template v-for>) doesn't need to
// patch children order, but it may contain dynamicChildren.
patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG);
if ( parentComponent && parentComponent.type.__hmrId) {
traverseStaticChildren(n1, n2);
}
}
else {
// keyed / unkeyed, or manual fragments.
// for keyed & unkeyed, since they are compiler generated from v-for,
// each child is guaranteed to be a block so the fragment will never
// have dynamicChildren.
patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);
}
}
};
const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
if (n1 == null) {
if (n2.shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {
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);
}
{
pushWarningContext(initialVNode);
startMeasure(instance, `mount`);
}
// inject renderer internals for keepAlive
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
}
// resolve props and slots for setup context
{
startMeasure(instance, `init`);
}
setupComponent(instance);
{
endMeasure(instance, `init`);
}
// setup() is async. This component relies on async logic to be resolved
// before proceeding
if ( instance.asyncDep) {
if (!parentSuspense) {
warn('async setup() is used without a suspense boundary!');
return;
}
parentSuspense.registerDep(instance, setupRenderEffect);
// Give it a placeholder if this is not hydration
if (!initialVNode.el) {
const placeholder = (instance.subTree = createVNode(Comment));
processCommentNode(null, placeholder, container, anchor);
}
return;
}
setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized);
{
popWarningContext();
endMeasure(instance, `mount`);
}
};
const updateComponent = (n1, n2, optimized) => {
const instance = (n2.component = n1.component);
if (shouldUpdateComponent(n1, n2, optimized)) {
if (
instance.asyncDep &&
!instance.asyncResolved) {
// async & still pending - just update props and slots
// since the component's reactive effect for render isn't set-up yet
{
pushWarningContext(n2);
}
updateComponentPreRender(instance, n2, optimized);
{
popWarningContext();
}
return;
}
else {
// normal update
instance.next = n2;
// in case the child component is also queued, remove it to avoid
// double updating the same child component in the same flush.
invalidateJob(instance.update);
// instance.update is the reactive effect runner.
instance.update();
}
}
else {
// no update needed. just copy over properties
n2.component = n1.component;
n2.el = n1.el;
}
};
const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
// create reactive effect for rendering
instance.update = effect(function componentEffect() {
if (!instance.isMounted) {
let vnodeHook;
const { el, props } = initialVNode;
const { bm, m, a, parent } = instance;
{
startMeasure(instance, `render`);
}
const subTree = (instance.subTree = renderComponentRoot(instance));
{
endMeasure(instance, `render`);
}
// beforeMount hook
if (bm) {
invokeArrayFns(bm);
}
// onVnodeBeforeMount
if ((vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}
if (el && hydrateNode) {
{
startMeasure(instance, `hydrate`);
}
// vnode has adopted host node - perform hydration instead of mount.
hydrateNode(initialVNode.el, subTree, instance, parentSuspense);
{
endMeasure(instance, `hydrate`);
}
}
else {
{
startMeasure(instance, `patch`);
}
patch(null, subTree, container, anchor, instance, parentSuspense, isSVG);
{
endMeasure(instance, `patch`);
}
initialVNode.el = subTree.el;
}
// mounted hook
if (m) {
queuePostRenderEffect(m, parentSuspense);
}
// onVnodeMounted
if ((vnodeHook = props && props.onVnodeMounted)) {
queuePostRenderEffect(() => {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}, parentSuspense);
}
// activated hook for keep-alive roots.
if (a &&
initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
queuePostRenderEffect(a, parentSuspense);
}
instance.isMounted = true;
}
else {
// updateComponent
// This is triggered by mutation of component's own state (next: null)
// OR parent calling processComponent (next: VNode)
let { next, bu, u, parent, vnode } = instance;
let vnodeHook;
{
pushWarningContext(next || instance.vnode);
}
if (next) {
updateComponentPreRender(instance, next, optimized);
}
else {
next = vnode;
}
{
startMeasure(instance, `render`);
}
const nextTree = renderComponentRoot(instance);
{
endMeasure(instance, `render`);
}
const prevTree = instance.subTree;
instance.subTree = nextTree;
next.el = vnode.el;
// beforeUpdate hook
if (bu) {
invokeArrayFns(bu);
}
// onVnodeBeforeUpdate
if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}
// reset refs
// only needed if previous patch had refs
if (instance.refs !== EMPTY_OBJ) {
instance.refs = {};
}
{
startMeasure(instance, `patch`);
}
patch(prevTree, nextTree,
// parent may have changed if it's in a teleport
hostParentNode(prevTree.el),
// anchor may have changed if it's in a fragment
getNextHostNode(prevTree), instance, parentSuspense, isSVG);
{
endMeasure(instance, `patch`);
}
next.el = nextTree.el;
if (next === null) {
// self-triggered update. In case of HOC, update parent component
// vnode el. HOC is indicated by parent instance's subTree pointing
// to child component's vnode
updateHOCHostEl(instance, nextTree.el);
}
// updated hook
if (u) {
queuePostRenderEffect(u, parentSuspense);
}
// onVnodeUpdated
if ((vnodeHook = next.props && next.props.onVnodeUpdated)) {
queuePostRenderEffect(() => {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}, parentSuspense);
}
{
popWarningContext();
}
}
}, createDevEffectOptions(instance) );
};
const updateComponentPreRender = (instance, nextVNode, optimized) => {
if ( instance.type.__hmrId) {
optimized = false;
}
nextVNode.component = instance;
const prevProps = instance.vnode.props;
instance.vnode = nextVNode;
instance.next = null;
updateProps(instance, nextVNode.props, prevProps, optimized);
updateSlots(instance, nextVNode.children);
};
const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized = false) => {
const c1 = n1 && n1.children;
const prevShapeFlag = n1 ? n1.shapeFlag : 0;
const c2 = n2.children;
const { patchFlag, shapeFlag } = n2;
// fast path
if (patchFlag > 0) {
if (patchFlag & 128 /* KEYED_FRAGMENT */) {
// this could be either fully-keyed or mixed (some keyed some not)
// presence of patchFlag means children are guaranteed to be arrays
patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
return;
}
else if (patchFlag & 256 /* UNKEYED_FRAGMENT */) {
// unkeyed
patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
return;
}
}
// children has 3 possibilities: text, array or no children.
if (shapeFlag & 8 /* TEXT_CHILDREN */) {
// text children fast path
if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {
unmountChildren(c1, parentComponent, parentSuspense);
}
if (c2 !== c1) {
hostSetElementText(container, c2);
}
}
else {
if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {
// prev children was array
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
// two arrays, cannot assume anything, do full diff
patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else {
// no new children, just unmount old
unmountChildren(c1, parentComponent, parentSuspense, true);
}
}
else {
// prev children was text OR null
// new children is array OR null
if (prevShapeFlag & 8 /* TEXT_CHILDREN */) {
hostSetElementText(container, '');
}
// mount new if array
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
}
}
};
const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
c1 = c1 || EMPTY_ARR;
c2 = c2 || EMPTY_ARR;
const oldLength = c1.length;
const newLength = c2.length;
const commonLength = Math.min(oldLength, newLength);
let i;
for (i = 0; i < commonLength; i++) {
const nextChild = (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i]));
patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, optimized);
}
if (oldLength > newLength) {
// remove old
unmountChildren(c1, parentComponent, parentSuspense, true, commonLength);
}
else {
// mount new
mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, commonLength);
}
};
// can be all-keyed or mixed
const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized) => {
let i = 0;
const l2 = c2.length;
let e1 = c1.length - 1; // prev ending index
let e2 = l2 - 1; // next ending index
// 1. sync from start
// (a b) c
// (a b) d e
while (i <= e1 && i <= e2) {
const n1 = c1[i];
const n2 = (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i]));
if (isSameVNodeType(n1, n2)) {
patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);
}
else {
break;
}
i++;
}
// 2. sync from end
// a (b c)
// d e (b c)
while (i <= e1 && i <= e2) {
const n1 = c1[e1];
const n2 = (c2[e2] = optimized
? cloneIfMounted(c2[e2])
: normalizeVNode(c2[e2]));
if (isSameVNodeType(n1, n2)) {
patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);
}
else {
break;
}
e1--;
e2--;
}
// 3. common sequence + mount
// (a b)
// (a b) c
// i = 2, e1 = 1, e2 = 2
// (a b)
// c (a b)
// i = 0, e1 = -1, e2 = 0
if (i > e1) {
if (i <= e2) {
const nextPos = e2 + 1;
const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
while (i <= e2) {
patch(null, (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i])), container, anchor, parentComponent, parentSuspense, isSVG);
i++;
}
}
}
// 4. common sequence + unmount
// (a b) c
// (a b)
// i = 2, e1 = 2, e2 = 1
// a (b c)
// (b c)
// i = 0, e1 = 0, e2 = -1
else if (i > e2) {
while (i <= e1) {
unmount(c1[i], parentComponent, parentSuspense, true);
i++;
}
}
// 5. unknown sequence
// [i ... e1 + 1]: a b [c d e] f g
// [i ... e2 + 1]: a b [e d c h] f g
// i = 2, e1 = 4, e2 = 5
else {
const s1 = i; // prev starting index
const s2 = i; // next starting index
// 5.1 build key:index map for newChildren
const keyToNewIndexMap = new Map();
for (i = s2; i <= e2; i++) {
const nextChild = (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i]));
if (nextChild.key != null) {
if ( keyToNewIndexMap.has(nextChild.key)) {
warn(`Duplicate keys found during update:`, JSON.stringify(nextChild.key), `Make sure keys are unique.`);
}
keyToNewIndexMap.set(nextChild.key, i);
}
}
// 5.2 loop through old children left to be patched and try to patch
// matching nodes & remove nodes that are no longer present
let j;
let patched = 0;
const toBePatched = e2 - s2 + 1;
let moved = false;
// used to track whether any node has moved
let maxNewIndexSoFar = 0;
// works as Map<newIndex, oldIndex>
// Note that oldIndex is offset by +1
// and oldIndex = 0 is a special value indicating the new node has
// no corresponding old node.
// used for determining longest stable subsequence
const newIndexToOldIndexMap = new Array(toBePatched);
for (i = 0; i < toBePatched; i++)
newIndexToOldIndexMap[i] = 0;
for (i = s1; i <= e1; i++) {
const prevChild = c1[i];
if (patched >= toBePatched) {
// all new children have been patched so this can only be a removal
unmount(prevChild, parentComponent, parentSuspense, true);
continue;
}
let newIndex;
if (prevChild.key != null) {
newIndex = keyToNewIndexMap.get(prevChild.key);
}
else {
// key-less node, try to locate a key-less node of the same type
for (j = s2; j <= e2; j++) {
if (newIndexToOldIndexMap[j - s2] === 0 &&
isSameVNodeType(prevChild, c2[j])) {
newIndex = j;
break;
}
}
}
if (newIndex === undefined) {
unmount(prevChild, parentComponent, parentSuspense, true);
}
else {
newIndexToOldIndexMap[newIndex - s2] = i + 1;
if (newIndex >= maxNewIndexSoFar) {
maxNewIndexSoFar = newIndex;
}
else {
moved = true;
}
patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, optimized);
patched++;
}
}
// 5.3 move and mount
// generate longest stable subsequence only when nodes have moved
const increasingNewIndexSequence = moved
? getSequence(newIndexToOldIndexMap)
: EMPTY_ARR;
j = increasingNewIndexSequence.length - 1;
// looping backwards so that we can use last patched node as anchor
for (i = toBePatched - 1; i >= 0; i--) {
const nextIndex = s2 + i;
const nextChild = c2[nextIndex];
const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
if (newIndexToOldIndexMap[i] === 0) {
// mount new
patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG);
}
else if (moved) {
// move if:
// There is no stable subsequence (e.g. a reverse)
// OR current node is not among the stable sequence
if (j < 0 || i !== increasingNewIndexSequence[j]) {
move(nextChild, container, anchor, 2 /* REORDER */);
}
else {
j--;
}
}
}
}
};
const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
const { el, type, transition, children, shapeFlag } = vnode;
if (shapeFlag & 6 /* COMPONENT */) {
move(vnode.component.subTree, container, anchor, moveType);
return;
}
if ( shapeFlag & 128 /* SUSPENSE */) {
vnode.suspense.move(container, anchor, moveType);
return;
}
if (shapeFlag & 64 /* TELEPORT */) {
type.move(vnode, container, anchor, internals);
return;
}
if (type === Fragment) {
hostInsert(el, container, anchor);
for (let i = 0; i < children.length; i++) {
move(children[i], container, anchor, moveType);
}
hostInsert(vnode.anchor, container, anchor);
return;
}
// static node move can only happen when force updating HMR
if ( type === Static) {
moveStaticNode(vnode, container, anchor);
return;
}
// single nodes
const needTransition = moveType !== 2 /* REORDER */ &&
shapeFlag & 1 /* ELEMENT */ &&
transition;
if (needTransition) {
if (moveType === 0 /* ENTER */) {
transition.beforeEnter(el);
hostInsert(el, container, anchor);
queuePostRenderEffect(() => transition.enter(el), parentSuspense);
}
else {
const { leave, delayLeave, afterLeave } = transition;
const remove = () => hostInsert(el, container, anchor);
const performLeave = () => {
leave(el, () => {
remove();
afterLeave && afterLeave();
});
};
if (delayLeave) {
delayLeave(el, remove, performLeave);
}
else {
performLeave();
}
}
}
else {
hostInsert(el, container, anchor);
}
};
const unmount = (vnode, parentComponent, parentSuspense, doRemove = false) => {
const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode;
const shouldInvokeDirs = shapeFlag & 1 /* ELEMENT */ && dirs;
const shouldKeepAlive = shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
let vnodeHook;
// unset ref
if (ref != null && parentComponent) {
setRef(ref, null, parentComponent, null);
}
if ((vnodeHook = props && props.onVnodeBeforeUnmount) && !shouldKeepAlive) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
if (shapeFlag & 6 /* COMPONENT */) {
if (shouldKeepAlive) {
parentComponent.ctx.deactivate(vnode);
}
else {
unmountComponent(vnode.component, parentSuspense, doRemove);
}
}
else {
if ( shapeFlag & 128 /* SUSPENSE */) {
vnode.suspense.unmount(parentSuspense, doRemove);
return;
}
if (shouldInvokeDirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount');
}
if (dynamicChildren &&
// #1153: fast path should not be taken for non-stable (v-for) fragments
(type !== Fragment ||
(patchFlag > 0 && patchFlag & 64 /* STABLE_FRAGMENT */))) {
// fast path for block nodes: only need to unmount dynamic children.
unmountChildren(dynamicChildren, parentComponent, parentSuspense);
}
else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
unmountChildren(children, parentComponent, parentSuspense);
}
// an unmounted teleport should always remove its children
if (shapeFlag & 64 /* TELEPORT */) {
vnode.type.remove(vnode, internals);
}
if (doRemove) {
remove(vnode);
}
}
if (((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) &&
!shouldKeepAlive) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
shouldInvokeDirs &&
invokeDirectiveHook(vnode, null, parentComponent, 'unmounted');
}, parentSuspense);
}
};
const remove = vnode => {
const { type, el, anchor, transition } = vnode;
if (type === Fragment) {
removeFragment(el, anchor);
return;
}
if ( type === Static) {
removeStaticNode(vnode);
return;
}
const performRemove = () => {
hostRemove(el);
if (transition && !transition.persisted && transition.afterLeave) {
transition.afterLeave();
}
};
if (vnode.shapeFlag & 1 /* ELEMENT */ &&
transition &&
!transition.persisted) {
const { leave, delayLeave } = transition;
const performLeave = () => leave(el, performRemove);
if (delayLeave) {
delayLeave(vnode.el, performRemove, performLeave);
}
else {
performLeave();
}
}
else {
performRemove();
}
};
const removeFragment = (cur, end) => {
// For fragments, directly remove all contained DOM nodes.
// (fragment child nodes cannot have transition)
let next;
while (cur !== end) {
next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(end);
};
const unmountComponent = (instance, parentSuspense, doRemove) => {
if ( instance.type.__hmrId) {
unregisterHMR(instance);
}
const { bum, effects, update, subTree, um, da, isDeactivated } = instance;
// beforeUnmount hook
if (bum) {
invokeArrayFns(bum);
}
if (effects) {
for (let i = 0; i < effects.length; i++) {
stop(effects[i]);
}
}
// update may be null if a component is unmounted before its async
// setup has resolved.
if (update) {
stop(update);
unmount(subTree, instance, parentSuspense, doRemove);
}
// unmounted hook
if (um) {
queuePostRenderEffect(um, parentSuspense);
}
// deactivated hook
if (da &&
!isDeactivated &&
instance.vnode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
queuePostRenderEffect(da, parentSuspense);
}
queuePostRenderEffect(() => {
instance.isUnmounted = true;
}, parentSuspense);
// A component with async dep inside a pending suspense is unmounted before
// its async dep resolves. This should remove the dep from the suspense, and
// cause the suspense to resolve immediately if that was the last dep.
if (
parentSuspense &&
!parentSuspense.isResolved &&
!parentSuspense.isUnmounted &&
instance.asyncDep &&
!instance.asyncResolved) {
parentSuspense.deps--;
if (parentSuspense.deps === 0) {
parentSuspense.resolve();
}
}
};
const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, start = 0) => {
for (let i = start; i < children.length; i++) {
unmount(children[i], parentComponent, parentSuspense, doRemove);
}
};
const getNextHostNode = vnode => {
if (vnode.shapeFlag & 6 /* COMPONENT */) {
return getNextHostNode(vnode.component.subTree);
}
if ( vnode.shapeFlag & 128 /* SUSPENSE */) {
return vnode.suspense.next();
}
return hostNextSibling((vnode.anchor || vnode.el));
};
/**
* #1156
* When a component is HMR-enabled, we need to make sure that all static nodes
* inside a block also inherit the DOM element from the previous tree so that
* HMR updates (which are full updates) can retrieve the element for patching.
*
* Dev only.
*/
const traverseStaticChildren = (n1, n2) => {
const ch1 = n1.children;
const ch2 = n2.children;
if (isArray(ch1) && isArray(ch2)) {
for (let i = 0; i < ch1.length; i++) {
const c1 = ch1[i];
const c2 = ch2[i];
if (isVNode(c1) &&
isVNode(c2) &&
c2.shapeFlag & 1 /* ELEMENT */ &&
!c2.dynamicChildren) {
if (c2.patchFlag <= 0) {
c2.el = c1.el;
}
traverseStaticChildren(c1, c2);
}
}
}
};
const render = (vnode, container) => {
if (vnode == null) {
if (container._vnode) {
unmount(container._vnode, null, null, true);
}
}
else {
patch(container._vnode || null, vnode, container);
}
flushPostFlushCbs();
container._vnode = vnode;
};
const internals = {
p: patch,
um: unmount,
m: move,
r: remove,
mt: mountComponent,
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
n: getNextHostNode,
o: options
};
let hydrate;
let hydrateNode;
if (createHydrationFns) {
[hydrate, hydrateNode] = createHydrationFns(internals);
}
return {
render,
hydrate,
createApp: createAppAPI(render, hydrate)
};
}
function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [
vnode,
prevVNode
]);
}
// https://en.wikipedia.org/wiki/Longest_increasing_subsequence
function getSequence(arr) {
const p = arr.slice();
const result = [0];
let i, j, u, v, c;
const len = arr.length;
for (i = 0; i < len; i++) {
const arrI = arr[i];
if (arrI !== 0) {
j = result[result.length - 1];
if (arr[j] < arrI) {
p[i] = j;
result.push(i);
continue;
}
u = 0;
v = result.length - 1;
while (u < v) {
c = ((u + v) / 2) | 0;
if (arr[result[c]] < arrI) {
u = c + 1;
}
else {
v = c;
}
}
if (arrI < arr[result[u]]) {
if (u > 0) {
p[i] = result[u - 1];
}
result[u] = i;
}
}
}
u = result.length;
v = result[u - 1];
while (u-- > 0) {
result[u] = v;
v = p[v];
}
return result;
}
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: new Map()
};
onMounted(() => {
state.isMounted = true;
});
onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
const BaseTransitionImpl = {
name: `BaseTransition`,
inheritRef: true,
props: {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: Function,
onEnter: Function,
onAfterEnter: Function,
onEnterCancelled: Function,
// leave
onBeforeLeave: Function,
onLeave: Function,
onAfterLeave: Function,
onLeaveCancelled: Function
},
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
return () => {
const children = slots.default && slots.default();
if (!children || !children.length) {
return;
}
// warn multiple elements
if ( children.length > 1) {
warn('<transition> can only be used on a single element or component. Use ' +
'<transition-group> for lists.');
}
// there's no need to track reactivity for these props so use the raw
// props for a bit better perf
const rawProps = toRaw(props);
const { mode } = rawProps;
// check mode
if ( mode && !['in-out', 'out-in', 'default'].includes(mode)) {
warn(`invalid <transition> mode: ${mode}`);
}
// at this point children has a guaranteed length of 1.
const child = children[0];
if (state.isLeaving) {
return emptyPlaceholder(child);
}
// in the case of <transition><keep-alive/></transition>, we need to
// compare the type of the kept-alive children.
const innerChild = getKeepAliveChild(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
const enterHooks = (innerChild.transition = resolveTransitionHooks(innerChild, rawProps, state, instance));
const oldChild = instance.subTree;
const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
// handle mode
if (oldInnerChild &&
oldInnerChild.type !== Comment &&
!isSameVNodeType(innerChild, oldInnerChild)) {
const prevHooks = oldInnerChild.transition;
const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);
// update old tree's hooks in case of dynamic transition
setTransitionHooks(oldInnerChild, leavingHooks);
// switching between different views
if (mode === 'out-in') {
state.isLeaving = true;
// return placeholder node and queue update when leave finishes
leavingHooks.afterLeave = () => {
state.isLeaving = false;
instance.update();
};
return emptyPlaceholder(child);
}
else if (mode === 'in-out') {
delete prevHooks.delayedLeave;
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
// early removal callback
el._leaveCb = () => {
earlyRemove();
el._leaveCb = undefined;
delete enterHooks.delayedLeave;
};
enterHooks.delayedLeave = delayedLeave;
};
}
}
return child;
};
}
};
// export the public type for h/tsx inference
// also to avoid inline import() in generated d.ts files
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
// The transition hooks are attached to the vnode as vnode.transition
// and will be called at appropriate timing in the renderer.
function resolveTransitionHooks(vnode, { appear, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled }, state, instance) {
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook = (hook, args) => {
hook &&
callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);
};
const hooks = {
persisted,
beforeEnter(el) {
if (!appear && !state.isMounted) {
return;
}
// for same element (v-show)
if (el._leaveCb) {
el._leaveCb(true /* cancelled */);
}
// for toggled element with same key (v-if)
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode &&
isSameVNodeType(vnode, leavingVNode) &&
leavingVNode.el._leaveCb) {
// force early removal (not cancelled)
leavingVNode.el._leaveCb();
}
callHook(onBeforeEnter, [el]);
},
enter(el) {
if (!appear && !state.isMounted) {
return;
}
let called = false;
const afterEnter = (el._enterCb = (cancelled) => {
if (called)
return;
called = true;
if (cancelled) {
callHook(onEnterCancelled, [el]);
}
else {
callHook(onAfterEnter, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el._enterCb = undefined;
});
if (onEnter) {
onEnter(el, afterEnter);
}
else {
afterEnter();
}
},
leave(el, remove) {
const key = String(vnode.key);
if (el._enterCb) {
el._enterCb(true /* cancelled */);
}
if (state.isUnmounting) {
return remove();
}
callHook(onBeforeLeave, [el]);
let called = false;
const afterLeave = (el._leaveCb = (cancelled) => {
if (called)
return;
called = true;
remove();
if (cancelled) {
callHook(onLeaveCancelled, [el]);
}
else {
callHook(onAfterLeave, [el]);
}
el._leaveCb = undefined;
if (leavingVNodesCache[key] === vnode) {
delete leavingVNodesCache[key];
}
});
leavingVNodesCache[key] = vnode;
if (onLeave) {
onLeave(el, afterLeave);
}
else {
afterLeave();
}
}
};
return hooks;
}
// the placeholder really only handles one special case: KeepAlive
// in the case of a KeepAlive in a leave phase we need to return a KeepAlive
// placeholder with empty content to avoid the KeepAlive instance from being
// unmounted.
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]
: undefined
: vnode;
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {
setTransitionHooks(vnode.component.subTree, hooks);
}
else {
vnode.transition = hooks;
}
}
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
const 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,
inheritRef: true,
props: {
include: [String, RegExp, Array],
exclude: [String, RegExp, Array],
max: [String, Number]
},
setup(props, { slots }) {
const cache = new Map();
const keys = new Set();
let current = null;
const instance = getCurrentInstance();
const parentSuspense = instance.suspense;
// KeepAlive communicates with the instantiated renderer via the
// ctx where the renderer passes in its internals,
// and the KeepAlive instance exposes activate/deactivate implementations.
// The whole point of this is to avoid importing KeepAlive directly in the
// renderer to facilitate tree-shaking.
const sharedContext = instance.ctx;
const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;
const storageContainer = createElement('div');
sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
const child = vnode.component;
move(vnode, container, anchor, 0 /* ENTER */, parentSuspense);
// in case props have changed
patch(child.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, optimized);
queuePostRenderEffect(() => {
child.isDeactivated = false;
if (child.a) {
invokeArrayFns(child.a);
}
}, parentSuspense);
};
sharedContext.deactivate = (vnode) => {
move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense);
queuePostRenderEffect(() => {
const component = vnode.component;
if (component.da) {
invokeArrayFns(component.da);
}
component.isDeactivated = true;
}, parentSuspense);
};
function unmount(vnode) {
// reset the shapeFlag so it can be properly unmounted
vnode.shapeFlag = 4 /* STATEFUL_COMPONENT */;
_unmount(vnode, instance, parentSuspense);
}
function pruneCache(filter) {
cache.forEach((vnode, key) => {
const name = getName(vnode.type);
if (name && (!filter || !filter(name))) {
pruneCacheEntry(key);
}
});
}
function pruneCacheEntry(key) {
const cached = cache.get(key);
if (!current || cached.type !== current.type) {
unmount(cached);
}
else if (current) {
// current active instance should no longer be kept-alive.
// we can't unmount it now but it might be later, so reset its flag now.
current.shapeFlag = 4 /* STATEFUL_COMPONENT */;
}
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));
});
onBeforeUnmount(() => {
cache.forEach(unmount);
});
return () => {
if (!slots.default) {
return null;
}
const children = slots.default();
let vnode = children[0];
if (children.length > 1) {
{
warn(`KeepAlive should contain exactly one component child.`);
}
current = null;
return children;
}
else if (!isVNode(vnode) ||
!(vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */)) {
current = null;
return vnode;
}
const comp = vnode.type;
const name = getName(comp);
const { include, exclude, max } = props;
if ((include && (!name || !matches(include, name))) ||
(exclude && name && matches(exclude, name))) {
return vnode;
}
const key = vnode.key == null ? comp : vnode.key;
const cachedVNode = cache.get(key);
// clone vnode if it's reused because we are going to mutate it
if (vnode.el) {
vnode = cloneVNode(vnode);
}
cache.set(key, vnode);
if (cachedVNode) {
// copy over mounted state
vnode.el = cachedVNode.el;
vnode.component = cachedVNode.component;
if (vnode.transition) {
// recursively update transition hooks on subTree
setTransitionHooks(vnode, vnode.transition);
}
// avoid vnode being mounted as fresh
vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */;
// make this key the freshest
keys.delete(key);
keys.add(key);
}
else {
keys.add(key);
// prune oldest entry
if (max && keys.size > parseInt(max, 10)) {
pruneCacheEntry(keys.values().next().value);
}
}
// avoid vnode being unmounted
vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
current = vnode;
return vnode;
};
}
};
// export the public type for h/tsx inference
// also to avoid inline import() in generated d.ts files
const KeepAlive = KeepAliveImpl;
function getName(comp) {
return comp.displayName || comp.name;
}
function matches(pattern, name) {
if (isArray(pattern)) {
return pattern.some((p) => matches(p, name));
}
else if (isString(pattern)) {
return pattern.split(',').indexOf(name) > -1;
}
else if (pattern.test) {
return pattern.test(name);
}
/* istanbul ignore next */
return false;
}
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a" /* ACTIVATED */, target);
}
function onDeactivated(hook, target) {
registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
// cache the deactivate branch check wrapper for injected hooks so the same
// hook can be properly deduped by the scheduler. "__wdc" stands for "with
// deactivation check".
const wrappedHook = hook.__wdc ||
(hook.__wdc = () => {
// only fire the hook if the target instance is NOT in a deactivated branch.
let current = target;
while (current) {
if (current.isDeactivated) {
return;
}
current = current.parent;
}
hook();
});
injectHook(type, wrappedHook, target);
// In addition to registering it on the target instance, we walk up the parent
// chain and register it on all ancestor instances that are keep-alive roots.
// This avoids the need to walk the entire component tree when invoking these
// hooks, and more importantly, avoids the need to track child components in
// arrays.
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) {
injectHook(type, hook, keepAliveRoot, true /* prepend */);
onUnmounted(() => {
remove(keepAliveRoot[type], hook);
}, target);
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
// cache the error handling wrapper for injected hooks so the same hook
// can be properly deduped by the scheduler. "__weh" stands for "with error
// handling".
const wrappedHook = hook.__weh ||
(hook.__weh = (...args) => {
if (target.isUnmounted) {
return;
}
// disable tracking inside all lifecycle hooks
// since they can potentially be called inside effects.
pauseTracking();
// Set currentInstance during hook invocation.
// This assumes the hook does not synchronously trigger other hooks, which
// can only be false when the user does something really funky.
setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
setCurrentInstance(null);
resetTracking();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
}
else {
hooks.push(wrappedHook);
}
}
else {
const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;
warn(`${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.`
));
}
}
const createHook = (lifecycle) => (hook, target = currentInstance) =>
// post-create lifecycle registrations are noops during SSR
!isInSSRComponentSetup && injectHook(lifecycle, hook, target);
const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */);
const onMounted = createHook("m" /* MOUNTED */);
const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */);
const onUpdated = createHook("u" /* UPDATED */);
const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */);
const onUnmounted = createHook("um" /* UNMOUNTED */);
const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */);
const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */);
const onErrorCaptured = (hook, target = currentInstance) => {
injectHook("ec" /* ERROR_CAPTURED */, hook, target);
};
const invoke = (fn) => fn();
// Simple effect.
function watchEffect(effect, options) {
return doWatch(effect, null, options);
}
// initial value for watchers to trigger on undefined initial values
const INITIAL_WATCHER_VALUE = {};
// implementation
function watch(source, cb, options) {
if ( !isFunction(cb)) {
warn(`\`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 !== undefined) {
warn(`watch() "immediate" option is only respected when using the ` +
`watch(source, callback, options?) signature.`);
}
if (deep !== undefined) {
warn(`watch() "deep" option is only respected when using the ` +
`watch(source, callback, options?) signature.`);
}
}
const warnInvalidSource = (s) => {
warn(`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 = currentInstance;
let getter;
if (isArray(source)) {
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 /* WATCH_GETTER */);
}
else {
warnInvalidSource(s);
}
});
}
else if (isRef(source)) {
getter = () => source.value;
}
else if (isReactive(source)) {
getter = () => source;
deep = true;
}
else if (isFunction(source)) {
if (cb) {
// getter with cb
getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);
}
else {
// no cb -> simple effect
getter = () => {
if (instance && instance.isUnmounted) {
return;
}
if (cleanup) {
cleanup();
}
return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);
};
}
}
else {
getter = NOOP;
warnInvalidSource(source);
}
if (cb && deep) {
const baseGetter = getter;
getter = () => traverse(baseGetter());
}
let cleanup;
const onInvalidate = (fn) => {
cleanup = runner.options.onStop = () => {
callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);
};
};
let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;
const applyCb = cb
? () => {
if (instance && instance.isUnmounted) {
return;
}
const newValue = runner();
if (deep || hasChanged(newValue, oldValue)) {
// cleanup before running cb again
if (cleanup) {
cleanup();
}
callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [
newValue,
// pass undefined as the old value when it's changed for the first time
oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,
onInvalidate
]);
oldValue = newValue;
}
}
: void 0;
let scheduler;
if (flush === 'sync') {
scheduler = invoke;
}
else if (flush === 'pre') {
scheduler = job => {
if (!instance || instance.isMounted) {
queueJob(job);
}
else {
// with 'pre' option, the first call must happen before
// the component is mounted so it is called synchronously.
job();
}
};
}
else {
scheduler = job => queuePostRenderEffect(job, instance && instance.suspense);
}
const runner = effect(getter, {
lazy: true,
// so it runs before component update effects in pre flush mode
computed: true,
onTrack,
onTrigger,
scheduler: applyCb ? () => scheduler(applyCb) : scheduler
});
recordInstanceBoundEffect(runner);
// initial run
if (applyCb) {
if (immediate) {
applyCb();
}
else {
oldValue = runner();
}
}
else {
runner();
}
return () => {
stop(runner);
if (instance) {
remove(instance.effects, runner);
}
};
}
// this.$watch
function instanceWatch(source, cb, options) {
const publicThis = this.proxy;
const getter = isString(source)
? () => publicThis[source]
: source.bind(publicThis);
const stop = watch(getter, cb.bind(publicThis), options);
onBeforeUnmount(stop, this);
return stop;
}
function traverse(value, seen = new Set()) {
if (!isObject(value) || seen.has(value)) {
return value;
}
seen.add(value);
if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], seen);
}
}
else if (value instanceof Map) {
value.forEach((v, key) => {
// to register mutation dep for existing keys
traverse(value.get(key), seen);
});
}
else if (value instanceof Set) {
value.forEach(v => {
traverse(v, seen);
});
}
else {
for (const key in value) {
traverse(value[key], seen);
}
}
return value;
}
function provide(key, value) {
if (!currentInstance) {
{
warn(`provide() can only be used inside setup().`);
}
}
else {
let provides = currentInstance.provides;
// by default an instance inherits its parent's provides object
// but when it needs to provide values of its own, it creates its
// own provides object using parent provides object as prototype.
// this way in `inject` we can simply look up injections from direct
// parent and let the prototype chain do the work.
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
// TS doesn't allow symbol as index type
provides[key] = value;
}
}
function inject(key, defaultValue) {
// fallback to `currentRenderingInstance` so that this can be called in
// a functional component
const instance = currentInstance || currentRenderingInstance;
if (instance) {
const provides = instance.provides;
if (key in provides) {
// TS doesn't allow symbol as index type
return provides[key];
}
else if (arguments.length > 1) {
return defaultValue;
}
else {
warn(`injection "${String(key)}" not found.`);
}
}
else {
warn(`inject() can only be used inside setup() or functional components.`);
}
}
function createDuplicateChecker() {
const cache = Object.create(null);
return (type, key) => {
if (cache[key]) {
warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
}
else {
cache[key] = type;
}
};
}
function applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) {
const {
// composition
mixins, extends: extendsOptions,
// state
data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions,
// assets
components, directives,
// lifecycle
beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, renderTracked, renderTriggered, errorCaptured } = options;
const publicThis = instance.proxy;
const ctx = instance.ctx;
const globalMixins = instance.appContext.mixins;
// call it only during dev
// applyOptions is called non-as-mixin once per instance
if (!asMixin) {
callSyncHook('beforeCreate', options, publicThis, globalMixins);
// global mixins are applied first
applyMixins(instance, globalMixins, deferredData, deferredWatch);
}
// extending a base component...
if (extendsOptions) {
applyOptions(instance, extendsOptions, deferredData, deferredWatch, true);
}
// local mixins
if (mixins) {
applyMixins(instance, mixins, deferredData, deferredWatch);
}
const checkDuplicateProperties = createDuplicateChecker() ;
{
const propsOptions = normalizePropsOptions(options)[0];
if (propsOptions) {
for (const key in propsOptions) {
checkDuplicateProperties("Props" /* PROPS */, key);
}
}
}
// options initialization order (to be consistent with Vue 2):
// - props (already done outside of this function)
// - inject
// - methods
// - data (deferred since it relies on `this` access)
// - computed
// - watch (deferred since it relies on `this` access)
if (injectOptions) {
if (isArray(injectOptions)) {
for (let i = 0; i < injectOptions.length; i++) {
const key = injectOptions[i];
ctx[key] = inject(key);
{
checkDuplicateProperties("Inject" /* INJECT */, key);
}
}
}
else {
for (const key in injectOptions) {
const opt = injectOptions[key];
if (isObject(opt)) {
ctx[key] = inject(opt.from, opt.default);
}
else {
ctx[key] = inject(opt);
}
{
checkDuplicateProperties("Inject" /* INJECT */, key);
}
}
}
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (isFunction(methodHandler)) {
ctx[key] = methodHandler.bind(publicThis);
{
checkDuplicateProperties("Methods" /* METHODS */, key);
}
}
else {
warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` +
`Did you reference the function correctly?`);
}
}
}
if (dataOptions) {
if ( !isFunction(dataOptions)) {
warn(`The data option must be a function. ` +
`Plain object usage is no longer supported.`);
}
if (asMixin) {
deferredData.push(dataOptions);
}
else {
resolveData(instance, dataOptions, publicThis);
}
}
if (!asMixin) {
if (deferredData.length) {
deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));
}
{
const rawData = toRaw(instance.data);
for (const key in rawData) {
checkDuplicateProperties("Data" /* DATA */, key);
// expose data on ctx during dev
if (key[0] !== '$' && key[0] !== '_') {
Object.defineProperty(ctx, key, {
configurable: true,
enumerable: true,
get: () => rawData[key],
set: NOOP
});
}
}
}
}
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get = isFunction(opt)
? opt.bind(publicThis, publicThis)
: isFunction(opt.get)
? opt.get.bind(publicThis, publicThis)
: NOOP;
if ( get === NOOP) {
warn(`Computed property "${key}" has no getter.`);
}
const set = !isFunction(opt) && isFunction(opt.set)
? opt.set.bind(publicThis)
: () => {
warn(`Write operation failed: computed property "${key}" is readonly.`);
}
;
const c = computed$1({
get,
set
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: v => (c.value = v)
});
{
checkDuplicateProperties("Computed" /* COMPUTED */, key);
}
}
}
if (watchOptions) {
deferredWatch.push(watchOptions);
}
if (!asMixin && deferredWatch.length) {
deferredWatch.forEach(watchOptions => {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
});
}
if (provideOptions) {
const provides = isFunction(provideOptions)
? provideOptions.call(publicThis)
: provideOptions;
for (const key in provides) {
provide(key, provides[key]);
}
}
// asset options
if (components) {
extend(instance.components, components);
}
if (directives) {
extend(instance.directives, directives);
}
// lifecycle options
if (!asMixin) {
callSyncHook('created', options, publicThis, globalMixins);
}
if (beforeMount) {
onBeforeMount(beforeMount.bind(publicThis));
}
if (mounted) {
onMounted(mounted.bind(publicThis));
}
if (beforeUpdate) {
onBeforeUpdate(beforeUpdate.bind(publicThis));
}
if (updated) {
onUpdated(updated.bind(publicThis));
}
if (activated) {
onActivated(activated.bind(publicThis));
}
if (deactivated) {
onDeactivated(deactivated.bind(publicThis));
}
if (errorCaptured) {
onErrorCaptured(errorCaptured.bind(publicThis));
}
if (renderTracked) {
onRenderTracked(renderTracked.bind(publicThis));
}
if (renderTriggered) {
onRenderTriggered(renderTriggered.bind(publicThis));
}
if (beforeUnmount) {
onBeforeUnmount(beforeUnmount.bind(publicThis));
}
if (unmounted) {
onUnmounted(unmounted.bind(publicThis));
}
}
function callSyncHook(name, options, ctx, globalMixins) {
callHookFromMixins(name, globalMixins, ctx);
const baseHook = options.extends && options.extends[name];
if (baseHook) {
baseHook.call(ctx);
}
const mixins = options.mixins;
if (mixins) {
callHookFromMixins(name, mixins, ctx);
}
const selfHook = options[name];
if (selfHook) {
selfHook.call(ctx);
}
}
function callHookFromMixins(name, mixins, ctx) {
for (let i = 0; i < mixins.length; i++) {
const fn = mixins[i][name];
if (fn) {
fn.call(ctx);
}
}
}
function applyMixins(instance, mixins, deferredData, deferredWatch) {
for (let i = 0; i < mixins.length; i++) {
applyOptions(instance, mixins[i], deferredData, deferredWatch, true);
}
}
function resolveData(instance, dataFn, publicThis) {
const data = dataFn.call(publicThis, publicThis);
if ( isPromise(data)) {
warn(`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)) {
warn(`data() should return an object.`);
}
else if (instance.data === EMPTY_OBJ) {
instance.data = reactive(data);
}
else {
// existing data: this is a mixin or extends.
extend(instance.data, data);
}
}
function createWatcher(raw, ctx, publicThis, key) {
const getter = () => publicThis[key];
if (isString(raw)) {
const handler = ctx[raw];
if (isFunction(handler)) {
watch(getter, handler);
}
else {
warn(`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 {
watch(getter, raw.handler.bind(publicThis), raw);
}
}
else {
warn(`Invalid watch option: "${key}"`);
}
}
function resolveMergedOptions(instance) {
const raw = instance.type;
const { __merged, mixins, extends: extendsOptions } = raw;
if (__merged)
return __merged;
const globalMixins = instance.appContext.mixins;
if (!globalMixins.length && !mixins && !extendsOptions)
return raw;
const options = {};
globalMixins.forEach(m => mergeOptions(options, m, instance));
extendsOptions && mergeOptions(options, extendsOptions, instance);
mixins && mixins.forEach(m => mergeOptions(options, m, instance));
mergeOptions(options, raw, instance);
return (raw.__merged = options);
}
function mergeOptions(to, from, instance) {
const strats = instance.appContext.config.optionMergeStrategies;
for (const key in from) {
const strat = strats && strats[key];
if (strat) {
to[key] = strat(to[key], from[key], instance.proxy, key);
}
else if (!hasOwn(to, key)) {
to[key] = from[key];
}
}
}
const publicPropertiesMap = {
$: i => i,
$el: i => i.vnode.el,
$data: i => i.data,
$props: i => ( shallowReadonly(i.props) ),
$attrs: i => ( shallowReadonly(i.attrs) ),
$slots: i => ( shallowReadonly(i.slots) ),
$refs: i => ( shallowReadonly(i.refs) ),
$parent: i => i.parent && i.parent.proxy,
$root: i => i.root && i.root.proxy,
$emit: i => i.emit,
$options: i => ( resolveMergedOptions(i) ),
$forceUpdate: i => () => queueJob(i.update),
$nextTick: () => nextTick,
$watch: i => instanceWatch.bind(i)
};
const PublicInstanceProxyHandlers = {
get({ _: instance }, key) {
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
// let @vue/reatvitiy know it should never observe Vue public instances.
if (key === "__v_skip" /* skip */) {
return true;
}
// data / props / ctx
// This getter gets called for every property access on the render context
// during render and is a major hotspot. The most expensive part of this
// is the multiple hasOwn() calls. It's much faster to do a simple property
// access on a plain object, so we use an accessCache object (with null
// prototype) to memoize what access type a key corresponds to.
if (key[0] !== '$') {
const n = accessCache[key];
if (n !== undefined) {
switch (n) {
case 0 /* SETUP */:
return setupState[key];
case 1 /* DATA */:
return data[key];
case 3 /* CONTEXT */:
return ctx[key];
case 2 /* PROPS */:
return props[key];
// default: just fallthrough
}
}
else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
accessCache[key] = 0 /* SETUP */;
return setupState[key];
}
else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
accessCache[key] = 1 /* DATA */;
return data[key];
}
else if (
// only cache other properties when instance has declared (thus stable)
// props
type.props &&
hasOwn(normalizePropsOptions(type)[0], key)) {
accessCache[key] = 2 /* PROPS */;
return props[key];
}
else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 3 /* CONTEXT */;
return ctx[key];
}
else {
accessCache[key] = 4 /* OTHER */;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
// public $xxx properties
if (publicGetter) {
if (key === '$attrs') {
track(instance, "get" /* GET */, key);
markAttrsAccessed();
}
return publicGetter(instance);
}
else if (
// css module (injected by vue-loader)
(cssModule = type.__cssModules) &&
(cssModule = cssModule[key])) {
return cssModule;
}
else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
// user may set custom properties to `this` that start with `$`
accessCache[key] = 3 /* CONTEXT */;
return ctx[key];
}
else if (
// global properties
((globalProperties = appContext.config.globalProperties),
hasOwn(globalProperties, key))) {
return globalProperties[key];
}
else if (
currentRenderingInstance &&
// #1091 avoid internal isRef/isVNode checks on component instance leading
// to infinite warning loop
key.indexOf('__v') !== 0) {
if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) {
warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +
`character and is not proxied on the render context.`);
}
else {
warn(`Property ${JSON.stringify(key)} was accessed during render ` +
`but is not defined on instance.`);
}
}
},
set({ _: instance }, key, value) {
const { data, setupState, ctx } = instance;
if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
setupState[key] = value;
}
else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
data[key] = value;
}
else if (key in instance.props) {
warn(`Attempting to mutate prop "${key}". Props are readonly.`, instance);
return false;
}
if (key[0] === '$' && key.slice(1) in instance) {
warn(`Attempting to mutate public property "${key}". ` +
`Properties starting with $ are reserved and readonly.`, instance);
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, type, appContext } }, key) {
return (accessCache[key] !== undefined ||
(data !== EMPTY_OBJ && hasOwn(data, key)) ||
(setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||
(type.props && hasOwn(normalizePropsOptions(type)[0], key)) ||
hasOwn(ctx, key) ||
hasOwn(publicPropertiesMap, key) ||
hasOwn(appContext.config.globalProperties, key));
}
};
{
PublicInstanceProxyHandlers.ownKeys = (target) => {
warn(`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);
};
}
const RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {
get(target, key) {
// fast path for unscopables when using `with` block
if (key === Symbol.unscopables) {
return;
}
return PublicInstanceProxyHandlers.get(target, key, target);
},
has(_, key) {
const has = key[0] !== '_' && !isGloballyWhitelisted(key);
if ( !has && PublicInstanceProxyHandlers.has(_, key)) {
warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);
}
return has;
}
});
// In dev mode, the proxy target exposes the same properties as seen on `this`
// for easier console inspection. In prod mode it will be an empty object so
// these properties definitions can be skipped.
function createRenderContext(instance) {
const target = {};
// expose internal instance for proxy handlers
Object.defineProperty(target, `_`, {
configurable: true,
enumerable: false,
get: () => instance
});
// expose public properties
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
});
});
// expose global properties
const { globalProperties } = instance.appContext.config;
Object.keys(globalProperties).forEach(key => {
Object.defineProperty(target, key, {
configurable: true,
enumerable: false,
get: () => globalProperties[key],
set: NOOP
});
});
return target;
}
// dev only
function exposePropsOnRenderContext(instance) {
const { ctx, type } = instance;
const propsOptions = normalizePropsOptions(type)[0];
if (propsOptions) {
Object.keys(propsOptions).forEach(key => {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => instance.props[key],
set: NOOP
});
});
}
}
// dev only
function exposeSetupStateOnRenderContext(instance) {
const { ctx, setupState } = instance;
Object.keys(toRaw(setupState)).forEach(key => {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => setupState[key],
set: NOOP
});
});
}
const emptyAppContext = createAppContext();
let uid$1 = 0;
function createComponentInstance(vnode, parent, suspense) {
// inherit parent app context - or - if root, adopt from root vnode
const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
const instance = {
uid: uid$1++,
vnode,
parent,
appContext,
type: vnode.type,
root: null,
next: null,
subTree: null,
update: null,
render: null,
proxy: null,
withProxy: null,
effects: null,
provides: parent ? parent.provides : Object.create(appContext.provides),
accessCache: null,
renderCache: [],
// state
ctx: EMPTY_OBJ,
data: EMPTY_OBJ,
props: EMPTY_OBJ,
attrs: EMPTY_OBJ,
slots: EMPTY_OBJ,
refs: EMPTY_OBJ,
setupState: EMPTY_OBJ,
setupContext: null,
// per-instance asset storage (mutable during options resolution)
components: Object.create(appContext.components),
directives: Object.create(appContext.directives),
// suspense related
suspense,
asyncDep: null,
asyncResolved: false,
// lifecycle hooks
// not using enums here because it results in computed properties
isMounted: false,
isUnmounted: false,
isDeactivated: false,
bc: null,
c: null,
bm: null,
m: null,
bu: null,
u: null,
um: null,
bum: null,
da: null,
a: null,
rtg: null,
rtc: null,
ec: null,
emit: null // to be set immediately
};
{
instance.ctx = createRenderContext(instance);
}
instance.root = parent ? parent.root : instance;
instance.emit = emit.bind(null, instance);
return instance;
}
let currentInstance = null;
const getCurrentInstance = () => currentInstance || currentRenderingInstance;
const setCurrentInstance = (instance) => {
currentInstance = instance;
};
const isBuiltInTag = /*#__PURE__*/ makeMap('slot,component');
function validateComponentName(name, config) {
const appIsNativeTag = config.isNativeTag || NO;
if (isBuiltInTag(name) || appIsNativeTag(name)) {
warn('Do not use built-in or reserved HTML elements as component id: ' + name);
}
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false) {
isInSSRComponentSetup = isSSR;
const { props, children, shapeFlag } = instance.vnode;
const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */;
initProps(instance, props, isStateful, isSSR);
initSlots(instance, children);
const setupResult = isStateful
? setupStatefulComponent(instance, isSSR)
: undefined;
isInSSRComponentSetup = false;
return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
const Component = instance.type;
{
if (Component.name) {
validateComponentName(Component.name, instance.appContext.config);
}
if (Component.components) {
const names = Object.keys(Component.components);
for (let i = 0; i < names.length; i++) {
validateComponentName(names[i], instance.appContext.config);
}
}
if (Component.directives) {
const names = Object.keys(Component.directives);
for (let i = 0; i < names.length; i++) {
validateDirectiveName(names[i]);
}
}
}
// 0. create render proxy property access cache
instance.accessCache = {};
// 1. create public instance / render proxy
// also mark it raw so it's never observed
instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
{
exposePropsOnRenderContext(instance);
}
// 2. call setup()
const { setup } = Component;
if (setup) {
const setupContext = (instance.setupContext =
setup.length > 1 ? createSetupContext(instance) : null);
currentInstance = instance;
pauseTracking();
const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [ shallowReadonly(instance.props) , setupContext]);
resetTracking();
currentInstance = null;
if (isPromise(setupResult)) {
if (isSSR) {
// return the promise so server-renderer can wait on it
return setupResult.then((resolvedResult) => {
handleSetupResult(instance, resolvedResult);
});
}
else {
// async setup returned Promise.
// bail here and wait for re-entry.
instance.asyncDep = setupResult;
}
}
else {
handleSetupResult(instance, setupResult);
}
}
else {
finishComponentSetup(instance);
}
}
function handleSetupResult(instance, setupResult, isSSR) {
if (isFunction(setupResult)) {
// setup returned an inline render function
instance.render = setupResult;
}
else if (isObject(setupResult)) {
if ( isVNode(setupResult)) {
warn(`setup() should not return VNodes directly - ` +
`return a render function instead.`);
}
// setup returned bindings.
// assuming a render function compiled from template is present.
instance.setupState = reactive(setupResult);
{
exposeSetupStateOnRenderContext(instance);
}
}
else if ( setupResult !== undefined) {
warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`);
}
finishComponentSetup(instance);
}
let compile$1;
/**
* For runtime-dom to register the compiler.
* Note the exported method uses any to avoid d.ts relying on the compiler types.
*/
function registerRuntimeCompiler(_compile) {
compile$1 = _compile;
}
function finishComponentSetup(instance, isSSR) {
const Component = instance.type;
// template / render function normalization
if (!instance.render) {
if (compile$1 && Component.template && !Component.render) {
{
startMeasure(instance, `compile`);
}
Component.render = compile$1(Component.template, {
isCustomElement: instance.appContext.config.isCustomElement || NO
});
{
endMeasure(instance, `compile`);
}
Component.render._rc = true;
}
if ( !Component.render) {
/* istanbul ignore if */
if (!compile$1 && Component.template) {
warn(`Component provided template option but ` +
`runtime compilation is not supported in this build of Vue.` +
( ` Use "vue.global.js" instead.`
) /* should not happen */);
}
else {
warn(`Component is missing template or render function.`);
}
}
instance.render = (Component.render || NOOP);
// for runtime-compiled render functions using `with` blocks, the render
// proxy used needs a different `has` handler which is more performant and
// also only allows a whitelist of globals to fallthrough.
if (instance.render._rc) {
instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
}
}
// support for 2.x options
{
currentInstance = instance;
applyOptions(instance, Component);
currentInstance = null;
}
}
const attrHandlers = {
get: (target, key) => {
{
markAttrsAccessed();
}
return target[key];
},
set: () => {
warn(`setupContext.attrs is readonly.`);
return false;
},
deleteProperty: () => {
warn(`setupContext.attrs is readonly.`);
return false;
}
};
function createSetupContext(instance) {
{
// We use getters in dev in case libs like test-utils overwrite instance
// properties (overwrites should not be done in prod)
return Object.freeze({
get attrs() {
return new Proxy(instance.attrs, attrHandlers);
},
get slots() {
return shallowReadonly(instance.slots);
},
get emit() {
return (event, ...args) => instance.emit(event, ...args);
}
});
}
}
// record effects created during a component's setup() so that they can be
// stopped when the component unmounts
function recordInstanceBoundEffect(effect) {
if (currentInstance) {
(currentInstance.effects || (currentInstance.effects = [])).push(effect);
}
}
const classifyRE = /(?:^|[-_])(\w)/g;
const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');
function formatComponentName(Component, isRoot = false) {
let name = isFunction(Component)
? Component.displayName || Component.name
: Component.name;
if (!name && Component.__file) {
const match = Component.__file.match(/([^/\\]+)\.vue$/);
if (match) {
name = match[1];
}
}
return name ? classify(name) : isRoot ? `App` : `Anonymous`;
}
function computed$1(getterOrOptions) {
const c = computed(getterOrOptions);
recordInstanceBoundEffect(c.effect);
return c;
}
// implementation, close to no-op
function defineComponent(options) {
return isFunction(options) ? { setup: options } : options;
}
function defineAsyncComponent(source) {
if (isFunction(source)) {
source = { loader: source };
}
const { loader, loadingComponent: loadingComponent, errorComponent: 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((resolve, reject) => {
const userRetry = () => resolve(retry());
const userFail = () => reject(err);
userOnError(err, userRetry, userFail, retries + 1);
});
}
else {
throw err;
}
})
.then((comp) => {
if (thisRequest !== pendingRequest && pendingRequest) {
return pendingRequest;
}
if ( !comp) {
warn(`Async component loader resolved to undefined. ` +
`If you are using retry(), make sure to return its return value.`);
}
// interop module default
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({
__asyncLoader: load,
name: 'AsyncComponentWrapper',
setup() {
const instance = currentInstance;
// already resolved
if (resolvedComp) {
return () => createInnerComp(resolvedComp, instance);
}
const onError = (err) => {
pendingRequest = null;
handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */);
};
// suspense-controlled or SSR.
if (( suspensible && instance.suspense) ||
(false )) {
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) {
const err = new Error(`Async component timed out after ${timeout}ms.`);
onError(err);
error.value = err;
}
}, timeout);
}
load()
.then(() => {
loaded.value = true;
})
.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, { vnode: { props, children } }) {
return createVNode(comp, props, children);
}
// Actual implementation
function h(type, propsOrChildren, children) {
if (arguments.length === 2) {
if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
// single vnode without props
if (isVNode(propsOrChildren)) {
return createVNode(type, null, [propsOrChildren]);
}
// props without children
return createVNode(type, propsOrChildren);
}
else {
// omit props
return createVNode(type, null, propsOrChildren);
}
}
else {
if (isVNode(children)) {
children = [children];
}
return createVNode(type, propsOrChildren, children);
}
}
const useCSSModule = (name = '$style') => {
{
{
warn(`useCSSModule() is not supported in the global build.`);
}
return EMPTY_OBJ;
}
};
const ssrContextKey = Symbol( `ssrContext` );
const useSSRContext = () => {
{
warn(`useSsrContext() is not supported in the global build.`);
}
};
/**
* Actual implementation
*/
function renderList(source, renderItem) {
let ret;
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);
}
}
else if (typeof source === 'number') {
ret = new Array(source);
for (let i = 0; i < source; i++) {
ret[i] = renderItem(i + 1, i);
}
}
else if (isObject(source)) {
if (source[Symbol.iterator]) {
ret = Array.from(source, renderItem);
}
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);
}
}
}
else {
ret = [];
}
return ret;
}
/**
* For prefixing keys in v-on="obj" with "on"
* @private
*/
function toHandlers(obj) {
const ret = {};
if ( !isObject(obj)) {
warn(`v-on with no argument expects an object value.`);
return ret;
}
for (const key in obj) {
ret[`on${key}`] = obj[key];
}
return ret;
}
/**
* Compiler runtime helper for rendering <slot/>
* @private
*/
function renderSlot(slots, name, props = {},
// this is not a user-facing function, so the fallback is always generated by
// the compiler and guaranteed to be a function returning an array
fallback) {
let slot = slots[name];
if ( slot && slot.length > 1) {
warn(`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 = () => [];
}
return (openBlock(),
createBlock(Fragment, { key: props.key }, slot ? slot(props) : fallback ? fallback() : [], slots._ ? 64 /* STABLE_FRAGMENT */ : -2 /* BAIL */));
}
/**
* Compiler runtime helper for creating dynamic slots object
* @private
*/
function createSlots(slots, dynamicSlots) {
for (let i = 0; i < dynamicSlots.length; i++) {
const slot = dynamicSlots[i];
// array of dynamic slot generated by <template v-for="..." #[...]>
if (isArray(slot)) {
for (let j = 0; j < slot.length; j++) {
slots[slot[j].name] = slot[j].fn;
}
}
else if (slot) {
// conditional single slot generated by <template v-if="..." #foo>
slots[slot.name] = slot.fn;
}
}
return slots;
}
// Core API ------------------------------------------------------------------
const version = "3.0.0-beta.15";
/**
* @private
*/
const _toDisplayString = toDisplayString;
/**
* @private
*/
const _camelize = camelize;
/**
* SSR utils for \@vue/server-renderer. Only exposed in cjs builds.
* @internal
*/
const ssrUtils = ( null);
const svgNS = 'http://www.w3.org/2000/svg';
const doc = (typeof document !== 'undefined' ? document : null);
let tempContainer;
let tempSVGContainer;
const nodeOps = {
insert: (child, parent, anchor) => {
if (anchor) {
parent.insertBefore(child, anchor);
}
else {
parent.appendChild(child);
}
},
remove: child => {
const parent = child.parentNode;
if (parent) {
parent.removeChild(child);
}
},
createElement: (tag, isSVG, is) => isSVG
? doc.createElementNS(svgNS, tag)
: doc.createElement(tag, is ? { is } : undefined),
createText: text => doc.createTextNode(text),
createComment: text => doc.createComment(text),
setText: (node, text) => {
node.nodeValue = text;
},
setElementText: (el, text) => {
el.textContent = text;
},
parentNode: node => node.parentNode,
nextSibling: node => node.nextSibling,
querySelector: selector => doc.querySelector(selector),
setScopeId(el, id) {
el.setAttribute(id, '');
},
cloneNode(el) {
return el.cloneNode(true);
},
// __UNSAFE__
// Reason: innerHTML.
// Static content here can only come from compiled templates.
// As long as the user only uses trusted templates, this is safe.
insertStaticContent(content, parent, anchor, isSVG) {
const temp = isSVG
? tempSVGContainer ||
(tempSVGContainer = doc.createElementNS(svgNS, 'svg'))
: tempContainer || (tempContainer = doc.createElement('div'));
temp.innerHTML = content;
const first = temp.firstChild;
let node = first;
let last = node;
while (node) {
last = node;
nodeOps.insert(node, parent, anchor);
node = temp.firstChild;
}
return [first, last];
}
};
// compiler should normalize class + :class bindings on the same element
// into a single binding ['staticClass', dynamic]
function patchClass(el, value, isSVG) {
if (value == null) {
value = '';
}
if (isSVG) {
el.setAttribute('class', value);
}
else {
// directly setting className should be faster than setAttribute in theory
// if this is an element during a transition, take the temporary transition
// classes into account.
const transitionClasses = el._vtc;
if (transitionClasses) {
value = (value
? [value, ...transitionClasses]
: [...transitionClasses]).join(' ');
}
el.className = value;
}
}
function patchStyle(el, prev, next) {
const style = el.style;
if (!next) {
el.removeAttribute('style');
}
else if (isString(next)) {
if (prev !== next) {
style.cssText = next;
}
}
else {
for (const key in next) {
setStyle(style, key, next[key]);
}
if (prev && !isString(prev)) {
for (const key in prev) {
if (!next[key]) {
setStyle(style, key, '');
}
}
}
}
}
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
if (name.startsWith('--')) {
// custom property definition
style.setProperty(name, val);
}
else {
const prefixed = autoPrefix(style, name);
if (importantRE.test(val)) {
// !important
style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');
}
else {
style[prefixed] = val;
}
}
}
const prefixes = ['Webkit', 'Moz', 'ms'];
const prefixCache = {};
function autoPrefix(style, rawName) {
const cached = prefixCache[rawName];
if (cached) {
return cached;
}
let name = _camelize(rawName);
if (name !== 'filter' && name in style) {
return (prefixCache[rawName] = name);
}
name = capitalize(name);
for (let i = 0; i < prefixes.length; i++) {
const prefixed = prefixes[i] + name;
if (prefixed in style) {
return (prefixCache[rawName] = prefixed);
}
}
return rawName;
}
const xlinkNS = 'http://www.w3.org/1999/xlink';
function patchAttr(el, key, value, isSVG) {
if (isSVG && key.startsWith('xlink:')) {
if (value == null) {
el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
}
else {
el.setAttributeNS(xlinkNS, key, value);
}
}
else {
// note we are only checking boolean attributes that don't have a
// corresponding dom prop of the same name here.
const isBoolean = isSpecialBooleanAttr(key);
if (value == null || (isBoolean && value === false)) {
el.removeAttribute(key);
}
else {
el.setAttribute(key, isBoolean ? '' : value);
}
}
}
// __UNSAFE__
// functions. The user is reponsible for using them with only trusted content.
function patchDOMProp(el, key, value,
// the following args are passed only due to potential innerHTML/textContent
// overriding existing VNodes, in which case the old tree must be properly
// unmounted.
prevChildren, parentComponent, parentSuspense, unmountChildren) {
if (key === 'innerHTML' || key === 'textContent') {
if (prevChildren) {
unmountChildren(prevChildren, parentComponent, parentSuspense);
}
el[key] = value == null ? '' : value;
return;
}
if (key === 'value' && el.tagName !== 'PROGRESS') {
// store value as _value as well since
// non-string values will be stringified.
el._value = value;
el.value = value == null ? '' : value;
return;
}
if (value === '' && typeof el[key] === 'boolean') {
// e.g. <select multiple> compiles to { multiple: '' }
el[key] = true;
}
else if (value == null && typeof el[key] === 'string') {
// e.g. <div :id="null">
el[key] = '';
}
else {
// some properties perform value validation and throw
try {
el[key] = value;
}
catch (e) {
{
warn(`Failed setting prop "${key}" on <${el.tagName.toLowerCase()}>: ` +
`value ${value} is invalid.`, e);
}
}
}
}
// Async edge case fix requires storing an event listener's attach timestamp.
let _getNow = Date.now;
// Determine what event timestamp the browser is using. Annoyingly, the
// timestamp can either be hi-res (relative to page load) or low-res
// (relative to UNIX epoch), so in order to compare time we have to use the
// same timestamp type when saving the flush timestamp.
if (typeof document !== 'undefined' &&
_getNow() > document.createEvent('Event').timeStamp) {
// if the low-res timestamp which is bigger than the event timestamp
// (which is evaluated AFTER) it means the event is using a hi-res timestamp,
// and we need to use the hi-res version for event listeners as well.
_getNow = () => performance.now();
}
// To avoid the overhead of repeatedly calling performance.now(), we cache
// and use the same timestamp for all event listeners attached in the same tick.
let cachedNow = 0;
const p$1 = Promise.resolve();
const reset = () => {
cachedNow = 0;
};
const getNow = () => cachedNow || (p$1.then(reset), (cachedNow = _getNow()));
function addEventListener(el, event, handler, options) {
el.addEventListener(event, handler, options);
}
function removeEventListener(el, event, handler, options) {
el.removeEventListener(event, handler, options);
}
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
const name = rawName.slice(2).toLowerCase();
const prevOptions = prevValue && 'options' in prevValue && prevValue.options;
const nextOptions = nextValue && 'options' in nextValue && nextValue.options;
const invoker = prevValue && prevValue.invoker;
const value = nextValue && 'handler' in nextValue ? nextValue.handler : nextValue;
if (prevOptions || nextOptions) {
const prev = prevOptions || EMPTY_OBJ;
const next = nextOptions || EMPTY_OBJ;
if (prev.capture !== next.capture ||
prev.passive !== next.passive ||
prev.once !== next.once) {
if (invoker) {
removeEventListener(el, name, invoker, prev);
}
if (nextValue && value) {
const invoker = createInvoker(value, instance);
nextValue.invoker = invoker;
addEventListener(el, name, invoker, next);
}
return;
}
}
if (nextValue && value) {
if (invoker) {
prevValue.invoker = null;
invoker.value = value;
nextValue.invoker = invoker;
invoker.lastUpdated = getNow();
}
else {
addEventListener(el, name, createInvoker(value, instance), nextOptions || void 0);
}
}
else if (invoker) {
removeEventListener(el, name, invoker, prevOptions || void 0);
}
}
function createInvoker(initialValue, instance) {
const invoker = (e) => {
// async edge case #6566: inner click event triggers patch, event handler
// attached to outer element during patch, and triggered again. This
// happens because browsers fire microtask ticks between event propagation.
// the solution is simple: we save the timestamp when a handler is attached,
// and the handler would only fire if the event passed to it was fired
// AFTER it was attached.
const timeStamp = e.timeStamp || _getNow();
if (timeStamp >= invoker.lastUpdated - 1) {
callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);
}
};
invoker.value = initialValue;
initialValue.invoker = invoker;
invoker.lastUpdated = getNow();
return invoker;
}
function patchStopImmediatePropagation(e, value) {
if (isArray(value)) {
const originalStop = e.stopImmediatePropagation;
e.stopImmediatePropagation = () => {
originalStop.call(e);
e._stopped = true;
};
return value.map(fn => (e) => !e._stopped && fn(e));
}
else {
return value;
}
}
const nativeOnRE = /^on[a-z]/;
const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
switch (key) {
// special
case 'class':
patchClass(el, nextValue, isSVG);
break;
case 'style':
patchStyle(el, prevValue, nextValue);
break;
default:
if (isOn(key)) {
// ignore v-model listeners
if (!key.startsWith('onUpdate:')) {
patchEvent(el, key, prevValue, nextValue, parentComponent);
}
}
else if (
// spellcheck and draggable are numerated attrs, however their
// corresponding DOM properties are actually booleans - this leads to
// setting it with a string "false" value leading it to be coerced to
// `true`, so we need to always treat them as attributes.
// Note that `contentEditable` doesn't have this problem: its DOM
// property is also enumerated string values.
key !== 'spellcheck' &&
key !== 'draggable' &&
(isSVG
? // most keys must be set as attribute on svg elements to work
// ...except innerHTML
key === 'innerHTML' ||
// or native onclick with function values
(key in el && nativeOnRE.test(key) && isFunction(nextValue))
: // for normal html elements, set as a property if it exists
key in el &&
// except native onclick with string values
!(nativeOnRE.test(key) && isString(nextValue)))) {
patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);
}
else {
// special case for <input v-model type="checkbox"> with
// :true-value & :false-value
// store value as dom properties since non-string values will be
// stringified.
if (key === 'true-value') {
el._trueValue = nextValue;
}
else if (key === 'false-value') {
el._falseValue = nextValue;
}
patchAttr(el, key, nextValue, isSVG);
}
break;
}
};
const TRANSITION$1 = 'transition';
const ANIMATION = 'animation';
// DOM Transition is a higher-order-component based on the platform-agnostic
// base Transition component, with DOM-specific logic.
const Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);
Transition.inheritRef = true;
const DOMTransitionPropsValidators = {
name: String,
type: String,
css: {
type: Boolean,
default: true
},
duration: [String, Number, Object],
enterFromClass: String,
enterActiveClass: String,
enterToClass: String,
appearFromClass: String,
appearActiveClass: String,
appearToClass: String,
leaveFromClass: String,
leaveActiveClass: String,
leaveToClass: String
};
const TransitionPropsValidators = (Transition.props = extend({}, BaseTransition.props, DOMTransitionPropsValidators));
function resolveTransitionProps(rawProps) {
let { name = 'v', type, css = true, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;
const baseProps = {};
for (const key in rawProps) {
if (!(key in DOMTransitionPropsValidators)) {
baseProps[key] = rawProps[key];
}
}
if (!css) {
return baseProps;
}
const originEnterClass = [enterFromClass, enterActiveClass, enterToClass];
const instance = getCurrentInstance();
const durations = normalizeDuration(duration);
const enterDuration = durations && durations[0];
const leaveDuration = durations && durations[1];
const { appear, onBeforeEnter, onEnter, onLeave } = baseProps;
// is appearing
if (appear && !instance.isMounted) {
enterFromClass = appearFromClass;
enterActiveClass = appearActiveClass;
enterToClass = appearToClass;
}
const finishEnter = (el, done) => {
removeTransitionClass(el, enterToClass);
removeTransitionClass(el, enterActiveClass);
done && done();
// reset enter class
if (appear) {
[enterFromClass, enterActiveClass, enterToClass] = originEnterClass;
}
};
const finishLeave = (el, done) => {
removeTransitionClass(el, leaveToClass);
removeTransitionClass(el, leaveActiveClass);
done && done();
};
// only needed for user hooks called in nextFrame
// sync errors are already handled by BaseTransition
function callHookWithErrorHandling(hook, args) {
callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);
}
return extend(baseProps, {
onBeforeEnter(el) {
onBeforeEnter && onBeforeEnter(el);
addTransitionClass(el, enterActiveClass);
addTransitionClass(el, enterFromClass);
},
onEnter(el, done) {
nextFrame(() => {
const resolve = () => finishEnter(el, done);
onEnter && callHookWithErrorHandling(onEnter, [el, resolve]);
removeTransitionClass(el, enterFromClass);
addTransitionClass(el, enterToClass);
if (!(onEnter && onEnter.length > 1)) {
if (enterDuration) {
setTimeout(resolve, enterDuration);
}
else {
whenTransitionEnds(el, type, resolve);
}
}
});
},
onLeave(el, done) {
addTransitionClass(el, leaveActiveClass);
addTransitionClass(el, leaveFromClass);
nextFrame(() => {
const resolve = () => finishLeave(el, done);
onLeave && callHookWithErrorHandling(onLeave, [el, resolve]);
removeTransitionClass(el, leaveFromClass);
addTransitionClass(el, leaveToClass);
if (!(onLeave && onLeave.length > 1)) {
if (leaveDuration) {
setTimeout(resolve, leaveDuration);
}
else {
whenTransitionEnds(el, type, resolve);
}
}
});
},
onEnterCancelled: finishEnter,
onLeaveCancelled: finishLeave
});
}
function normalizeDuration(duration) {
if (duration == null) {
return null;
}
else if (isObject(duration)) {
return [NumberOf(duration.enter), NumberOf(duration.leave)];
}
else {
const n = NumberOf(duration);
return [n, n];
}
}
function NumberOf(val) {
const res = toNumber(val);
validateDuration(res);
return res;
}
function validateDuration(val) {
if (typeof val !== 'number') {
warn(`<transition> explicit duration is not a valid number - ` +
`got ${JSON.stringify(val)}.`);
}
else if (isNaN(val)) {
warn(`<transition> explicit duration is NaN - ` +
'the duration expression might be incorrect.');
}
}
function addTransitionClass(el, cls) {
cls.split(/\s+/).forEach(c => c && el.classList.add(c));
(el._vtc ||
(el._vtc = new Set())).add(cls);
}
function removeTransitionClass(el, cls) {
cls.split(/\s+/).forEach(c => c && el.classList.remove(c));
const { _vtc } = el;
if (_vtc) {
_vtc.delete(cls);
if (!_vtc.size) {
el._vtc = undefined;
}
}
}
function nextFrame(cb) {
requestAnimationFrame(() => {
requestAnimationFrame(cb);
});
}
function whenTransitionEnds(el, expectedType, cb) {
const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
if (!type) {
return cb();
}
const endEvent = type + 'end';
let ended = 0;
const end = () => {
el.removeEventListener(endEvent, onEnd);
cb();
};
const onEnd = (e) => {
if (e.target === el) {
if (++ended >= propCount) {
end();
}
}
};
setTimeout(() => {
if (ended < propCount) {
end();
}
}, timeout + 1);
el.addEventListener(endEvent, onEnd);
}
function getTransitionInfo(el, expectedType) {
const styles = window.getComputedStyle(el);
// JSDOM may return undefined for transition properties
const getStyleProperties = (key) => (styles[key] || '').split(', ');
const transitionDelays = getStyleProperties(TRANSITION$1 + 'Delay');
const transitionDurations = getStyleProperties(TRANSITION$1 + 'Duration');
const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
const animationDelays = getStyleProperties(ANIMATION + 'Delay');
const animationDurations = getStyleProperties(ANIMATION + 'Duration');
const animationTimeout = getTimeout(animationDelays, animationDurations);
let type = null;
let timeout = 0;
let propCount = 0;
/* istanbul ignore if */
if (expectedType === TRANSITION$1) {
if (transitionTimeout > 0) {
type = TRANSITION$1;
timeout = transitionTimeout;
propCount = transitionDurations.length;
}
}
else if (expectedType === ANIMATION) {
if (animationTimeout > 0) {
type = ANIMATION;
timeout = animationTimeout;
propCount = animationDurations.length;
}
}
else {
timeout = Math.max(transitionTimeout, animationTimeout);
type =
timeout > 0
? transitionTimeout > animationTimeout
? TRANSITION$1
: ANIMATION
: null;
propCount = type
? type === TRANSITION$1
? transitionDurations.length
: animationDurations.length
: 0;
}
const hasTransform = type === TRANSITION$1 &&
/\b(transform|all)(,|$)/.test(styles[TRANSITION$1 + 'Property']);
return {
type,
timeout,
propCount,
hasTransform
};
}
function getTimeout(delays, durations) {
while (delays.length < durations.length) {
delays = delays.concat(delays);
}
return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
}
// Old versions of Chromium (below 61.0.3163.100) formats floating pointer
// numbers in a locale-dependent way, using a comma instead of a dot.
// If comma is not replaced with a dot, the input will be rounded down
// (i.e. acting as a floor function) causing unexpected behaviors
function toMs(s) {
return Number(s.slice(0, -1).replace(',', '.')) * 1000;
}
const positionMap = new WeakMap();
const newPositionMap = new WeakMap();
const TransitionGroupImpl = {
props: extend({}, TransitionPropsValidators, {
tag: String,
moveClass: String
}),
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
let prevChildren;
let children;
let hasMove = null;
onUpdated(() => {
// children is guaranteed to exist after initial render
if (!prevChildren.length) {
return;
}
const moveClass = props.moveClass || `${props.name || 'v'}-move`;
// Check if move transition is needed. This check is cached per-instance.
hasMove =
hasMove === null
? (hasMove = hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass))
: hasMove;
if (!hasMove) {
return;
}
// we divide the work into three loops to avoid mixing DOM reads and writes
// in each iteration - which helps prevent layout thrashing.
prevChildren.forEach(callPendingCbs);
prevChildren.forEach(recordPosition);
const movedChildren = prevChildren.filter(applyTranslation);
// force reflow to put everything in position
forceReflow();
movedChildren.forEach(c => {
const el = c.el;
const style = el.style;
addTransitionClass(el, moveClass);
style.transform = style.webkitTransform = style.transitionDuration = '';
const cb = (el._moveCb = (e) => {
if (e && e.target !== el) {
return;
}
if (!e || /transform$/.test(e.propertyName)) {
el.removeEventListener('transitionend', cb);
el._moveCb = null;
removeTransitionClass(el, moveClass);
}
});
el.addEventListener('transitionend', cb);
});
});
return () => {
const rawProps = toRaw(props);
const cssTransitionProps = resolveTransitionProps(rawProps);
const tag = rawProps.tag || Fragment;
prevChildren = children;
const slotChildren = slots.default ? slots.default() : [];
children = getTransitionRawChildren(slotChildren);
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.key != null) {
setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));
}
else {
warn(`<TransitionGroup> children must be keyed.`);
}
}
if (prevChildren) {
for (let i = 0; i < prevChildren.length; i++) {
const child = prevChildren[i];
setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));
positionMap.set(child, child.el.getBoundingClientRect());
}
}
return createVNode(tag, null, slotChildren);
};
}
};
function getTransitionRawChildren(children) {
let ret = [];
for (let i = 0; i < children.length; i++) {
const child = children[i];
// handle fragment children case, e.g. v-for
if (child.type === Fragment) {
ret = ret.concat(getTransitionRawChildren(child.children));
}
// comment placeholders should be skipped, e.g. v-if
else if (child.type !== Comment) {
ret.push(child);
}
}
return ret;
}
// remove mode props as TransitionGroup doesn't support it
delete TransitionGroupImpl.props.mode;
const TransitionGroup = TransitionGroupImpl;
function callPendingCbs(c) {
const el = c.el;
if (el._moveCb) {
el._moveCb();
}
if (el._enterCb) {
el._enterCb();
}
}
function recordPosition(c) {
newPositionMap.set(c, c.el.getBoundingClientRect());
}
function applyTranslation(c) {
const oldPos = positionMap.get(c);
const newPos = newPositionMap.get(c);
const dx = oldPos.left - newPos.left;
const dy = oldPos.top - newPos.top;
if (dx || dy) {
const s = c.el.style;
s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
s.transitionDuration = '0s';
return c;
}
}
// this is put in a dedicated function to avoid the line from being treeshaken
function forceReflow() {
return document.body.offsetHeight;
}
function hasCSSTransform(el, root, moveClass) {
// Detect whether an element with the move class applied has
// CSS transitions. Since the element may be inside an entering
// transition at this very moment, we make a clone of it and remove
// all other transition classes applied to ensure only the move class
// is applied.
const clone = el.cloneNode();
if (el._vtc) {
el._vtc.forEach(cls => {
cls.split(/\s+/).forEach(c => c && clone.classList.remove(c));
});
}
moveClass.split(/\s+/).forEach(c => c && clone.classList.add(c));
clone.style.display = 'none';
const container = (root.nodeType === 1
? root
: root.parentNode);
container.appendChild(clone);
const { hasTransform } = getTransitionInfo(clone);
container.removeChild(clone);
return hasTransform;
}
const getModelAssigner = (vnode) => {
const fn = vnode.props['onUpdate:modelValue'];
return isArray(fn) ? value => invokeArrayFns(fn, value) : fn;
};
function onCompositionStart(e) {
e.target.composing = true;
}
function onCompositionEnd(e) {
const target = e.target;
if (target.composing) {
target.composing = false;
trigger$1(target, 'input');
}
}
function trigger$1(el, type) {
const e = document.createEvent('HTMLEvents');
e.initEvent(type, true, true);
el.dispatchEvent(e);
}
// We are exporting the v-model runtime directly as vnode hooks so that it can
// be tree-shaken in case v-model is never used.
const vModelText = {
beforeMount(el, { value, modifiers: { lazy, trim, number } }, vnode) {
el.value = value;
el._assign = getModelAssigner(vnode);
const castToNumber = number || el.type === 'number';
addEventListener(el, lazy ? 'change' : 'input', e => {
if (e.target.composing)
return;
let domValue = el.value;
if (trim) {
domValue = domValue.trim();
}
else if (castToNumber) {
domValue = toNumber(domValue);
}
el._assign(domValue);
});
if (trim) {
addEventListener(el, 'change', () => {
el.value = el.value.trim();
});
}
if (!lazy) {
addEventListener(el, 'compositionstart', onCompositionStart);
addEventListener(el, 'compositionend', onCompositionEnd);
// Safari < 10.2 & UIWebView doesn't fire compositionend when
// switching focus before confirming composition choice
// this also fixes the issue where some browsers e.g. iOS Chrome
// fires "change" instead of "input" on autocomplete.
addEventListener(el, 'change', onCompositionEnd);
}
},
beforeUpdate(el, { value, oldValue, modifiers: { trim, number } }, vnode) {
el._assign = getModelAssigner(vnode);
if (value === oldValue) {
return;
}
if (document.activeElement === el) {
if (trim && el.value.trim() === value) {
return;
}
if ((number || el.type === 'number') && toNumber(el.value) === value) {
return;
}
}
el.value = value;
}
};
const vModelCheckbox = {
beforeMount(el, binding, vnode) {
setChecked(el, binding, vnode);
el._assign = getModelAssigner(vnode);
addEventListener(el, 'change', () => {
const modelValue = el._modelValue;
const elementValue = getValue(el);
const checked = el.checked;
const assign = el._assign;
if (isArray(modelValue)) {
const index = looseIndexOf(modelValue, elementValue);
const found = index !== -1;
if (checked && !found) {
assign(modelValue.concat(elementValue));
}
else if (!checked && found) {
const filtered = [...modelValue];
filtered.splice(index, 1);
assign(filtered);
}
}
else {
assign(getCheckboxValue(el, checked));
}
});
},
beforeUpdate(el, binding, vnode) {
el._assign = getModelAssigner(vnode);
setChecked(el, binding, vnode);
}
};
function setChecked(el, { value, oldValue }, vnode) {
el._modelValue = value;
if (isArray(value)) {
el.checked = looseIndexOf(value, vnode.props.value) > -1;
}
else if (value !== oldValue) {
el.checked = looseEqual(value, getCheckboxValue(el, true));
}
}
const vModelRadio = {
beforeMount(el, { value }, vnode) {
el.checked = looseEqual(value, vnode.props.value);
el._assign = getModelAssigner(vnode);
addEventListener(el, 'change', () => {
el._assign(getValue(el));
});
},
beforeUpdate(el, { value, oldValue }, vnode) {
el._assign = getModelAssigner(vnode);
if (value !== oldValue) {
el.checked = looseEqual(value, vnode.props.value);
}
}
};
const vModelSelect = {
// use mounted & updated because <select> relies on its children <option>s.
mounted(el, { value }, vnode) {
setSelected(el, value);
el._assign = getModelAssigner(vnode);
addEventListener(el, 'change', () => {
const selectedVal = Array.prototype.filter
.call(el.options, (o) => o.selected)
.map(getValue);
el._assign(el.multiple ? selectedVal : selectedVal[0]);
});
},
beforeUpdate(el, _binding, vnode) {
el._assign = getModelAssigner(vnode);
},
updated(el, { value }) {
setSelected(el, value);
}
};
function setSelected(el, value) {
const isMultiple = el.multiple;
if (isMultiple && !isArray(value)) {
warn(`<select multiple v-model> expects an Array value for its binding, ` +
`but got ${Object.prototype.toString.call(value).slice(8, -1)}.`);
return;
}
for (let i = 0, l = el.options.length; i < l; i++) {
const option = el.options[i];
const optionValue = getValue(option);
if (isMultiple) {
option.selected = looseIndexOf(value, optionValue) > -1;
}
else {
if (looseEqual(getValue(option), value)) {
el.selectedIndex = i;
return;
}
}
}
if (!isMultiple) {
el.selectedIndex = -1;
}
}
// retrieve raw value set via :value bindings
function getValue(el) {
return '_value' in el ? el._value : el.value;
}
// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings
function getCheckboxValue(el, checked) {
const key = checked ? '_trueValue' : '_falseValue';
return key in el ? el[key] : checked;
}
const vModelDynamic = {
beforeMount(el, binding, vnode) {
callModelHook(el, binding, vnode, null, 'beforeMount');
},
mounted(el, binding, vnode) {
callModelHook(el, binding, vnode, null, 'mounted');
},
beforeUpdate(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate');
},
updated(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, 'updated');
}
};
function callModelHook(el, binding, vnode, prevVNode, hook) {
let modelToUse;
switch (el.tagName) {
case 'SELECT':
modelToUse = vModelSelect;
break;
case 'TEXTAREA':
modelToUse = vModelText;
break;
default:
switch (el.type) {
case 'checkbox':
modelToUse = vModelCheckbox;
break;
case 'radio':
modelToUse = vModelRadio;
break;
default:
modelToUse = vModelText;
}
}
const fn = modelToUse[hook];
fn && fn(el, binding, vnode, prevVNode);
}
const systemModifiers = ['ctrl', 'shift', 'alt', 'meta'];
const modifierGuards = {
stop: e => e.stopPropagation(),
prevent: e => e.preventDefault(),
self: e => e.target !== e.currentTarget,
ctrl: e => !e.ctrlKey,
shift: e => !e.shiftKey,
alt: e => !e.altKey,
meta: e => !e.metaKey,
left: e => 'button' in e && e.button !== 0,
middle: e => 'button' in e && e.button !== 1,
right: e => 'button' in e && e.button !== 2,
exact: (e, modifiers) => systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m))
};
/**
* @private
*/
const withModifiers = (fn, modifiers) => {
return (event, ...args) => {
for (let i = 0; i < modifiers.length; i++) {
const guard = modifierGuards[modifiers[i]];
if (guard && guard(event, modifiers))
return;
}
return fn(event, ...args);
};
};
// Kept for 2.x compat.
// Note: IE11 compat for `spacebar` and `del` is removed for now.
const keyNames = {
esc: 'escape',
space: ' ',
up: 'arrow-up',
left: 'arrow-left',
right: 'arrow-right',
down: 'arrow-down',
delete: 'backspace'
};
/**
* @private
*/
const withKeys = (fn, modifiers) => {
return (event) => {
if (!('key' in event))
return;
const eventKey = hyphenate(event.key);
if (
// None of the provided key modifiers match the current event key
!modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) {
return;
}
return fn(event);
};
};
const vShow = {
beforeMount(el, { value }, { transition }) {
el._vod = el.style.display === 'none' ? '' : el.style.display;
if (transition && value) {
transition.beforeEnter(el);
}
else {
setDisplay(el, value);
}
},
mounted(el, { value }, { transition }) {
if (transition && value) {
transition.enter(el);
}
},
updated(el, { value, oldValue }, { transition }) {
if (!value === !oldValue)
return;
if (transition) {
if (value) {
transition.beforeEnter(el);
setDisplay(el, true);
transition.enter(el);
}
else {
transition.leave(el, () => {
setDisplay(el, false);
});
}
}
else {
setDisplay(el, value);
}
},
beforeUnmount(el) {
setDisplay(el, true);
}
};
function setDisplay(el, value) {
el.style.display = value ? el._vod : 'none';
}
const rendererOptions = extend({ patchProp }, nodeOps);
// lazy create the renderer - this makes core renderer logic tree-shakable
// in case the user only imports reactivity utilities from Vue.
let renderer;
let enabledHydration = false;
function ensureRenderer() {
return renderer || (renderer = createRenderer(rendererOptions));
}
function ensureHydrationRenderer() {
renderer = enabledHydration
? renderer
: createHydrationRenderer(rendererOptions);
enabledHydration = true;
return renderer;
}
// use explicit type casts here to avoid import() calls in rolled-up d.ts
const render = ((...args) => {
ensureRenderer().render(...args);
});
const hydrate = ((...args) => {
ensureHydrationRenderer().hydrate(...args);
});
const createApp = ((...args) => {
const app = ensureRenderer().createApp(...args);
{
injectNativeTagCheck(app);
}
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (!container)
return;
const component = app._component;
if (!isFunction(component) && !component.render && !component.template) {
component.template = container.innerHTML;
}
// clear content before mounting
container.innerHTML = '';
const proxy = mount(container);
container.removeAttribute('v-cloak');
return proxy;
};
return app;
});
const createSSRApp = ((...args) => {
const app = ensureHydrationRenderer().createApp(...args);
{
injectNativeTagCheck(app);
}
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (container) {
return mount(container, true);
}
};
return app;
});
function injectNativeTagCheck(app) {
// Inject `isNativeTag`
// this is used for component name validation (dev only)
Object.defineProperty(app.config, 'isNativeTag', {
value: (tag) => isHTMLTag(tag) || isSVGTag(tag),
writable: false
});
}
function normalizeContainer(container) {
if (isString(container)) {
const res = document.querySelector(container);
if ( !res) {
warn(`Failed to mount app: mount target selector returned null.`);
}
return res;
}
return container;
}
// This entry is the "full-build" that includes both the runtime
const compileCache = Object.create(null);
function compileToFunction(template, options) {
if (!isString(template)) {
if (template.nodeType) {
template = template.innerHTML;
}
else {
warn(`invalid template option: `, template);
return NOOP;
}
}
const key = template;
const cached = compileCache[key];
if (cached) {
return cached;
}
if (template[0] === '#') {
const el = document.querySelector(template);
if ( !el) {
warn(`Template element not found or is empty: ${template}`);
}
// __UNSAFE__
// Reason: potential execution of JS expressions in in-DOM template.
// The user must make sure the in-DOM template is trusted. If it's rendered
// by the server, the template should not contain any user data.
template = el ? el.innerHTML : ``;
}
const { code } = compile(template, extend({
hoistStatic: true,
onError(err) {
{
const message = `Template compilation error: ${err.message}`;
const codeFrame = err.loc &&
generateCodeFrame(template, err.loc.start.offset, err.loc.end.offset);
warn(codeFrame ? `${message}\n${codeFrame}` : message);
}
}
}, options));
// The wildcard import results in a huge object with every export
// with keys that cannot be mangled, and can be quite heavy size-wise.
// In the global build we know `Vue` is available globally so we can avoid
// the wildcard object.
const render = ( new Function(code)()
);
return (compileCache[key] = render);
}
registerRuntimeCompiler(compileToFunction);
exports.BaseTransition = BaseTransition;
exports.Comment = Comment;
exports.Fragment = Fragment;
exports.KeepAlive = KeepAlive;
exports.Static = Static;
exports.Suspense = Suspense;
exports.Teleport = Teleport;
exports.Text = Text;
exports.Transition = Transition;
exports.TransitionGroup = TransitionGroup;
exports.callWithAsyncErrorHandling = callWithAsyncErrorHandling;
exports.callWithErrorHandling = callWithErrorHandling;
exports.camelize = _camelize;
exports.cloneVNode = cloneVNode;
exports.compile = compileToFunction;
exports.computed = computed$1;
exports.createApp = createApp;
exports.createBlock = createBlock;
exports.createCommentVNode = createCommentVNode;
exports.createHydrationRenderer = createHydrationRenderer;
exports.createRenderer = createRenderer;
exports.createSSRApp = createSSRApp;
exports.createSlots = createSlots;
exports.createStaticVNode = createStaticVNode;
exports.createTextVNode = createTextVNode;
exports.createVNode = createVNode;
exports.customRef = customRef;
exports.defineAsyncComponent = defineAsyncComponent;
exports.defineComponent = defineComponent;
exports.getCurrentInstance = getCurrentInstance;
exports.h = h;
exports.handleError = handleError;
exports.hydrate = hydrate;
exports.inject = inject;
exports.isProxy = isProxy;
exports.isReactive = isReactive;
exports.isReadonly = isReadonly;
exports.isRef = isRef;
exports.isVNode = isVNode;
exports.markRaw = markRaw;
exports.mergeProps = mergeProps;
exports.nextTick = nextTick;
exports.onActivated = onActivated;
exports.onBeforeMount = onBeforeMount;
exports.onBeforeUnmount = onBeforeUnmount;
exports.onBeforeUpdate = onBeforeUpdate;
exports.onDeactivated = onDeactivated;
exports.onErrorCaptured = onErrorCaptured;
exports.onMounted = onMounted;
exports.onRenderTracked = onRenderTracked;
exports.onRenderTriggered = onRenderTriggered;
exports.onUnmounted = onUnmounted;
exports.onUpdated = onUpdated;
exports.openBlock = openBlock;
exports.popScopeId = popScopeId;
exports.provide = provide;
exports.pushScopeId = pushScopeId;
exports.queuePostFlushCb = queuePostFlushCb;
exports.reactive = reactive;
exports.readonly = readonly;
exports.ref = ref;
exports.registerRuntimeCompiler = registerRuntimeCompiler;
exports.render = render;
exports.renderList = renderList;
exports.renderSlot = renderSlot;
exports.resolveComponent = resolveComponent;
exports.resolveDirective = resolveDirective;
exports.resolveDynamicComponent = resolveDynamicComponent;
exports.resolveTransitionHooks = resolveTransitionHooks;
exports.setBlockTracking = setBlockTracking;
exports.setTransitionHooks = setTransitionHooks;
exports.shallowReactive = shallowReactive;
exports.shallowReadonly = shallowReadonly;
exports.shallowRef = shallowRef;
exports.ssrContextKey = ssrContextKey;
exports.ssrUtils = ssrUtils;
exports.toDisplayString = _toDisplayString;
exports.toHandlers = toHandlers;
exports.toRaw = toRaw;
exports.toRef = toRef;
exports.toRefs = toRefs;
exports.transformVNodeArgs = transformVNodeArgs;
exports.triggerRef = triggerRef;
exports.unref = unref;
exports.useCSSModule = useCSSModule;
exports.useSSRContext = useSSRContext;
exports.useTransitionState = useTransitionState;
exports.vModelCheckbox = vModelCheckbox;
exports.vModelDynamic = vModelDynamic;
exports.vModelRadio = vModelRadio;
exports.vModelSelect = vModelSelect;
exports.vModelText = vModelText;
exports.vShow = vShow;
exports.version = version;
exports.warn = warn;
exports.watch = watch;
exports.watchEffect = watchEffect;
exports.withCtx = withCtx;
exports.withDirectives = withDirectives;
exports.withKeys = withKeys;
exports.withModifiers = withModifiers;
exports.withScopeId = withScopeId;
return exports;
}({}));
| cdnjs/cdnjs | ajax/libs/vue/3.0.0-beta.15/vue.global.js | JavaScript | mit | 475,253 |
// Send an HTTP POST request to http://localhost:8099 and pipe process.stdin into
// it. Pipe the response stream to process.stdout.
var request = require('request');
process.stdin.pipe(request.post('http://localhost:8099')).pipe(process.stdout);
| josedab/node-examples | nodeschool/stream-adventure/http-client.js | JavaScript | mit | 253 |
var Properties = require ("../../build/enhanced-properties");
var assert = require ("assert");
Properties.SENSITIVITY = false;
var keys = {
a: { value: "b", comment: null }
};
var sections = {
test: {
a: { value: "d", comment: null }
},
section: {
a: { value: "e", comment: null }
}
};
new Properties ().load ("test2", function (error){
assert.deepEqual (this._keys, keys);
assert.deepEqual (this.getSection ("test")._keys, sections.test);
assert.deepEqual (this.getSection ("section")._keys, sections.section);
assert.ok (this.getSection ("Test") === this.getSection ("test"));
}); | travis4all/Node-EnhancedProperties | test/tests/sensitivity.js | JavaScript | mit | 599 |
/*!
* Bootstrap-select v1.13.15 (https://developer.snapappointments.com/bootstrap-select)
*
* Copyright 2012-2020 SnapAppointments, LLC
* Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
*/
!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Aucune s\xe9lection",noneResultsText:"Aucun r\xe9sultat pour {0}",countSelectedText:function(e,t){return 1<e?"{0} \xe9l\xe9ments s\xe9lectionn\xe9s":"{0} \xe9l\xe9ment s\xe9lectionn\xe9"},maxOptionsText:function(e,t){return[1<e?"Limite atteinte ({n} \xe9l\xe9ments max)":"Limite atteinte ({n} \xe9l\xe9ment max)",1<t?"Limite du groupe atteinte ({n} \xe9l\xe9ments max)":"Limite du groupe atteinte ({n} \xe9l\xe9ment max)"]},multipleSeparator:", ",selectAllText:"Tout s\xe9lectionner",deselectAllText:"Tout d\xe9s\xe9lectionner"}}); | cdnjs/cdnjs | ajax/libs/bootstrap-select/1.13.15/js/i18n/defaults-fr_FR.min.js | JavaScript | mit | 1,061 |
import expect from 'expect'
import React from 'react'
import { mount } from 'enzyme'
import MillerColumnsSelectField from '../../src/elements/MillerColumnsSelectField'
import ListItem from '../../src/elements/ListItem'
describe('elements', () => {
describe('MillerColumnsSelectField', () => {
it('should fire the onChange event', () => {
const spy = expect.createSpy()
const wrapperProps = {
label: 'test',
placeholder: 'test',
onChange: spy,
childForValue: () => {}
}
const wrapper = mount(
<MillerColumnsSelectField {...wrapperProps}>
<ListItem value={1}>Test 1</ListItem>
<ListItem value={2}>Test 2</ListItem>
</MillerColumnsSelectField>
)
wrapper.find('div.ladbPFInp').simulate('click')
wrapper
.find('li')
.first()
.find('div.ladbChk')
.simulate('click')
expect(spy).toHaveBeenCalled()
})
it('should fire the onChange event for token removal', () => {
const spy = expect.createSpy()
const wrapperProps = {
label: 'test',
placeholder: 'test',
onChange: spy,
value: 1,
childForValue: (value) => `Test ${value}`
}
const wrapper = mount(
<MillerColumnsSelectField {...wrapperProps}>
<ListItem value={1}>Test 1</ListItem>
<ListItem value={2}>Test 2</ListItem>
</MillerColumnsSelectField>
)
wrapper.find('.ladbTknRemove').simulate('click')
expect(spy).toHaveBeenCalledWith(1, false)
})
it('should display token for current value', () => {
const wrapperProps = {
label: 'test',
placeholder: 'test',
value: 2,
childForValue: (value) => `Test ${value}`
}
const wrapper = mount(
<MillerColumnsSelectField {...wrapperProps}>
<ListItem value={1}>Test 1</ListItem>
<ListItem value={2}>Test 2</ListItem>
</MillerColumnsSelectField>
)
expect(wrapper.find('.ladbTkn').text()).toEqual('Test 2')
})
it('should display token for multiple values', () => {
const wrapperProps = {
label: 'test',
placeholder: 'test',
value: [2, 3],
childForValue: (value) => `Test ${value}`
}
const wrapper = mount(
<MillerColumnsSelectField {...wrapperProps}>
<ListItem value={1}>Test 1</ListItem>
<ListItem value={2}>Test 2</ListItem>
<ListItem value={3}>Test 3</ListItem>
</MillerColumnsSelectField>
)
expect(wrapper.find('.ladbTkn').first().text()).toEqual('Test 2')
expect(wrapper.find('.ladbTkn').last().text()).toEqual('Test 3')
})
it('should display token for nested items', () => {
const wrapperProps = {
label: 'test',
placeholder: 'test',
value: 4,
createNextLevelItems: () => [
<ListItem key={3} value={3}>Test 3</ListItem>,
<ListItem key={4} value={4}>Test 4</ListItem>
],
childForValue: (value) => `Test ${value}`
}
const wrapper = mount(
<MillerColumnsSelectField {...wrapperProps}>
<ListItem value={1}>Test 1</ListItem>
<ListItem value={2}>Test 2</ListItem>
</MillerColumnsSelectField>
)
expect(wrapper.find('.ladbTkn').exists()).toBe(true)
expect(wrapper.find('.ladbTkn').text()).toEqual('Test 4')
})
it('should display the placeholder if no value is defined', () => {
const wrapperProps = {
label: 'test',
placeholder: 'test',
onChange: () => {},
childForValue: () => {}
}
const wrapper = mount(
<MillerColumnsSelectField {...wrapperProps}>
<ListItem value={1}>Test 1</ListItem>
<ListItem value={2}>Test 2</ListItem>
</MillerColumnsSelectField>
)
expect(wrapper.find('.ladbPFPH').exists()).toBe(true)
expect(wrapper.find('.ladbPFPH').text()).toEqual('test')
})
})
})
| LADB/ladb-ui | test/elements/MillerColumnsSelectField.test.js | JavaScript | mit | 4,041 |
import React from 'react';
import ReactShallowRenderer from 'react-test-renderer/shallow';
import RadioPicker from 'chamel/Picker/RadioPicker';
/**
* Test rendering the RadioPicker
*/
describe("RadioPicker Component", () => {
// Basic validation that render works in edit mode and returns children
it("Should render", () => {
const renderer = new ReactShallowRenderer();
const renderedDocument = renderer.render(
<RadioPicker/>
);
expect(renderedDocument.type).toBe('div');
});
});
| skystebnicki/chamel | test/unit/Picker/RadioPicker.test.js | JavaScript | mit | 521 |
// @flow
import type { IObservableArray } from 'mobx'
import { extendObservable, runInAction, observable, computed } from 'mobx'
import createRouteStateTreeNode from './createRouteStateTreeNode'
import type { ObservableMap } from 'mobx'
import createRoute from './createRoute'
import RouterStateTree from './RouterStateTree'
import qs from 'querystring'
import areRoutesEqual from './util/areRoutesEqual'
import type Navigation from './Navigation'
import type {
Location,
Query,
Params,
Route,
RouteStateTreeNode,
PathElement,
Config,
} from './types'
type TreeNodeMetaData<C, D> = {
node: RouteStateTreeNode<C, D>,
parent: null | RouteStateTreeNode<C, D>
}
class RouterStore {
location: Location
params: ObservableMap<Params>
state: RouterStateTree
nextKey = 0
// Create a map of all nodes in tree so we can perform faster lookup.
// Instances should be exactly the same as in state tree.
cache: ObservableMap<TreeNodeMetaData<*, *>>
// Keep a list of activated nodes so we can track differences when transitioning to a new state.
routes: IObservableArray<Route<*, *>>
prevRoutes: IObservableArray<Route<*, *>>
error: any
cancelledSequence: number
constructor(root: RouteStateTreeNode<*, *>) {
extendObservable(this, {
state: new RouterStateTree(root),
cancelledSequence: -1,
location: {},
params: observable.map({}),
cache: observable.map({ [root.value.key]: root }),
routes: observable.array([]),
prevRoutes: observable.array([]),
error: null
}, {
state: observable.ref,
cancelledSequence: observable.ref
})
}
getNextKey = (): string => {
const key = this.nextKey
runInAction(() => {
this.nextKey++
})
return `${key}`
}
/* Queries */
// Returns a list of the next routes from the matched path.
// If the route is not currently active or has changed, then it will be created from factory function.
getNextRoutes(path: PathElement<*, *>[], location: Location): Route<*, *>[] {
const query = getQueryParams(location)
return path.map(element => {
const matchedQueryParams = this.getMatchedQueryParams(element.node, query)
const newRoute = createRoute(element.node, element.parentUrl, element.segment, element.params, query)
const existingRoute = this.routes.find(x => areRoutesEqual(x, newRoute))
if (existingRoute) {
return existingRoute
} else {
return observable(createRoute(element.node, element.parentUrl, element.segment, element.params, matchedQueryParams))
}
})
}
getNode(key: string): null | RouteStateTreeNode<*, *> {
const x = this.cache.get(key)
if (x) {
const { node } = x
return node
} else {
return null
}
}
getNodeUnsafe(key: string): RouteStateTreeNode<*, *> {
const x = this.getNode(key)
if (!x) {
throw new Error(`Cannot find node with key ${key}`)
} else {
return x
}
}
getRoute(key: string): null | Route<*, *> {
const x = this.routes.find(route => route.node.value.key === key)
if (x) {
return x
} else {
return null
}
}
getRouteUnsafe(key: string): Route<*, *> {
const x = this.getRoute(key)
if (x) {
return x
} else {
throw new Error(`Cannot find route with key ${key}`)
}
}
getParams(key: string): null | Params {
const params = this.params.get(key)
if (params) {
return params
} else {
return null
}
}
/* Mutations */
replaceChildren(node: RouteStateTreeNode<*, *>, children: Config<*>[]): void {
node.children.replace(children.map(x => this._createNode(node, x)))
}
updateError(err: any) {
runInAction(() => {
this.error = err
})
}
updateRoutes(routes: Route<*, *>[]) {
runInAction(() => {
this.prevRoutes.replace(this.routes.slice())
this.routes.replace(routes)
// Update params
this.params.clear()
this.routes.forEach(route => {
this.params.set(route.node.value.key, route.params)
})
})
}
updateLocation(nextLocation: Location) {
runInAction(() => {
this.location = nextLocation
})
}
clearPrevRoutes() {
runInAction(() => {
this.prevRoutes.replace([])
})
}
cancel(navigation: null | Navigation) {
if (navigation) {
this.cancelledSequence = navigation.sequence
}
}
isCancelled(navigation: null | Navigation) {
return navigation ? navigation.sequence <= this.cancelledSequence : false
}
getMatchedQueryParams(node: RouteStateTreeNode<*, *>, query: Query): Query {
return Object.keys(query)
.filter(key => node.value.query.includes(key))
.reduce((acc, key) => {
acc[key] = query[key]
return acc
}, {})
}
/* Private helpers */
_createNode(parent: RouteStateTreeNode<*, *>, config: Config<*>) {
const node = createRouteStateTreeNode(config, parent.value.getContext, this.getNextKey)
this._storeInCache(parent, node)
return node
}
_storeInCache(parent: RouteStateTreeNode<*, *>, node: RouteStateTreeNode<*, *>) {
this.cache.set(node.value.key, { node: node, parent })
node.children.forEach(child => this._storeInCache(node, child))
}
}
function getQueryParams(location: Location): Query {
return location.search != null ? qs.parse(location.search.substr(1)) : {}
}
export default RouterStore
| mobx-little-router/mobx-little-router | packages/mobx-little-router/src/model/RouterStore.js | JavaScript | mit | 5,454 |
/* jshint node:true */
'use strict';
var gulp = require('gulp');
var gUtil = require('gulp-util');
var gClean = require('gulp-clean');
var msxLogic = require('gulp-msx-logic');
var mithrilComponents = require('./mithrilComponents');
var msx = require('./vendor/msx/msx-main');
var through = require('through2');
function msxTransform() {
return through.obj(function (file, enc, cb) {
try {
file.contents = new Buffer(msx.transform(file.contents.toString()));
}
catch (err) {
err.fileName = file.path;
this.emit('error', new gUtil.PluginError('msx', err));
}
this.push(file);
cb();
});
}
console.log('test for gulp-mithril-components');
gulp.task('clean', function () {
return gulp.src('./test/build/**.*', {read: false})
.pipe(gClean());
});
gulp.task('components', function() {
return gulp.src('./test/components/*.html')
.pipe(mithrilComponents({showFiles:true}))
.pipe(msxTransform())
.pipe(msxLogic())
.pipe(gulp.dest('./test/build'))
.on('error', function(e) {
console.error(e.message + '\n in ' + e.fileName);
});
});
gulp.task('msx', function() {
return gulp.src('./test/components/*.html')
.pipe(mithrilComponents({showFiles:true}))
//.pipe(msxTransform())
//.pipe(msxLogic())
.pipe(gulp.dest('./test/msx'))
.on('error', function(e) {
console.error(e.message + '\n in ' + e.fileName);
});
});
gulp.task('test', ['clean', 'components'] /*, function () {
require('./test/test.js');
}*/);
| eddyystop/gulp-mithril-components | gulpfile.js | JavaScript | mit | 1,524 |
class ServerError {
constructor(message, status = 500) {
this.message = message;
this.status = status;
}
}
module.exports = {
ServerError,
};
| zurfyx/express-api-starter-kit | src/helpers/server.js | JavaScript | mit | 157 |
/**
* jQuery.break()
*
* (c) Wil Neeley, Trestle Media, LLC.
* Code may be freely distributed under the MIT license.
*/
;(function ( $, window, document, undefined ) {
// The plugin's name
var pluginName = 'break';
// The plugin's defaults
var defaults = {
// Since media queries measurement of the the viewport sizes differs from JavaScript's measurement, when this option
// is configured to true, we calculate the scroll bar width of the window and add it to JavaScript's calculation to
// compensate.
media: false,
// An array of breakpoint objects. Each object contains the point at which a break should occur and contains the
// callbacks to execute once above, once below, continuously above, and continuously below.
points: [
{
point: 768,
name: undefined,
onBelow: function( point, width ) {},
onAbove: function( point, width ) {},
onBelowOnce: function( point, width ) {},
onAboveOnce: function( point, width ) {}
}
]
};
// Plugin constructor
function Plugin( element, options ) {
this.element = element;
this.options = $.extend( {}, defaults, options);
this._defaults = defaults;
this._name = pluginName;
this.init();
}
Plugin.prototype.init = function() {
var plugin = this;
// Determine the scroll bar width
var parent, child, scroll_width;
if ( scroll_width === undefined ) {
parent = $('<div style="width:50px; height:50px; overflow:auto"><div/></div>').appendTo('body');
child = parent.children();
scroll_width = child.innerWidth() - child.height(99).innerWidth();
parent.remove();
}
// For each breakpoint, attach the default happen once flags
$.each(plugin.options.points, function(index, breakpoint) {
breakpoint['_once_below'] = true;
breakpoint['_once_above'] = true;
});
// Define our resize handler
var resizeBreakpointHandler = function() {
var width = plugin.options.media ? $(plugin.element).width() + scroll_width : $(plugin.element).width();
// For each breakpoint, perform our tests
$.each(plugin.options.points, function(index, breakpoint) {
// Breakpoint is below
if ( width < breakpoint.point ) {
// Execute breakpoint code once
if (breakpoint._once_below) {
breakpoint._once_below = false;
breakpoint._once_above = true;
// Only execute the callback if it is defined
if ('onBelowOnce' in breakpoint) {
breakpoint.onBelowOnce( width, breakpoint.point );
}
}
// Execute breakpoint callback continuously if it is defined
if ('onBelow' in breakpoint) {
breakpoint.onBelow( width, breakpoint.point );
}
// Breakpoint is above
} else {
// Execute breakpoint code once
if (breakpoint._once_above) {
breakpoint._once_above = false;
breakpoint._once_below = true;
// Only execute the callback if it is defined
if ('onAboveOnce' in breakpoint) {
breakpoint.onAboveOnce( width, breakpoint.point );
}
}
// Execute breakpoint callback continuously if it is defined
if ('onAbove' in breakpoint) {
breakpoint.onAbove( width, breakpoint.point );
}
}
});
};
// Attach the our resize handler to the resize event
$(this.element).bind('resize', resizeBreakpointHandler);
// Call the resize handler once initially
resizeBreakpointHandler();
};
// Plugin wrapper around constructor preventing multiple instantiations
$.fn[pluginName] = function ( options ) {
return this.each(function () {
if (!$.data(this, 'plugin_' + pluginName)) {
$.data(this, 'plugin_' + pluginName, new Plugin( this, options ));
}
});
};
})( jQuery, window, document ); | Xaxis/jquery.break | jquery.break.js | JavaScript | mit | 4,124 |
var breadcrumbs=[['-1',"",""],['2',"SOLUTION-WIDE PROPERTIES Reference","topic_0000000000000C16.html"],['131',"Tlece.ConsoleApp Namespace","topic_0000000000000C0A.html"],['132',"BillingProcessor Class","topic_0000000000000C0B.html"],['133',"BillingProcessor Constructor","topic_0000000000000C0C.html"]]; | asiboro/asiboro.github.io | vsdoc/toc--/topic_0000000000000C0C.html.js | JavaScript | mit | 303 |
import { PETFINDER_KEY } from '../env.secret';
const PETFINDER_URL = 'http://api.petfinder.com/';
const BASE_API_PARAMS = {
key: PETFINDER_KEY,
format: 'json',
};
// Return GET query string parameters based on an object
const getQueryString = obj => (
Object.keys(obj)
.filter(key => !!obj[key]) // filter out empty values
.map(key => `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`)
.join('&')
);
// `fetch` with abstraction for API URI and settings
const apiFetch = async (
resource,
{ queryParams, ...settings } = { queryParams: {} },
) => {
// these are used in both the try and catch
let res;
let data;
let finalParams;
let finalURL;
try {
// Build GET params, including API required settings
finalParams = Object.assign({}, BASE_API_PARAMS, queryParams);
const queryString = getQueryString(finalParams);
// Construct URL and call resource
finalURL = `${PETFINDER_URL}${resource}?${queryString}`;
res = await fetch(finalURL, settings);
data = await res.json();
// Parse and return response
return { data, res };
} catch (error) {
console.info({ params: finalParams, url: finalURL, res });
return { data, res, error };
}
};
export default apiFetch;
// Expose tested methods
let _private; // eslint-disable-line import/no-mutable-exports, no-underscore-dangle
if (process.env.NODE_ENV === 'test') _private = { getQueryString };
export { _private };
| bendman/open-adopt | app/api/fetch.js | JavaScript | mit | 1,469 |
'use strict';
window.app.directive("ehSimple", function() {
return function(scope, element) {
element.addClass("plain");
}
});
window.app.directive('contacts', ['dataservice', function (dataservice) {
return {
restrict: 'A',
templateUrl: '/app/directives/contacts/contacts.html',
link: function (scope, element, attrs) {
scope.contacts = [];
dataservice.getContacts().then(function(data) {
scope.contacts = data.results;
});
}
}
}]); | rodolfotorres/Visual-Studio-Angular-Template | src/VStorm/VStorm/app/directives/contacts/contacts.js | JavaScript | mit | 545 |
Package.describe({
name: 'mars:bootstrap-table',
version: '0.0.1',
// Brief, one-line summary of the package.
summary: '',
// URL to the Git repository containing the source code for this package.
git: '',
// By default, Meteor will default to using README.md for documentation.
// To avoid submitting documentation, set this field to null.
documentation: 'README.md'
});
Package.onUse(function(api) {
api.use('ecmascript');
api.addFiles([
'bootstrap-table.js',
], ['client']);
});
| yuyixg/Rocket.Chat | packages/mars_bootstrap-table/package.js | JavaScript | mit | 512 |
import * as XState from 'xstate';
const { Machine } = XState;
const { assign } = XState.actions;
const cameraMachine = Machine(
{
id: 'camera',
initial: 'enumeratingDevices',
context: {
/* 💁 selected is just the deviceId */
selected: null,
available: [],
},
states: {
enumeratingDevices: {
invoke: {
id: 'enumerateDevices',
src: () => navigator.mediaDevices.enumerateDevices(),
onDone: {
target: 'devicesEnumerated',
/* 💁 this wasn't working as an action string */
actions: assign({
available: (ctx, event) => event.data.filter(
deviceInformation => deviceInformation.kind === 'videoinput',
),
}),
},
onError: {
target: 'failure',
actions: assign({ error: (ctx, event) => event.data }),
},
},
},
devicesEnumerated: {
on: {
'': [
{
target: 'noCameras',
cond: 'noCamerasFound',
},
{
target: 'gettingUserMedia',
cond: 'cameraAlreadySelected',
},
{
target: 'idle',
cond: 'camerasFound',
},
],
},
},
failure: {},
noCameras: {},
idle: {
on: {
SELECT: {
target: 'gettingUserMedia',
actions: 'assignCamera'
},
},
},
gettingUserMedia: {
invoke: {
id: 'getUserMedia',
src: ctx => {
const constraints = {
audio: false,
video: {
deviceId: ctx.selected ? { exact: ctx.selected } : undefined,
},
};
return navigator.mediaDevices.getUserMedia(constraints);
},
onDone: {
target: 'streaming',
actions: (ctx, event) => {
// side effect
window.localStream = event.data;
},
},
onError: 'failure',
},
},
streaming: {
on: {
SELECT: {
target: 'gettingUserMedia',
actions: 'assignCamera',
},
},
},
},
},
{
actions: {
assignCamera: assign({
selected: (ctx, event) => {
window.localStorage.setItem('selectedCameraId', event.payload);
return event.payload;
},
}),
},
guards: {
noCamerasFound: ctx => ctx.available.length === 0,
camerasFound: ctx => ctx.available.length > 0,
cameraAlreadySelected: ctx => ctx.selected !== null,
},
},
);
export default cameraMachine;
| DBaker2/boxman | src/machines/camera-machine.js | JavaScript | mit | 2,793 |
var Module;
if (typeof Module === 'undefined') Module = eval('(function() { try { return Module || {} } catch(e) { return {} } })()');
if (!Module.expectedDataFileDownloads) {
Module.expectedDataFileDownloads = 0;
Module.finishedDataFileDownloads = 0;
}
Module.expectedDataFileDownloads++;
(function() {
var PACKAGE_PATH;
if (typeof window === 'object') {
PACKAGE_PATH = window['encodeURIComponent'](window.location.pathname.toString().substring(0, window.location.pathname.toString().lastIndexOf('/')) + '/');
} else {
// worker
PACKAGE_PATH = encodeURIComponent(location.pathname.toString().substring(0, location.pathname.toString().lastIndexOf('/')) + '/');
}
var PACKAGE_NAME = 'LlamaRapBattle-WebGL.data';
var REMOTE_PACKAGE_BASE = 'LlamaRapBattle-WebGL.data';
if (typeof Module['locateFilePackage'] === 'function' && !Module['locateFile']) {
Module['locateFile'] = Module['locateFilePackage'];
Module.printErr('warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)');
}
var REMOTE_PACKAGE_NAME = typeof Module['locateFile'] === 'function' ?
Module['locateFile'](REMOTE_PACKAGE_BASE) :
((Module['filePackagePrefixURL'] || '') + REMOTE_PACKAGE_BASE);
var REMOTE_PACKAGE_SIZE = 14374619;
var PACKAGE_UUID = 'b0b734b6-923a-43f8-823b-fb76647d3043';
function fetchRemotePackage(packageName, packageSize, callback, errback) {
var xhr = new XMLHttpRequest();
xhr.open('GET', packageName, true);
xhr.responseType = 'arraybuffer';
xhr.onprogress = function(event) {
var url = packageName;
var size = packageSize;
if (event.total) size = event.total;
if (event.loaded) {
if (!xhr.addedTotal) {
xhr.addedTotal = true;
if (!Module.dataFileDownloads) Module.dataFileDownloads = {};
Module.dataFileDownloads[url] = {
loaded: event.loaded,
total: size
};
} else {
Module.dataFileDownloads[url].loaded = event.loaded;
}
var total = 0;
var loaded = 0;
var num = 0;
for (var download in Module.dataFileDownloads) {
var data = Module.dataFileDownloads[download];
total += data.total;
loaded += data.loaded;
num++;
}
total = Math.ceil(total * Module.expectedDataFileDownloads/num);
if (Module['setStatus']) Module['setStatus']('Downloading data... (' + loaded + '/' + total + ')');
} else if (!Module.dataFileDownloads) {
if (Module['setStatus']) Module['setStatus']('Downloading data...');
}
};
xhr.onload = function(event) {
var packageData = xhr.response;
callback(packageData);
};
xhr.send(null);
};
function handleError(error) {
console.error('package error:', error);
};
var fetched = null, fetchedCallback = null;
fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, function(data) {
if (fetchedCallback) {
fetchedCallback(data);
fetchedCallback = null;
} else {
fetched = data;
}
}, handleError);
function runWithFS() {
function assert(check, msg) {
if (!check) throw msg + new Error().stack;
}
Module['FS_createPath']('/', 'Resources', true, true);
function DataRequest(start, end, crunched, audio) {
this.start = start;
this.end = end;
this.crunched = crunched;
this.audio = audio;
}
DataRequest.prototype = {
requests: {},
open: function(mode, name) {
this.name = name;
this.requests[name] = this;
Module['addRunDependency']('fp ' + this.name);
},
send: function() {},
onload: function() {
var byteArray = this.byteArray.subarray(this.start, this.end);
this.finish(byteArray);
},
finish: function(byteArray) {
var that = this;
Module['FS_createPreloadedFile'](this.name, null, byteArray, true, true, function() {
Module['removeRunDependency']('fp ' + that.name);
}, function() {
if (that.audio) {
Module['removeRunDependency']('fp ' + that.name); // workaround for chromium bug 124926 (still no audio with this, but at least we don't hang)
} else {
Module.printErr('Preloading file ' + that.name + ' failed');
}
}, false, true); // canOwn this data in the filesystem, it is a slide into the heap that will never change
this.requests[this.name] = null;
},
};
new DataRequest(0, 152876, 0, 0).open('GET', '/level0');
new DataRequest(152876, 311976, 0, 0).open('GET', '/level1');
new DataRequest(311976, 467248, 0, 0).open('GET', '/level2');
new DataRequest(467248, 638700, 0, 0).open('GET', '/mainData');
new DataRequest(638700, 639150, 0, 0).open('GET', '/methods_pointedto_by_uievents.xml');
new DataRequest(639150, 2122246, 0, 0).open('GET', '/sharedassets0.assets');
new DataRequest(2122246, 2127330, 0, 0).open('GET', '/sharedassets1.assets');
new DataRequest(2127330, 9065444, 0, 0).open('GET', '/sharedassets1.resource');
new DataRequest(9065444, 9081636, 0, 0).open('GET', '/sharedassets2.assets');
new DataRequest(9081636, 12295683, 0, 0).open('GET', '/sharedassets2.resource');
new DataRequest(12295683, 12300139, 0, 0).open('GET', '/sharedassets3.assets');
new DataRequest(12300139, 13860511, 0, 0).open('GET', '/Resources/unity_default_resources');
new DataRequest(13860511, 14374619, 0, 0).open('GET', '/Resources/unity_builtin_extra');
function processPackageData(arrayBuffer) {
Module.finishedDataFileDownloads++;
assert(arrayBuffer, 'Loading data file failed.');
var byteArray = new Uint8Array(arrayBuffer);
var curr;
// Reuse the bytearray from the XHR as the source for file reads.
DataRequest.prototype.byteArray = byteArray;
DataRequest.prototype.requests["/level0"].onload();
DataRequest.prototype.requests["/level1"].onload();
DataRequest.prototype.requests["/level2"].onload();
DataRequest.prototype.requests["/mainData"].onload();
DataRequest.prototype.requests["/methods_pointedto_by_uievents.xml"].onload();
DataRequest.prototype.requests["/sharedassets0.assets"].onload();
DataRequest.prototype.requests["/sharedassets1.assets"].onload();
DataRequest.prototype.requests["/sharedassets1.resource"].onload();
DataRequest.prototype.requests["/sharedassets2.assets"].onload();
DataRequest.prototype.requests["/sharedassets2.resource"].onload();
DataRequest.prototype.requests["/sharedassets3.assets"].onload();
DataRequest.prototype.requests["/Resources/unity_default_resources"].onload();
DataRequest.prototype.requests["/Resources/unity_builtin_extra"].onload();
Module['removeRunDependency']('datafile_LlamaRapBattle-WebGL.data');
};
Module['addRunDependency']('datafile_LlamaRapBattle-WebGL.data');
if (!Module.preloadResults) Module.preloadResults = {};
Module.preloadResults[PACKAGE_NAME] = {fromCache: false};
if (fetched) {
processPackageData(fetched);
fetched = null;
} else {
fetchedCallback = processPackageData;
}
}
if (Module['calledRun']) {
runWithFS();
} else {
if (!Module['preRun']) Module['preRun'] = [];
Module["preRun"].push(runWithFS); // FS is not initialized yet, wait for it
}
})();
| SunilRao01/Llama-Rap-Battle | Battle Piece/LlamaRapBattle-WebGL/Release/fileloader.js | JavaScript | mit | 7,786 |
/**
* @license Highstock JS v8.0.4 (2020-03-10)
* @module highcharts/indicators/ema
* @requires highcharts
* @requires highcharts/modules/stock
*
* Indicator series type for Highstock
*
* (c) 2010-2019 Sebastian Bochan
*
* License: www.highcharts.com/license
*/
'use strict';
import '../../indicators/ema.src.js';
| cdnjs/cdnjs | ajax/libs/highcharts/8.0.4/es-modules/masters/indicators/ema.src.js | JavaScript | mit | 325 |
/**
* @license Highcharts Gantt JS v9.2.0 (2021-08-18)
*
* CurrentDateIndicator
*
* (c) 2010-2021 Lars A. V. Cabrera
*
* License: www.highcharts.com/license
*/
'use strict';
(function (factory) {
if (typeof module === 'object' && module.exports) {
factory['default'] = factory;
module.exports = factory;
} else if (typeof define === 'function' && define.amd) {
define('highcharts/modules/current-date-indicator', ['highcharts'], function (Highcharts) {
factory(Highcharts);
factory.Highcharts = Highcharts;
return factory;
});
} else {
factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
}
}(function (Highcharts) {
var _modules = Highcharts ? Highcharts._modules : {};
function _registerModule(obj, path, args, fn) {
if (!obj.hasOwnProperty(path)) {
obj[path] = fn.apply(null, args);
}
}
_registerModule(_modules, 'Extensions/CurrentDateIndication.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Color/Palette.js'], _modules['Core/Axis/PlotLineOrBand/PlotLineOrBand.js'], _modules['Core/Utilities.js']], function (Axis, Palette, PlotLineOrBand, U) {
/* *
*
* (c) 2016-2021 Highsoft AS
*
* Author: Lars A. V. Cabrera
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var addEvent = U.addEvent,
merge = U.merge,
wrap = U.wrap;
/**
* Show an indicator on the axis for the current date and time. Can be a
* boolean or a configuration object similar to
* [xAxis.plotLines](#xAxis.plotLines).
*
* @sample gantt/current-date-indicator/demo
* Current date indicator enabled
* @sample gantt/current-date-indicator/object-config
* Current date indicator with custom options
*
* @declare Highcharts.CurrentDateIndicatorOptions
* @type {boolean|CurrentDateIndicatorOptions}
* @default true
* @extends xAxis.plotLines
* @excluding value
* @product gantt
* @apioption xAxis.currentDateIndicator
*/
var defaultOptions = {
color: Palette.highlightColor20,
width: 2,
/**
* @declare Highcharts.AxisCurrentDateIndicatorLabelOptions
*/
label: {
/**
* Format of the label. This options is passed as the fist argument to
* [dateFormat](/class-reference/Highcharts#.dateFormat) function.
*
* @type {string}
* @default %a, %b %d %Y, %H:%M
* @product gantt
* @apioption xAxis.currentDateIndicator.label.format
*/
format: '%a, %b %d %Y, %H:%M',
formatter: function (value, format) {
return this.axis.chart.time.dateFormat(format || '', value);
},
rotation: 0,
/**
* @type {Highcharts.CSSObject}
*/
style: {
/** @internal */
fontSize: '10px'
}
}
};
/* eslint-disable no-invalid-this */
addEvent(Axis, 'afterSetOptions', function () {
var options = this.options,
cdiOptions = options.currentDateIndicator;
if (cdiOptions) {
var plotLineOptions = typeof cdiOptions === 'object' ?
merge(defaultOptions,
cdiOptions) :
merge(defaultOptions);
plotLineOptions.value = Date.now();
plotLineOptions.className = 'highcharts-current-date-indicator';
if (!options.plotLines) {
options.plotLines = [];
}
options.plotLines.push(plotLineOptions);
}
});
addEvent(PlotLineOrBand, 'render', function () {
// If the label already exists, update its text
if (this.label) {
this.label.attr({
text: this.getLabelText(this.options.label)
});
}
});
wrap(PlotLineOrBand.prototype, 'getLabelText', function (defaultMethod, defaultLabelOptions) {
var options = this.options;
if (options &&
options.className &&
options.className.indexOf('highcharts-current-date-indicator') !== -1 &&
options.label &&
typeof options.label.formatter === 'function') {
options.value = Date.now();
return options.label.formatter
.call(this, options.value, options.label.format);
}
return defaultMethod.call(this, defaultLabelOptions);
});
});
_registerModule(_modules, 'masters/modules/current-date-indicator.src.js', [], function () {
});
})); | cdnjs/cdnjs | ajax/libs/highcharts/9.2.0/modules/current-date-indicator.src.js | JavaScript | mit | 5,333 |
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
/* Tabulator v4.9.2 (c) Oliver Folkerd */
var DataTree = function DataTree(table) {
this.table = table;
this.indent = 10;
this.field = "";
this.collapseEl = null;
this.expandEl = null;
this.branchEl = null;
this.elementField = false;
this.startOpen = function () {};
this.displayIndex = 0;
};
DataTree.prototype.initialize = function () {
var dummyEl = null,
firstCol = this.table.columnManager.getFirstVisibileColumn(),
options = this.table.options;
this.field = options.dataTreeChildField;
this.indent = options.dataTreeChildIndent;
this.elementField = options.dataTreeElementColumn || (firstCol ? firstCol.field : false);
if (options.dataTreeBranchElement) {
if (options.dataTreeBranchElement === true) {
this.branchEl = document.createElement("div");
this.branchEl.classList.add("tabulator-data-tree-branch");
} else {
if (typeof options.dataTreeBranchElement === "string") {
dummyEl = document.createElement("div");
dummyEl.innerHTML = options.dataTreeBranchElement;
this.branchEl = dummyEl.firstChild;
} else {
this.branchEl = options.dataTreeBranchElement;
}
}
}
if (options.dataTreeCollapseElement) {
if (typeof options.dataTreeCollapseElement === "string") {
dummyEl = document.createElement("div");
dummyEl.innerHTML = options.dataTreeCollapseElement;
this.collapseEl = dummyEl.firstChild;
} else {
this.collapseEl = options.dataTreeCollapseElement;
}
} else {
this.collapseEl = document.createElement("div");
this.collapseEl.classList.add("tabulator-data-tree-control");
this.collapseEl.tabIndex = 0;
this.collapseEl.innerHTML = "<div class='tabulator-data-tree-control-collapse'></div>";
}
if (options.dataTreeExpandElement) {
if (typeof options.dataTreeExpandElement === "string") {
dummyEl = document.createElement("div");
dummyEl.innerHTML = options.dataTreeExpandElement;
this.expandEl = dummyEl.firstChild;
} else {
this.expandEl = options.dataTreeExpandElement;
}
} else {
this.expandEl = document.createElement("div");
this.expandEl.classList.add("tabulator-data-tree-control");
this.expandEl.tabIndex = 0;
this.expandEl.innerHTML = "<div class='tabulator-data-tree-control-expand'></div>";
}
switch (_typeof(options.dataTreeStartExpanded)) {
case "boolean":
this.startOpen = function (row, index) {
return options.dataTreeStartExpanded;
};
break;
case "function":
this.startOpen = options.dataTreeStartExpanded;
break;
default:
this.startOpen = function (row, index) {
return options.dataTreeStartExpanded[index];
};
break;
}
};
DataTree.prototype.initializeRow = function (row) {
var childArray = row.getData()[this.field];
var isArray = Array.isArray(childArray);
var children = isArray || !isArray && (typeof childArray === "undefined" ? "undefined" : _typeof(childArray)) === "object" && childArray !== null;
if (!children && row.modules.dataTree && row.modules.dataTree.branchEl) {
row.modules.dataTree.branchEl.parentNode.removeChild(row.modules.dataTree.branchEl);
}
if (!children && row.modules.dataTree && row.modules.dataTree.controlEl) {
row.modules.dataTree.controlEl.parentNode.removeChild(row.modules.dataTree.controlEl);
}
row.modules.dataTree = {
index: row.modules.dataTree ? row.modules.dataTree.index : 0,
open: children ? row.modules.dataTree ? row.modules.dataTree.open : this.startOpen(row.getComponent(), 0) : false,
controlEl: row.modules.dataTree && children ? row.modules.dataTree.controlEl : false,
branchEl: row.modules.dataTree && children ? row.modules.dataTree.branchEl : false,
parent: row.modules.dataTree ? row.modules.dataTree.parent : false,
children: children
};
};
DataTree.prototype.layoutRow = function (row) {
var cell = this.elementField ? row.getCell(this.elementField) : row.getCells()[0],
el = cell.getElement(),
config = row.modules.dataTree;
if (config.branchEl) {
if (config.branchEl.parentNode) {
config.branchEl.parentNode.removeChild(config.branchEl);
}
config.branchEl = false;
}
if (config.controlEl) {
if (config.controlEl.parentNode) {
config.controlEl.parentNode.removeChild(config.controlEl);
}
config.controlEl = false;
}
this.generateControlElement(row, el);
row.getElement().classList.add("tabulator-tree-level-" + config.index);
if (config.index) {
if (this.branchEl) {
config.branchEl = this.branchEl.cloneNode(true);
el.insertBefore(config.branchEl, el.firstChild);
if (this.table.rtl) {
config.branchEl.style.marginRight = (config.branchEl.offsetWidth + config.branchEl.style.marginLeft) * (config.index - 1) + config.index * this.indent + "px";
} else {
config.branchEl.style.marginLeft = (config.branchEl.offsetWidth + config.branchEl.style.marginRight) * (config.index - 1) + config.index * this.indent + "px";
}
} else {
if (this.table.rtl) {
el.style.paddingRight = parseInt(window.getComputedStyle(el, null).getPropertyValue('padding-right')) + config.index * this.indent + "px";
} else {
el.style.paddingLeft = parseInt(window.getComputedStyle(el, null).getPropertyValue('padding-left')) + config.index * this.indent + "px";
}
}
}
};
DataTree.prototype.generateControlElement = function (row, el) {
var _this = this;
var config = row.modules.dataTree,
el = el || row.getCells()[0].getElement(),
oldControl = config.controlEl;
if (config.children !== false) {
if (config.open) {
config.controlEl = this.collapseEl.cloneNode(true);
config.controlEl.addEventListener("click", function (e) {
e.stopPropagation();
_this.collapseRow(row);
});
} else {
config.controlEl = this.expandEl.cloneNode(true);
config.controlEl.addEventListener("click", function (e) {
e.stopPropagation();
_this.expandRow(row);
});
}
config.controlEl.addEventListener("mousedown", function (e) {
e.stopPropagation();
});
if (oldControl && oldControl.parentNode === el) {
oldControl.parentNode.replaceChild(config.controlEl, oldControl);
} else {
el.insertBefore(config.controlEl, el.firstChild);
}
}
};
DataTree.prototype.setDisplayIndex = function (index) {
this.displayIndex = index;
};
DataTree.prototype.getDisplayIndex = function () {
return this.displayIndex;
};
DataTree.prototype.getRows = function (rows) {
var _this2 = this;
var output = [];
rows.forEach(function (row, i) {
var config, children;
output.push(row);
if (row instanceof Row) {
row.create();
config = row.modules.dataTree.children;
if (!config.index && config.children !== false) {
children = _this2.getChildren(row);
children.forEach(function (child) {
child.create();
output.push(child);
});
}
}
});
return output;
};
DataTree.prototype.getChildren = function (row, allChildren) {
var _this3 = this;
var config = row.modules.dataTree,
children = [],
output = [];
if (config.children !== false && (config.open || allChildren)) {
if (!Array.isArray(config.children)) {
config.children = this.generateChildren(row);
}
if (this.table.modExists("filter") && this.table.options.dataTreeFilter) {
children = this.table.modules.filter.filter(config.children);
} else {
children = config.children;
}
if (this.table.modExists("sort") && this.table.options.dataTreeSort) {
this.table.modules.sort.sort(children);
}
children.forEach(function (child) {
output.push(child);
var subChildren = _this3.getChildren(child);
subChildren.forEach(function (sub) {
output.push(sub);
});
});
}
return output;
};
DataTree.prototype.generateChildren = function (row) {
var _this4 = this;
var children = [];
var childArray = row.getData()[this.field];
if (!Array.isArray(childArray)) {
childArray = [childArray];
}
childArray.forEach(function (childData) {
var childRow = new Row(childData || {}, _this4.table.rowManager);
childRow.create();
childRow.modules.dataTree.index = row.modules.dataTree.index + 1;
childRow.modules.dataTree.parent = row;
if (childRow.modules.dataTree.children) {
childRow.modules.dataTree.open = _this4.startOpen(childRow.getComponent(), childRow.modules.dataTree.index);
}
children.push(childRow);
});
return children;
};
DataTree.prototype.expandRow = function (row, silent) {
var config = row.modules.dataTree;
if (config.children !== false) {
config.open = true;
row.reinitialize();
this.table.rowManager.refreshActiveData("tree", false, true);
this.table.options.dataTreeRowExpanded(row.getComponent(), row.modules.dataTree.index);
}
};
DataTree.prototype.collapseRow = function (row) {
var config = row.modules.dataTree;
if (config.children !== false) {
config.open = false;
row.reinitialize();
this.table.rowManager.refreshActiveData("tree", false, true);
this.table.options.dataTreeRowCollapsed(row.getComponent(), row.modules.dataTree.index);
}
};
DataTree.prototype.toggleRow = function (row) {
var config = row.modules.dataTree;
if (config.children !== false) {
if (config.open) {
this.collapseRow(row);
} else {
this.expandRow(row);
}
}
};
DataTree.prototype.getTreeParent = function (row) {
return row.modules.dataTree.parent ? row.modules.dataTree.parent.getComponent() : false;
};
DataTree.prototype.getFilteredTreeChildren = function (row) {
var config = row.modules.dataTree,
output = [],
children;
if (config.children) {
if (!Array.isArray(config.children)) {
config.children = this.generateChildren(row);
}
if (this.table.modExists("filter") && this.table.options.dataTreeFilter) {
children = this.table.modules.filter.filter(config.children);
} else {
children = config.children;
}
children.forEach(function (childRow) {
if (childRow instanceof Row) {
output.push(childRow);
}
});
}
return output;
};
DataTree.prototype.rowDelete = function (row) {
var parent = row.modules.dataTree.parent,
childIndex;
if (parent) {
childIndex = this.findChildIndex(row, parent);
if (childIndex !== false) {
parent.data[this.field].splice(childIndex, 1);
}
if (!parent.data[this.field].length) {
delete parent.data[this.field];
}
this.initializeRow(parent);
this.layoutRow(parent);
}
this.table.rowManager.refreshActiveData("tree", false, true);
};
DataTree.prototype.addTreeChildRow = function (row, data, top, index) {
var childIndex = false;
if (typeof data === "string") {
data = JSON.parse(data);
}
if (!Array.isArray(row.data[this.field])) {
row.data[this.field] = [];
row.modules.dataTree.open = this.startOpen(row.getComponent(), row.modules.dataTree.index);
}
if (typeof index !== "undefined") {
childIndex = this.findChildIndex(index, row);
if (childIndex !== false) {
row.data[this.field].splice(top ? childIndex : childIndex + 1, 0, data);
}
}
if (childIndex === false) {
if (top) {
row.data[this.field].unshift(data);
} else {
row.data[this.field].push(data);
}
}
this.initializeRow(row);
this.layoutRow(row);
this.table.rowManager.refreshActiveData("tree", false, true);
};
DataTree.prototype.findChildIndex = function (subject, parent) {
var _this5 = this;
var match = false;
if ((typeof subject === "undefined" ? "undefined" : _typeof(subject)) == "object") {
if (subject instanceof Row) {
//subject is row element
match = subject.data;
} else if (subject instanceof RowComponent) {
//subject is public row component
match = subject._getSelf().data;
} else if (typeof HTMLElement !== "undefined" && subject instanceof HTMLElement) {
if (parent.modules.dataTree) {
match = parent.modules.dataTree.children.find(function (childRow) {
return childRow instanceof Row ? childRow.element === subject : false;
});
if (match) {
match = match.data;
}
}
}
} else if (typeof subject == "undefined" || subject === null) {
match = false;
} else {
//subject should be treated as the index of the row
match = parent.data[this.field].find(function (row) {
return row.data[_this5.table.options.index] == subject;
});
}
if (match) {
if (Array.isArray(parent.data[this.field])) {
match = parent.data[this.field].indexOf(match);
}
if (match == -1) {
match = false;
}
}
//catch all for any other type of input
return match;
};
DataTree.prototype.getTreeChildren = function (row, component, recurse) {
var _this6 = this;
var config = row.modules.dataTree,
output = [];
if (config.children) {
if (!Array.isArray(config.children)) {
config.children = this.generateChildren(row);
}
config.children.forEach(function (childRow) {
if (childRow instanceof Row) {
output.push(component ? childRow.getComponent() : childRow);
if (recurse) {
output = output.concat(_this6.getTreeChildren(childRow, component, recurse));
}
}
});
}
return output;
};
DataTree.prototype.checkForRestyle = function (cell) {
if (!cell.row.cells.indexOf(cell)) {
cell.row.reinitialize();
}
};
DataTree.prototype.getChildField = function () {
return this.field;
};
DataTree.prototype.redrawNeeded = function (data) {
return (this.field ? typeof data[this.field] !== "undefined" : false) || (this.elementField ? typeof data[this.elementField] !== "undefined" : false);
};
Tabulator.prototype.registerModule("dataTree", DataTree); | cdnjs/cdnjs | ajax/libs/tabulator/4.9.2/js/modules/data_tree.js | JavaScript | mit | 13,682 |
import _extends from "@babel/runtime/helpers/extends";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
var _excluded = ["defaultValue", "grow", "style", "onResize", "className", "getRootRef", "getRef", "sizeY", "rows"];
import { createScopedElement } from "../../lib/jsxRuntime";
import * as React from "react";
import { classNames } from "../../lib/classNames";
import { FormField } from "../FormField/FormField";
import { withAdaptivity } from "../../hoc/withAdaptivity";
import { getClassName } from "../../helpers/getClassName";
import { useEnsuredControl } from "../../hooks/useEnsuredControl";
import { useExternRef } from "../../hooks/useExternRef";
import { usePlatform } from "../../hooks/usePlatform";
var Textarea = /*#__PURE__*/React.memo(function (_ref) {
var _ref$defaultValue = _ref.defaultValue,
defaultValue = _ref$defaultValue === void 0 ? "" : _ref$defaultValue,
_ref$grow = _ref.grow,
grow = _ref$grow === void 0 ? true : _ref$grow,
style = _ref.style,
onResize = _ref.onResize,
className = _ref.className,
getRootRef = _ref.getRootRef,
getRef = _ref.getRef,
sizeY = _ref.sizeY,
_ref$rows = _ref.rows,
rows = _ref$rows === void 0 ? 2 : _ref$rows,
restProps = _objectWithoutProperties(_ref, _excluded);
var _useEnsuredControl = useEnsuredControl(restProps, {
defaultValue: defaultValue
}),
_useEnsuredControl2 = _slicedToArray(_useEnsuredControl, 2),
value = _useEnsuredControl2[0],
onChange = _useEnsuredControl2[1];
var currentScrollHeight = React.useRef();
var elementRef = useExternRef(getRef);
var platform = usePlatform(); // autosize input
React.useEffect(function () {
var el = elementRef.current;
if (grow && el.offsetParent) {
el.style.height = null;
el.style.height = "".concat(el.scrollHeight, "px");
if (el.scrollHeight !== currentScrollHeight.current && onResize) {
onResize(el);
currentScrollHeight.current = el.scrollHeight;
}
}
}, [grow, value, sizeY]);
return createScopedElement(FormField, {
vkuiClass: classNames(getClassName("Textarea", platform), "Textarea--sizeY-".concat(sizeY)),
className: className,
style: style,
getRootRef: getRootRef,
disabled: restProps.disabled
}, createScopedElement("textarea", _extends({}, restProps, {
rows: rows,
vkuiClass: "Textarea__el",
value: value,
onChange: onChange,
ref: elementRef
})));
});
export default withAdaptivity(Textarea, {
sizeY: true
});
//# sourceMappingURL=Textarea.js.map | cdnjs/cdnjs | ajax/libs/vkui/4.24.0/components/Textarea/Textarea.js | JavaScript | mit | 2,687 |
/**
* @license Highstock JS v9.1.1 (2021-06-04)
*
* Slow Stochastic series type for Highcharts Stock
*
* (c) 2010-2021 Pawel Fus
*
* License: www.highcharts.com/license
*/
'use strict';
(function (factory) {
if (typeof module === 'object' && module.exports) {
factory['default'] = factory;
module.exports = factory;
} else if (typeof define === 'function' && define.amd) {
define('highcharts/indicators/indicators', ['highcharts', 'highcharts/modules/stock'], function (Highcharts) {
factory(Highcharts);
factory.Highcharts = Highcharts;
return factory;
});
} else {
factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
}
}(function (Highcharts) {
var _modules = Highcharts ? Highcharts._modules : {};
function _registerModule(obj, path, args, fn) {
if (!obj.hasOwnProperty(path)) {
obj[path] = fn.apply(null, args);
}
}
_registerModule(_modules, 'Mixins/IndicatorRequired.js', [_modules['Core/Utilities.js']], function (U) {
/**
*
* (c) 2010-2021 Daniel Studencki
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var error = U.error;
/* eslint-disable no-invalid-this, valid-jsdoc */
var requiredIndicatorMixin = {
/**
* Check whether given indicator is loaded,
else throw error.
* @private
* @param {Highcharts.Indicator} indicator
* Indicator constructor function.
* @param {string} requiredIndicator
* Required indicator type.
* @param {string} type
* Type of indicator where function was called (parent).
* @param {Highcharts.IndicatorCallbackFunction} callback
* Callback which is triggered if the given indicator is loaded.
* Takes indicator as an argument.
* @param {string} errMessage
* Error message that will be logged in console.
* @return {boolean}
* Returns false when there is no required indicator loaded.
*/
isParentLoaded: function (indicator,
requiredIndicator,
type,
callback,
errMessage) {
if (indicator) {
return callback ? callback(indicator) : true;
}
error(errMessage || this.generateMessage(type, requiredIndicator));
return false;
},
/**
* @private
* @param {string} indicatorType
* Indicator type
* @param {string} required
* Required indicator
* @return {string}
* Error message
*/
generateMessage: function (indicatorType, required) {
return 'Error: "' + indicatorType +
'" indicator type requires "' + required +
'" indicator loaded before. Please read docs: ' +
'https://api.highcharts.com/highstock/plotOptions.' +
indicatorType;
}
};
return requiredIndicatorMixin;
});
_registerModule(_modules, 'Stock/Indicators/SlowStochastic/SlowStochasticIndicator.js', [_modules['Mixins/IndicatorRequired.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (RequiredIndicatorMixin, SeriesRegistry, U) {
/* *
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d,
b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d,
b) { d.__proto__ = b; }) ||
function (d,
b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var StochasticIndicator = SeriesRegistry.seriesTypes.stochastic;
var seriesTypes = SeriesRegistry.seriesTypes;
var extend = U.extend,
merge = U.merge;
/**
* The Slow Stochastic series type.
*
* @private
* @class
* @name Highcharts.seriesTypes.slowstochastic
*
* @augments Highcharts.Series
*/
var SlowStochasticIndicator = /** @class */ (function (_super) {
__extends(SlowStochasticIndicator, _super);
function SlowStochasticIndicator() {
var _this = _super !== null && _super.apply(this,
arguments) || this;
_this.data = void 0;
_this.options = void 0;
_this.points = void 0;
return _this;
}
SlowStochasticIndicator.prototype.init = function () {
var args = arguments,
ctx = this;
RequiredIndicatorMixin.isParentLoaded(seriesTypes.stochastic, 'stochastic', ctx.type, function (indicator) {
indicator.prototype.init.apply(ctx, args);
return;
});
};
SlowStochasticIndicator.prototype.getValues = function (series, params) {
var periods = params.periods,
fastValues = seriesTypes.stochastic.prototype.getValues.call(this,
series,
params),
slowValues = {
values: [],
xData: [],
yData: []
};
var i = 0;
if (!fastValues) {
return;
}
slowValues.xData = fastValues.xData.slice(periods[1] - 1);
var fastYData = fastValues.yData.slice(periods[1] - 1);
// Get SMA(%D)
var smoothedValues = seriesTypes.sma.prototype.getValues.call(this, {
xData: slowValues.xData,
yData: fastYData
}, {
index: 1,
period: periods[2]
});
if (!smoothedValues) {
return;
}
var xDataLen = slowValues.xData.length;
// Format data
for (; i < xDataLen; i++) {
slowValues.yData[i] = [
fastYData[i][1],
smoothedValues.yData[i - periods[2] + 1] || null
];
slowValues.values[i] = [
slowValues.xData[i],
fastYData[i][1],
smoothedValues.yData[i - periods[2] + 1] || null
];
}
return slowValues;
};
/**
* Slow Stochastic oscillator. This series requires the `linkedTo` option
* to be set and should be loaded after `stock/indicators/indicators.js`
* and `stock/indicators/stochastic.js` files.
*
* @sample stock/indicators/slow-stochastic
* Slow Stochastic oscillator
*
* @extends plotOptions.stochastic
* @since 8.0.0
* @product highstock
* @requires stock/indicators/indicators
* @requires stock/indicators/stochastic
* @requires stock/indicators/slowstochastic
* @optionparent plotOptions.slowstochastic
*/
SlowStochasticIndicator.defaultOptions = merge(StochasticIndicator.defaultOptions, {
params: {
/**
* Periods for Slow Stochastic oscillator: [%K, %D, SMA(%D)].
*
* @type {Array<number,number,number>}
* @default [14, 3, 3]
*/
periods: [14, 3, 3]
}
});
return SlowStochasticIndicator;
}(StochasticIndicator));
extend(SlowStochasticIndicator.prototype, {
nameBase: 'Slow Stochastic'
});
SeriesRegistry.registerSeriesType('slowstochastic', SlowStochasticIndicator);
/* *
*
* Default Export
*
* */
/**
* A Slow Stochastic indicator. If the [type](#series.slowstochastic.type)
* option is not specified, it is inherited from [chart.type](#chart.type).
*
* @extends series,plotOptions.slowstochastic
* @since 8.0.0
* @product highstock
* @requires stock/indicators/indicators
* @requires stock/indicators/stochastic
* @requires stock/indicators/slowstochastic
* @apioption series.slowstochastic
*/
''; // to include the above in the js output
return SlowStochasticIndicator;
});
_registerModule(_modules, 'masters/indicators/slow-stochastic.src.js', [], function () {
});
})); | cdnjs/cdnjs | ajax/libs/highcharts/9.1.1/indicators/slow-stochastic.src.js | JavaScript | mit | 9,983 |
/*!
* DevExtreme (dx.messages.en.js)
* Version: 19.1.12
* Build date: Fri Oct 09 2020
*
* Copyright (c) 2012 - 2020 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
"use strict";
! function(root, factory) {
if ("function" === typeof define && define.amd) {
define(function(require) {
factory(require("devextreme/localization"))
})
} else {
if ("object" === typeof module && module.exports) {
factory(require("devextreme/localization"))
} else {
factory(DevExpress.localization)
}
}
}(this, function(localization) {
localization.loadMessages({
en: {
Yes: "Yes",
No: "No",
Cancel: "Cancel",
Clear: "Clear",
Done: "Done",
Loading: "Loading...",
Select: "Select...",
Search: "Search",
Back: "Back",
OK: "OK",
"dxCollectionWidget-noDataText": "No data to display",
"dxDropDownEditor-selectLabel": "Select",
"validation-required": "Required",
"validation-required-formatted": "{0} is required",
"validation-numeric": "Value must be a number",
"validation-numeric-formatted": "{0} must be a number",
"validation-range": "Value is out of range",
"validation-range-formatted": "{0} is out of range",
"validation-stringLength": "The length of the value is not correct",
"validation-stringLength-formatted": "The length of {0} is not correct",
"validation-custom": "Value is invalid",
"validation-custom-formatted": "{0} is invalid",
"validation-compare": "Values do not match",
"validation-compare-formatted": "{0} does not match",
"validation-pattern": "Value does not match pattern",
"validation-pattern-formatted": "{0} does not match pattern",
"validation-email": "Email is invalid",
"validation-email-formatted": "{0} is invalid",
"validation-mask": "Value is invalid",
"dxLookup-searchPlaceholder": "Minimum character number: {0}",
"dxList-pullingDownText": "Pull down to refresh...",
"dxList-pulledDownText": "Release to refresh...",
"dxList-refreshingText": "Refreshing...",
"dxList-pageLoadingText": "Loading...",
"dxList-nextButtonText": "More",
"dxList-selectAll": "Select All",
"dxListEditDecorator-delete": "Delete",
"dxListEditDecorator-more": "More",
"dxScrollView-pullingDownText": "Pull down to refresh...",
"dxScrollView-pulledDownText": "Release to refresh...",
"dxScrollView-refreshingText": "Refreshing...",
"dxScrollView-reachBottomText": "Loading...",
"dxDateBox-simulatedDataPickerTitleTime": "Select time",
"dxDateBox-simulatedDataPickerTitleDate": "Select date",
"dxDateBox-simulatedDataPickerTitleDateTime": "Select date and time",
"dxDateBox-validation-datetime": "Value must be a date or time",
"dxFileUploader-selectFile": "Select file",
"dxFileUploader-dropFile": "or Drop file here",
"dxFileUploader-bytes": "bytes",
"dxFileUploader-kb": "kb",
"dxFileUploader-Mb": "Mb",
"dxFileUploader-Gb": "Gb",
"dxFileUploader-upload": "Upload",
"dxFileUploader-uploaded": "Uploaded",
"dxFileUploader-readyToUpload": "Ready to upload",
"dxFileUploader-uploadFailedMessage": "Upload failed",
"dxFileUploader-invalidFileExtension": "File type is not allowed",
"dxFileUploader-invalidMaxFileSize": "File is too large",
"dxFileUploader-invalidMinFileSize": "File is too small",
"dxRangeSlider-ariaFrom": "From",
"dxRangeSlider-ariaTill": "Till",
"dxSwitch-switchedOnText": "ON",
"dxSwitch-switchedOffText": "OFF",
"dxForm-optionalMark": "optional",
"dxForm-requiredMessage": "{0} is required",
"dxNumberBox-invalidValueMessage": "Value must be a number",
"dxNumberBox-noDataText": "No data",
"dxDataGrid-columnChooserTitle": "Column Chooser",
"dxDataGrid-columnChooserEmptyText": "Drag a column here to hide it",
"dxDataGrid-groupContinuesMessage": "Continues on the next page",
"dxDataGrid-groupContinuedMessage": "Continued from the previous page",
"dxDataGrid-groupHeaderText": "Group by This Column",
"dxDataGrid-ungroupHeaderText": "Ungroup",
"dxDataGrid-ungroupAllText": "Ungroup All",
"dxDataGrid-editingEditRow": "Edit",
"dxDataGrid-editingSaveRowChanges": "Save",
"dxDataGrid-editingCancelRowChanges": "Cancel",
"dxDataGrid-editingDeleteRow": "Delete",
"dxDataGrid-editingUndeleteRow": "Undelete",
"dxDataGrid-editingConfirmDeleteMessage": "Are you sure you want to delete this record?",
"dxDataGrid-validationCancelChanges": "Cancel changes",
"dxDataGrid-groupPanelEmptyText": "Drag a column header here to group by that column",
"dxDataGrid-noDataText": "No data",
"dxDataGrid-searchPanelPlaceholder": "Search...",
"dxDataGrid-filterRowShowAllText": "(All)",
"dxDataGrid-filterRowResetOperationText": "Reset",
"dxDataGrid-filterRowOperationEquals": "Equals",
"dxDataGrid-filterRowOperationNotEquals": "Does not equal",
"dxDataGrid-filterRowOperationLess": "Less than",
"dxDataGrid-filterRowOperationLessOrEquals": "Less than or equal to",
"dxDataGrid-filterRowOperationGreater": "Greater than",
"dxDataGrid-filterRowOperationGreaterOrEquals": "Greater than or equal to",
"dxDataGrid-filterRowOperationStartsWith": "Starts with",
"dxDataGrid-filterRowOperationContains": "Contains",
"dxDataGrid-filterRowOperationNotContains": "Does not contain",
"dxDataGrid-filterRowOperationEndsWith": "Ends with",
"dxDataGrid-filterRowOperationBetween": "Between",
"dxDataGrid-filterRowOperationBetweenStartText": "Start",
"dxDataGrid-filterRowOperationBetweenEndText": "End",
"dxDataGrid-applyFilterText": "Apply filter",
"dxDataGrid-trueText": "true",
"dxDataGrid-falseText": "false",
"dxDataGrid-sortingAscendingText": "Sort Ascending",
"dxDataGrid-sortingDescendingText": "Sort Descending",
"dxDataGrid-sortingClearText": "Clear Sorting",
"dxDataGrid-editingSaveAllChanges": "Save changes",
"dxDataGrid-editingCancelAllChanges": "Discard changes",
"dxDataGrid-editingAddRow": "Add a row",
"dxDataGrid-summaryMin": "Min: {0}",
"dxDataGrid-summaryMinOtherColumn": "Min of {1} is {0}",
"dxDataGrid-summaryMax": "Max: {0}",
"dxDataGrid-summaryMaxOtherColumn": "Max of {1} is {0}",
"dxDataGrid-summaryAvg": "Avg: {0}",
"dxDataGrid-summaryAvgOtherColumn": "Avg of {1} is {0}",
"dxDataGrid-summarySum": "Sum: {0}",
"dxDataGrid-summarySumOtherColumn": "Sum of {1} is {0}",
"dxDataGrid-summaryCount": "Count: {0}",
"dxDataGrid-columnFixingFix": "Fix",
"dxDataGrid-columnFixingUnfix": "Unfix",
"dxDataGrid-columnFixingLeftPosition": "To the left",
"dxDataGrid-columnFixingRightPosition": "To the right",
"dxDataGrid-exportTo": "Export",
"dxDataGrid-exportToExcel": "Export to Excel file",
"dxDataGrid-exporting": "Exporting...",
"dxDataGrid-excelFormat": "Excel file",
"dxDataGrid-selectedRows": "Selected rows",
"dxDataGrid-exportSelectedRows": "Export selected rows",
"dxDataGrid-exportAll": "Export all data",
"dxDataGrid-headerFilterEmptyValue": "(Blanks)",
"dxDataGrid-headerFilterOK": "OK",
"dxDataGrid-headerFilterCancel": "Cancel",
"dxDataGrid-ariaColumn": "Column",
"dxDataGrid-ariaValue": "Value",
"dxDataGrid-ariaFilterCell": "Filter cell",
"dxDataGrid-ariaCollapse": "Collapse",
"dxDataGrid-ariaExpand": "Expand",
"dxDataGrid-ariaDataGrid": "Data grid",
"dxDataGrid-ariaSearchInGrid": "Search in data grid",
"dxDataGrid-ariaSelectAll": "Select all",
"dxDataGrid-ariaSelectRow": "Select row",
"dxDataGrid-filterBuilderPopupTitle": "Filter Builder",
"dxDataGrid-filterPanelCreateFilter": "Create Filter",
"dxDataGrid-filterPanelClearFilter": "Clear",
"dxDataGrid-filterPanelFilterEnabledHint": "Enable the filter",
"dxTreeList-ariaTreeList": "Tree list",
"dxTreeList-editingAddRowToNode": "Add",
"dxPager-infoText": "Page {0} of {1} ({2} items)",
"dxPager-pagesCountText": "of",
"dxPivotGrid-grandTotal": "Grand Total",
"dxPivotGrid-total": "{0} Total",
"dxPivotGrid-fieldChooserTitle": "Field Chooser",
"dxPivotGrid-showFieldChooser": "Show Field Chooser",
"dxPivotGrid-expandAll": "Expand All",
"dxPivotGrid-collapseAll": "Collapse All",
"dxPivotGrid-sortColumnBySummary": 'Sort "{0}" by This Column',
"dxPivotGrid-sortRowBySummary": 'Sort "{0}" by This Row',
"dxPivotGrid-removeAllSorting": "Remove All Sorting",
"dxPivotGrid-dataNotAvailable": "N/A",
"dxPivotGrid-rowFields": "Row Fields",
"dxPivotGrid-columnFields": "Column Fields",
"dxPivotGrid-dataFields": "Data Fields",
"dxPivotGrid-filterFields": "Filter Fields",
"dxPivotGrid-allFields": "All Fields",
"dxPivotGrid-columnFieldArea": "Drop Column Fields Here",
"dxPivotGrid-dataFieldArea": "Drop Data Fields Here",
"dxPivotGrid-rowFieldArea": "Drop Row Fields Here",
"dxPivotGrid-filterFieldArea": "Drop Filter Fields Here",
"dxScheduler-editorLabelTitle": "Subject",
"dxScheduler-editorLabelStartDate": "Start Date",
"dxScheduler-editorLabelEndDate": "End Date",
"dxScheduler-editorLabelDescription": "Description",
"dxScheduler-editorLabelRecurrence": "Repeat",
"dxScheduler-openAppointment": "Open appointment",
"dxScheduler-recurrenceNever": "Never",
"dxScheduler-recurrenceDaily": "Daily",
"dxScheduler-recurrenceWeekly": "Weekly",
"dxScheduler-recurrenceMonthly": "Monthly",
"dxScheduler-recurrenceYearly": "Yearly",
"dxScheduler-recurrenceRepeatEvery": "Repeat Every",
"dxScheduler-recurrenceRepeatOn": "Repeat On",
"dxScheduler-recurrenceEnd": "End repeat",
"dxScheduler-recurrenceAfter": "After",
"dxScheduler-recurrenceOn": "On",
"dxScheduler-recurrenceRepeatDaily": "day(s)",
"dxScheduler-recurrenceRepeatWeekly": "week(s)",
"dxScheduler-recurrenceRepeatMonthly": "month(s)",
"dxScheduler-recurrenceRepeatYearly": "year(s)",
"dxScheduler-switcherDay": "Day",
"dxScheduler-switcherWeek": "Week",
"dxScheduler-switcherWorkWeek": "Work Week",
"dxScheduler-switcherMonth": "Month",
"dxScheduler-switcherAgenda": "Agenda",
"dxScheduler-switcherTimelineDay": "Timeline Day",
"dxScheduler-switcherTimelineWeek": "Timeline Week",
"dxScheduler-switcherTimelineWorkWeek": "Timeline Work Week",
"dxScheduler-switcherTimelineMonth": "Timeline Month",
"dxScheduler-recurrenceRepeatOnDate": "on date",
"dxScheduler-recurrenceRepeatCount": "occurrence(s)",
"dxScheduler-allDay": "All day",
"dxScheduler-confirmRecurrenceEditMessage": "Do you want to edit only this appointment or the whole series?",
"dxScheduler-confirmRecurrenceDeleteMessage": "Do you want to delete only this appointment or the whole series?",
"dxScheduler-confirmRecurrenceEditSeries": "Edit series",
"dxScheduler-confirmRecurrenceDeleteSeries": "Delete series",
"dxScheduler-confirmRecurrenceEditOccurrence": "Edit appointment",
"dxScheduler-confirmRecurrenceDeleteOccurrence": "Delete appointment",
"dxScheduler-noTimezoneTitle": "No timezone",
"dxScheduler-moreAppointments": "{0} more",
"dxCalendar-todayButtonText": "Today",
"dxCalendar-ariaWidgetName": "Calendar",
"dxColorView-ariaRed": "Red",
"dxColorView-ariaGreen": "Green",
"dxColorView-ariaBlue": "Blue",
"dxColorView-ariaAlpha": "Transparency",
"dxColorView-ariaHex": "Color code",
"dxTagBox-selected": "{0} selected",
"dxTagBox-allSelected": "All selected ({0})",
"dxTagBox-moreSelected": "{0} more",
"vizExport-printingButtonText": "Print",
"vizExport-titleMenuText": "Exporting/Printing",
"vizExport-exportButtonText": "{0} file",
"dxFilterBuilder-and": "And",
"dxFilterBuilder-or": "Or",
"dxFilterBuilder-notAnd": "Not And",
"dxFilterBuilder-notOr": "Not Or",
"dxFilterBuilder-addCondition": "Add Condition",
"dxFilterBuilder-addGroup": "Add Group",
"dxFilterBuilder-enterValueText": "<enter a value>",
"dxFilterBuilder-filterOperationEquals": "Equals",
"dxFilterBuilder-filterOperationNotEquals": "Does not equal",
"dxFilterBuilder-filterOperationLess": "Is less than",
"dxFilterBuilder-filterOperationLessOrEquals": "Is less than or equal to",
"dxFilterBuilder-filterOperationGreater": "Is greater than",
"dxFilterBuilder-filterOperationGreaterOrEquals": "Is greater than or equal to",
"dxFilterBuilder-filterOperationStartsWith": "Starts with",
"dxFilterBuilder-filterOperationContains": "Contains",
"dxFilterBuilder-filterOperationNotContains": "Does not contain",
"dxFilterBuilder-filterOperationEndsWith": "Ends with",
"dxFilterBuilder-filterOperationIsBlank": "Is blank",
"dxFilterBuilder-filterOperationIsNotBlank": "Is not blank",
"dxFilterBuilder-filterOperationBetween": "Is between",
"dxFilterBuilder-filterOperationAnyOf": "Is any of",
"dxFilterBuilder-filterOperationNoneOf": "Is none of",
"dxHtmlEditor-dialogColorCaption": "Change Font Color",
"dxHtmlEditor-dialogBackgroundCaption": "Change Background Color",
"dxHtmlEditor-dialogLinkCaption": "Add Link",
"dxHtmlEditor-dialogLinkUrlField": "URL",
"dxHtmlEditor-dialogLinkTextField": "Text",
"dxHtmlEditor-dialogLinkTargetField": "Open link in new window",
"dxHtmlEditor-dialogImageCaption": "Add Image",
"dxHtmlEditor-dialogImageUrlField": "URL",
"dxHtmlEditor-dialogImageAltField": "Alternate text",
"dxHtmlEditor-dialogImageWidthField": "Width (px)",
"dxHtmlEditor-dialogImageHeightField": "Height (px)",
"dxHtmlEditor-heading": "Heading",
"dxHtmlEditor-normalText": "Normal text",
"dxFileManager-newFolderName": "Untitled folder",
"dxFileManager-errorNoAccess": "Access denied. The operation cannot be completed.",
"dxFileManager-errorDirectoryExistsFormat": "Directory '{0}' already exists.",
"dxFileManager-errorFileExistsFormat": "File '{0}' already exists.",
"dxFileManager-errorFileNotFoundFormat": "File '{0}' not found",
"dxFileManager-errorDefault": "Unspecified error."
}
})
});
| cdnjs/cdnjs | ajax/libs/devextreme/19.1.12/js/localization/dx.messages.en.js | JavaScript | mit | 16,658 |
import { B as Behavior } from './index-87ddde59.js';
const ORIENT_ATTR = 'orient';
const VERTICAL = 'vertical';
const HORIZONTAL = 'horizontal';
class OrientBehavior extends Behavior {
constructor(host, value = '') {
super(host);
const mods = value.split(/\s+/g);
this.aria = !mods.includes('no-aria');
this.dynamic = mods.includes('dynamic');
this.orient = mods.includes('v') ? 'v' : 'h';
if (this.dynamic) {
host.addEventListener('focusin', () => {
const styles = getComputedStyle(host);
this.set(styles.flexFlow.includes('column')
|| styles.getPropertyValue('--orient') === 'v' ? 'v' : 'h');
}, { passive: true });
}
}
set(val) {
const { host } = this;
if (val == null) {
const attrValue = host.nuGetAttr(ORIENT_ATTR, true);
val = attrValue != null ? attrValue : 'h';
}
const orientation = val === 'v' ? VERTICAL : HORIZONTAL;
host.nuSetAria('orientation', orientation);
host.nuSetContext('orientation', orientation);
this.orient = orientation;
}
connected() {
this.set();
}
changed(name) {
if (name === ORIENT_ATTR) {
this.set();
}
}
}
export default OrientBehavior;
export { HORIZONTAL, ORIENT_ATTR, VERTICAL };
| cdnjs/cdnjs | ajax/libs/numl/1.0.0-beta.22/dev/orient-707fde4e.js | JavaScript | mit | 1,272 |
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file San 主文件
*/
(function (root) {
// 人工调整打包代码顺序，通过注释手工写一些依赖
// // require('./util/guid');
// // require('./util/empty');
// // require('./util/extend');
// // require('./util/inherits');
// // require('./util/each');
// // require('./util/contains');
// // require('./util/bind');
// // require('./browser/on');
// // require('./browser/un');
// // require('./browser/svg-tags');
// // require('./browser/create-el');
// // require('./browser/remove-el');
// // require('./util/next-tick');
// // require('./browser/ie');
// // require('./browser/ie-old-than-9');
// // require('./browser/input-event-compatible');
// // require('./browser/auto-close-tags');
// // require('./util/data-types.js');
// // require('./util/create-data-types-checker.js');
// // require('./parser/walker');
// // require('./parser/parse-template');
// // require('./runtime/change-expr-compare');
// // require('./runtime/data-change-type');
// // require('./runtime/default-filters');
// // require('./view/life-cycle');
// // require('./view/node-type');
// // require('./view/get-prop-handler');
// // require('./view/is-data-change-by-element');
// // require('./view/get-event-listener');
// // require('./view/create-node');
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 唯一id
*/
/**
* 获取唯一id
*
* @type {number} 唯一id
*/
var guid = 1;
// exports = module.exports = guid;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 空函数
*/
/**
* 啥都不干
*/
function empty() {}
// exports = module.exports = empty;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 属性拷贝
*/
/**
* 对象属性拷贝
*
* @param {Object} target 目标对象
* @param {Object} source 源对象
* @return {Object} 返回目标对象
*/
function extend(target, source) {
for (var key in source) {
/* istanbul ignore else */
if (source.hasOwnProperty(key)) {
var value = source[key];
if (typeof value !== 'undefined') {
target[key] = value;
}
}
}
return target;
}
// exports = module.exports = extend;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 构建类之间的继承关系
*/
// var extend = require('./extend');
/**
* 构建类之间的继承关系
*
* @param {Function} subClass 子类函数
* @param {Function} superClass 父类函数
*/
function inherits(subClass, superClass) {
/* jshint -W054 */
var subClassProto = subClass.prototype;
var F = new Function();
F.prototype = superClass.prototype;
subClass.prototype = new F();
subClass.prototype.constructor = subClass;
extend(subClass.prototype, subClassProto);
/* jshint +W054 */
}
// exports = module.exports = inherits;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 遍历数组
*/
/**
* 遍历数组集合
*
* @param {Array} array 数组源
* @param {function(Any,number):boolean} iterator 遍历函数
*/
function each(array, iterator) {
if (array && array.length > 0) {
for (var i = 0, l = array.length; i < l; i++) {
if (iterator(array[i], i) === false) {
break;
}
}
}
}
// exports = module.exports = each;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 判断数组中是否包含某项
*/
// var each = require('./each');
/**
* 判断数组中是否包含某项
*
* @param {Array} array 数组
* @param {*} value 包含的项
* @return {boolean}
*/
function contains(array, value) {
var result = false;
each(array, function (item) {
result = item === value;
return !result;
});
return result;
}
// exports = module.exports = contains;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file bind函数
*/
/**
* Function.prototype.bind 方法的兼容性封装
*
* @param {Function} func 要bind的函数
* @param {Object} thisArg this指向对象
* @param {...*} args 预设的初始参数
* @return {Function}
*/
function bind(func, thisArg) {
var nativeBind = Function.prototype.bind;
var slice = Array.prototype.slice;
// #[begin] allua
// if (nativeBind && func.bind === nativeBind) {
// #[end]
return nativeBind.apply(func, slice.call(arguments, 1));
// #[begin] allua
// }
//
// /* istanbul ignore next */
// var args = slice.call(arguments, 2);
// /* istanbul ignore next */
// return function () {
// return func.apply(thisArg, args.concat(slice.call(arguments)));
// };
// #[end]
}
// exports = module.exports = bind;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file DOM 事件挂载
*/
/**
* DOM 事件挂载
*
* @inner
* @param {HTMLElement} el DOM元素
* @param {string} eventName 事件名
* @param {Function} listener 监听函数
* @param {boolean} capture 是否是捕获阶段
*/
function on(el, eventName, listener, capture) {
// #[begin] allua
// /* istanbul ignore else */
// if (el.addEventListener) {
// #[end]
el.addEventListener(eventName, listener, capture);
// #[begin] allua
// }
// else {
// el.attachEvent('on' + eventName, listener);
// }
// #[end]
}
// exports = module.exports = on;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file DOM 事件卸载
*/
/**
* DOM 事件卸载
*
* @inner
* @param {HTMLElement} el DOM元素
* @param {string} eventName 事件名
* @param {Function} listener 监听函数
* @param {boolean} capture 是否是捕获阶段
*/
function un(el, eventName, listener, capture) {
// #[begin] allua
// /* istanbul ignore else */
// if (el.addEventListener) {
// #[end]
el.removeEventListener(eventName, listener, capture);
// #[begin] allua
// }
// else {
// el.detachEvent('on' + eventName, listener);
// }
// #[end]
}
// exports = module.exports = un;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 将字符串逗号切分返回对象
*/
// var each = require('../util/each');
/**
* 将字符串逗号切分返回对象
*
* @param {string} source 源字符串
* @return {Object}
*/
function splitStr2Obj(source) {
var result = {};
each(
source.split(','),
function (key) {
result[key] = key;
}
);
return result;
}
// exports = module.exports = splitStr2Obj;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file SVG标签表
*/
// var splitStr2Obj = require('../util/split-str-2-obj');
/**
* svgTags
*
* @see https://www.w3.org/TR/SVG/svgdtd.html 只取常用
* @type {Object}
*/
var svgTags = splitStr2Obj(''
// structure
+ 'svg,g,defs,desc,metadata,symbol,use,'
// image & shape
+ 'image,path,rect,circle,line,ellipse,polyline,polygon,'
// text
+ 'text,tspan,tref,textpath,'
// other
+ 'marker,pattern,clippath,mask,filter,cursor,view,animate,'
// font
+ 'font,font-face,glyph,missing-glyph,'
// camel
+ 'animateColor,animateMotion,animateTransform,textPath,foreignObject'
);
// exports = module.exports = svgTags;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file DOM创建
*/
// var svgTags = require('./svg-tags');
/**
* 创建 DOM 元素
*
* @param {string} tagName tagName
* @return {HTMLElement}
*/
function createEl(tagName) {
if (svgTags[tagName] && document.createElementNS) {
return document.createElementNS('http://www.w3.org/2000/svg', tagName);
}
return document.createElement(tagName);
}
// exports = module.exports = createEl;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 移除DOM
*/
/**
* 将 DOM 从页面中移除
*
* @param {HTMLElement} el DOM元素
*/
function removeEl(el) {
if (el && el.parentNode) {
el.parentNode.removeChild(el);
}
}
// exports = module.exports = removeEl;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 在下一个时间周期运行任务
*/
// 该方法参照了vue2.5.0的实现，感谢vue团队
// SEE: https://github.com/vuejs/vue/blob/0948d999f2fddf9f90991956493f976273c5da1f/src/core/util/env.js#L68
// var bind = require('./bind');
/**
* 下一个周期要执行的任务列表
*
* @inner
* @type {Array}
*/
var nextTasks = [];
/**
* 执行下一个周期任务的函数
*
* @inner
* @type {Function}
*/
var nextHandler;
/**
* 浏览器是否支持原生Promise
* 对Promise做判断，是为了禁用一些不严谨的Promise的polyfill
*
* @inner
* @type {boolean}
*/
var isNativePromise = typeof Promise === 'function' && /native code/.test(Promise);
/**
* 在下一个时间周期运行任务
*
* @inner
* @param {Function} fn 要运行的任务函数
* @param {Object=} thisArg this指向对象
*/
function nextTick(fn, thisArg) {
if (thisArg) {
fn = bind(fn, thisArg);
}
nextTasks.push(fn);
if (nextHandler) {
return;
}
nextHandler = function () {
var tasks = nextTasks.slice(0);
nextTasks = [];
nextHandler = null;
for (var i = 0, l = tasks.length; i < l; i++) {
tasks[i]();
}
};
// 非标准方法，但是此方法非常吻合要求。
/* istanbul ignore next */
if (typeof setImmediate === 'function') {
setImmediate(nextHandler);
}
// 用MessageChannel去做setImmediate的polyfill
// 原理是将新的message事件加入到原有的dom events之后
else if (typeof MessageChannel === 'function') {
var channel = new MessageChannel();
var port = channel.port2;
channel.port1.onmessage = nextHandler;
port.postMessage(1);
}
// for native app
else if (isNativePromise) {
Promise.resolve().then(nextHandler);
}
else {
setTimeout(nextHandler, 0);
}
}
// exports = module.exports = nextTick;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file ie版本号
*/
// #[begin] allua
// /**
// * 从userAgent中ie版本号的匹配信息
// *
// * @type {Array}
// */
// var ieVersionMatch = typeof navigator !== 'undefined'
// && navigator.userAgent.match(/msie\s*([0-9]+)/i);
//
// /**
// * ie版本号，非ie时为0
// *
// * @type {number}
// */
// var ie = ieVersionMatch ? /* istanbul ignore next */ ieVersionMatch[1] - 0 : 0;
// #[end]
// exports = module.exports = ie;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 是否 IE 并且小于 9
*/
// var ie = require('./ie');
// HACK:
// 1. IE8下，设置innerHTML时如果以html comment开头，comment会被自动滤掉
// 为了保证stump存在，需要设置完html后，createComment并appendChild/insertBefore
// 2. IE8下，innerHTML还不支持custom element，所以需要用div替代，不用createElement
// 3. 虽然IE8已经优化了字符串+连接，碎片化连接性能不再退化
// 但是由于上面多个兼容场景都用 < 9 判断，所以字符串连接也沿用
// 所以结果是IE8下字符串连接用的是数组join的方式
// #[begin] allua
// /**
// * 是否 IE 并且小于 9
// */
// var ieOldThan9 = ie && /* istanbul ignore next */ ie < 9;
// #[end]
// exports = module.exports = ieOldThan9;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 触发元素事件
*/
/**
* 触发元素事件
*
* @inner
* @param {HTMLElement} el DOM元素
* @param {string} eventName 事件名
*/
function trigger(el, eventName) {
var event = document.createEvent('HTMLEvents');
event.initEvent(eventName, true, true);
el.dispatchEvent(event);
}
// exports = module.exports = trigger;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解决 IE9 在表单元素中删除字符时不触发事件的问题
*/
// var ie = require('./ie');
// var on = require('./on');
// var trigger = require('./trigger');
// #[begin] allua
// /* istanbul ignore if */
// if (ie === 9) {
// on(document, 'selectionchange', function () {
// var el = document.activeElement;
// if (el.tagName === 'TEXTAREA' || el.tagName === 'INPUT') {
// trigger(el, 'input');
// }
// });
// }
// #[end]
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 自闭合标签表
*/
// var splitStr2Obj = require('../util/split-str-2-obj');
/**
* 自闭合标签列表
*
* @type {Object}
*/
var autoCloseTags = splitStr2Obj('area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr');
// exports = module.exports = autoCloseTags;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file data types
*/
// var bind = require('./bind');
// var empty = require('./empty');
// var extend = require('./extend');
// #[begin] error
// var ANONYMOUS_CLASS_NAME = '<<anonymous>>';
//
// /**
// * 获取精确的类型
// *
// * @NOTE 如果 obj 是一个 DOMElement，我们会返回 `element`；
// *
// * @param {*} obj 目标
// * @return {string}
// */
// function getDataType(obj) {
// // 不支持element了。data应该是纯数据
// // if (obj && obj.nodeType === 1) {
// // return 'element';
// // }
//
// return Object.prototype.toString
// .call(obj)
// .slice(8, -1)
// .toLowerCase();
// }
// #[end]
/**
* 创建链式的数据类型校验器
*
* @param {Function} validate 真正的校验器
* @return {Function}
*/
function createChainableChecker(validate) {
/* istanbul ignore next */
var chainedChecker = function () {};
chainedChecker.isRequired = empty;
// 只在 error 功能启用时才有实际上的 dataTypes 检测
// #[begin] error
// validate = validate || empty;
// var checkType = function (isRequired, data, dataName, componentName, fullDataName) {
//
// var dataValue = data[dataName];
// var dataType = getDataType(dataValue);
//
// /* istanbul ignore next */
// componentName = componentName || ANONYMOUS_CLASS_NAME;
//
// // 如果是 null 或 undefined，那么要提前返回啦
// if (dataValue == null) {
// // 是 required 就报错
// if (isRequired) {
// throw new Error('[SAN ERROR] '
// + 'The `' + dataName + '` '
// + 'is marked as required in `' + componentName + '`, '
// + 'but its value is ' + dataType
// );
// }
// // 不是 required，那就是 ok 的
// return;
// }
//
// validate(data, dataName, componentName, fullDataName);
//
// };
//
// chainedChecker = bind(checkType, null, false);
// chainedChecker.isRequired = bind(checkType, null, true);
// #[end]
return chainedChecker;
}
// #[begin] error
// /**
// * 生成主要类型数据校验器
// *
// * @param {string} type 主类型
// * @return {Function}
// */
// function createPrimaryTypeChecker(type) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// var dataValue = data[dataName];
// var dataType = getDataType(dataValue);
//
// if (dataType !== type) {
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + fullDataName + '` of type'
// + '(' + dataType + ' supplied to ' + componentName + ', '
// + 'expected ' + type + ')'
// );
// }
//
// });
//
// }
//
//
//
// /**
// * 生成 arrayOf 校验器
// *
// * @param {Function} arrayItemChecker 数组中每项数据的校验器
// * @return {Function}
// */
// function createArrayOfChecker(arrayItemChecker) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// if (typeof arrayItemChecker !== 'function') {
// throw new Error('[SAN ERROR] '
// + 'Data `' + dataName + '` of `' + componentName + '` has invalid '
// + 'DataType notation inside `arrayOf`, expected `function`'
// );
// }
//
// var dataValue = data[dataName];
// var dataType = getDataType(dataValue);
//
// if (dataType !== 'array') {
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + fullDataName + '` of type'
// + '(' + dataType + ' supplied to ' + componentName + ', '
// + 'expected array)'
// );
// }
//
// for (var i = 0, len = dataValue.length; i < len; i++) {
// arrayItemChecker(dataValue, i, componentName, fullDataName + '[' + i + ']');
// }
//
// });
//
// }
//
// /**
// * 生成 instanceOf 检测器
// *
// * @param {Function|Class} expectedClass 期待的类
// * @return {Function}
// */
// function createInstanceOfChecker(expectedClass) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// var dataValue = data[dataName];
//
// if (dataValue instanceof expectedClass) {
// return;
// }
//
// var dataValueClassName = dataValue.constructor && dataValue.constructor.name
// ? dataValue.constructor.name
// : /* istanbul ignore next */ ANONYMOUS_CLASS_NAME;
//
// /* istanbul ignore next */
// var expectedClassName = expectedClass.name || ANONYMOUS_CLASS_NAME;
//
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + fullDataName + '` of type'
// + '(' + dataValueClassName + ' supplied to ' + componentName + ', '
// + 'expected instance of ' + expectedClassName + ')'
// );
//
//
// });
//
// }
//
// /**
// * 生成 shape 校验器
// *
// * @param {Object} shapeTypes shape 校验规则
// * @return {Function}
// */
// function createShapeChecker(shapeTypes) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// if (getDataType(shapeTypes) !== 'object') {
// throw new Error('[SAN ERROR] '
// + 'Data `' + fullDataName + '` of `' + componentName + '` has invalid '
// + 'DataType notation inside `shape`, expected `object`'
// );
// }
//
// var dataValue = data[dataName];
// var dataType = getDataType(dataValue);
//
// if (dataType !== 'object') {
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + fullDataName + '` of type'
// + '(' + dataType + ' supplied to ' + componentName + ', '
// + 'expected object)'
// );
// }
//
// for (var shapeKeyName in shapeTypes) {
// /* istanbul ignore else */
// if (shapeTypes.hasOwnProperty(shapeKeyName)) {
// var checker = shapeTypes[shapeKeyName];
// if (typeof checker === 'function') {
// checker(dataValue, shapeKeyName, componentName, fullDataName + '.' + shapeKeyName);
// }
// }
// }
//
// });
//
// }
//
// /**
// * 生成 oneOf 校验器
// *
// * @param {Array} expectedEnumValues 期待的枚举值
// * @return {Function}
// */
// function createOneOfChecker(expectedEnumValues) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// if (getDataType(expectedEnumValues) !== 'array') {
// throw new Error('[SAN ERROR] '
// + 'Data `' + fullDataName + '` of `' + componentName + '` has invalid '
// + 'DataType notation inside `oneOf`, array is expected.'
// );
// }
//
// var dataValue = data[dataName];
//
// for (var i = 0, len = expectedEnumValues.length; i < len; i++) {
// if (dataValue === expectedEnumValues[i]) {
// return;
// }
// }
//
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + fullDataName + '` of value'
// + '(`' + dataValue + '` supplied to ' + componentName + ', '
// + 'expected one of ' + expectedEnumValues.join(',') + ')'
// );
//
// });
//
// }
//
// /**
// * 生成 oneOfType 校验器
// *
// * @param {Array<Function>} expectedEnumOfTypeValues 期待的枚举类型
// * @return {Function}
// */
// function createOneOfTypeChecker(expectedEnumOfTypeValues) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// if (getDataType(expectedEnumOfTypeValues) !== 'array') {
// throw new Error('[SAN ERROR] '
// + 'Data `' + dataName + '` of `' + componentName + '` has invalid '
// + 'DataType notation inside `oneOf`, array is expected.'
// );
// }
//
// var dataValue = data[dataName];
//
// for (var i = 0, len = expectedEnumOfTypeValues.length; i < len; i++) {
//
// var checker = expectedEnumOfTypeValues[i];
//
// if (typeof checker !== 'function') {
// continue;
// }
//
// try {
// checker(data, dataName, componentName, fullDataName);
// // 如果 checker 完成校验没报错，那就返回了
// return;
// }
// catch (e) {
// // 如果有错误，那么应该把错误吞掉
// }
//
// }
//
// // 所有的可接受 type 都失败了，才丢一个异常
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + dataName + '` of value'
// + '(`' + dataValue + '` supplied to ' + componentName + ')'
// );
//
// });
//
// }
//
// /**
// * 生成 objectOf 校验器
// *
// * @param {Function} typeChecker 对象属性值校验器
// * @return {Function}
// */
// function createObjectOfChecker(typeChecker) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName) {
//
// if (typeof typeChecker !== 'function') {
// throw new Error('[SAN ERROR] '
// + 'Data `' + dataName + '` of `' + componentName + '` has invalid '
// + 'DataType notation inside `objectOf`, expected function'
// );
// }
//
// var dataValue = data[dataName];
// var dataType = getDataType(dataValue);
//
// if (dataType !== 'object') {
// throw new Error('[SAN ERROR] '
// + 'Invalid ' + componentName + ' data `' + dataName + '` of type'
// + '(' + dataType + ' supplied to ' + componentName + ', '
// + 'expected object)'
// );
// }
//
// for (var dataKeyName in dataValue) {
// /* istanbul ignore else */
// if (dataValue.hasOwnProperty(dataKeyName)) {
// typeChecker(
// dataValue,
// dataKeyName,
// componentName,
// fullDataName + '.' + dataKeyName
// );
// }
// }
//
//
// });
//
// }
//
// /**
// * 生成 exact 校验器
// *
// * @param {Object} shapeTypes object 形态定义
// * @return {Function}
// */
// function createExactChecker(shapeTypes) {
//
// return createChainableChecker(function (data, dataName, componentName, fullDataName, secret) {
//
// if (getDataType(shapeTypes) !== 'object') {
// throw new Error('[SAN ERROR] '
// + 'Data `' + dataName + '` of `' + componentName + '` has invalid '
// + 'DataType notation inside `exact`'
// );
// }
//
// var dataValue = data[dataName];
// var dataValueType = getDataType(dataValue);
//
// if (dataValueType !== 'object') {
// throw new Error('[SAN ERROR] '
// + 'Invalid data `' + fullDataName + '` of type `' + dataValueType + '`'
// + '(supplied to ' + componentName + ', expected `object`)'
// );
// }
//
// var allKeys = {};
//
// // 先合入 shapeTypes
// extend(allKeys, shapeTypes);
// // 再合入 dataValue
// extend(allKeys, dataValue);
// // 保证 allKeys 的类型正确
//
// for (var key in allKeys) {
// /* istanbul ignore else */
// if (allKeys.hasOwnProperty(key)) {
// var checker = shapeTypes[key];
//
// // dataValue 中有一个多余的数据项
// if (!checker) {
// throw new Error('[SAN ERROR] '
// + 'Invalid data `' + fullDataName + '` key `' + key + '` '
// + 'supplied to `' + componentName + '`. '
// + '(`' + key + '` is not defined in `DataTypes.exact`)'
// );
// }
//
// if (!(key in dataValue)) {
// throw new Error('[SAN ERROR] '
// + 'Invalid data `' + fullDataName + '` key `' + key + '` '
// + 'supplied to `' + componentName + '`. '
// + '(`' + key + '` is marked `required` in `DataTypes.exact`)'
// );
// }
//
// checker(
// dataValue,
// key,
// componentName,
// fullDataName + '.' + key,
// secret
// );
//
// }
// }
//
// });
//
// }
// #[end]
/* eslint-disable fecs-valid-var-jsdoc */
var DataTypes = {
array: createChainableChecker(),
object: createChainableChecker(),
func: createChainableChecker(),
string: createChainableChecker(),
number: createChainableChecker(),
bool: createChainableChecker(),
symbol: createChainableChecker(),
any: createChainableChecker,
arrayOf: createChainableChecker,
instanceOf: createChainableChecker,
shape: createChainableChecker,
oneOf: createChainableChecker,
oneOfType: createChainableChecker,
objectOf: createChainableChecker,
exact: createChainableChecker
};
// #[begin] error
// DataTypes = {
//
// any: createChainableChecker(),
//
// // 类型检测
// array: createPrimaryTypeChecker('array'),
// object: createPrimaryTypeChecker('object'),
// func: createPrimaryTypeChecker('function'),
// string: createPrimaryTypeChecker('string'),
// number: createPrimaryTypeChecker('number'),
// bool: createPrimaryTypeChecker('boolean'),
// symbol: createPrimaryTypeChecker('symbol'),
//
// // 复合类型检测
// arrayOf: createArrayOfChecker,
// instanceOf: createInstanceOfChecker,
// shape: createShapeChecker,
// oneOf: createOneOfChecker,
// oneOfType: createOneOfTypeChecker,
// objectOf: createObjectOfChecker,
// exact: createExactChecker
//
// };
// /* eslint-enable fecs-valid-var-jsdoc */
// #[end]
// module.exports = DataTypes;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 创建数据检测函数
*/
// #[begin] error
//
// /**
// * 创建数据检测函数
// *
// * @param {Object} dataTypes 数据格式
// * @param {string} componentName 组件名
// * @return {Function}
// */
// function createDataTypesChecker(dataTypes, componentName) {
//
// /**
// * 校验 data 是否满足 data types 的格式
// *
// * @param {*} data 数据
// */
// return function (data) {
//
// for (var dataTypeName in dataTypes) {
// /* istanbul ignore else */
// if (dataTypes.hasOwnProperty(dataTypeName)) {
//
// var dataTypeChecker = dataTypes[dataTypeName];
//
// if (typeof dataTypeChecker !== 'function') {
// throw new Error('[SAN ERROR] '
// + componentName + ':' + dataTypeName + ' is invalid; '
// + 'it must be a function, usually from san.DataTypes'
// );
// }
//
// dataTypeChecker(
// data,
// dataTypeName,
// componentName,
// dataTypeName
// );
//
//
// }
// }
//
// };
//
// }
//
// #[end]
// module.exports = createDataTypesChecker;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 字符串源码读取类
*/
/**
* 字符串源码读取类，用于模板字符串解析过程
*
* @class
* @param {string} source 要读取的字符串
*/
function Walker(source) {
this.source = source;
this.len = this.source.length;
this.index = 0;
}
/**
* 获取当前字符码
*
* @return {number}
*/
Walker.prototype.currentCode = function () {
return this.source.charCodeAt(this.index);
};
/**
* 截取字符串片段
*
* @param {number} start 起始位置
* @param {number} end 结束位置
* @return {string}
*/
Walker.prototype.cut = function (start, end) {
return this.source.slice(start, end);
};
/**
* 向前读取字符
*
* @param {number} distance 读取字符数
*/
Walker.prototype.go = function (distance) {
this.index += distance;
};
/**
* 读取下一个字符，返回下一个字符的 code
*
* @return {number}
*/
Walker.prototype.nextCode = function () {
this.go(1);
return this.currentCode();
};
/**
* 获取相应位置字符的 code
*
* @param {number} index 字符位置
* @return {number}
*/
Walker.prototype.charCode = function (index) {
return this.source.charCodeAt(index);
};
/**
* 向前读取字符，直到遇到指定字符再停止
* 未指定字符时，当遇到第一个非空格、制表符的字符停止
*
* @param {number=} charCode 指定字符的code
* @return {boolean} 当指定字符时，返回是否碰到指定的字符
*/
Walker.prototype.goUntil = function (charCode) {
var code;
while (this.index < this.len && (code = this.currentCode())) {
switch (code) {
case 32: // 空格 space
case 9: // 制表符 tab
case 13: // \r
case 10: // \n
this.index++;
break;
default:
if (code === charCode) {
this.index++;
return 1;
}
return;
}
}
};
/**
* 向前读取符合规则的字符片段，并返回规则匹配结果
*
* @param {RegExp} reg 字符片段的正则表达式
* @param {boolean} isMatchStart 是否必须匹配当前位置
* @return {Array?}
*/
Walker.prototype.match = function (reg, isMatchStart) {
reg.lastIndex = this.index;
var match = reg.exec(this.source);
if (match && (!isMatchStart || this.index === match.index)) {
this.index = reg.lastIndex;
return match;
}
};
// exports = module.exports = Walker;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 把 kebab case 字符串转换成 camel case
*/
/**
* 把 kebab case 字符串转换成 camel case
*
* @param {string} source 源字符串
* @return {string}
*/
function kebab2camel(source) {
return source.replace(/-+(.)/ig, function (match, alpha) {
return alpha.toUpperCase();
});
}
// exports = module.exports = kebab2camel;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file bool属性表
*/
// var splitStr2Obj = require('../util/split-str-2-obj');
/**
* bool属性表
*
* @type {Object}
*/
var boolAttrs = splitStr2Obj(
'allowpaymentrequest,async,autofocus,autoplay,'
+ 'checked,controls,default,defer,disabled,formnovalidate,'
+ 'hidden,ismap,itemscope,loop,multiple,muted,nomodule,novalidate,'
+ 'open,readonly,required,reversed,selected,typemustmatch'
);
// exports = module.exports = boolAttrs;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 表达式类型
*/
/**
* 表达式类型
*
* @const
* @type {Object}
*/
var ExprType = {
STRING: 1,
NUMBER: 2,
BOOL: 3,
ACCESSOR: 4,
INTERP: 5,
CALL: 6,
TEXT: 7,
BINARY: 8,
UNARY: 9,
TERTIARY: 10,
OBJECT: 11,
ARRAY: 12,
NULL: 13
};
// exports = module.exports = ExprType;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 创建访问表达式对象
*/
// var ExprType = require('./expr-type');
/**
* 创建访问表达式对象
*
* @param {Array} paths 访问路径
* @return {Object}
*/
function createAccessor(paths) {
return {
type: 4,
paths: paths
};
}
// exports = module.exports = createAccessor;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取字符串
*/
// var ExprType = require('./expr-type');
/**
* 读取字符串
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readString(walker) {
var startCode = walker.currentCode();
var startIndex = walker.index;
var charCode;
walkLoop: while ((charCode = walker.nextCode())) {
switch (charCode) {
case 92: // \
walker.go(1);
break;
case startCode:
walker.go(1);
break walkLoop;
}
}
var literal = walker.cut(startIndex, walker.index);
return {
type: 1,
// 处理字符转义
value: (new Function('return ' + literal))()
};
}
// exports = module.exports = readString;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取一元表达式
*/
// var ExprType = require('./expr-type');
// var readString = require('./read-string');
// var readNumber = require('./read-number');
// var readCall = require('./read-call');
// var readParenthesizedExpr = require('./read-parenthesized-expr');
// var readTertiaryExpr = require('./read-tertiary-expr');
function postUnaryExpr(expr, operator) {
switch (operator) {
case 33:
var value;
switch (expr.type) {
case 2:
case 1:
case 3:
value = !expr.value;
break;
case 12:
case 11:
value = false;
break;
case 13:
value = true;
break;
}
if (value != null) {
return {
type: 3,
value: value
};
}
break;
case 43:
switch (expr.type) {
case 2:
case 1:
case 3:
return {
type: 2,
value: +expr.value
};
}
break;
case 45:
switch (expr.type) {
case 2:
case 1:
case 3:
return {
type: 2,
value: -expr.value
};
}
break;
}
return {
type: 9,
expr: expr,
operator: operator
};
}
/**
* 读取一元表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readUnaryExpr(walker) {
walker.goUntil();
var currentCode = walker.currentCode();
switch (currentCode) {
case 33: // !
case 43: // +
case 45: // -
walker.go(1);
return postUnaryExpr(readUnaryExpr(walker), currentCode);
case 34: // "
case 39: // '
return readString(walker);
case 48: // number
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
return readNumber(walker);
case 40: // (
return readParenthesizedExpr(walker);
// array literal
case 91: // [
walker.go(1);
var arrItems = [];
while (!walker.goUntil(93)) { // ]
var item = {};
arrItems.push(item);
if (walker.currentCode() === 46 && walker.match(/\.\.\.\s*/g)) {
item.spread = true;
}
item.expr = readTertiaryExpr(walker);
walker.goUntil(44); // ,
}
return {
type: 12,
items: arrItems
};
// object literal
case 123: // {
walker.go(1);
var objItems = [];
while (!walker.goUntil(125)) { // }
var item = {};
objItems.push(item);
if (walker.currentCode() === 46 && walker.match(/\.\.\.\s*/g)) {
item.spread = true;
item.expr = readTertiaryExpr(walker);
}
else {
// #[begin] error
// var walkerIndexBeforeName = walker.index;
// #[end]
item.name = readUnaryExpr(walker);
// #[begin] error
// if (item.name.type > 4) {
// throw new Error(
// '[SAN FATAL] unexpect object name: '
// + walker.cut(walkerIndexBeforeName, walker.index)
// );
// }
// #[end]
if (walker.goUntil(58)) { // :
item.expr = readTertiaryExpr(walker);
}
else {
item.expr = item.name;
}
if (item.name.type === 4) {
item.name = item.name.paths[0];
}
}
walker.goUntil(44); // ,
}
return {
type: 11,
items: objItems
};
}
return readCall(walker);
}
// exports = module.exports = readUnaryExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取数字
*/
// var ExprType = require('./expr-type');
// var readUnaryExpr = require('./read-unary-expr');
/**
* 读取数字
*
* @inner
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readNumber(walker) {
var match = walker.match(/\s*([0-9]+(\.[0-9]+)?)/g, 1);
if (match) {
return {
type: 2,
value: +match[1]
};
}
}
// exports = module.exports = readNumber;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取ident
*/
/**
* 读取ident
* 这里的 ident 指标识符(identifier)，也就是通常意义上的变量名
* 这里默认的变量名规则为：由美元符号($)、数字、字母或者下划线(_)构成的字符串
*
* @inner
* @param {Walker} walker 源码读取对象
* @return {string}
*/
function readIdent(walker) {
var match = walker.match(/\s*([\$0-9a-z_]+)/ig, 1);
// #[begin] error
// if (!match) {
// throw new Error('[SAN FATAL] expect an ident: ' + walker.cut(walker.index));
// }
// #[end]
return match[1];
}
// exports = module.exports = readIdent;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取三元表达式
*/
// var ExprType = require('./expr-type');
// var readLogicalORExpr = require('./read-logical-or-expr');
/**
* 读取三元表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readTertiaryExpr(walker) {
var conditional = readLogicalORExpr(walker);
walker.goUntil();
if (walker.currentCode() === 63) { // ?
walker.go(1);
var yesExpr = readTertiaryExpr(walker);
walker.goUntil();
if (walker.currentCode() === 58) { // :
walker.go(1);
return {
type: 10,
segs: [
conditional,
yesExpr,
readTertiaryExpr(walker)
]
};
}
}
return conditional;
}
// exports = module.exports = readTertiaryExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取访问表达式
*/
// var ExprType = require('./expr-type');
// var createAccessor = require('./create-accessor');
// var readIdent = require('./read-ident');
// var readTertiaryExpr = require('./read-tertiary-expr');
/**
* 读取访问表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readAccessor(walker) {
var firstSeg = readIdent(walker);
switch (firstSeg) {
case 'true':
case 'false':
return {
type: 3,
value: firstSeg === 'true'
};
case 'null':
return {
type: 13
};
}
var result = createAccessor([
{
type: 1,
value: firstSeg
}
]);
/* eslint-disable no-constant-condition */
accessorLoop: while (1) {
/* eslint-enable no-constant-condition */
switch (walker.currentCode()) {
case 46: // .
walker.go(1);
// ident as string
result.paths.push({
type: 1,
value: readIdent(walker)
});
break;
case 91: // [
walker.go(1);
result.paths.push(readTertiaryExpr(walker));
walker.goUntil(93); // ]
break;
default:
break accessorLoop;
}
}
return result;
}
// exports = module.exports = readAccessor;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取调用
*/
// var ExprType = require('./expr-type');
// var readAccessor = require('./read-accessor');
// var readTertiaryExpr = require('./read-tertiary-expr');
/**
* 读取调用
*
* @param {Walker} walker 源码读取对象
* @param {Array=} defaultArgs 默认参数
* @return {Object}
*/
function readCall(walker, defaultArgs) {
walker.goUntil();
var result = readAccessor(walker);
var args;
if (walker.goUntil(40)) { // (
args = [];
while (!walker.goUntil(41)) { // )
args.push(readTertiaryExpr(walker));
walker.goUntil(44); // ,
}
}
else if (defaultArgs) {
args = defaultArgs;
}
if (args) {
result = {
type: 6,
name: result,
args: args
};
}
return result;
}
// exports = module.exports = readCall;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取括号表达式
*/
// var readTertiaryExpr = require('./read-tertiary-expr');
/**
* 读取括号表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readParenthesizedExpr(walker) {
walker.go(1);
var expr = readTertiaryExpr(walker);
walker.goUntil(41); // )
expr.parenthesized = true;
return expr;
}
// exports = module.exports = readParenthesizedExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取乘法表达式
*/
// var ExprType = require('./expr-type');
// var readUnaryExpr = require('./read-unary-expr');
/**
* 读取乘法表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readMultiplicativeExpr(walker) {
var expr = readUnaryExpr(walker);
while (1) {
walker.goUntil();
var code = walker.currentCode();
switch (code) {
case 37: // %
case 42: // *
case 47: // /
walker.go(1);
expr = {
type: 8,
operator: code,
segs: [expr, readUnaryExpr(walker)]
};
continue;
}
break;
}
return expr;
}
// exports = module.exports = readMultiplicativeExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取加法表达式
*/
// var ExprType = require('./expr-type');
// var readMultiplicativeExpr = require('./read-multiplicative-expr');
/**
* 读取加法表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readAdditiveExpr(walker) {
var expr = readMultiplicativeExpr(walker);
while (1) {
walker.goUntil();
var code = walker.currentCode();
switch (code) {
case 43: // +
case 45: // -
walker.go(1);
expr = {
type: 8,
operator: code,
segs: [expr, readMultiplicativeExpr(walker)]
};
continue;
}
break;
}
return expr;
}
// exports = module.exports = readAdditiveExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取关系判断表达式
*/
// var ExprType = require('./expr-type');
// var readAdditiveExpr = require('./read-additive-expr');
/**
* 读取关系判断表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readRelationalExpr(walker) {
var expr = readAdditiveExpr(walker);
walker.goUntil();
var code = walker.currentCode();
switch (code) {
case 60: // <
case 62: // >
if (walker.nextCode() === 61) {
code += 61;
walker.go(1);
}
return {
type: 8,
operator: code,
segs: [expr, readAdditiveExpr(walker)]
};
}
return expr;
}
// exports = module.exports = readRelationalExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取相等比对表达式
*/
// var ExprType = require('./expr-type');
// var readRelationalExpr = require('./read-relational-expr');
/**
* 读取相等比对表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readEqualityExpr(walker) {
var expr = readRelationalExpr(walker);
walker.goUntil();
var code = walker.currentCode();
switch (code) {
case 61: // =
case 33: // !
if (walker.nextCode() === 61) {
code += 61;
if (walker.nextCode() === 61) {
code += 61;
walker.go(1);
}
return {
type: 8,
operator: code,
segs: [expr, readRelationalExpr(walker)]
};
}
walker.go(-1);
}
return expr;
}
// exports = module.exports = readEqualityExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取逻辑与表达式
*/
// var ExprType = require('./expr-type');
// var readEqualityExpr = require('./read-equality-expr');
/**
* 读取逻辑与表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readLogicalANDExpr(walker) {
var expr = readEqualityExpr(walker);
walker.goUntil();
if (walker.currentCode() === 38) { // &
if (walker.nextCode() === 38) {
walker.go(1);
return {
type: 8,
operator: 76,
segs: [expr, readLogicalANDExpr(walker)]
};
}
walker.go(-1);
}
return expr;
}
// exports = module.exports = readLogicalANDExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 读取逻辑或表达式
*/
// var ExprType = require('./expr-type');
// var readLogicalANDExpr = require('./read-logical-and-expr');
/**
* 读取逻辑或表达式
*
* @param {Walker} walker 源码读取对象
* @return {Object}
*/
function readLogicalORExpr(walker) {
var expr = readLogicalANDExpr(walker);
walker.goUntil();
if (walker.currentCode() === 124) { // |
if (walker.nextCode() === 124) {
walker.go(1);
return {
type: 8,
operator: 248,
segs: [expr, readLogicalORExpr(walker)]
};
}
walker.go(-1);
}
return expr;
}
// exports = module.exports = readLogicalORExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析表达式
*/
// var Walker = require('./walker');
// var readTertiaryExpr = require('./read-tertiary-expr');
/**
* 解析表达式
*
* @param {string} source 源码
* @return {Object}
*/
function parseExpr(source) {
if (!source) {
return;
}
if (typeof source === 'object' && source.type) {
return source;
}
var expr = readTertiaryExpr(new Walker(source));
expr.raw = source;
return expr;
}
// exports = module.exports = parseExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析调用
*/
// var Walker = require('./walker');
// var ExprType = require('./expr-type');
// var readCall = require('./read-call');
/**
* 解析调用
*
* @param {string} source 源码
* @param {Array=} defaultArgs 默认参数
* @return {Object}
*/
function parseCall(source, defaultArgs) {
var expr = readCall(new Walker(source), defaultArgs);
if (expr.type !== 6) {
expr = {
type: 6,
name: expr,
args: defaultArgs || []
};
}
expr.raw = source;
return expr;
}
// exports = module.exports = parseCall;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析插值替换
*/
// var Walker = require('./walker');
// var readTertiaryExpr = require('./read-tertiary-expr');
// var ExprType = require('./expr-type');
// var readCall = require('./read-call');
/**
* 解析插值替换
*
* @param {string} source 源码
* @return {Object}
*/
function parseInterp(source) {
var walker = new Walker(source);
var interp = {
type: 5,
expr: readTertiaryExpr(walker),
filters: [],
raw: source
};
while (walker.goUntil(124)) { // |
var callExpr = readCall(walker, []);
switch (callExpr.name.paths[0].value) {
case 'html':
break;
case 'raw':
interp.original = 1;
break;
default:
interp.filters.push(callExpr);
}
}
return interp;
}
// exports = module.exports = parseInterp;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解码 HTML 字符实体
*/
var ENTITY_DECODE_MAP = {
lt: '<',
gt: '>',
nbsp: ' ',
quot: '\"',
emsp: '\u2003',
ensp: '\u2002',
thinsp: '\u2009',
copy: '\xa9',
reg: '\xae',
zwnj: '\u200c',
zwj: '\u200d',
amp: '&'
};
/**
* 解码 HTML 字符实体
*
* @param {string} source 要解码的字符串
* @return {string}
*/
function decodeHTMLEntity(source) {
return source
.replace(/&#([0-9]+);/g, function (match, code) {
return String.fromCharCode(+code);
})
.replace(/&#x([0-9a-f]+);/ig, function (match, code) {
return String.fromCharCode(parseInt(code, 16));
})
.replace(/&([a-z]+);/ig, function (match, code) {
return ENTITY_DECODE_MAP[code] || match;
});
}
// exports = module.exports = decodeHTMLEntity;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析文本
*/
// var Walker = require('./walker');
// var ExprType = require('./expr-type');
// var parseInterp = require('./parse-interp');
// var decodeHTMLEntity = require('../util/decode-html-entity');
/**
* 对字符串进行可用于new RegExp的字面化
*
* @inner
* @param {string} source 需要字面化的字符串
* @return {string} 字符串字面化结果
*/
function regexpLiteral(source) {
return source.replace(/[\^\[\]\$\(\)\{\}\?\*\.\+\\]/g, function (c) {
return '\\' + c;
});
}
var delimRegCache = {};
/**
* 解析文本
*
* @param {string} source 源码
* @param {Array?} delimiters 分隔符。默认为 ['{{', '}}']
* @return {Object}
*/
function parseText(source, delimiters) {
delimiters = delimiters || ['{{', '}}'];
var regCacheKey = delimiters[0] + '>..<' + delimiters[1];
var exprStartReg = delimRegCache[regCacheKey];
if (!exprStartReg) {
exprStartReg = new RegExp(
regexpLiteral(delimiters[0])
+ '\\s*([\\s\\S]+?)\\s*'
+ regexpLiteral(delimiters[1]),
'g'
);
delimRegCache[regCacheKey] = exprStartReg;
}
var exprMatch;
var walker = new Walker(source);
var beforeIndex = 0;
var expr = {
type: 7,
segs: []
};
function pushStringToSeg(text) {
text && expr.segs.push({
type: 1,
literal: text,
value: decodeHTMLEntity(text)
});
}
var delimEndLen = delimiters[1].length;
while ((exprMatch = walker.match(exprStartReg)) != null) {
var interpSource = exprMatch[1];
var interpLen = exprMatch[0].length;
if (walker.cut(walker.index + 1 - delimEndLen, walker.index + 1) === delimiters[1]) {
interpSource += walker.cut(walker.index, walker.index + 1);
walker.go(1);
interpLen++;
}
pushStringToSeg(walker.cut(
beforeIndex,
walker.index - interpLen
));
var interp = parseInterp(interpSource);
expr.original = expr.original || interp.original;
expr.segs.push(interp);
beforeIndex = walker.index;
}
pushStringToSeg(walker.cut(beforeIndex));
if (expr.segs.length === 1 && expr.segs[0].type === 1) {
expr.value = expr.segs[0].value;
}
return expr;
}
// exports = module.exports = parseText;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析指令
*/
// var Walker = require('./walker');
// var parseExpr = require('./parse-expr');
// var parseCall = require('./parse-call');
// var parseText = require('./parse-text');
// var readAccessor = require('./read-accessor');
// var readUnaryExpr = require('./read-unary-expr');
/**
* 指令解析器
*
* @inner
* @type {Object}
*/
var directiveParsers = {
'for': function (value) {
var walker = new Walker(value);
var match = walker.match(/^\s*([$0-9a-z_]+)(\s*,\s*([$0-9a-z_]+))?\s+in\s+/ig, 1);
if (match) {
var directive = {
item: match[1],
value: readUnaryExpr(walker)
};
if (match[3]) {
directive.index = match[3];
}
if (walker.match(/\s*trackby\s+/ig, 1)) {
var start = walker.index;
directive.trackBy = readAccessor(walker);
directive.trackBy.raw = walker.cut(start, walker.index);
}
return directive;
}
// #[begin] error
// throw new Error('[SAN FATAL] for syntax error: ' + value);
// #[end]
},
'ref': function (value, options) {
return {
value: parseText(value, options.delimiters)
};
},
'if': function (value) {
return {
value: parseExpr(value.replace(/(^\{\{|\}\}$)/g, ''))
};
},
'elif': function (value) {
return {
value: parseExpr(value.replace(/(^\{\{|\}\}$)/g, ''))
};
},
'else': function () {
return {
value: {}
};
},
'bind': function (value) {
return {
value: parseExpr(value.replace(/(^\{\{|\}\}$)/g, ''))
};
},
'html': function (value) {
return {
value: parseExpr(value.replace(/(^\{\{|\}\}$)/g, ''))
};
},
'transition': function (value) {
return {
value: parseCall(value)
};
}
};
/**
* 解析指令
*
* @param {ANode} aNode 抽象节点
* @param {string} name 指令名称
* @param {string} value 指令值
* @param {Object} options 解析参数
* @param {Array?} options.delimiters 插值分隔符列表
*/
function parseDirective(aNode, name, value, options) {
if (name === 'else-if') {
name = 'elif';
}
var parser = directiveParsers[name];
if (parser) {
(aNode.directives[name] = parser(value, options)).raw = value;
}
}
// exports = module.exports = parseDirective;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析抽象节点属性
*/
// var each = require('../util/each');
// var kebab2camel = require('../util/kebab2camel');
// var boolAttrs = require('../browser/bool-attrs');
// var ExprType = require('./expr-type');
// var createAccessor = require('./create-accessor');
// var parseExpr = require('./parse-expr');
// var parseCall = require('./parse-call');
// var parseText = require('./parse-text');
// var parseDirective = require('./parse-directive');
/**
* 解析抽象节点属性
*
* @param {ANode} aNode 抽象节点
* @param {string} name 属性名称
* @param {string} value 属性值
* @param {Object} options 解析参数
* @param {Array?} options.delimiters 插值分隔符列表
*/
function integrateAttr(aNode, name, value, options) {
var prefixIndex = name.indexOf('-');
var realName;
var prefix;
if (prefixIndex > 0) {
prefix = name.slice(0, prefixIndex);
realName = name.slice(prefixIndex + 1);
}
switch (prefix) {
case 'on':
var event = {
name: realName,
modifier: {}
};
aNode.events.push(event);
var colonIndex;
while ((colonIndex = value.indexOf(':')) > 0) {
var modifier = value.slice(0, colonIndex);
// eventHandler("dd:aa") 这种情况不能算modifier，需要辨识
if (!/^[a-z]+$/i.test(modifier)) {
break;
}
event.modifier[modifier] = true;
value = value.slice(colonIndex + 1);
}
event.expr = parseCall(value, [
createAccessor([
{type: 1, value: '$event'}
])
]);
break;
case 'san':
case 's':
parseDirective(aNode, realName, value, options);
break;
case 'prop':
integrateProp(aNode, realName, value, options);
break;
case 'var':
if (!aNode.vars) {
aNode.vars = [];
}
realName = kebab2camel(realName);
aNode.vars.push({
name: realName,
expr: parseExpr(value.replace(/(^\{\{|\}\}$)/g, ''))
});
break;
default:
integrateProp(aNode, name, value, options);
}
}
/**
* 解析抽象节点绑定属性
*
* @inner
* @param {ANode} aNode 抽象节点
* @param {string} name 属性名称
* @param {string} rawValue 属性值
* @param {Object} options 解析参数
* @param {Array?} options.delimiters 插值分隔符列表
*/
function integrateProp(aNode, name, rawValue, options) {
// parse two way binding, e.g. value="{=ident=}"
var value = rawValue || '';
var xMatch = value.match(/^\{=\s*(.*?)\s*=\}$/);
if (xMatch) {
aNode.props.push({
name: name,
expr: parseExpr(xMatch[1]),
x: 1,
raw: value
});
return;
}
var expr = parseText(value, options.delimiters);
// 这里不能把只有一个插值的属性抽取
// 因为插值里的值可能是html片段，容易被注入
// 组件的数据绑定在组件init时做抽取
switch (name) {
case 'class':
case 'style':
each(expr.segs, function (seg) {
if (seg.type === 5) {
seg.filters.push({
type: 6,
name: createAccessor([
{
type: 1,
value: '_' + name
}
]),
args: []
});
}
});
break;
}
if (expr.type === 7) {
switch (expr.segs.length) {
case 0:
if (boolAttrs[name]) {
expr = {
type: 3,
value: true
};
}
break;
case 1:
expr = expr.segs[0];
if (expr.type === 5 && expr.filters.length === 0) {
expr = expr.expr;
}
}
}
aNode.props.push({
name: name,
expr: expr,
raw: rawValue
});
}
// exports = module.exports = integrateAttr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 解析模板
*/
// var Walker = require('./walker');
// var integrateAttr = require('./integrate-attr');
// var parseText = require('./parse-text');
// var svgTags = require('../browser/svg-tags');
// var autoCloseTags = require('../browser/auto-close-tags');
// #[begin] error
// function getXPath(stack, currentTagName) {
// var path = ['ROOT'];
// for (var i = 1, len = stack.length; i < len; i++) {
// path.push(stack[i].tagName);
// }
// if (currentTagName) {
// path.push(currentTagName);
// }
// return path.join('>');
// }
// #[end]
/* eslint-disable fecs-max-statements */
/**
* 解析 template
*
* @param {string} source template源码
* @param {Object?} options 解析参数
* @param {string?} options.trimWhitespace 空白文本的处理策略。none|blank|all
* @param {Array?} options.delimiters 插值分隔符列表
* @return {ANode}
*/
function parseTemplate(source, options) {
options = options || {};
options.trimWhitespace = options.trimWhitespace || 'none';
var rootNode = {
directives: {},
props: [],
events: [],
children: []
};
if (typeof source !== 'string') {
return rootNode;
}
source = source.replace(/<!--([\s\S]*?)-->/mg, '').replace(/(^\s+|\s+$)/g, '');
var walker = new Walker(source);
var tagReg = /<(\/)?([a-z][a-z0-9-]*)\s*/ig;
var attrReg = /([-:0-9a-z\[\]_]+)(\s*=\s*(['"])([^\3]*?)\3)?\s*/ig;
var tagMatch;
var currentNode = rootNode;
var stack = [rootNode];
var stackIndex = 0;
var beforeLastIndex = 0;
while ((tagMatch = walker.match(tagReg)) != null) {
var tagMatchStart = walker.index - tagMatch[0].length;
var tagEnd = tagMatch[1];
var tagName = tagMatch[2];
if (!svgTags[tagName]) {
tagName = tagName.toLowerCase();
}
// 62: >
// 47: /
// 处理 </xxxx >
if (tagEnd) {
if (walker.currentCode() === 62) {
// 满足关闭标签的条件时，关闭标签
// 向上查找到对应标签，找不到时忽略关闭
var closeIndex = stackIndex;
// #[begin] error
// // 如果正在闭合一个自闭合的标签，例如 </input>，报错
// if (autoCloseTags[tagName]) {
// throw new Error(''
// + '[SAN ERROR] ' + getXPath(stack, tagName) + ' is a `auto closed` tag, '
// + 'so it cannot be closed with </' + tagName + '>'
// );
// }
//
// // 如果关闭的 tag 和当前打开的不一致，报错
// if (
// stack[closeIndex].tagName !== tagName
// // 这里要把 table 自动添加 tbody 的情况给去掉
// && !(tagName === 'table' && stack[closeIndex].tagName === 'tbody')
// ) {
// throw new Error('[SAN ERROR] ' + getXPath(stack) + ' is closed with ' + tagName);
// }
// #[end]
pushTextNode(source.slice(beforeLastIndex, tagMatchStart));
while (closeIndex > 0 && stack[closeIndex].tagName !== tagName) {
closeIndex--;
}
if (closeIndex > 0) {
stackIndex = closeIndex - 1;
currentNode = stack[stackIndex];
}
walker.go(1);
}
// #[begin] error
// else {
// // 处理 </xxx 非正常闭合标签
//
// // 如果闭合标签时，匹配后的下一个字符是 <，即下一个标签的开始，那么当前闭合标签未闭合
// if (walker.currentCode() === 60) {
// throw new Error(''
// + '[SAN ERROR] ' + getXPath(stack)
// + '\'s close tag not closed'
// );
// }
//
// // 闭合标签有属性
// throw new Error(''
// + '[SAN ERROR] ' + getXPath(stack)
// + '\'s close tag has attributes'
// );
// }
// #[end]
}
else {
var aElement = {
directives: {},
props: [],
events: [],
children: [],
tagName: tagName
};
var tagClose = autoCloseTags[tagName];
// 解析 attributes
/* eslint-disable no-constant-condition */
while (1) {
/* eslint-enable no-constant-condition */
var nextCharCode = walker.currentCode();
// 标签结束时跳出 attributes 读取
// 标签可能直接结束或闭合结束
if (nextCharCode === 62) {
walker.go(1);
break;
}
// 遇到 /> 按闭合处理
if (nextCharCode === 47
&& walker.charCode(walker.index + 1) === 62
) {
walker.go(2);
tagClose = 1;
break;
}
// template 串结束了
// 这时候，说明这个读取周期的所有内容，都是text
if (!nextCharCode) {
pushTextNode(walker.cut(beforeLastIndex));
aElement = null;
break;
}
// #[begin] error
// // 在处理一个 open 标签时，如果遇到了 <， 即下一个标签的开始，则当前标签未能正常闭合，报错
// if (nextCharCode === 60) {
// throw new Error('[SAN ERROR] ' + getXPath(stack, tagName) + ' is not closed');
// }
// #[end]
// 读取 attribute
var attrMatch = walker.match(attrReg);
if (attrMatch) {
// #[begin] error
// // 如果属性有 =，但没取到 value，报错
// if (
// walker.charCode(attrMatch.index + attrMatch[1].length) === 61
// && !attrMatch[2]
// ) {
// throw new Error(''
// + '[SAN ERROR] ' + getXPath(stack, tagName) + ' attribute `'
// + attrMatch[1] + '` is not wrapped with ""'
// );
// }
// #[end]
integrateAttr(
aElement,
attrMatch[1],
attrMatch[3] ? attrMatch[4] : void(0),
options
);
}
}
if (aElement) {
pushTextNode(source.slice(beforeLastIndex, tagMatchStart));
// match if directive for else/elif directive
var elseDirective = aElement.directives['else'] // eslint-disable-line dot-notation
|| aElement.directives.elif;
if (elseDirective) {
var parentChildrenLen = currentNode.children.length;
var ifANode = null;
while (parentChildrenLen--) {
var parentChild = currentNode.children[parentChildrenLen];
if (parentChild.textExpr) {
currentNode.children.splice(parentChildrenLen, 1);
continue;
}
ifANode = parentChild;
break;
}
// #[begin] error
// if (!ifANode || !parentChild.directives['if']) { // eslint-disable-line dot-notation
// throw new Error('[SAN FATEL] else not match if.');
// }
// #[end]
if (ifANode) {
ifANode.elses = ifANode.elses || [];
ifANode.elses.push(aElement);
}
}
else {
if (aElement.tagName === 'tr' && currentNode.tagName === 'table') {
var tbodyNode = {
directives: {},
props: [],
events: [],
children: [],
tagName: 'tbody'
};
currentNode.children.push(tbodyNode);
currentNode = tbodyNode;
stack[++stackIndex] = tbodyNode;
}
currentNode.children.push(aElement);
}
if (!tagClose) {
currentNode = aElement;
stack[++stackIndex] = aElement;
}
}
}
beforeLastIndex = walker.index;
}
pushTextNode(walker.cut(beforeLastIndex));
return rootNode;
/**
* 在读取栈中添加文本节点
*
* @inner
* @param {string} text 文本内容
*/
function pushTextNode(text) {
switch (options.trimWhitespace) {
case 'blank':
if (/^\s+$/.test(text)) {
text = null;
}
break;
case 'all':
text = text.replace(/(^\s+|\s+$)/g, '');
break;
}
if (text) {
currentNode.children.push({
textExpr: parseText(text, options.delimiters)
});
}
}
}
/* eslint-enable fecs-max-statements */
// exports = module.exports = parseTemplate;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 默认filter
*/
/* eslint-disable fecs-camelcase */
function defaultStyleFilter(source) {
if (typeof source === 'object') {
var result = '';
for (var key in source) {
/* istanbul ignore else */
if (source.hasOwnProperty(key)) {
result += key + ':' + source[key] + ';';
}
}
return result;
}
return source;
}
/**
* 默认filter
*
* @const
* @type {Object}
*/
var DEFAULT_FILTERS = {
/**
* URL编码filter
*
* @param {string} source 源串
* @return {string} 替换结果串
*/
url: encodeURIComponent,
_class: function (source) {
if (source instanceof Array) {
return source.join(' ');
}
return source;
},
_style: defaultStyleFilter,
_xclass: function (outer, inner) {
if (outer instanceof Array) {
outer = outer.join(' ');
}
if (outer) {
if (inner) {
return inner + ' ' + outer;
}
return outer;
}
return inner;
},
_xstyle: function (outer, inner) {
outer = outer && defaultStyleFilter(outer);
if (outer) {
if (inner) {
return inner + ';' + outer;
}
return outer;
}
return inner;
}
};
/* eslint-enable fecs-camelcase */
// exports = module.exports = DEFAULT_FILTERS;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 表达式计算
*/
// var ExprType = require('../parser/expr-type');
// var extend = require('../util/extend');
// var DEFAULT_FILTERS = require('./default-filters');
// var evalArgs = require('./eval-args');
/**
* 计算表达式的值
*
* @param {Object} expr 表达式对象
* @param {Data} data 数据容器对象
* @param {Component=} owner 所属组件环境
* @return {*}
*/
function evalExpr(expr, data, owner) {
if (expr.value != null) {
return expr.value;
}
var value;
switch (expr.type) {
case 13:
return null;
case 9:
value = evalExpr(expr.expr, data, owner);
switch (expr.operator) {
case 33:
value = !value;
break;
case 43:
value = +value;
break;
case 45:
value = 0 - value;
break;
}
return value;
case 8:
value = evalExpr(expr.segs[0], data, owner);
var rightValue = evalExpr(expr.segs[1], data, owner);
/* eslint-disable eqeqeq */
switch (expr.operator) {
case 37:
value = value % rightValue;
break;
case 43:
value = value + rightValue;
break;
case 45:
value = value - rightValue;
break;
case 42:
value = value * rightValue;
break;
case 47:
value = value / rightValue;
break;
case 60:
value = value < rightValue;
break;
case 62:
value = value > rightValue;
break;
case 76:
value = value && rightValue;
break;
case 94:
value = value != rightValue;
break;
case 121:
value = value <= rightValue;
break;
case 122:
value = value == rightValue;
break;
case 123:
value = value >= rightValue;
break;
case 155:
value = value !== rightValue;
break;
case 183:
value = value === rightValue;
break;
case 248:
value = value || rightValue;
break;
}
/* eslint-enable eqeqeq */
return value;
case 10:
return evalExpr(
expr.segs[evalExpr(expr.segs[0], data, owner) ? 1 : 2],
data,
owner
);
case 12:
value = [];
for (var i = 0, l = expr.items.length; i < l; i++) {
var item = expr.items[i];
var itemValue = evalExpr(item.expr, data, owner);
if (item.spread) {
itemValue && (value = value.concat(itemValue));
}
else {
value.push(itemValue);
}
}
return value;
case 11:
value = {};
for (var i = 0, l = expr.items.length; i < l; i++) {
var item = expr.items[i];
var itemValue = evalExpr(item.expr, data, owner);
if (item.spread) {
itemValue && extend(value, itemValue);
}
else {
value[evalExpr(item.name, data, owner)] = itemValue;
}
}
return value;
case 4:
return data.get(expr);
case 5:
value = evalExpr(expr.expr, data, owner);
if (owner) {
for (var i = 0, l = expr.filters.length; i < l; i++) {
var filter = expr.filters[i];
var filterName = filter.name.paths[0].value;
switch (filterName) {
case 'url':
case '_class':
case '_style':
value = DEFAULT_FILTERS[filterName](value);
break;
case '_xclass':
case '_xstyle':
value = value = DEFAULT_FILTERS[filterName](value, evalExpr(filter.args[0], data, owner));
break;
default:
value = owner.filters[filterName] && owner.filters[filterName].apply(
owner,
[value].concat(evalArgs(filter.args, data, owner))
);
}
}
}
if (value == null) {
value = '';
}
return value;
case 6:
if (owner && expr.name.type === 4) {
var method = owner;
var pathsLen = expr.name.paths.length;
for (var i = 0; method && i < pathsLen; i++) {
method = method[evalExpr(expr.name.paths[i], data, owner)];
}
if (method) {
value = method.apply(owner, evalArgs(expr.args, data, owner));
}
}
break;
/* eslint-disable no-redeclare */
case 7:
var buf = '';
for (var i = 0, l = expr.segs.length; i < l; i++) {
var seg = expr.segs[i];
buf += seg.value || evalExpr(seg, data, owner);
}
return buf;
}
return value;
}
// exports = module.exports = evalExpr;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 为函数调用计算参数数组的值
*/
// var evalExpr = require('./eval-expr');
/**
* 为函数调用计算参数数组的值
*
* @param {Array} args 参数表达式列表
* @param {Data} data 数据环境
* @param {Component} owner 组件环境
* @return {Array}
*/
function evalArgs(args, data, owner) {
var result = [];
for (var i = 0; i < args.length; i++) {
result.push(evalExpr(args[i], data, owner));
}
return result;
}
// exports = module.exports = evalArgs;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 比较变更表达式与目标表达式之间的关系
*/
// var ExprType = require('../parser/expr-type');
// var evalExpr = require('./eval-expr');
/**
* 判断变更表达式与多个表达式之间的关系，0为完全没关系，1为有关系
*
* @inner
* @param {Object} changeExpr 目标表达式
* @param {Array} exprs 多个源表达式
* @param {Data} data 表达式所属数据环境
* @return {number}
*/
function changeExprCompareExprs(changeExpr, exprs, data) {
for (var i = 0, l = exprs.length; i < l; i++) {
if (changeExprCompare(changeExpr, exprs[i], data)) {
return 1;
}
}
return 0;
}
/**
* 比较变更表达式与目标表达式之间的关系，用于视图更新判断
* 视图更新需要根据其关系，做出相应的更新行为
*
* 0: 完全没关系
* 1: 变更表达式是目标表达式的母项(如a与a.b) 或 表示需要完全变化
* 2: 变更表达式是目标表达式相等
* >2: 变更表达式是目标表达式的子项，如a.b.c与a.b
*
* @param {Object} changeExpr 变更表达式
* @param {Object} expr 要比较的目标表达式
* @param {Data} data 表达式所属数据环境
* @return {number}
*/
function changeExprCompare(changeExpr, expr, data) {
var result = 0;
if (!expr.changeCache) {
expr.changeCache = {};
}
if (changeExpr.raw && !expr.dynamic) {
if (expr.changeCache[changeExpr.raw] != null) {
return expr.changeCache[changeExpr.raw];
}
}
switch (expr.type) {
case 4:
var paths = expr.paths;
var pathsLen = paths.length;
var changePaths = changeExpr.paths;
var changeLen = changePaths.length;
result = 1;
for (var i = 0; i < pathsLen; i++) {
var pathExpr = paths[i];
var pathExprValue = pathExpr.value;
if (pathExprValue == null && changeExprCompare(changeExpr, pathExpr, data)) {
result = 1;
break;
}
if (result && i < changeLen
/* eslint-disable eqeqeq */
&& (pathExprValue || evalExpr(pathExpr, data)) != changePaths[i].value
/* eslint-enable eqeqeq */
) {
result = 0;
}
}
if (result) {
result = Math.max(1, changeLen - pathsLen + 2);
}
break;
case 9:
result = changeExprCompare(changeExpr, expr.expr, data) ? 1 : 0;
break;
case 7:
case 8:
case 10:
result = changeExprCompareExprs(changeExpr, expr.segs, data);
break;
case 12:
case 11:
for (var i = 0; i < expr.items.length; i++) {
if (changeExprCompare(changeExpr, expr.items[i].expr, data)) {
result = 1;
break;
}
}
break;
case 5:
if (changeExprCompare(changeExpr, expr.expr, data)) {
result = 1;
}
else {
for (var i = 0; i < expr.filters.length; i++) {
if (changeExprCompareExprs(changeExpr, expr.filters[i].args, data)) {
result = 1;
break;
}
}
}
break;
case 6:
if (changeExprCompareExprs(changeExpr, expr.name.paths, data)
|| changeExprCompareExprs(changeExpr, expr.args, data)
) {
result = 1;
}
break;
}
if (changeExpr.raw && !expr.dynamic) {
expr.changeCache[changeExpr.raw] = result;
}
return result;
}
// exports = module.exports = changeExprCompare;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 数据变更类型枚举
*/
/**
* 数据变更类型枚举
*
* @const
* @type {Object}
*/
var DataChangeType = {
SET: 1,
SPLICE: 2
};
// exports = module.exports = DataChangeType;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 生命周期类
*/
function lifeCycleOwnIs(name) {
return this[name];
}
/* eslint-disable fecs-valid-var-jsdoc */
/**
* 节点生命周期信息
*
* @inner
* @type {Object}
*/
var LifeCycle = {
start: {},
compiled: {
is: lifeCycleOwnIs,
compiled: true
},
inited: {
is: lifeCycleOwnIs,
compiled: true,
inited: true
},
created: {
is: lifeCycleOwnIs,
compiled: true,
inited: true,
created: true
},
attached: {
is: lifeCycleOwnIs,
compiled: true,
inited: true,
created: true,
attached: true
},
leaving: {
is: lifeCycleOwnIs,
compiled: true,
inited: true,
created: true,
attached: true,
leaving: true
},
detached: {
is: lifeCycleOwnIs,
compiled: true,
inited: true,
created: true,
detached: true
},
disposed: {
is: lifeCycleOwnIs,
disposed: true
}
};
/* eslint-enable fecs-valid-var-jsdoc */
// exports = module.exports = LifeCycle;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 节点类型
*/
/**
* 节点类型
*
* @const
* @type {Object}
*/
var NodeType = {
TEXT: 1,
IF: 2,
FOR: 3,
ELEM: 4,
CMPT: 5,
SLOT: 6,
TPL: 7,
LOADER: 8
};
// exports = module.exports = NodeType;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 获取 ANode props 数组中相应 name 的项
*/
/**
* 获取 ANode props 数组中相应 name 的项
*
* @param {Object} aNode ANode对象
* @param {string} name name属性匹配串
* @return {Object}
*/
function getANodeProp(aNode, name) {
var index = aNode.hotspot.props[name];
if (index != null) {
return aNode.props[index];
}
}
// exports = module.exports = getANodeProp;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 获取属性处理对象
*/
// var contains = require('../util/contains');
// var empty = require('../util/empty');
// var svgTags = require('../browser/svg-tags');
// var ie = require('../browser/ie');
// var evalExpr = require('../runtime/eval-expr');
// var getANodeProp = require('./get-a-node-prop');
// var NodeType = require('./node-type');
/**
* HTML 属性和 DOM 操作属性的对照表
*
* @inner
* @const
* @type {Object}
*/
var HTML_ATTR_PROP_MAP = {
'readonly': 'readOnly',
'cellpadding': 'cellPadding',
'cellspacing': 'cellSpacing',
'colspan': 'colSpan',
'rowspan': 'rowSpan',
'valign': 'vAlign',
'usemap': 'useMap',
'frameborder': 'frameBorder',
'for': 'htmlFor'
};
/**
* 默认的元素的属性设置的变换方法
*
* @inner
* @type {Object}
*/
function defaultElementPropHandler(el, value, name) {
var propName = HTML_ATTR_PROP_MAP[name] || name;
var valueNotNull = value != null;
// input 的 type 是个特殊属性，其实也应该用 setAttribute
// 但是 type 不应该运行时动态改变，否则会有兼容性问题
// 所以这里直接就不管了
if (propName in el) {
el[propName] = valueNotNull ? value : '';
}
else if (valueNotNull) {
el.setAttribute(name, value);
}
if (!valueNotNull) {
el.removeAttribute(name);
}
}
function svgPropHandler(el, value, name) {
el.setAttribute(name, value);
}
function boolPropHandler(el, value, name) {
var propName = HTML_ATTR_PROP_MAP[name] || name;
el[propName] = !!value;
}
/* eslint-disable fecs-properties-quote */
/**
* 默认的属性设置变换方法
*
* @inner
* @type {Object}
*/
var defaultElementPropHandlers = {
style: function (el, value) {
el.style.cssText = value;
},
'class': function (el, value) { // eslint-disable-line
if (
// #[begin] allua
// ie
// ||
// #[end]
el.className !== value
) {
el.className = value;
}
},
slot: empty,
draggable: boolPropHandler
};
/* eslint-enable fecs-properties-quote */
var analInputChecker = {
checkbox: contains,
radio: function (a, b) {
return a === b;
}
};
function analInputCheckedState(element, value) {
var bindValue = getANodeProp(element.aNode, 'value');
var bindType = getANodeProp(element.aNode, 'type');
if (bindValue && bindType) {
var type = evalExpr(bindType.expr, element.scope, element.owner);
if (analInputChecker[type]) {
var bindChecked = getANodeProp(element.aNode, 'checked');
if (bindChecked != null && !bindChecked.hintExpr) {
bindChecked.hintExpr = bindValue.expr;
}
return !!analInputChecker[type](
value,
element.data
? evalExpr(bindValue.expr, element.data, element)
: evalExpr(bindValue.expr, element.scope, element.owner)
);
}
}
}
var elementPropHandlers = {
input: {
multiple: boolPropHandler,
checked: function (el, value, name, element) {
var state = analInputCheckedState(element, value);
boolPropHandler(
el,
state != null ? state : value,
'checked',
element
);
// #[begin] allua
// // 代码不用抽出来防重复，allua内的代码在现代浏览器版本会被编译时干掉，gzip也会处理重复问题
// // see: #378
// /* istanbul ignore if */
// if (ie && ie < 8 && !element.lifeCycle.attached) {
// boolPropHandler(
// el,
// state != null ? state : value,
// 'defaultChecked',
// element
// );
// }
// #[end]
},
readonly: boolPropHandler,
disabled: boolPropHandler,
autofocus: boolPropHandler,
required: boolPropHandler
},
option: {
value: function (el, value, name, element) {
defaultElementPropHandler(el, value, name, element);
if (isOptionSelected(element, value)) {
el.selected = true;
}
}
},
select: {
readonly: boolPropHandler,
disabled: boolPropHandler,
autofocus: boolPropHandler,
required: boolPropHandler
},
textarea: {
readonly: boolPropHandler,
disabled: boolPropHandler,
autofocus: boolPropHandler,
required: boolPropHandler
},
button: {
disabled: boolPropHandler,
autofocus: boolPropHandler,
type: function (el, value) {
el.setAttribute('type', value);
}
}
};
function isOptionSelected(element, value) {
var parentSelect = element.parent;
while (parentSelect) {
if (parentSelect.tagName === 'select') {
break;
}
parentSelect = parentSelect.parent;
}
if (parentSelect) {
var selectValue = null;
var prop;
var expr;
if ((prop = getANodeProp(parentSelect.aNode, 'value'))
&& (expr = prop.expr)
) {
selectValue = parentSelect.nodeType === 5
? evalExpr(expr, parentSelect.data, parentSelect)
: evalExpr(expr, parentSelect.scope, parentSelect.owner)
|| '';
}
if (selectValue === value) {
return 1;
}
}
}
/**
* 获取属性处理对象
*
* @param {string} tagName 元素tag
* @param {string} attrName 属性名
* @return {Object}
*/
function getPropHandler(tagName, attrName) {
if (svgTags[tagName]) {
return svgPropHandler;
}
var tagPropHandlers = elementPropHandlers[tagName];
if (!tagPropHandlers) {
tagPropHandlers = elementPropHandlers[tagName] = {};
}
var propHandler = tagPropHandlers[attrName];
if (!propHandler) {
propHandler = defaultElementPropHandlers[attrName] || defaultElementPropHandler;
tagPropHandlers[attrName] = propHandler;
}
return propHandler;
}
// exports = module.exports = getPropHandler;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 判断变更是否来源于元素
*/
/**
* 判断变更是否来源于元素，来源于元素时，视图更新需要阻断
*
* @param {Object} change 变更对象
* @param {Element} element 元素
* @param {string?} propName 属性名，可选。需要精确判断是否来源于此属性时传入
* @return {boolean}
*/
function isDataChangeByElement(change, element, propName) {
var changeTarget = change.option.target;
return changeTarget && changeTarget.node === element
&& (!propName || changeTarget.prop === propName);
}
// exports = module.exports = isDataChangeByElement;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 在对象上使用accessor表达式查找方法
*/
// var evalExpr = require('../runtime/eval-expr');
/**
* 在对象上使用accessor表达式查找方法
*
* @param {Object} source 源对象
* @param {Object} nameExpr 表达式
* @param {Data} data 所属数据环境
* @return {Function}
*/
function findMethod(source, nameExpr, data) {
var method = source;
for (var i = 0; method != null && i < nameExpr.paths.length; i++) {
method = method[evalExpr(nameExpr.paths[i], data)];
}
return method;
}
// exports = module.exports = findMethod;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 数据类
*/
// var ExprType = require('../parser/expr-type');
// var evalExpr = require('./eval-expr');
// var DataChangeType = require('./data-change-type');
// var createAccessor = require('../parser/create-accessor');
// var parseExpr = require('../parser/parse-expr');
/**
* 数据类
*
* @class
* @param {Object?} data 初始数据
* @param {Model?} parent 父级数据容器
*/
function Data(data, parent) {
this.parent = parent;
this.raw = data || {};
this.listeners = [];
}
// #[begin] error
// // 以下两个函数只在开发模式下可用，在生产模式下不存在
// /**
// * DataTypes 检测
// */
// Data.prototype.checkDataTypes = function () {
// if (this.typeChecker) {
// this.typeChecker(this.raw);
// }
// };
//
// /**
// * 设置 type checker
// *
// * @param {Function} typeChecker 类型校验器
// */
// Data.prototype.setTypeChecker = function (typeChecker) {
// this.typeChecker = typeChecker;
// };
//
// #[end]
/**
* 添加数据变更的事件监听器
*
* @param {Function} listener 监听函数
*/
Data.prototype.listen = function (listener) {
if (typeof listener === 'function') {
this.listeners.push(listener);
}
};
/**
* 移除数据变更的事件监听器
*
* @param {Function} listener 监听函数
*/
Data.prototype.unlisten = function (listener) {
var len = this.listeners.length;
while (len--) {
if (!listener || this.listeners[len] === listener) {
this.listeners.splice(len, 1);
}
}
};
/**
* 触发数据变更
*
* @param {Object} change 变更信息对象
*/
Data.prototype.fire = function (change) {
if (change.option.silent || change.option.silence || change.option.quiet) {
return;
}
for (var i = 0; i < this.listeners.length; i++) {
this.listeners[i].call(this, change);
}
};
/**
* 获取数据项
*
* @param {string|Object?} expr 数据项路径
* @param {Data?} callee 当前数据获取的调用环境
* @return {*}
*/
Data.prototype.get = function (expr, callee) {
var value = this.raw;
if (!expr) {
return value;
}
if (typeof expr !== 'object') {
expr = parseExpr(expr);
}
var paths = expr.paths;
callee = callee || this;
value = value[paths[0].value];
if (value == null && this.parent) {
value = this.parent.get(expr, callee);
}
else {
for (var i = 1, l = paths.length; value != null && i < l; i++) {
value = value[paths[i].value || evalExpr(paths[i], callee)];
}
}
return value;
};
/**
* 数据对象变更操作
*
* @inner
* @param {Object|Array} source 要变更的源数据
* @param {Array} exprPaths 属性路径
* @param {number} pathsStart 当前处理的属性路径指针位置
* @param {number} pathsLen 属性路径长度
* @param {*} value 变更属性值
* @param {Data} data 对应的Data对象
* @return {*} 变更后的新数据
*/
function immutableSet(source, exprPaths, pathsStart, pathsLen, value, data) {
if (pathsStart >= pathsLen) {
return value;
}
if (source == null) {
source = {};
}
var pathExpr = exprPaths[pathsStart];
var prop = evalExpr(pathExpr, data);
var result = source;
if (source instanceof Array) {
var index = +prop;
prop = isNaN(index) ? prop : index;
result = source.slice(0);
result[prop] = immutableSet(source[prop], exprPaths, pathsStart + 1, pathsLen, value, data);
}
else if (typeof source === 'object') {
result = {};
for (var key in source) {
/* istanbul ignore else */
if (key !== prop && source.hasOwnProperty(key)) {
result[key] = source[key];
}
}
result[prop] = immutableSet(source[prop], exprPaths, pathsStart + 1, pathsLen, value, data);
}
if (pathExpr.value == null) {
exprPaths[pathsStart] = {
type: typeof prop === 'string' ? 1 : 2,
value: prop
};
}
return result;
}
/**
* 设置数据项
*
* @param {string|Object} expr 数据项路径
* @param {*} value 数据值
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
*/
Data.prototype.set = function (expr, value, option) {
option = option || {};
// #[begin] error
// var exprRaw = expr;
// #[end]
expr = parseExpr(expr);
// #[begin] error
// if (expr.type !== 4) {
// throw new Error('[SAN ERROR] Invalid Expression in Data set: ' + exprRaw);
// }
// #[end]
if (this.get(expr) === value && !option.force) {
return;
}
expr = {
type: 4,
paths: expr.paths.slice(0),
raw: expr.raw
};
var prop = expr.paths[0].value;
this.raw[prop] = immutableSet(this.raw[prop], expr.paths, 1, expr.paths.length, value, this);
this.fire({
type: 1,
expr: expr,
value: value,
option: option
});
// #[begin] error
// this.checkDataTypes();
// #[end]
};
/**
* 合并更新数据项
*
* @param {string|Object} expr 数据项路径
* @param {Object} source 待合并的数据值
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
*/
Data.prototype.merge = function (expr, source, option) {
option = option || {};
// #[begin] error
// var exprRaw = expr;
// #[end]
expr = parseExpr(expr);
// #[begin] error
// if (expr.type !== 4) {
// throw new Error('[SAN ERROR] Invalid Expression in Data merge: ' + exprRaw);
// }
//
// if (typeof this.get(expr) !== 'object') {
// throw new Error('[SAN ERROR] Merge Expects a Target of Type \'object\'; got ' + typeof oldValue);
// }
//
// if (typeof source !== 'object') {
// throw new Error('[SAN ERROR] Merge Expects a Source of Type \'object\'; got ' + typeof source);
// }
// #[end]
for (var key in source) { // eslint-disable-line
this.set(
createAccessor(
expr.paths.concat(
[
{
type: 1,
value: key
}
]
)
),
source[key],
option
);
}
};
/**
* 基于更新函数更新数据项
*
* @param {string|Object} expr 数据项路径
* @param {Function} fn 数据处理函数
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
*/
Data.prototype.apply = function (expr, fn, option) {
// #[begin] error
// var exprRaw = expr;
// #[end]
expr = parseExpr(expr);
// #[begin] error
// if (expr.type !== 4) {
// throw new Error('[SAN ERROR] Invalid Expression in Data apply: ' + exprRaw);
// }
// #[end]
var oldValue = this.get(expr);
// #[begin] error
// if (typeof fn !== 'function') {
// throw new Error(
// '[SAN ERROR] Invalid Argument\'s Type in Data apply: '
// + 'Expected Function but got ' + typeof fn
// );
// }
// #[end]
this.set(expr, fn(oldValue), option);
};
/**
* 数组数据项splice操作
*
* @param {string|Object} expr 数据项路径
* @param {Array} args splice 接受的参数列表，数组项与Array.prototype.splice的参数一致
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
* @return {Array} 新数组
*/
Data.prototype.splice = function (expr, args, option) {
option = option || {};
// #[begin] error
// var exprRaw = expr;
// #[end]
expr = parseExpr(expr);
// #[begin] error
// if (expr.type !== 4) {
// throw new Error('[SAN ERROR] Invalid Expression in Data splice: ' + exprRaw);
// }
// #[end]
expr = {
type: 4,
paths: expr.paths.slice(0),
raw: expr.raw
};
var target = this.get(expr);
var returnValue = [];
if (target instanceof Array) {
var index = args[0];
var len = target.length;
if (index > len) {
index = len;
}
else if (index < 0) {
index = len + index;
if (index < 0) {
index = 0;
}
}
var newArray = target.slice(0);
returnValue = newArray.splice.apply(newArray, args);
this.raw = immutableSet(this.raw, expr.paths, 0, expr.paths.length, newArray, this);
this.fire({
expr: expr,
type: 2,
index: index,
deleteCount: returnValue.length,
value: returnValue,
insertions: args.slice(2),
option: option
});
}
// #[begin] error
// this.checkDataTypes();
// #[end]
return returnValue;
};
/**
* 数组数据项push操作
*
* @param {string|Object} expr 数据项路径
* @param {*} item 要push的值
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
* @return {number} 新数组的length属性
*/
Data.prototype.push = function (expr, item, option) {
var target = this.get(expr);
if (target instanceof Array) {
this.splice(expr, [target.length, 0, item], option);
return target.length + 1;
}
};
/**
* 数组数据项pop操作
*
* @param {string|Object} expr 数据项路径
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
* @return {*}
*/
Data.prototype.pop = function (expr, option) {
var target = this.get(expr);
if (target instanceof Array) {
var len = target.length;
if (len) {
return this.splice(expr, [len - 1, 1], option)[0];
}
}
};
/**
* 数组数据项shift操作
*
* @param {string|Object} expr 数据项路径
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
* @return {*}
*/
Data.prototype.shift = function (expr, option) {
return this.splice(expr, [0, 1], option)[0];
};
/**
* 数组数据项unshift操作
*
* @param {string|Object} expr 数据项路径
* @param {*} item 要unshift的值
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
* @return {number} 新数组的length属性
*/
Data.prototype.unshift = function (expr, item, option) {
var target = this.get(expr);
if (target instanceof Array) {
this.splice(expr, [0, 0, item], option);
return target.length + 1;
}
};
/**
* 数组数据项移除操作
*
* @param {string|Object} expr 数据项路径
* @param {number} index 要移除项的索引
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
*/
Data.prototype.removeAt = function (expr, index, option) {
this.splice(expr, [index, 1], option);
};
/**
* 数组数据项移除操作
*
* @param {string|Object} expr 数据项路径
* @param {*} value 要移除的项
* @param {Object=} option 设置参数
* @param {boolean} option.silent 静默设置，不触发变更事件
*/
Data.prototype.remove = function (expr, value, option) {
var target = this.get(expr);
if (target instanceof Array) {
var len = target.length;
while (len--) {
if (target[len] === value) {
this.splice(expr, [len, 1], option);
break;
}
}
}
};
// exports = module.exports = Data;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 获取声明式事件的监听函数
*/
// var evalArgs = require('../runtime/eval-args');
// var findMethod = require('../runtime/find-method');
// var Data = require('../runtime/data');
/**
* 获取声明式事件的监听函数
*
* @param {Object} eventBind 绑定信息对象
* @param {Component} owner 所属组件环境
* @param {Data} data 数据环境
* @param {boolean} isComponentEvent 是否组件自定义事件
* @return {Function}
*/
function getEventListener(eventBind, owner, data, isComponentEvent) {
var args = eventBind.expr.args;
return function (e) {
e = isComponentEvent ? e : e || window.event;
var method = findMethod(owner, eventBind.expr.name, data);
if (typeof method === 'function') {
method.apply(
owner,
args.length ? evalArgs(args, new Data({ $event: e }, data), owner) : []
);
}
if (eventBind.modifier.prevent) {
e.preventDefault && e.preventDefault();
return false;
}
if (eventBind.modifier.stop) {
if (e.stopPropagation) {
e.stopPropagation();
}
else {
e.cancelBubble = true;
}
}
};
}
// exports = module.exports = getEventListener;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 判断变更数组是否影响到数据引用摘要
*/
/**
* 判断变更数组是否影响到数据引用摘要
*
* @param {Array} changes 变更数组
* @param {Object} dataRef 数据引用摘要
* @return {boolean}
*/
function changesIsInDataRef(changes, dataRef) {
if (dataRef) {
for (var i = 0; i < changes.length; i++) {
var change = changes[i];
if (!change.overview) {
var paths = change.expr.paths;
change.overview = paths[0].value;
if (paths.length > 1) {
change.extOverview = paths[0].value + '.' + paths[1].value;
change.wildOverview = paths[0].value + '.*';
}
}
if (dataRef[change.overview]
|| change.wildOverview && dataRef[change.wildOverview]
|| change.extOverview && dataRef[change.extOverview]
) {
return true;
}
}
}
}
// exports = module.exports = changesIsInDataRef;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file insertBefore 方法的兼容性封装
*/
/**
* insertBefore 方法的兼容性封装
*
* @param {HTMLNode} targetEl 要插入的节点
* @param {HTMLElement} parentEl 父元素
* @param {HTMLElement?} beforeEl 在此元素之前插入
*/
function insertBefore(targetEl, parentEl, beforeEl) {
if (parentEl) {
if (beforeEl) {
parentEl.insertBefore(targetEl, beforeEl);
}
else {
parentEl.appendChild(targetEl);
}
}
}
// exports = module.exports = insertBefore;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 元素的基本属性
*/
var baseProps = {
'class': 1,
'style': 1,
'id': 1
};
// exports = module.exports = baseProps;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 元素子节点遍历操作类
*/
// var removeEl = require('../browser/remove-el');
// #[begin] reverse
/**
* 元素子节点遍历操作类
*
* @inner
* @class
* @param {HTMLElement} el 要遍历的元素
*/
function DOMChildrenWalker(el) {
this.raw = [];
this.index = 0;
this.target = el;
var child = el.firstChild;
var next;
while (child) {
next = child.nextSibling;
switch (child.nodeType) {
case 3:
if (/^\s*$/.test(child.data || child.textContent)) {
removeEl(child);
}
else {
this.raw.push(child);
}
break;
case 1:
case 8:
this.raw.push(child);
}
child = next;
}
this.current = this.raw[this.index];
this.next = this.raw[this.index + 1];
}
/**
* 往下走一个元素
*/
DOMChildrenWalker.prototype.goNext = function () {
this.current = this.raw[++this.index];
this.next = this.raw[this.index + 1];
};
// #[end]
// exports = module.exports = DOMChildrenWalker;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 元素节点类
*/
// var changeExprCompare = require('../runtime/change-expr-compare');
// var changesIsInDataRef = require('../runtime/changes-is-in-data-ref');
// var evalExpr = require('../runtime/eval-expr');
// var insertBefore = require('../browser/insert-before');
// var LifeCycle = require('./life-cycle');
// var NodeType = require('./node-type');
// var baseProps = require('./base-props');
// var reverseElementChildren = require('./reverse-element-children');
// var isDataChangeByElement = require('./is-data-change-by-element');
// var getPropHandler = require('./get-prop-handler');
// var createNode = require('./create-node');
// var elementOwnDetach = require('./element-own-detach');
// var elementOwnDispose = require('./element-own-dispose');
// var elementOwnOnEl = require('./element-own-on-el');
// var elementOwnAttached = require('./element-own-attached');
// var nodeSBindInit = require('./node-s-bind-init');
// var nodeSBindUpdate = require('./node-s-bind-update');
// var warnSetHTML = require('./warn-set-html');
// var getNodePath = require('./get-node-path');
/**
* 元素节点类
*
* @class
* @param {Object} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker?} reverseWalker 子元素遍历对象
*/
function Element(aNode, parent, scope, owner, reverseWalker) {
this.aNode = aNode;
this.owner = owner;
this.scope = scope;
this.parent = parent;
this.lifeCycle = LifeCycle.start;
this.children = [];
this._elFns = [];
this.parentComponent = parent.nodeType === 5
? parent
: parent.parentComponent;
this.tagName = aNode.tagName;
// #[begin] allua
// // ie8- 不支持innerHTML输出自定义标签
// /* istanbul ignore if */
// if (ieOldThan9 && this.tagName.indexOf('-') > 0) {
// this.tagName = 'div';
// }
// #[end]
this._sbindData = nodeSBindInit(aNode.directives.bind, this.scope, this.owner);
this.lifeCycle = LifeCycle.inited;
// #[begin] reverse
if (reverseWalker) {
var currentNode = reverseWalker.current;
/* istanbul ignore if */
if (!currentNode) {
throw new Error('[SAN REVERSE ERROR] Element not found. \nPaths: '
+ getNodePath(this).join(' > '));
}
/* istanbul ignore if */
if (currentNode.nodeType !== 1) {
throw new Error('[SAN REVERSE ERROR] Element type not match, expect 1 but '
+ currentNode.nodeType + '.\nPaths: '
+ getNodePath(this).join(' > '));
}
/* istanbul ignore if */
if (currentNode.tagName.toLowerCase() !== this.tagName) {
throw new Error('[SAN REVERSE ERROR] Element tagName not match, expect '
+ this.tagName + ' but meat ' + currentNode.tagName.toLowerCase() + '.\nPaths: '
+ getNodePath(this).join(' > '));
}
this.el = currentNode;
reverseWalker.goNext();
reverseElementChildren(this, this.scope, this.owner);
this.lifeCycle = LifeCycle.created;
this._attached();
this.lifeCycle = LifeCycle.attached;
}
// #[end]
}
Element.prototype.nodeType = 4;
/**
* 将元素attach到页面
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
Element.prototype.attach = function (parentEl, beforeEl) {
if (!this.lifeCycle.attached) {
if (!this.el) {
var sourceNode = this.aNode.hotspot.sourceNode;
var props = this.aNode.props;
if (sourceNode) {
this.el = sourceNode.cloneNode(false);
props = this.aNode.hotspot.dynamicProps;
}
else {
this.el = createEl(this.tagName);
}
if (this._sbindData) {
for (var key in this._sbindData) {
if (this._sbindData.hasOwnProperty(key)) {
getPropHandler(this.tagName, key)(
this.el,
this._sbindData[key],
key,
this
);
}
}
}
for (var i = 0, l = props.length; i < l; i++) {
var prop = props[i];
var value = evalExpr(prop.expr, this.scope, this.owner);
if (value || !baseProps[prop.name]) {
prop.handler(this.el, value, prop.name, this);
}
}
this.lifeCycle = LifeCycle.created;
}
insertBefore(this.el, parentEl, beforeEl);
if (!this._contentReady) {
var htmlDirective = this.aNode.directives.html;
if (htmlDirective) {
// #[begin] error
// warnSetHTML(this.el);
// #[end]
this.el.innerHTML = evalExpr(htmlDirective.value, this.scope, this.owner);
}
else {
for (var i = 0, l = this.aNode.children.length; i < l; i++) {
var childANode = this.aNode.children[i];
var child = childANode.Clazz
? new childANode.Clazz(childANode, this, this.scope, this.owner)
: createNode(childANode, this, this.scope, this.owner);
this.children.push(child);
child.attach(this.el);
}
}
this._contentReady = 1;
}
this._attached();
this.lifeCycle = LifeCycle.attached;
}
};
Element.prototype.detach = elementOwnDetach;
Element.prototype.dispose = elementOwnDispose;
Element.prototype._onEl = elementOwnOnEl;
Element.prototype._leave = function () {
if (this.leaveDispose) {
if (!this.lifeCycle.disposed) {
var len = this.children.length;
while (len--) {
this.children[len].dispose(1, 1);
}
len = this._elFns.length;
while (len--) {
var fn = this._elFns[len];
un(this.el, fn[0], fn[1], fn[2]);
}
this._elFns = null;
// #[begin] allua
// /* istanbul ignore if */
// if (this._inputTimer) {
// clearInterval(this._inputTimer);
// this._inputTimer = null;
// }
// #[end]
// 如果没有parent，说明是一个root component，一定要从dom树中remove
if (!this.disposeNoDetach || !this.parent) {
removeEl(this.el);
}
this.lifeCycle = LifeCycle.detached;
this.el = null;
this.owner = null;
this.scope = null;
this.children = null;
this.lifeCycle = LifeCycle.disposed;
if (this._ondisposed) {
this._ondisposed();
}
}
}
};
/**
* 视图更新
*
* @param {Array} changes 数据变化信息
*/
Element.prototype._update = function (changes) {
var dataHotspot = this.aNode.hotspot.data;
if (dataHotspot && changesIsInDataRef(changes, dataHotspot)) {
// update s-bind
var me = this;
this._sbindData = nodeSBindUpdate(
this.aNode.directives.bind,
this._sbindData,
this.scope,
this.owner,
changes,
function (name, value) {
if (name in me.aNode.hotspot.props) {
return;
}
getPropHandler(me.tagName, name)(me.el, value, name, me);
}
);
// update prop
var dynamicProps = this.aNode.hotspot.dynamicProps;
for (var i = 0, l = dynamicProps.length; i < l; i++) {
var prop = dynamicProps[i];
var propName = prop.name;
for (var j = 0, changeLen = changes.length; j < changeLen; j++) {
var change = changes[j];
if (!isDataChangeByElement(change, this, propName)
&& (
changeExprCompare(change.expr, prop.expr, this.scope)
|| prop.hintExpr && changeExprCompare(change.expr, prop.hintExpr, this.scope)
)
) {
prop.handler(this.el, evalExpr(prop.expr, this.scope, this.owner), propName, this);
break;
}
}
}
// update content
var htmlDirective = this.aNode.directives.html;
if (htmlDirective) {
var len = changes.length;
while (len--) {
if (changeExprCompare(changes[len].expr, htmlDirective.value, this.scope)) {
// #[begin] error
// warnSetHTML(this.el);
// #[end]
this.el.innerHTML = evalExpr(htmlDirective.value, this.scope, this.owner);
break;
}
}
}
else {
for (var i = 0, l = this.children.length; i < l; i++) {
this.children[i]._update(changes);
}
}
}
};
/**
* 执行完成attached状态的行为
*/
Element.prototype._attached = elementOwnAttached;
// exports = module.exports = Element;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 创建节点对应的 stump comment 元素
*/
/**
* 创建节点对应的 stump comment 主元素
*/
function nodeOwnCreateStump() {
this.el = this.el || document.createComment(this.id);
}
// exports = module.exports = nodeOwnCreateStump;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 销毁释放元素的子元素
*/
/**
* 销毁释放元素的子元素
*
* @param {Array=} children 子元素数组
* @param {boolean=} noDetach 是否不要把节点从dom移除
* @param {boolean=} noTransition 是否不显示过渡动画效果
*/
function elementDisposeChildren(children, noDetach, noTransition) {
var len = children && children.length;
while (len--) {
children[len].dispose(noDetach, noTransition);
}
}
// exports = module.exports = elementDisposeChildren;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 简单执行销毁节点的行为
*/
// var removeEl = require('../browser/remove-el');
// var LifeCycle = require('./life-cycle');
// var elementDisposeChildren = require('./element-dispose-children');
/**
* 简单执行销毁节点的行为
*
* @param {boolean=} noDetach 是否不要把节点从dom移除
*/
function nodeOwnSimpleDispose(noDetach) {
elementDisposeChildren(this.children, noDetach, 1);
if (!noDetach) {
removeEl(this.el);
}
this.el = null;
this.owner = null;
this.scope = null;
this.children = null;
this.lifeCycle = LifeCycle.disposed;
if (this._ondisposed) {
this._ondisposed();
}
}
// exports = module.exports = nodeOwnSimpleDispose;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 异步组件类
*/
// var guid = require('../util/guid');
// var each = require('../util/each');
// var insertBefore = require('../browser/insert-before');
// var nodeOwnCreateStump = require('./node-own-create-stump');
// var nodeOwnSimpleDispose = require('./node-own-simple-dispose');
/**
* 异步组件类
*
* @class
* @param {Object} options 初始化参数
* @param {Object} loader 组件加载器
*/
function AsyncComponent(options, loader) {
this.options = options;
this.loader = loader;
this.id = guid++;
this.children = [];
// #[begin] reverse
var reverseWalker = options.reverseWalker;
if (reverseWalker) {
var PlaceholderComponent = this.loader.placeholder;
if (PlaceholderComponent) {
this.children[0] = new PlaceholderComponent(options);
}
this._create();
insertBefore(this.el, reverseWalker.target, reverseWalker.current);
var me = this;
this.loader.start(function (ComponentClass) {
me.onload(ComponentClass);
});
}
options.reverseWalker = null;
// #[end]
}
AsyncComponent.prototype._create = nodeOwnCreateStump;
AsyncComponent.prototype.dispose = nodeOwnSimpleDispose;
/**
* attach到页面
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
AsyncComponent.prototype.attach = function (parentEl, beforeEl) {
var PlaceholderComponent = this.loader.placeholder;
if (PlaceholderComponent) {
var component = new PlaceholderComponent(this.options);
this.children[0] = component;
component.attach(parentEl, beforeEl);
}
this._create();
insertBefore(this.el, parentEl, beforeEl);
var me = this;
this.loader.start(function (ComponentClass) {
me.onload(ComponentClass);
});
};
/**
* loader加载完成，渲染组件
*
* @param {Function=} ComponentClass 组件类
*/
AsyncComponent.prototype.onload = function (ComponentClass) {
if (this.el && ComponentClass) {
var component = new ComponentClass(this.options);
component.attach(this.el.parentNode, this.el);
var parentChildren = this.options.parent.children;
if (this.parentIndex == null || parentChildren[this.parentIndex] !== this) {
each(parentChildren, function (child, index) {
if (child instanceof AsyncComponent) {
child.parentIndex = index;
}
});
}
parentChildren[this.parentIndex] = component;
}
this.dispose();
};
/**
* 视图更新函数
*
* @param {Array} changes 数据变化信息
*/
AsyncComponent.prototype._update = function (changes) {
this.children[0] && this.children[0]._update(changes);
};
// exports = module.exports = AsyncComponent;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 通过组件反解创建节点的工厂方法
*/
// var Element = require('./element');
// var AsyncComponent = require('./async-component');
// #[begin] reverse
/**
* 通过组件反解创建节点
*
* @param {ANode} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker} reverseWalker 子元素遍历对象
* @return {Node}
*/
function createReverseNode(aNode, parent, scope, owner, reverseWalker) {
if (aNode.Clazz) {
return new aNode.Clazz(aNode, parent, scope, owner, reverseWalker);
}
var ComponentOrLoader = owner.getComponentType
? owner.getComponentType(aNode, scope)
: owner.components[aNode.tagName];
if (ComponentOrLoader) {
return typeof ComponentOrLoader === 'function'
? new ComponentOrLoader({
source: aNode,
owner: owner,
scope: scope,
parent: parent,
subTag: aNode.tagName,
reverseWalker: reverseWalker
})
: new AsyncComponent({
source: aNode,
owner: owner,
scope: scope,
parent: parent,
subTag: aNode.tagName,
reverseWalker: reverseWalker
}, ComponentOrLoader);
}
return new Element(aNode, parent, scope, owner, reverseWalker);
}
// #[end]
// exports = module.exports = createReverseNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 对元素的子节点进行反解
*/
// var each = require('../util/each');
// var DOMChildrenWalker = require('./dom-children-walker');
// var createReverseNode = require('./create-reverse-node');
// #[begin] reverse
/**
* 对元素的子节点进行反解
*
* @param {Object} element 元素
*/
function reverseElementChildren(element, scope, owner) {
var htmlDirective = element.aNode.directives.html;
if (!htmlDirective) {
var reverseWalker = new DOMChildrenWalker(element.el);
var aNodeChildren = element.aNode.children;
for (var i = 0, l = aNodeChildren.length; i < l; i++) {
element.children.push(
createReverseNode(aNodeChildren[i], element, scope, owner, reverseWalker)
);
}
}
}
// #[end]
// exports = module.exports = reverseElementChildren;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 创建节点的工厂方法
*/
// var Element = require('./element');
// var AsyncComponent = require('./async-component');
/**
* 创建节点
*
* @param {ANode} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @return {Node}
*/
function createNode(aNode, parent, scope, owner) {
if (aNode.Clazz) {
return new aNode.Clazz(aNode, parent, scope, owner);
}
var ComponentOrLoader = owner.getComponentType
? owner.getComponentType(aNode, scope)
: owner.components[aNode.tagName];
if (ComponentOrLoader) {
return typeof ComponentOrLoader === 'function'
? new ComponentOrLoader({
source: aNode,
owner: owner,
scope: scope,
parent: parent,
subTag: aNode.tagName
})
: new AsyncComponent({
source: aNode,
owner: owner,
scope: scope,
parent: parent,
subTag: aNode.tagName
}, ComponentOrLoader);
}
aNode.Clazz = Element;
return new Element(aNode, parent, scope, owner);
}
// exports = module.exports = createNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 获取 element 的 transition 控制对象
*/
// var evalArgs = require('../runtime/eval-args');
// var findMethod = require('../runtime/find-method');
// var NodeType = require('./node-type');
/**
* 获取 element 的 transition 控制对象
*
* @param {Object} element 元素
* @return {Object?}
*/
function elementGetTransition(element) {
var directive = element.aNode.directives.transition;
var owner = element.owner;
if (element.nodeType === 5) {
var cmptGivenTransition = element.source && element.source.directives.transition;
if (cmptGivenTransition) {
directive = cmptGivenTransition;
}
else {
owner = element;
}
}
var transition;
if (directive && owner) {
transition = findMethod(owner, directive.value.name);
if (typeof transition === 'function') {
transition = transition.apply(
owner,
evalArgs(directive.value.args, element.scope, owner)
);
}
}
return transition || element.transition;
}
// exports = module.exports = elementGetTransition;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 将元素从页面上移除
*/
// var elementGetTransition = require('./element-get-transition');
/**
* 将元素从页面上移除
*/
function elementOwnDetach() {
var lifeCycle = this.lifeCycle;
if (lifeCycle.leaving) {
return;
}
if (!this.disposeNoTransition) {
var transition = elementGetTransition(this);
if (transition && transition.leave) {
if (this._toPhase) {
this._toPhase('leaving');
}
else {
this.lifeCycle = LifeCycle.leaving;
}
var me = this;
transition.leave(this.el, function () {
me._leave();
});
return;
}
}
this._leave();
}
// exports = module.exports = elementOwnDetach;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 销毁释放元素
*/
/**
* 销毁释放元素
*
* @param {boolean=} noDetach 是否不要把节点从dom移除
* @param {boolean=} noTransition 是否不显示过渡动画效果
*/
function elementOwnDispose(noDetach, noTransition) {
this.leaveDispose = 1;
this.disposeNoDetach = noDetach;
this.disposeNoTransition = noTransition;
this.detach();
}
// exports = module.exports = elementOwnDispose;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 为元素的 el 绑定事件
*/
// var on = require('../browser/on');
/**
* 为元素的 el 绑定事件
*
* @param {string} name 事件名
* @param {Function} listener 监听器
* @param {boolean} capture 是否是捕获阶段触发
*/
function elementOwnOnEl(name, listener, capture) {
capture = !!capture;
this._elFns.push([name, listener, capture]);
on(this.el, name, listener, capture);
}
// exports = module.exports = elementOwnOnEl;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 是否浏览器环境
*/
var isBrowser = typeof window !== 'undefined';
// exports = module.exports = isBrowser;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 开发时的警告提示
*/
// #[begin] error
// /**
// * 开发时的警告提示
// *
// * @param {string} message 警告信息
// */
// function warn(message) {
// message = '[SAN WARNING] ' + message;
//
// /* eslint-disable no-console */
// /* istanbul ignore next */
// if (typeof console === 'object' && console.warn) {
// console.warn(message);
// }
// else {
// // 防止警告中断调用堆栈
// setTimeout(function () {
// throw new Error(message);
// }, 0);
// }
// /* eslint-enable no-console */
// }
// #[end]
// exports = module.exports = warn;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 事件绑定不存在的 warning
*/
// var each = require('../util/each');
// var warn = require('../util/warn');
// #[begin] error
// /**
// * 事件绑定不存在的 warning
// *
// * @param {Object} eventBind 事件绑定对象
// * @param {Component} owner 所属的组件对象
// */
// function warnEventListenMethod(eventBind, owner) {
// var valid = true;
// var method = owner;
// each(eventBind.expr.name.paths, function (path) {
// method = method[path.value];
// valid = !!method;
// return valid;
// });
//
// if (!valid) {
// var paths = [];
// each(eventBind.expr.name.paths, function (path) {
// paths.push(path.value);
// });
//
// warn(eventBind.name + ' listen fail,"' + paths.join('.') + '" not exist');
// }
// }
// #[end]
// exports = module.exports = warnEventListenMethod;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 完成元素 attached 后的行为
*/
// var empty = require('../util/empty');
// var isBrowser = require('../browser/is-browser');
// var trigger = require('../browser/trigger');
// var NodeType = require('./node-type');
// var elementGetTransition = require('./element-get-transition');
// var getEventListener = require('./get-event-listener');
// var warnEventListenMethod = require('./warn-event-listen-method');
/**
* 双绑输入框CompositionEnd事件监听函数
*
* @inner
*/
function inputOnCompositionEnd() {
if (!this.composing) {
return;
}
this.composing = 0;
trigger(this, 'input');
}
/**
* 双绑输入框CompositionStart事件监听函数
*
* @inner
*/
function inputOnCompositionStart() {
this.composing = 1;
}
function getXPropOutputer(element, xProp, data) {
return function () {
xPropOutput(element, xProp, data);
};
}
function getInputXPropOutputer(element, xProp, data) {
return function () {
if (!this.composing) {
xPropOutput(element, xProp, data);
}
};
}
// #[begin] allua
// /* istanbul ignore next */
// function getInputFocusXPropHandler(element, xProp, data) {
// return function () {
// element._inputTimer = setInterval(function () {
// xPropOutput(element, xProp, data);
// }, 16);
// };
// }
//
// /* istanbul ignore next */
// function getInputBlurXPropHandler(element) {
// return function () {
// clearInterval(element._inputTimer);
// element._inputTimer = null;
// };
// }
// #[end]
function xPropOutput(element, bindInfo, data) {
/* istanbul ignore if */
if (!element.lifeCycle.created) {
return;
}
var el = element.el;
if (element.tagName === 'input' && bindInfo.name === 'checked') {
var bindValue = getANodeProp(element.aNode, 'value');
var bindType = getANodeProp(element.aNode, 'type');
if (bindValue && bindType) {
switch (el.type.toLowerCase()) {
case 'checkbox':
data[el.checked ? 'push' : 'remove'](bindInfo.expr, el.value);
return;
case 'radio':
el.checked && data.set(bindInfo.expr, el.value, {
target: {
node: element,
prop: bindInfo.name
}
});
return;
}
}
}
data.set(bindInfo.expr, el[bindInfo.name], {
target: {
node: element,
prop: bindInfo.name
}
});
}
/**
* 完成元素 attached 后的行为
*
* @param {Object} element 元素节点
*/
function elementOwnAttached() {
if (this._rootNode) {
return;
}
var isComponent = this.nodeType === 5;
var data = isComponent ? this.data : this.scope;
/* eslint-disable no-redeclare */
// 处理自身变化时双向绑定的逻辑
var xProps = this.aNode.hotspot.xProps;
for (var i = 0, l = xProps.length; i < l; i++) {
var xProp = xProps[i];
switch (xProp.name) {
case 'value':
switch (this.tagName) {
case 'input':
case 'textarea':
if (isBrowser && window.CompositionEvent) {
this._onEl('change', inputOnCompositionEnd);
this._onEl('compositionstart', inputOnCompositionStart);
this._onEl('compositionend', inputOnCompositionEnd);
}
// #[begin] allua
// /* istanbul ignore else */
// if ('oninput' in this.el) {
// #[end]
this._onEl('input', getInputXPropOutputer(this, xProp, data));
// #[begin] allua
// }
// else {
// this._onEl('focusin', getInputFocusXPropHandler(this, xProp, data));
// this._onEl('focusout', getInputBlurXPropHandler(this));
// }
// #[end]
break;
case 'select':
this._onEl('change', getXPropOutputer(this, xProp, data));
break;
}
break;
case 'checked':
switch (this.tagName) {
case 'input':
switch (this.el.type) {
case 'checkbox':
case 'radio':
this._onEl('click', getXPropOutputer(this, xProp, data));
}
}
break;
}
}
var owner = isComponent ? this : this.owner;
for (var i = 0, l = this.aNode.events.length; i < l; i++) {
var eventBind = this.aNode.events[i];
// #[begin] error
// warnEventListenMethod(eventBind, owner);
// #[end]
this._onEl(
eventBind.name,
getEventListener(eventBind, owner, data, eventBind.modifier),
eventBind.modifier.capture
);
}
if (isComponent) {
for (var i = 0, l = this.nativeEvents.length; i < l; i++) {
var eventBind = this.nativeEvents[i];
// #[begin] error
// warnEventListenMethod(eventBind, this.owner);
// #[end]
this._onEl(
eventBind.name,
getEventListener(eventBind, this.owner, this.scope),
eventBind.modifier.capture
);
}
}
var transition = elementGetTransition(this);
if (transition && transition.enter) {
transition.enter(this.el, empty);
}
}
// exports = module.exports = elementOwnAttached;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 初始化节点的 s-bind 数据
*/
// var evalExpr = require('../runtime/eval-expr');
/**
* 初始化节点的 s-bind 数据
*
* @param {Object} sBind bind指令对象
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @return {boolean}
*/
function nodeSBindInit(sBind, scope, owner) {
if (sBind && scope) {
return evalExpr(sBind.value, scope, owner);
}
}
// exports = module.exports = nodeSBindInit;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 计算两个对象 key 的并集
*/
/**
* 计算两个对象 key 的并集
*
* @param {Object} obj1 目标对象
* @param {Object} obj2 源对象
* @return {Array}
*/
function unionKeys(obj1, obj2) {
var result = [];
var key;
for (key in obj1) {
/* istanbul ignore else */
if (obj1.hasOwnProperty(key)) {
result.push(key);
}
}
for (key in obj2) {
/* istanbul ignore else */
if (obj2.hasOwnProperty(key)) {
!obj1[key] && result.push(key);
}
}
return result;
}
// exports = module.exports = unionKeys;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 更新节点的 s-bind 数据
*/
// var unionKeys = require('../util/union-keys');
// var evalExpr = require('../runtime/eval-expr');
// var changeExprCompare = require('../runtime/change-expr-compare');
/**
* 更新节点的 s-bind 数据
*
* @param {Object} sBind bind指令对象
* @param {Object} oldBindData 当前s-bind数据
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {Array} changes 变更数组
* @param {Function} updater 绑定对象子项变更的更新函数
*/
function nodeSBindUpdate(sBind, oldBindData, scope, owner, changes, updater) {
if (sBind) {
var len = changes.length;
while (len--) {
if (changeExprCompare(changes[len].expr, sBind.value, scope)) {
var newBindData = evalExpr(sBind.value, scope, owner);
var keys = unionKeys(newBindData, oldBindData);
for (var i = 0, l = keys.length; i < l; i++) {
var key = keys[i];
var value = newBindData[key];
if (value !== oldBindData[key]) {
updater(key, value);
}
}
return newBindData;
}
}
}
}
// exports = module.exports = nodeSBindUpdate;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 判断元素是否不允许设置HTML
*/
// some html elements cannot set innerHTML in old ie
// see: https://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx
/**
* 判断元素是否不允许设置HTML
*
* @param {HTMLElement} el 要判断的元素
* @return {boolean}
*/
function noSetHTML(el) {
return /^(col|colgroup|frameset|style|table|tbody|tfoot|thead|tr|select)$/i.test(el.tagName);
}
// exports = module.exports = noSetHTML;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 获取节点 stump 的 comment
*/
// var noSetHTML = require('../browser/no-set-html');
// var warn = require('../util/warn');
// #[begin] error
// /**
// * 获取节点 stump 的 comment
// *
// * @param {HTMLElement} el HTML元素
// */
// function warnSetHTML(el) {
// // dont warn if not in browser runtime
// /* istanbul ignore if */
// if (!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document)) {
// return;
// }
//
// // some html elements cannot set innerHTML in old ie
// // see: https://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx
// if (noSetHTML(el)) {
// warn('set html for element "' + el.tagName + '" may cause an error in old IE');
// }
// }
// #[end]
// exports = module.exports = warnSetHTML;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 获取节点在组件树中的路径
*/
// var NodeType = require('./node-type');
// #[begin] reverse
/**
* 获取节点在组件树中的路径
*
* @param {Node} node 节点对象
* @return {Array}
*/
/* istanbul ignore next */
function getNodePath(node) {
var nodePaths = [];
var nodeParent = node;
while (nodeParent) {
switch (nodeParent.nodeType) {
case 4:
nodePaths.unshift(nodeParent.tagName);
break;
case 2:
nodePaths.unshift('if');
break;
case 3:
nodePaths.unshift('for[' + nodeParent.anode.directives['for'].raw + ']'); // eslint-disable-line dot-notation
break;
case 6:
nodePaths.unshift('slot[' + (nodeParent.name || 'default') + ']');
break;
case 7:
nodePaths.unshift('template');
break;
case 5:
nodePaths.unshift('component[' + (nodeParent.subTag || 'root') + ']');
break;
case 1:
nodePaths.unshift('text');
break;
}
nodeParent = nodeParent.parent;
}
return nodePaths;
}
// #[end]
// exports = module.exports = getNodePath;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 给 devtool 发通知消息
*/
// var isBrowser = require('../browser/is-browser');
// #[begin] devtool
// var san4devtool;
//
// /**
// * 给 devtool 发通知消息
// *
// * @param {string} name 消息名称
// * @param {*} arg 消息参数
// */
// function emitDevtool(name, arg) {
// /* istanbul ignore if */
// if (isBrowser && san4devtool && san4devtool.debug && window.__san_devtool__) {
// window.__san_devtool__.emit(name, arg);
// }
// }
//
// emitDevtool.start = function (main) {
// san4devtool = main;
// emitDevtool('san', main);
// };
// #[end]
// exports = module.exports = emitDevtool;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 组件类
*/
// var bind = require('../util/bind');
// var each = require('../util/each');
// var guid = require('../util/guid');
// var extend = require('../util/extend');
// var nextTick = require('../util/next-tick');
// var emitDevtool = require('../util/emit-devtool');
// var ExprType = require('../parser/expr-type');
// var parseExpr = require('../parser/parse-expr');
// var parseTemplate = require('../parser/parse-template');
// var createAccessor = require('../parser/create-accessor');
// var removeEl = require('../browser/remove-el');
// var Data = require('../runtime/data');
// var evalExpr = require('../runtime/eval-expr');
// var changeExprCompare = require('../runtime/change-expr-compare');
// var DataChangeType = require('../runtime/data-change-type');
// var insertBefore = require('../browser/insert-before');
// var un = require('../browser/un');
// var createNode = require('./create-node');
// var compileComponent = require('./compile-component');
// var preheatANode = require('./preheat-a-node');
// var LifeCycle = require('./life-cycle');
// var getANodeProp = require('./get-a-node-prop');
// var isDataChangeByElement = require('./is-data-change-by-element');
// var getEventListener = require('./get-event-listener');
// var reverseElementChildren = require('./reverse-element-children');
// var NodeType = require('./node-type');
// var nodeSBindInit = require('./node-s-bind-init');
// var nodeSBindUpdate = require('./node-s-bind-update');
// var elementOwnAttached = require('./element-own-attached');
// var elementOwnOnEl = require('./element-own-on-el');
// var elementOwnDetach = require('./element-own-detach');
// var elementOwnDispose = require('./element-own-dispose');
// var warnEventListenMethod = require('./warn-event-listen-method');
// var elementDisposeChildren = require('./element-dispose-children');
// var createDataTypesChecker = require('../util/create-data-types-checker');
// var warn = require('../util/warn');
/**
* 组件类
*
* @class
* @param {Object} options 初始化参数
*/
function Component(options) { // eslint-disable-line
// #[begin] error
// for (var key in Component.prototype) {
// if (this[key] !== Component.prototype[key]) {
// /* eslint-disable max-len */
// warn('\`' + key + '\` is a reserved key of san components. Overriding this property may cause unknown exceptions.');
// /* eslint-enable max-len */
// }
// }
// #[end]
options = options || {};
this.lifeCycle = LifeCycle.start;
this.children = [];
this._elFns = [];
this.listeners = {};
this.slotChildren = [];
this.implicitChildren = [];
var clazz = this.constructor;
this.filters = this.filters || clazz.filters || {};
this.computed = this.computed || clazz.computed || {};
this.messages = this.messages || clazz.messages || {};
if (options.transition) {
this.transition = options.transition;
}
this.subTag = options.subTag;
// compile
compileComponent(clazz);
var protoANode = clazz.prototype.aNode;
preheatANode(protoANode);
this.tagName = protoANode.tagName;
this.source = typeof options.source === 'string'
? parseTemplate(options.source).children[0]
: options.source;
preheatANode(this.source);
this.sourceSlotNameProps = [];
this.sourceSlots = {
named: {}
};
this.owner = options.owner;
this.scope = options.scope;
this.el = options.el;
var parent = options.parent;
if (parent) {
this.parent = parent;
this.parentComponent = parent.nodeType === 5
? parent
: parent && parent.parentComponent;
}
else if (this.owner) {
this.parentComponent = this.owner;
this.scope = this.owner.data;
}
this.id = guid++;
// #[begin] reverse
// 组件反解，读取注入的组件数据
if (this.el) {
var firstCommentNode = this.el.firstChild;
if (firstCommentNode && firstCommentNode.nodeType === 3) {
firstCommentNode = firstCommentNode.nextSibling;
}
if (firstCommentNode && firstCommentNode.nodeType === 8) {
var stumpMatch = firstCommentNode.data.match(/^\s*s-data:([\s\S]+)?$/);
if (stumpMatch) {
var stumpText = stumpMatch[1];
// fill component data
options.data = (new Function('return '
+ stumpText
.replace(/^[\s\n]*/, '')
.replace(
/"(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.\d+Z"/g,
function (match, y, mon, d, h, m, s) {
return 'new Date(' + (+y) + ',' + (+mon) + ',' + (+d)
+ ',' + (+h) + ',' + (+m) + ',' + (+s) + ')';
}
)
))();
if (firstCommentNode.previousSibling) {
removeEl(firstCommentNode.previousSibling);
}
removeEl(firstCommentNode);
}
}
}
// #[end]
// native事件数组
this.nativeEvents = [];
if (this.source) {
// 组件运行时传入的结构，做slot解析
this._initSourceSlots(1);
for (var i = 0, l = this.source.events.length; i < l; i++) {
var eventBind = this.source.events[i];
// 保存当前实例的native事件，下面创建aNode时候做合并
if (eventBind.modifier.native) {
this.nativeEvents.push(eventBind);
}
else {
// #[begin] error
// warnEventListenMethod(eventBind, options.owner);
// #[end]
this.on(
eventBind.name,
getEventListener(eventBind, options.owner, this.scope, 1),
eventBind
);
}
}
this.tagName = this.tagName || this.source.tagName;
this.binds = this.source.hotspot.binds;
// init s-bind data
this._srcSbindData = nodeSBindInit(this.source.directives.bind, this.scope, this.owner);
}
this._toPhase('compiled');
// init data
var initData = extend(
typeof this.initData === 'function' && this.initData() || {},
options.data || this._srcSbindData
);
if (this.binds && this.scope) {
for (var i = 0, l = this.binds.length; i < l; i++) {
var bindInfo = this.binds[i];
var value = evalExpr(bindInfo.expr, this.scope, this.owner);
if (typeof value !== 'undefined') {
// See: https://github.com/ecomfe/san/issues/191
initData[bindInfo.name] = value;
}
}
}
this.data = new Data(initData);
this.tagName = this.tagName || 'div';
// #[begin] allua
// // ie8- 不支持innerHTML输出自定义标签
// /* istanbul ignore if */
// if (ieOldThan9 && this.tagName.indexOf('-') > 0) {
// this.tagName = 'div';
// }
// #[end]
// #[begin] error
// // 在初始化 + 数据绑定后，开始数据校验
// // NOTE: 只在开发版本中进行属性校验
// var dataTypes = this.dataTypes || clazz.dataTypes;
// if (dataTypes) {
// var dataTypeChecker = createDataTypesChecker(
// dataTypes,
// this.subTag || this.name || clazz.name
// );
// this.data.setTypeChecker(dataTypeChecker);
// this.data.checkDataTypes();
// }
// #[end]
this.computedDeps = {};
for (var expr in this.computed) {
if (this.computed.hasOwnProperty(expr) && !this.computedDeps[expr]) {
this._calcComputed(expr);
}
}
this._initDataChanger();
this._sbindData = nodeSBindInit(this.aNode.directives.bind, this.data, this);
this._toPhase('inited');
// #[begin] reverse
var hasRootNode = this.aNode.hotspot.hasRootNode
|| (this.getComponentType
? this.getComponentType(this.aNode, this.data)
: this.components[this.aNode.tagName]
);
var reverseWalker = options.reverseWalker;
if (this.el || reverseWalker) {
if (hasRootNode) {
reverseWalker = reverseWalker || new DOMChildrenWalker(this.el);
this._rootNode = createReverseNode(this.aNode, this, this.data, this, reverseWalker);
this._rootNode._getElAsRootNode && (this.el = this._rootNode._getElAsRootNode());
}
else {
if (reverseWalker) {
var currentNode = reverseWalker.current;
if (currentNode && currentNode.nodeType === 1) {
this.el = currentNode;
reverseWalker.goNext();
}
}
reverseElementChildren(this, this.data, this);
}
this._toPhase('created');
this._attached();
this._toPhase('attached');
}
// #[end]
}
/**
* 初始化创建组件外部传入的插槽对象
*
* @protected
* @param {boolean} isFirstTime 是否初次对sourceSlots进行计算
*/
Component.prototype._initSourceSlots = function (isFirstTime) {
this.sourceSlots.named = {};
// 组件运行时传入的结构，做slot解析
if (this.source && this.scope) {
var sourceChildren = this.source.children;
for (var i = 0, l = sourceChildren.length; i < l; i++) {
var child = sourceChildren[i];
var target;
var slotBind = !child.textExpr && getANodeProp(child, 'slot');
if (slotBind) {
isFirstTime && this.sourceSlotNameProps.push(slotBind);
var slotName = evalExpr(slotBind.expr, this.scope, this.owner);
target = this.sourceSlots.named[slotName];
if (!target) {
target = this.sourceSlots.named[slotName] = [];
}
target.push(child);
}
else if (isFirstTime) {
target = this.sourceSlots.noname;
if (!target) {
target = this.sourceSlots.noname = [];
}
target.push(child);
}
}
}
};
/**
* 类型标识
*
* @type {string}
*/
Component.prototype.nodeType = 5;
/**
* 在下一个更新周期运行函数
*
* @param {Function} fn 要运行的函数
*/
Component.prototype.nextTick = nextTick;
Component.prototype._ctx = (new Date()).getTime().toString(16);
/* eslint-disable operator-linebreak */
/**
* 使节点到达相应的生命周期
*
* @protected
* @param {string} name 生命周期名称
*/
Component.prototype._callHook =
Component.prototype._toPhase = function (name) {
if (!this.lifeCycle[name]) {
this.lifeCycle = LifeCycle[name] || this.lifeCycle;
if (typeof this[name] === 'function') {
this[name]();
}
this._afterLife = this.lifeCycle;
// 通知devtool
// #[begin] devtool
// emitDevtool('comp-' + name, this);
// #[end]
}
};
/* eslint-enable operator-linebreak */
/**
* 添加事件监听器
*
* @param {string} name 事件名
* @param {Function} listener 监听器
* @param {string?} declaration 声明式
*/
Component.prototype.on = function (name, listener, declaration) {
if (typeof listener === 'function') {
if (!this.listeners[name]) {
this.listeners[name] = [];
}
this.listeners[name].push({fn: listener, declaration: declaration});
}
};
/**
* 移除事件监听器
*
* @param {string} name 事件名
* @param {Function=} listener 监听器
*/
Component.prototype.un = function (name, listener) {
var nameListeners = this.listeners[name];
var len = nameListeners && nameListeners.length;
while (len--) {
if (!listener || listener === nameListeners[len].fn) {
nameListeners.splice(len, 1);
}
}
};
/**
* 派发事件
*
* @param {string} name 事件名
* @param {Object} event 事件对象
*/
Component.prototype.fire = function (name, event) {
var me = this;
each(this.listeners[name], function (listener) {
listener.fn.call(me, event);
});
};
/**
* 计算 computed 属性的值
*
* @private
* @param {string} computedExpr computed表达式串
*/
Component.prototype._calcComputed = function (computedExpr) {
var computedDeps = this.computedDeps[computedExpr];
if (!computedDeps) {
computedDeps = this.computedDeps[computedExpr] = {};
}
var me = this;
this.data.set(computedExpr, this.computed[computedExpr].call({
data: {
get: function (expr) {
// #[begin] error
// if (!expr) {
// throw new Error('[SAN ERROR] call get method in computed need argument');
// }
// #[end]
if (!computedDeps[expr]) {
computedDeps[expr] = 1;
if (me.computed[expr] && !me.computedDeps[expr]) {
me._calcComputed(expr);
}
me.watch(expr, function () {
me._calcComputed(computedExpr);
});
}
return me.data.get(expr);
}
}
}));
};
/**
* 派发消息
* 组件可以派发消息，消息将沿着组件树向上传递，直到遇上第一个处理消息的组件
*
* @param {string} name 消息名称
* @param {*?} value 消息值
*/
Component.prototype.dispatch = function (name, value) {
var parentComponent = this.parentComponent;
while (parentComponent) {
var receiver = parentComponent.messages[name] || parentComponent.messages['*'];
if (typeof receiver === 'function') {
receiver.call(
parentComponent,
{target: this, value: value, name: name}
);
break;
}
parentComponent = parentComponent.parentComponent;
}
};
/**
* 获取组件内部的 slot
*
* @param {string=} name slot名称，空为default slot
* @return {Array}
*/
Component.prototype.slot = function (name) {
var result = [];
var me = this;
function childrenTraversal(children) {
each(children, function (child) {
if (child.nodeType === 6 && child.owner === me) {
if (child.isNamed && child.name === name
|| !child.isNamed && !name
) {
result.push(child);
}
}
else {
childrenTraversal(child.children);
}
});
}
childrenTraversal(this.children);
return result;
};
/**
* 获取带有 san-ref 指令的子组件引用
*
* @param {string} name 子组件的引用名
* @return {Component}
*/
Component.prototype.ref = function (name) {
var refTarget;
var owner = this;
function childrenTraversal(children) {
each(children, function (child) {
elementTraversal(child);
return !refTarget;
});
}
function elementTraversal(element) {
var nodeType = element.nodeType;
if (nodeType === 1) {
return;
}
if (element.owner === owner) {
var ref;
switch (element.nodeType) {
case 4:
ref = element.aNode.directives.ref;
if (ref && evalExpr(ref.value, element.scope, owner) === name) {
refTarget = element.el;
}
break;
case 5:
ref = element.source.directives.ref;
if (ref && evalExpr(ref.value, element.scope, owner) === name) {
refTarget = element;
}
}
!refTarget && childrenTraversal(element.slotChildren);
}
!refTarget && childrenTraversal(element.children);
}
childrenTraversal(this.children);
return refTarget;
};
/**
* 视图更新函数
*
* @param {Array?} changes 数据变化信息
*/
Component.prototype._update = function (changes) {
if (this.lifeCycle.disposed) {
return;
}
var me = this;
var needReloadForSlot = false;
this._notifyNeedReload = function () {
needReloadForSlot = true;
};
if (changes) {
if (this.source) {
this._srcSbindData = nodeSBindUpdate(
this.source.directives.bind,
this._srcSbindData,
this.scope,
this.owner,
changes,
function (name, value) {
if (name in me.source.hotspot.props) {
return;
}
me.data.set(name, value, {
target: {
node: me.owner
}
});
}
);
}
each(changes, function (change) {
var changeExpr = change.expr;
each(me.binds, function (bindItem) {
var relation;
var setExpr = bindItem.name;
var updateExpr = bindItem.expr;
if (!isDataChangeByElement(change, me, setExpr)
&& (relation = changeExprCompare(changeExpr, updateExpr, me.scope))
) {
if (relation > 2) {
setExpr = createAccessor(
[
{
type: 1,
value: setExpr
}
].concat(changeExpr.paths.slice(updateExpr.paths.length))
);
updateExpr = changeExpr;
}
if (relation >= 2 && change.type === 2) {
me.data.splice(setExpr, [change.index, change.deleteCount].concat(change.insertions), {
target: {
node: me.owner
}
});
}
else {
me.data.set(setExpr, evalExpr(updateExpr, me.scope, me.owner), {
target: {
node: me.owner
}
});
}
}
});
each(me.sourceSlotNameProps, function (bindItem) {
needReloadForSlot = needReloadForSlot || changeExprCompare(changeExpr, bindItem.expr, me.scope);
return !needReloadForSlot;
});
});
if (needReloadForSlot) {
this._initSourceSlots();
this._repaintChildren();
}
else {
var slotChildrenLen = this.slotChildren.length;
while (slotChildrenLen--) {
var slotChild = this.slotChildren[slotChildrenLen];
if (slotChild.lifeCycle.disposed) {
this.slotChildren.splice(slotChildrenLen, 1);
}
else if (slotChild.isInserted) {
slotChild._update(changes, 1);
}
}
}
}
var dataChanges = this._dataChanges;
if (dataChanges) {
this._dataChanges = null;
this._sbindData = nodeSBindUpdate(
this.aNode.directives.bind,
this._sbindData,
this.data,
this,
dataChanges,
function (name, value) {
if (me._rootNode || (name in me.aNode.hotspot.props)) {
return;
}
getPropHandler(me.tagName, name)(me.el, value, name, me);
}
);
if (this._rootNode) {
this._rootNode._update(dataChanges);
this._rootNode._getElAsRootNode && (this.el = this._rootNode._getElAsRootNode());
}
else {
var dynamicProps = this.aNode.hotspot.dynamicProps;
for (var i = 0; i < dynamicProps.length; i++) {
var prop = dynamicProps[i];
for (var j = 0; j < dataChanges.length; j++) {
var change = dataChanges[j];
if (changeExprCompare(change.expr, prop.expr, this.data)
|| prop.hintExpr && changeExprCompare(change.expr, prop.hintExpr, this.data)
) {
prop.handler(this.el, evalExpr(prop.expr, this.data, this), prop.name, this);
break;
}
}
}
for (var i = 0; i < this.children.length; i++) {
this.children[i]._update(dataChanges);
}
}
if (needReloadForSlot) {
this._initSourceSlots();
this._repaintChildren();
}
for (var i = 0; i < this.implicitChildren.length; i++) {
this.implicitChildren[i]._update(dataChanges);
}
this._toPhase('updated');
if (this.owner && this._updateBindxOwner(dataChanges)) {
this.owner._update();
}
}
this._notifyNeedReload = null;
};
Component.prototype._updateBindxOwner = function (dataChanges) {
var me = this;
var xbindUped;
each(dataChanges, function (change) {
each(me.binds, function (bindItem) {
var changeExpr = change.expr;
if (bindItem.x
&& !isDataChangeByElement(change, me.owner)
&& changeExprCompare(changeExpr, parseExpr(bindItem.name), me.data)
) {
var updateScopeExpr = bindItem.expr;
if (changeExpr.paths.length > 1) {
updateScopeExpr = createAccessor(
bindItem.expr.paths.concat(changeExpr.paths.slice(1))
);
}
xbindUped = 1;
me.scope.set(
updateScopeExpr,
evalExpr(changeExpr, me.data, me),
{
target: {
node: me,
prop: bindItem.name
}
}
);
}
});
});
return xbindUped;
};
/**
* 重新绘制组件的内容
* 当 dynamic slot name 发生变更或 slot 匹配发生变化时，重新绘制
* 在组件级别重绘有点粗暴，但是能保证视图结果正确性
*/
Component.prototype._repaintChildren = function () {
// TODO: repaint once?
if (this._rootNode) {
var parentEl = this._rootNode.el.parentNode;
var beforeEl = this._rootNode.el.nextSibling;
this._rootNode.dispose(0, 1);
this.slotChildren = [];
this._rootNode = createNode(this.aNode, this, this.data, this);
this._rootNode.attach(parentEl, beforeEl);
this._rootNode._getElAsRootNode && (this.el = this._rootNode._getElAsRootNode());
}
else {
elementDisposeChildren(this.children, 0, 1);
this.children = [];
this.slotChildren = [];
for (var i = 0, l = this.aNode.children.length; i < l; i++) {
var child = createNode(this.aNode.children[i], this, this.data, this);
this.children.push(child);
child.attach(this.el);
}
}
};
/**
* 初始化组件内部监听数据变化
*
* @private
* @param {Object} change 数据变化信息
*/
Component.prototype._initDataChanger = function (change) {
var me = this;
this._dataChanger = function (change) {
if (me._afterLife.created) {
if (!me._dataChanges) {
nextTick(me._update, me);
me._dataChanges = [];
}
me._dataChanges.push(change);
}
else if (me.lifeCycle.inited && me.owner) {
me._updateBindxOwner([change]);
}
};
this.data.listen(this._dataChanger);
};
/**
* 监听组件的数据变化
*
* @param {string} dataName 变化的数据项
* @param {Function} listener 监听函数
*/
Component.prototype.watch = function (dataName, listener) {
var dataExpr = parseExpr(dataName);
this.data.listen(bind(function (change) {
if (changeExprCompare(change.expr, dataExpr, this.data)) {
listener.call(this, evalExpr(dataExpr, this.data, this), change);
}
}, this));
};
Component.prototype._getElAsRootNode = function () {
return this.el;
};
/**
* 将组件attach到页面
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
Component.prototype.attach = function (parentEl, beforeEl) {
if (!this.lifeCycle.attached) {
this._attach(parentEl, beforeEl);
// element 都是内部创建的，只有动态创建的 component 才会进入这个分支
if (this.owner && !this.parent) {
this.owner.implicitChildren.push(this);
}
}
};
Component.prototype._attach = function (parentEl, beforeEl) {
var hasRootNode = this.aNode.hotspot.hasRootNode
|| (this.getComponentType
? this.getComponentType(this.aNode, this.data)
: this.components[this.aNode.tagName]
);
if (hasRootNode) {
this._rootNode = createNode(this.aNode, this, this.data, this);
this._rootNode.attach(parentEl, beforeEl);
this._rootNode._getElAsRootNode && (this.el = this._rootNode._getElAsRootNode());
}
else {
if (!this.el) {
var sourceNode = this.aNode.hotspot.sourceNode;
var props = this.aNode.props;
if (sourceNode) {
this.el = sourceNode.cloneNode(false);
props = this.aNode.hotspot.dynamicProps;
}
else {
this.el = createEl(this.tagName);
}
if (this._sbindData) {
for (var key in this._sbindData) {
if (this._sbindData.hasOwnProperty(key)) {
getPropHandler(this.tagName, key)(
this.el,
this._sbindData[key],
key,
this
);
}
}
}
for (var i = 0, l = props.length; i < l; i++) {
var prop = props[i];
var value = evalExpr(prop.expr, this.data, this);
if (value || !baseProps[prop.name]) {
prop.handler(this.el, value, prop.name, this);
}
}
this._toPhase('created');
}
insertBefore(this.el, parentEl, beforeEl);
if (!this._contentReady) {
for (var i = 0, l = this.aNode.children.length; i < l; i++) {
var childANode = this.aNode.children[i];
var child = childANode.Clazz
? new childANode.Clazz(childANode, this, this.data, this)
: createNode(childANode, this, this.data, this);
this.children.push(child);
child.attach(this.el);
}
this._contentReady = 1;
}
this._attached();
}
this._toPhase('attached');
};
Component.prototype.detach = elementOwnDetach;
Component.prototype.dispose = elementOwnDispose;
Component.prototype._onEl = elementOwnOnEl;
Component.prototype._attached = elementOwnAttached;
Component.prototype._leave = function () {
if (this.leaveDispose) {
if (!this.lifeCycle.disposed) {
this.data.unlisten();
this.dataChanger = null;
this._dataChanges = null;
var len = this.implicitChildren.length;
while (len--) {
this.implicitChildren[len].dispose(0, 1);
}
this.implicitChildren = null;
this.source = null;
this.sourceSlots = null;
this.sourceSlotNameProps = null;
// 这里不用挨个调用 dispose 了，因为 children 释放链会调用的
this.slotChildren = null;
if (this._rootNode) {
// 如果没有parent，说明是一个root component，一定要从dom树中remove
this._rootNode.dispose(this.disposeNoDetach && this.parent);
}
else {
var len = this.children.length;
while (len--) {
this.children[len].dispose(1, 1);
}
len = this._elFns.length;
while (len--) {
var fn = this._elFns[len];
un(this.el, fn[0], fn[1], fn[2]);
}
this._elFns = null;
// #[begin] allua
// /* istanbul ignore if */
// if (this._inputTimer) {
// clearInterval(this._inputTimer);
// this._inputTimer = null;
// }
// #[end]
// 如果没有parent，说明是一个root component，一定要从dom树中remove
if (!this.disposeNoDetach || !this.parent) {
removeEl(this.el);
}
}
this._toPhase('detached');
this._rootNode = null;
this.el = null;
this.owner = null;
this.scope = null;
this.children = null;
this._toPhase('disposed');
if (this._ondisposed) {
this._ondisposed();
}
}
}
else if (this.lifeCycle.attached) {
removeEl(this.el);
this._toPhase('detached');
}
};
// exports = module.exports = Component;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 创建组件类
*/
// var Component = require('./component');
// var inherits = require('../util/inherits');
/**
* 创建组件类
*
* @param {Object} proto 组件类的方法表
* @param {Function=} SuperComponent 父组件类
* @return {Function}
*/
function defineComponent(proto, SuperComponent) {
// 如果传入一个不是 san component 的 constructor，直接返回不是组件构造函数
// 这种场景导致的错误 san 不予考虑
if (typeof proto === 'function') {
return proto;
}
// #[begin] error
// if (typeof proto !== 'object') {
// throw new Error('[SAN FATAL] defineComponent need a plain object.');
// }
// #[end]
function ComponentClass(option) { // eslint-disable-line
Component.call(this, option);
}
ComponentClass.prototype = proto;
inherits(ComponentClass, SuperComponent || Component);
return ComponentClass;
}
// exports = module.exports = defineComponent;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 组件Loader类
*/
// var nextTick = require('../util/next-tick');
// var each = require('../util/each');
/**
* 组件Loader类
*
* @class
*
* @param {Function} load load方法
* @param {Function=} placeholder loading过程中渲染的组件
* @param {Function=} fallback load失败时渲染的组件
*/
function ComponentLoader(load, placeholder, fallback) {
this.load = load;
this.placeholder = placeholder;
this.fallback = fallback;
this.listeners = [];
}
/**
* 开始加载组件
*
* @param {Function} onload 组件加载完成监听函数
*/
ComponentLoader.prototype.start = function (onload) {
var me = this;
switch (this.state) {
case 2:
nextTick(function () {
onload(me.Component);
});
break;
case 1:
this.listeners.push(onload);
break;
default:
this.listeners.push(onload);
this.state = 1;
var startLoad = this.load();
var done = function (RealComponent) {
me.done(RealComponent);
};
if (startLoad && typeof startLoad.then === 'function') {
startLoad.then(done, done);
}
}
};
/**
* 完成组件加载
*
* @param {Function=} ComponentClass 组件类
*/
ComponentLoader.prototype.done = function (ComponentClass) {
this.state = 2;
ComponentClass = ComponentClass || this.fallback;
this.Component = ComponentClass;
each(this.listeners, function (listener) {
listener(ComponentClass);
});
};
// exports = module.exports = ComponentLoader;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 编译组件类
*/
// var warn = require('../util/warn');
// var parseTemplate = require('../parser/parse-template');
// var parseText = require('../parser/parse-text');
// var defineComponent = require('./define-component');
// var ComponentLoader = require('./component-loader');
/**
* 编译组件类。预解析template和components
*
* @param {Function} ComponentClass 组件类
*/
function compileComponent(ComponentClass) {
var proto = ComponentClass.prototype;
// pre define components class
/* istanbul ignore else */
if (!proto.hasOwnProperty('_cmptReady')) {
proto.components = ComponentClass.components || proto.components || {};
var components = proto.components;
for (var key in components) { // eslint-disable-line
var componentClass = components[key];
if (typeof componentClass === 'object' && !(componentClass instanceof ComponentLoader)) {
components[key] = defineComponent(componentClass);
}
else if (componentClass === 'self') {
components[key] = ComponentClass;
}
}
proto._cmptReady = 1;
}
// pre compile template
/* istanbul ignore else */
if (!proto.hasOwnProperty('aNode')) {
var aNode = parseTemplate(ComponentClass.template || proto.template, {
trimWhitespace: proto.trimWhitespace || ComponentClass.trimWhitespace,
delimiters: proto.delimiters || ComponentClass.delimiters
});
var firstChild = aNode.children[0];
if (firstChild && firstChild.textExpr) {
firstChild = null;
}
// #[begin] error
// if (aNode.children.length !== 1 || !firstChild) {
// warn('Component template must have a root element.');
// }
// #[end]
proto.aNode = firstChild = firstChild || {
directives: {},
props: [],
events: [],
children: []
};
if (firstChild.tagName === 'template') {
firstChild.tagName = null;
}
if (proto.autoFillStyleAndId !== false && ComponentClass.autoFillStyleAndId !== false) {
var toExtraProp = {
'class': 0, style: 0, id: 0
};
var len = firstChild.props.length;
while (len--) {
var prop = firstChild.props[len];
if (toExtraProp[prop.name] != null) {
toExtraProp[prop.name] = prop;
firstChild.props.splice(len, 1);
}
}
toExtraProp.id = toExtraProp.id || { name: 'id', expr: parseExpr('id') };
if (toExtraProp['class']) {
var classExpr = parseText('{{class | _xclass}}').segs[0];
classExpr.filters[0].args.push(toExtraProp['class'].expr);
toExtraProp['class'].expr = classExpr;
}
else {
toExtraProp['class'] = {
name: 'class',
expr: parseText('{{class | _class}}')
};
}
if (toExtraProp.style) {
var styleExpr = parseText('{{style | _xstyle}}').segs[0];
styleExpr.filters[0].args.push(toExtraProp.style.expr);
toExtraProp.style.expr = styleExpr;
}
else {
toExtraProp.style = {
name: 'style',
expr: parseText('{{style | _style}}')
};
}
firstChild.props.push(
toExtraProp['class'], // eslint-disable-line dot-notation
toExtraProp.style,
toExtraProp.id
);
}
}
}
// exports = module.exports = compileComponent;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 常用标签表，用于 element 创建优化
*/
// var splitStr2Obj = require('../util/split-str-2-obj');
/**
* 常用标签表
*
* @type {Object}
*/
var hotTags = splitStr2Obj(
'div,span,img,ul,ol,li,dl,dt,dd,a,b,u,hr,'
+ 'form,input,textarea,button,label,select,option,'
+ 'table,tbody,th,tr,td,thead,main,aside,header,footer,nav'
);
// exports = module.exports = hotTags;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 判断是否结束桩
*/
// #[begin] reverse
/**
* 判断是否结束桩
*
* @param {HTMLElement|HTMLComment} target 要判断的元素
* @param {string} type 桩类型
* @return {boolean}
*/
function isEndStump(target, type) {
return target.nodeType === 8 && target.data === '/s-' + type;
}
// #[end]
// exports = module.exports = isEndStump;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file text 节点类
*/
// var isBrowser = require('../browser/is-browser');
// var removeEl = require('../browser/remove-el');
// var insertBefore = require('../browser/insert-before');
// var changeExprCompare = require('../runtime/change-expr-compare');
// var evalExpr = require('../runtime/eval-expr');
// var NodeType = require('./node-type');
// var warnSetHTML = require('./warn-set-html');
// var isEndStump = require('./is-end-stump');
// var getNodePath = require('./get-node-path');
/**
* text 节点类
*
* @class
* @param {Object} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker?} reverseWalker 子元素遍历对象
*/
function TextNode(aNode, parent, scope, owner, reverseWalker) {
this.aNode = aNode;
this.owner = owner;
this.scope = scope;
this.parent = parent;
// #[begin] reverse
if (reverseWalker) {
var currentNode = reverseWalker.current;
if (currentNode) {
switch (currentNode.nodeType) {
case 8:
if (currentNode.data === 's-text') {
this.sel = currentNode;
currentNode.data = this.id;
reverseWalker.goNext();
while (1) { // eslint-disable-line
currentNode = reverseWalker.current;
/* istanbul ignore if */
if (!currentNode) {
throw new Error('[SAN REVERSE ERROR] Text end flag not found. \nPaths: '
+ getNodePath(this).join(' > '));
}
if (isEndStump(currentNode, 'text')) {
this.el = currentNode;
reverseWalker.goNext();
currentNode.data = this.id;
break;
}
reverseWalker.goNext();
}
}
break;
case 3:
reverseWalker.goNext();
if (!this.aNode.textExpr.original) {
this.el = currentNode;
}
break;
}
}
else {
this.el = document.createTextNode('');
insertBefore(this.el, reverseWalker.target, reverseWalker.current);
}
}
// #[end]
}
TextNode.prototype.nodeType = 1;
/**
* 将text attach到页面
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
TextNode.prototype.attach = function (parentEl, beforeEl) {
this.content = evalExpr(this.aNode.textExpr, this.scope, this.owner);
if (this.aNode.textExpr.original) {
this.sel = document.createComment(this.id);
insertBefore(this.sel, parentEl, beforeEl);
this.el = document.createComment(this.id);
insertBefore(this.el, parentEl, beforeEl);
var tempFlag = document.createElement('script');
parentEl.insertBefore(tempFlag, this.el);
tempFlag.insertAdjacentHTML('beforebegin', this.content);
parentEl.removeChild(tempFlag);
}
else {
this.el = document.createTextNode(this.content);
insertBefore(this.el, parentEl, beforeEl);
}
};
/**
* 销毁 text 节点
*
* @param {boolean=} noDetach 是否不要把节点从dom移除
*/
TextNode.prototype.dispose = function (noDetach) {
if (!noDetach) {
removeEl(this.el);
removeEl(this.sel);
}
this.el = null;
this.sel = null;
};
var textUpdateProp = isBrowser
&& (typeof document.createTextNode('').textContent === 'string'
? 'textContent'
: 'data');
/**
* 更新 text 节点的视图
*
* @param {Array} changes 数据变化信息
*/
TextNode.prototype._update = function (changes) {
if (this.aNode.textExpr.value) {
return;
}
var len = changes.length;
while (len--) {
if (changeExprCompare(changes[len].expr, this.aNode.textExpr, this.scope)) {
var text = evalExpr(this.aNode.textExpr, this.scope, this.owner);
if (text !== this.content) {
this.content = text;
if (this.aNode.textExpr.original) {
var startRemoveEl = this.sel.nextSibling;
var parentEl = this.el.parentNode;
while (startRemoveEl !== this.el) {
var removeTarget = startRemoveEl;
startRemoveEl = startRemoveEl.nextSibling;
removeEl(removeTarget);
}
// #[begin] error
// warnSetHTML(parentEl);
// #[end]
var tempFlag = document.createElement('script');
parentEl.insertBefore(tempFlag, this.el);
tempFlag.insertAdjacentHTML('beforebegin', text);
parentEl.removeChild(tempFlag);
}
else {
this.el[textUpdateProp] = text;
}
}
return;
}
}
};
// exports = module.exports = TextNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 将没有 root 只有 children 的元素 attach 到页面
*/
// var insertBefore = require('../browser/insert-before');
// var LifeCycle = require('./life-cycle');
// var createNode = require('./create-node');
/**
* 将没有 root 只有 children 的元素 attach 到页面
* 主要用于 slot 和 template
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
function nodeOwnOnlyChildrenAttach(parentEl, beforeEl) {
this.sel = document.createComment(this.id);
insertBefore(this.sel, parentEl, beforeEl);
for (var i = 0; i < this.aNode.children.length; i++) {
var child = createNode(
this.aNode.children[i],
this,
this.childScope || this.scope,
this.childOwner || this.owner
);
this.children.push(child);
child.attach(parentEl, beforeEl);
}
this.el = document.createComment(this.id);
insertBefore(this.el, parentEl, beforeEl);
this.lifeCycle = LifeCycle.attached;
}
// exports = module.exports = nodeOwnOnlyChildrenAttach;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file slot 节点类
*/
// var each = require('../util/each');
// var guid = require('../util/guid');
// var extend = require('../util/extend');
// var ExprType = require('../parser/expr-type');
// var createAccessor = require('../parser/create-accessor');
// var evalExpr = require('../runtime/eval-expr');
// var Data = require('../runtime/data');
// var DataChangeType = require('../runtime/data-change-type');
// var changeExprCompare = require('../runtime/change-expr-compare');
// var insertBefore = require('../browser/insert-before');
// var removeEl = require('../browser/remove-el');
// var NodeType = require('./node-type');
// var LifeCycle = require('./life-cycle');
// var getANodeProp = require('./get-a-node-prop');
// var nodeSBindInit = require('./node-s-bind-init');
// var nodeSBindUpdate = require('./node-s-bind-update');
// var createReverseNode = require('./create-reverse-node');
// var elementDisposeChildren = require('./element-dispose-children');
// var nodeOwnOnlyChildrenAttach = require('./node-own-only-children-attach');
/**
* slot 节点类
*
* @class
* @param {Object} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker?} reverseWalker 子元素遍历对象
*/
function SlotNode(aNode, parent, scope, owner, reverseWalker) {
this.owner = owner;
this.scope = scope;
this.parent = parent;
this.parentComponent = parent.nodeType === 5
? parent
: parent.parentComponent;
this.id = guid++;
this.lifeCycle = LifeCycle.start;
this.children = [];
// calc slot name
this.nameBind = getANodeProp(aNode, 'name');
if (this.nameBind) {
this.isNamed = true;
this.name = evalExpr(this.nameBind.expr, this.scope, this.owner);
}
// calc aNode children
var sourceSlots = owner.sourceSlots;
var matchedSlots;
if (sourceSlots) {
matchedSlots = this.isNamed ? sourceSlots.named[this.name] : sourceSlots.noname;
}
if (matchedSlots) {
this.isInserted = true;
}
this.aNode = {
directives: aNode.directives,
props: [],
events: [],
children: matchedSlots || aNode.children.slice(0),
vars: aNode.vars
};
this._sbindData = nodeSBindInit(aNode.directives.bind, this.scope, this.owner);
// calc scoped slot vars
var initData;
if (this._sbindData) {
initData = extend({}, this._sbindData);
}
if (aNode.vars) {
initData = initData || {};
each(aNode.vars, function (varItem) {
initData[varItem.name] = evalExpr(varItem.expr, scope, owner);
});
}
// child owner & child scope
if (this.isInserted) {
this.childOwner = owner.owner;
this.childScope = owner.scope;
}
if (initData) {
this.isScoped = true;
this.childScope = new Data(initData, this.childScope || this.scope);
}
owner.slotChildren.push(this);
// #[begin] reverse
if (reverseWalker) {
var hasFlagComment;
// start flag
if (reverseWalker.current && reverseWalker.current.nodeType === 8) {
this.sel = reverseWalker.current;
hasFlagComment = 1;
reverseWalker.goNext();
}
else {
this.sel = document.createComment(this.id);
reverseWalker.current
? reverseWalker.target.insertBefore(this.sel, reverseWalker.current)
: reverseWalker.target.appendChild(this.sel);
}
var aNodeChildren = this.aNode.children;
for (var i = 0, l = aNodeChildren.length; i < l; i++) {
this.children.push(createReverseNode(
aNodeChildren[i],
this,
this.childScope || this.scope,
this.childOwner || this.owner,
reverseWalker
));
}
// end flag
if (hasFlagComment) {
this.el = reverseWalker.current;
reverseWalker.goNext();
}
else {
this.el = document.createComment(this.id);
reverseWalker.current
? reverseWalker.target.insertBefore(this.el, reverseWalker.current)
: reverseWalker.target.appendChild(this.el);
}
this.lifeCycle = LifeCycle.attached;
}
// #[end]
}
SlotNode.prototype.nodeType = 6;
/**
* 销毁释放 slot
*
* @param {boolean=} noDetach 是否不要把节点从dom移除
* @param {boolean=} noTransition 是否不显示过渡动画效果
*/
SlotNode.prototype.dispose = function (noDetach, noTransition) {
this.childOwner = null;
this.childScope = null;
elementDisposeChildren(this.children, noDetach, noTransition);
if (!noDetach) {
removeEl(this.el);
removeEl(this.sel);
}
this.sel = null;
this.el = null;
this.owner = null;
this.scope = null;
this.children = null;
this.lifeCycle = LifeCycle.disposed;
if (this._ondisposed) {
this._ondisposed();
}
};
SlotNode.prototype.attach = nodeOwnOnlyChildrenAttach;
/**
* 视图更新函数
*
* @param {Array} changes 数据变化信息
* @param {boolean=} isFromOuter 变化信息是否来源于父组件之外的组件
* @return {boolean}
*/
SlotNode.prototype._update = function (changes, isFromOuter) {
var me = this;
if (this.nameBind && evalExpr(this.nameBind.expr, this.scope, this.owner) !== this.name) {
this.owner._notifyNeedReload();
return false;
}
if (isFromOuter) {
if (this.isInserted) {
for (var i = 0; i < this.children.length; i++) {
this.children[i]._update(changes);
}
}
}
else {
if (this.isScoped) {
var varKeys = {};
each(this.aNode.vars, function (varItem) {
varKeys[varItem.name] = 1;
me.childScope.set(varItem.name, evalExpr(varItem.expr, me.scope, me.owner));
});
var scopedChanges = [];
this._sbindData = nodeSBindUpdate(
this.aNode.directives.bind,
this._sbindData,
this.scope,
this.owner,
changes,
function (name, value) {
if (varKeys[name]) {
return;
}
me.childScope.set(name, value);
scopedChanges.push({
type: 1,
expr: createAccessor([
{type: 1, value: name}
]),
value: value,
option: {}
});
}
);
each(changes, function (change) {
if (!me.isInserted) {
scopedChanges.push(change);
}
each(me.aNode.vars, function (varItem) {
var name = varItem.name;
var relation = changeExprCompare(change.expr, varItem.expr, me.scope);
if (relation < 1) {
return;
}
if (change.type !== 2) {
scopedChanges.push({
type: 1,
expr: createAccessor([
{type: 1, value: name}
]),
value: me.childScope.get(name),
option: change.option
});
}
else if (relation === 2) {
scopedChanges.push({
expr: createAccessor([
{type: 1, value: name}
]),
type: 2,
index: change.index,
deleteCount: change.deleteCount,
value: change.value,
insertions: change.insertions,
option: change.option
});
}
});
});
for (var i = 0; i < this.children.length; i++) {
this.children[i]._update(scopedChanges);
}
}
else if (!this.isInserted) {
for (var i = 0; i < this.children.length; i++) {
this.children[i]._update(changes);
}
}
}
};
// exports = module.exports = SlotNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file for 指令节点类
*/
// var inherits = require('../util/inherits');
// var each = require('../util/each');
// var guid = require('../util/guid');
// var ExprType = require('../parser/expr-type');
// var parseExpr = require('../parser/parse-expr');
// var createAccessor = require('../parser/create-accessor');
// var Data = require('../runtime/data');
// var DataChangeType = require('../runtime/data-change-type');
// var changeExprCompare = require('../runtime/change-expr-compare');
// var evalExpr = require('../runtime/eval-expr');
// var changesIsInDataRef = require('../runtime/changes-is-in-data-ref');
// var insertBefore = require('../browser/insert-before');
// var NodeType = require('./node-type');
// var createNode = require('./create-node');
// var createReverseNode = require('./create-reverse-node');
// var nodeOwnSimpleDispose = require('./node-own-simple-dispose');
// var nodeOwnCreateStump = require('./node-own-create-stump');
/**
* 循环项的数据容器类
*
* @inner
* @class
* @param {Object} forElement for元素对象
* @param {*} item 当前项的数据
* @param {number} index 当前项的索引
*/
function ForItemData(forElement, item, index) {
this.parent = forElement.scope;
this.raw = {};
this.listeners = [];
this.directive = forElement.aNode.directives['for']; // eslint-disable-line dot-notation
this.indexName = this.directive.index || '$index';
this.raw[this.directive.item] = item;
this.raw[this.indexName] = index;
}
/**
* 将数据操作的表达式，转换成为对parent数据操作的表达式
* 主要是对item和index进行处理
*
* @param {Object} expr 表达式
* @return {Object}
*/
ForItemData.prototype.exprResolve = function (expr) {
var me = this;
var directive = this.directive;
function resolveItem(expr) {
if (expr.type === 4 && expr.paths[0].value === directive.item) {
return createAccessor(
directive.value.paths.concat(
{
type: 2,
value: me.raw[me.indexName]
},
expr.paths.slice(1)
)
);
}
return expr;
}
expr = resolveItem(expr);
var resolvedPaths = [];
each(expr.paths, function (item) {
resolvedPaths.push(
item.type === 4 && item.paths[0].value === me.indexName
? {
type: 2,
value: me.raw[me.indexName]
}
: resolveItem(item)
);
});
return createAccessor(resolvedPaths);
};
// 代理数据操作方法
inherits(ForItemData, Data);
each(
['set', 'remove', 'unshift', 'shift', 'push', 'pop', 'splice'],
function (method) {
ForItemData.prototype['_' + method] = Data.prototype[method];
ForItemData.prototype[method] = function (expr) {
expr = this.exprResolve(parseExpr(expr));
this.parent[method].apply(
this.parent,
[expr].concat(Array.prototype.slice.call(arguments, 1))
);
};
}
);
/**
* for 指令节点类
*
* @class
* @param {Object} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker?} reverseWalker 子元素遍历对象
*/
function ForNode(aNode, parent, scope, owner, reverseWalker) {
this.aNode = aNode;
this.owner = owner;
this.scope = scope;
this.parent = parent;
this.parentComponent = parent.nodeType === 5
? parent
: parent.parentComponent;
this.id = guid++;
this.children = [];
this.param = aNode.directives['for']; // eslint-disable-line dot-notation
this.itemPaths = [
{
type: 1,
value: this.param.item
}
];
this.itemExpr = {
type: 4,
paths: this.itemPaths,
raw: this.param.item
};
if (this.param.index) {
this.indexExpr = createAccessor([{
type: 1,
value: '' + this.param.index
}]);
}
// #[begin] reverse
if (reverseWalker) {
this.listData = evalExpr(this.param.value, this.scope, this.owner);
if (this.listData instanceof Array) {
for (var i = 0; i < this.listData.length; i++) {
this.children.push(createReverseNode(
this.aNode.forRinsed,
this,
new ForItemData(this, this.listData[i], i),
this.owner,
reverseWalker
));
}
}
else if (this.listData && typeof this.listData === 'object') {
for (var i in this.listData) {
if (this.listData.hasOwnProperty(i) && this.listData[i] != null) {
this.children.push(createReverseNode(
this.aNode.forRinsed,
this,
new ForItemData(this, this.listData[i], i),
this.owner,
reverseWalker
));
}
}
}
this._create();
insertBefore(this.el, reverseWalker.target, reverseWalker.current);
}
// #[end]
}
ForNode.prototype.nodeType = 3;
ForNode.prototype._create = nodeOwnCreateStump;
ForNode.prototype.dispose = nodeOwnSimpleDispose;
/**
* 将元素attach到页面的行为
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
ForNode.prototype.attach = function (parentEl, beforeEl) {
this._create();
insertBefore(this.el, parentEl, beforeEl);
this.listData = evalExpr(this.param.value, this.scope, this.owner);
this._createChildren();
};
/**
* 创建子元素
*/
ForNode.prototype._createChildren = function () {
var parentEl = this.el.parentNode;
var listData = this.listData;
if (listData instanceof Array) {
for (var i = 0; i < listData.length; i++) {
var childANode = this.aNode.forRinsed;
var child = childANode.Clazz
? new childANode.Clazz(childANode, this, new ForItemData(this, listData[i], i), this.owner)
: createNode(childANode, this, new ForItemData(this, listData[i], i), this.owner);
this.children.push(child);
child.attach(parentEl, this.el);
}
}
else if (listData && typeof listData === 'object') {
for (var i in listData) {
if (listData.hasOwnProperty(i) && listData[i] != null) {
var childANode = this.aNode.forRinsed;
var child = childANode.Clazz
? new childANode.Clazz(childANode, this, new ForItemData(this, listData[i], i), this.owner)
: createNode(childANode, this, new ForItemData(this, listData[i], i), this.owner);
this.children.push(child);
child.attach(parentEl, this.el);
}
}
}
};
/* eslint-disable fecs-max-statements */
/**
* 视图更新函数
*
* @param {Array} changes 数据变化信息
*/
ForNode.prototype._update = function (changes) {
var listData = evalExpr(this.param.value, this.scope, this.owner);
var oldIsArr = this.listData instanceof Array;
var newIsArr = listData instanceof Array;
if (this.children.length) {
if (!listData || newIsArr && listData.length === 0) {
this._disposeChildren();
this.listData = listData;
}
else if (oldIsArr !== newIsArr || !newIsArr) {
// 就是这么暴力
// 不推荐使用for遍历object，用的话自己负责
this.listData = listData;
var isListChanged;
for (var cIndex = 0; !isListChanged && cIndex < changes.length; cIndex++) {
isListChanged = changeExprCompare(changes[cIndex].expr, this.param.value, this.scope);
}
var dataHotspot = this.aNode.hotspot.data;
if (isListChanged || dataHotspot && changesIsInDataRef(changes, dataHotspot)) {
var me = this;
this._disposeChildren(null, function () {
me._createChildren();
});
}
}
else {
this._updateArray(changes, listData);
this.listData = listData;
}
}
else {
this.listData = listData;
this._createChildren();
}
};
/**
* 销毁释放子元素
*
* @param {Array?} children 要销毁的子元素，默认为自身的children
* @param {Function} callback 释放完成的回调函数
*/
ForNode.prototype._disposeChildren = function (children, callback) {
var parentEl = this.el.parentNode;
var parentFirstChild = parentEl.firstChild;
var parentLastChild = parentEl.lastChild;
var len = this.children.length;
var violentClear = !this.aNode.directives.transition
&& !children
// 是否 parent 的唯一 child
&& len && parentFirstChild === this.children[0].el && parentLastChild === this.el
;
if (!children) {
children = this.children;
this.children = [];
}
var disposedChildCount = 0;
len = children.length;
// 调用入口处已保证此处必有需要被删除的 child
for (var i = 0; i < len; i++) {
var disposeChild = children[i];
if (violentClear) {
disposeChild && disposeChild.dispose(violentClear, violentClear);
}
else if (disposeChild) {
disposeChild._ondisposed = childDisposed;
disposeChild.dispose();
}
else {
childDisposed();
}
}
if (violentClear) {
// #[begin] allua
// /* istanbul ignore next */
// if (ie) {
// parentEl.innerHTML = '';
// }
// else {
// #[end]
parentEl.textContent = '';
// #[begin] allua
// }
// #[end]
this.el = document.createComment(this.id);
parentEl.appendChild(this.el);
callback && callback();
}
function childDisposed() {
disposedChildCount++;
if (disposedChildCount >= len) {
callback && callback();
}
}
};
ForNode.prototype.opti = typeof navigator !== 'undefined'
&& /chrome\/[0-9]+/i.test(navigator.userAgent);
/**
* 数组类型的视图更新
*
* @param {Array} changes 数据变化信息
* @param {Array} newList 新数组数据
*/
ForNode.prototype._updateArray = function (changes, newList) {
var oldChildrenLen = this.children.length;
var childrenChanges = new Array(oldChildrenLen);
function pushToChildrenChanges(change) {
for (var i = 0, l = childrenChanges.length; i < l; i++) {
(childrenChanges[i] = childrenChanges[i] || []).push(change);
}
childrenNeedUpdate = null;
isOnlyDispose = false;
}
var disposeChildren = [];
// 控制列表是否整体更新的变量
var isChildrenRebuild;
//
var isOnlyDispose = true;
var childrenNeedUpdate = {};
var newLen = newList.length;
var getItemKey = this.aNode.hotspot.getForKey;
/* eslint-disable no-redeclare */
for (var cIndex = 0; cIndex < changes.length; cIndex++) {
var change = changes[cIndex];
var relation = changeExprCompare(change.expr, this.param.value, this.scope);
if (!relation) {
// 无关时，直接传递给子元素更新，列表本身不需要动
pushToChildrenChanges(change);
}
else {
if (relation > 2) {
// 变更表达式是list绑定表达式的子项
// 只需要对相应的子项进行更新
var changePaths = change.expr.paths;
var forLen = this.param.value.paths.length;
var changeIndex = +evalExpr(changePaths[forLen], this.scope, this.owner);
if (isNaN(changeIndex)) {
pushToChildrenChanges(change);
}
else if (!isChildrenRebuild) {
isOnlyDispose = false;
childrenNeedUpdate && (childrenNeedUpdate[changeIndex] = 1);
childrenChanges[changeIndex] = childrenChanges[changeIndex] || [];
if (this.param.index) {
childrenChanges[changeIndex].push(change);
}
change = change.type === 1
? {
type: change.type,
expr: createAccessor(
this.itemPaths.concat(changePaths.slice(forLen + 1))
),
value: change.value,
option: change.option
}
: {
index: change.index,
deleteCount: change.deleteCount,
insertions: change.insertions,
type: change.type,
expr: createAccessor(
this.itemPaths.concat(changePaths.slice(forLen + 1))
),
value: change.value,
option: change.option
};
childrenChanges[changeIndex].push(change);
if (change.type === 1) {
if (this.children[changeIndex]) {
this.children[changeIndex].scope._set(
change.expr,
change.value,
{
silent: 1
}
);
}
else {
// 设置数组项的索引可能超出数组长度，此时需要新增
// 比如当前数组只有2项，但是set list[4]
this.children[changeIndex] = 0;
}
}
else if (this.children[changeIndex]) {
this.children[changeIndex].scope._splice(
change.expr,
[].concat(change.index, change.deleteCount, change.insertions),
{
silent: 1
}
);
}
}
}
else if (isChildrenRebuild) {
continue;
}
else if (relation === 2 && change.type === 2
&& (this.owner.updateMode !== 'optimized' || !this.opti || this.aNode.directives.transition)
) {
childrenNeedUpdate = null;
// 变更表达式是list绑定表达式本身数组的splice操作
// 此时需要删除部分项，创建部分项
var changeStart = change.index;
var deleteCount = change.deleteCount;
var insertionsLen = change.insertions.length;
var newCount = insertionsLen - deleteCount;
if (newCount) {
var indexChange = this.param.index
? {
type: 1,
option: change.option,
expr: this.indexExpr
}
: null;
for (var i = changeStart + deleteCount; i < this.children.length; i++) {
if (indexChange) {
isOnlyDispose = false;
(childrenChanges[i] = childrenChanges[i] || []).push(indexChange);
}
var child = this.children[i];
if (child) {
child.scope.raw[child.scope.indexName] = i - deleteCount + insertionsLen;
}
}
}
var deleteLen = deleteCount;
while (deleteLen--) {
if (deleteLen < insertionsLen) {
isOnlyDispose = false;
var i = changeStart + deleteLen;
// update
(childrenChanges[i] = childrenChanges[i] || []).push({
type: 1,
option: change.option,
expr: this.itemExpr,
value: change.insertions[deleteLen]
});
if (this.children[i]) {
this.children[i].scope.raw[this.param.item] = change.insertions[deleteLen];
}
}
}
if (newCount < 0) {
disposeChildren = disposeChildren.concat(
this.children.splice(changeStart + insertionsLen, -newCount)
);
childrenChanges.splice(changeStart + insertionsLen, -newCount);
}
else if (newCount > 0) {
isOnlyDispose = false;
var spliceArgs = [changeStart + deleteCount, 0].concat(new Array(newCount));
this.children.splice.apply(this.children, spliceArgs);
childrenChanges.splice.apply(childrenChanges, spliceArgs);
}
}
else {
childrenNeedUpdate = null;
isOnlyDispose = false;
isChildrenRebuild = 1;
// 变更表达式是list绑定表达式本身或母项的重新设值
// 此时需要更新整个列表
if (getItemKey && newLen && oldChildrenLen) {
// 如果设置了trackBy，用lis更新。开始 ====
var newListKeys = [];
var oldListKeys = [];
var newListKeysMap = {};
var oldListInNew = [];
var oldListKeyIndex = {};
for (var i = 0; i < newList.length; i++) {
var itemKey = getItemKey(newList[i]);
newListKeys.push(itemKey);
newListKeysMap[itemKey] = i;
};
for (var i = 0; i < this.listData.length; i++) {
var itemKey = getItemKey(this.listData[i]);
oldListKeys.push(itemKey);
oldListKeyIndex[itemKey] = i;
if (newListKeysMap[itemKey] != null) {
oldListInNew[i] = newListKeysMap[itemKey];
}
else {
oldListInNew[i] = -1;
disposeChildren.push(this.children[i]);
}
};
var newIndexStart = 0;
var newIndexEnd = newLen;
var oldIndexStart = 0;
var oldIndexEnd = oldChildrenLen;
// 优化：从头开始比对新旧 list 项是否相同
while (newIndexStart < newLen
&& oldIndexStart < oldChildrenLen
&& newListKeys[newIndexStart] === oldListKeys[oldIndexStart]
) {
if (this.listData[oldIndexStart] !== newList[newIndexStart]) {
this.children[oldIndexStart].scope.raw[this.param.item] = newList[newIndexStart];
(childrenChanges[oldIndexStart] = childrenChanges[oldIndexStart] || []).push({
type: 1,
option: change.option,
expr: this.itemExpr,
value: newList[newIndexStart]
});
}
// 对list更上级数据的直接设置
if (relation < 2) {
(childrenChanges[oldIndexStart] = childrenChanges[oldIndexStart] || []).push(change);
}
newIndexStart++;
oldIndexStart++;
}
var indexChange = this.param.index
? {
type: 1,
option: change.option,
expr: this.indexExpr
}
: null;
// 优化：从尾开始比对新旧 list 项是否相同
while (newIndexEnd > newIndexStart && oldIndexEnd > oldIndexStart
&& newListKeys[newIndexEnd - 1] === oldListKeys[oldIndexEnd - 1]
) {
newIndexEnd--;
oldIndexEnd--;
if (this.listData[oldIndexEnd] !== newList[newIndexEnd]) {
// refresh item
this.children[oldIndexEnd].scope.raw[this.param.item] = newList[newIndexEnd];
(childrenChanges[oldIndexEnd] = childrenChanges[oldIndexEnd] || []).push({
type: 1,
option: change.option,
expr: this.itemExpr,
value: newList[newIndexEnd]
});
}
// refresh index
if (newIndexEnd !== oldIndexEnd) {
this.children[oldIndexEnd].scope.raw[this.children[oldIndexEnd].scope.indexName] = newIndexEnd;
if (indexChange) {
(childrenChanges[oldIndexEnd] = childrenChanges[oldIndexEnd] || []).push(indexChange);
}
}
// 对list更上级数据的直接设置
if (relation < 2) {
(childrenChanges[oldIndexEnd] = childrenChanges[oldIndexEnd] || []).push(change);
}
}
var oldListLIS = [];
var lisIdx = [];
var lisPos = -1;
var lisSource = oldListInNew.slice(oldIndexStart, oldIndexEnd);
var len = oldIndexEnd - oldIndexStart;
var preIdx = new Array(len);
for (var i = 0; i < len; i++) {
var oldItemInNew = lisSource[i];
if (oldItemInNew === -1) {
continue;
}
var rePos = -1;
var rePosEnd = oldListLIS.length;
if (rePosEnd > 0 && oldListLIS[rePosEnd - 1] <= oldItemInNew) {
rePos = rePosEnd - 1;
}
else {
while (rePosEnd - rePos > 1) {
var mid = Math.floor((rePos + rePosEnd) / 2);
if (oldListLIS[mid] > oldItemInNew) {
rePosEnd = mid;
} else {
rePos = mid;
}
}
}
if (rePos !== -1) {
preIdx[i] = lisIdx[rePos];
}
if (rePos === lisPos) {
lisPos++;
oldListLIS[lisPos] = oldItemInNew;
lisIdx[lisPos] = i;
} else if (oldItemInNew < oldListLIS[rePos + 1]) {
oldListLIS[rePos + 1] = oldItemInNew;
lisIdx[rePos + 1] = i;
}
}
for (var i = lisIdx[lisPos]; lisPos >= 0; i = preIdx[i], lisPos--) {
oldListLIS[lisPos] = i;
}
var oldListLISPos = oldListLIS.length;
var staticPos = oldListLISPos ? oldListInNew[oldListLIS[--oldListLISPos] + oldIndexStart] : -1;
var newChildren = [];
var newChildrenChanges = [];
for (var i = newLen - 1; i >= 0; i--) {
if (i >= newIndexEnd) {
newChildren[i] = this.children[oldChildrenLen - newLen + i];
newChildrenChanges[i] = childrenChanges[oldChildrenLen - newLen + i];
}
else if (i < newIndexStart) {
newChildren[i] = this.children[i];
newChildrenChanges[i] = childrenChanges[i];
}
else {
var oldListIndex = oldListKeyIndex[newListKeys[i]];
if (i === staticPos) {
var oldScope = this.children[oldListIndex].scope;
// 如果数据本身引用发生变化，设置变更
if (this.listData[oldListIndex] !== newList[i]) {
oldScope.raw[this.param.item] = newList[i];
(childrenChanges[oldListIndex] = childrenChanges[oldListIndex] || []).push({
type: 1,
option: change.option,
expr: this.itemExpr,
value: newList[i]
});
}
// refresh index
if (indexChange && i !== oldListIndex) {
oldScope.raw[oldScope.indexName] = i;
if (indexChange) {
(childrenChanges[oldListIndex] = childrenChanges[oldListIndex] || []).push(indexChange);
}
}
// 对list更上级数据的直接设置
if (relation < 2) {
(childrenChanges[oldListIndex] = childrenChanges[oldListIndex] || []).push(change);
}
newChildren[i] = this.children[oldListIndex];
newChildrenChanges[i] = childrenChanges[oldListIndex];
staticPos = oldListLISPos ? oldListInNew[oldListLIS[--oldListLISPos] + oldIndexStart] : -1;
}
else {
if (oldListIndex != null) {
disposeChildren.push(this.children[oldListIndex]);
}
newChildren[i] = 0;
newChildrenChanges[i] = 0;
}
}
}
this.children = newChildren;
childrenChanges = newChildrenChanges;
// 如果设置了trackBy，用lis更新。结束 ====
}
else {
// 老的比新的多的部分，标记需要dispose
if (oldChildrenLen > newLen) {
disposeChildren = disposeChildren.concat(this.children.slice(newLen));
childrenChanges = childrenChanges.slice(0, newLen);
this.children = this.children.slice(0, newLen);
}
// 剩下的部分整项变更
for (var i = 0; i < newLen; i++) {
// 对list更上级数据的直接设置
if (relation < 2) {
(childrenChanges[i] = childrenChanges[i] || []).push(change);
}
if (this.children[i]) {
if (this.children[i].scope.raw[this.param.item] !== newList[i]) {
this.children[i].scope.raw[this.param.item] = newList[i];
(childrenChanges[i] = childrenChanges[i] || []).push({
type: 1,
option: change.option,
expr: this.itemExpr,
value: newList[i]
});
}
}
else {
this.children[i] = 0;
}
}
}
}
}
}
// 标记 length 是否发生变化
if (newLen !== oldChildrenLen && this.param.value.paths) {
var lengthChange = {
type: 1,
option: {},
expr: createAccessor(
this.param.value.paths.concat({
type: 1,
value: 'length'
})
)
};
if (changesIsInDataRef([lengthChange], this.aNode.hotspot.data)) {
pushToChildrenChanges(lengthChange);
}
}
// 执行视图更新，先删再刷新
this._doCreateAndUpdate = doCreateAndUpdate;
var me = this;
if (disposeChildren.length === 0) {
doCreateAndUpdate();
}
else {
this._disposeChildren(disposeChildren, function () {
if (doCreateAndUpdate === me._doCreateAndUpdate) {
doCreateAndUpdate();
}
});
}
function doCreateAndUpdate() {
me._doCreateAndUpdate = null;
if (isOnlyDispose) {
return;
}
var beforeEl = me.el;
var parentEl = beforeEl.parentNode;
// 对相应的项进行更新
// 如果不attached则直接创建，如果存在则调用更新函数
var j = -1;
for (var i = 0; i < newLen; i++) {
var child = me.children[i];
if (child) {
if (childrenChanges[i] && (!childrenNeedUpdate || childrenNeedUpdate[i])) {
child._update(childrenChanges[i]);
}
}
else {
if (j < i) {
j = i + 1;
beforeEl = null;
while (j < newLen) {
var nextChild = me.children[j];
if (nextChild) {
beforeEl = nextChild.sel || nextChild.el;
break;
}
j++;
}
}
me.children[i] = createNode(me.aNode.forRinsed, me, new ForItemData(me, newList[i], i), me.owner);
me.children[i].attach(parentEl, beforeEl || me.el);
}
}
}
};
// exports = module.exports = ForNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file if 指令节点类
*/
// var each = require('../util/each');
// var guid = require('../util/guid');
// var insertBefore = require('../browser/insert-before');
// var evalExpr = require('../runtime/eval-expr');
// var NodeType = require('./node-type');
// var createNode = require('./create-node');
// var createReverseNode = require('./create-reverse-node');
// var nodeOwnCreateStump = require('./node-own-create-stump');
// var nodeOwnSimpleDispose = require('./node-own-simple-dispose');
/**
* if 指令节点类
*
* @class
* @param {Object} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker?} reverseWalker 子元素遍历对象
*/
function IfNode(aNode, parent, scope, owner, reverseWalker) {
this.aNode = aNode;
this.owner = owner;
this.scope = scope;
this.parent = parent;
this.parentComponent = parent.nodeType === 5
? parent
: parent.parentComponent;
this.id = guid++;
this.children = [];
// #[begin] reverse
if (reverseWalker) {
if (evalExpr(this.aNode.directives['if'].value, this.scope, this.owner)) { // eslint-disable-line dot-notation
this.elseIndex = -1;
this.children[0] = createReverseNode(
this.aNode.ifRinsed,
this,
this.scope,
this.owner,
reverseWalker
);
}
else {
var me = this;
each(aNode.elses, function (elseANode, index) {
var elif = elseANode.directives.elif;
if (!elif || elif && evalExpr(elif.value, me.scope, me.owner)) {
me.elseIndex = index;
me.children[0] = createReverseNode(
elseANode,
me,
me.scope,
me.owner,
reverseWalker
);
return false;
}
});
}
this._create();
insertBefore(this.el, reverseWalker.target, reverseWalker.current);
}
// #[end]
}
IfNode.prototype.nodeType = 2;
IfNode.prototype._create = nodeOwnCreateStump;
IfNode.prototype.dispose = nodeOwnSimpleDispose;
/**
* attach到页面
*
* @param {HTMLElement} parentEl 要添加到的父元素
* @param {HTMLElement＝} beforeEl 要添加到哪个元素之前
*/
IfNode.prototype.attach = function (parentEl, beforeEl) {
var me = this;
var elseIndex;
var child;
if (evalExpr(this.aNode.directives['if'].value, this.scope, this.owner)) { // eslint-disable-line dot-notation
child = createNode(this.aNode.ifRinsed, this, this.scope, this.owner);
elseIndex = -1;
}
else {
each(this.aNode.elses, function (elseANode, index) {
var elif = elseANode.directives.elif;
if (!elif || elif && evalExpr(elif.value, me.scope, me.owner)) {
child = createNode(elseANode, me, me.scope, me.owner);
elseIndex = index;
return false;
}
});
}
if (child) {
this.children[0] = child;
child.attach(parentEl, beforeEl);
this.elseIndex = elseIndex;
}
this._create();
insertBefore(this.el, parentEl, beforeEl);
};
/**
* 视图更新函数
*
* @param {Array} changes 数据变化信息
*/
IfNode.prototype._update = function (changes) {
var me = this;
var childANode = this.aNode.ifRinsed;
var elseIndex;
if (evalExpr(this.aNode.directives['if'].value, this.scope, this.owner)) { // eslint-disable-line dot-notation
elseIndex = -1;
}
else {
each(this.aNode.elses, function (elseANode, index) {
var elif = elseANode.directives.elif;
if (elif && evalExpr(elif.value, me.scope, me.owner) || !elif) {
elseIndex = index;
childANode = elseANode;
return false;
}
});
}
var child = this.children[0];
if (elseIndex === this.elseIndex) {
child && child._update(changes);
}
else {
this.children = [];
if (child) {
child._ondisposed = newChild;
child.dispose();
}
else {
newChild();
}
this.elseIndex = elseIndex;
}
function newChild() {
if (typeof elseIndex !== 'undefined') {
(me.children[0] = createNode(childANode, me, me.scope, me.owner))
.attach(me.el.parentNode, me.el);
}
}
};
IfNode.prototype._getElAsRootNode = function () {
var child = this.children[0];
return child && child.el || this.el;
};
// exports = module.exports = IfNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file template 节点类
*/
// var each = require('../util/each');
// var guid = require('../util/guid');
// var insertBefore = require('../browser/insert-before');
// var removeEl = require('../browser/remove-el');
// var NodeType = require('./node-type');
// var LifeCycle = require('./life-cycle');
// var createReverseNode = require('./create-reverse-node');
// var elementDisposeChildren = require('./element-dispose-children');
// var nodeOwnOnlyChildrenAttach = require('./node-own-only-children-attach');
/**
* template 节点类
*
* @class
* @param {Object} aNode 抽象节点
* @param {Node} parent 父亲节点
* @param {Model} scope 所属数据环境
* @param {Component} owner 所属组件环境
* @param {DOMChildrenWalker?} reverseWalker 子元素遍历对象
*/
function TemplateNode(aNode, parent, scope, owner, reverseWalker) {
this.aNode = aNode;
this.owner = owner;
this.scope = scope;
this.parent = parent;
this.parentComponent = parent.nodeType === 5
? parent
: parent.parentComponent;
this.id = guid++;
this.lifeCycle = LifeCycle.start;
this.children = [];
// #[begin] reverse
if (reverseWalker) {
var hasFlagComment;
// start flag
if (reverseWalker.current && reverseWalker.current.nodeType === 8) {
this.sel = reverseWalker.current;
hasFlagComment = 1;
reverseWalker.goNext();
}
else {
this.sel = document.createComment(this.id);
insertBefore(this.sel, reverseWalker.target, reverseWalker.current);
}
// content
var aNodeChildren = this.aNode.children;
for (var i = 0, l = aNodeChildren.length; i < l; i++) {
this.children.push(
createReverseNode(aNodeChildren[i], this, this.scope, this.owner, reverseWalker)
);
}
// end flag
if (hasFlagComment) {
this.el = reverseWalker.current;
reverseWalker.goNext();
}
else {
this.el = document.createComment(this.id);
insertBefore(this.el, reverseWalker.target, reverseWalker.current);
}
this.lifeCycle = LifeCycle.attached;
}
// #[end]
}
TemplateNode.prototype.nodeType = 7;
TemplateNode.prototype.attach = nodeOwnOnlyChildrenAttach;
/**
* 销毁释放
*
* @param {boolean=} noDetach 是否不要把节点从dom移除
* @param {boolean=} noTransition 是否不显示过渡动画效果
*/
TemplateNode.prototype.dispose = function (noDetach, noTransition) {
elementDisposeChildren(this.children, noDetach, noTransition);
if (!noDetach) {
removeEl(this.el);
removeEl(this.sel);
}
this.sel = null;
this.el = null;
this.owner = null;
this.scope = null;
this.children = null;
this.lifeCycle = LifeCycle.disposed;
if (this._ondisposed) {
this._ondisposed();
}
};
/**
* 视图更新函数
*
* @param {Array} changes 数据变化信息
*/
TemplateNode.prototype._update = function (changes) {
for (var i = 0; i < this.children.length; i++) {
this.children[i]._update(changes);
}
};
// exports = module.exports = TemplateNode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file ANode预热
*/
// var ExprType = require('../parser/expr-type');
// var each = require('../util/each');
// var extend = require('../util/extend');
// var kebab2camel = require('../util/kebab2camel');
// var hotTags = require('../browser/hot-tags');
// var createEl = require('../browser/create-el');
// var getPropHandler = require('./get-prop-handler');
// var getANodeProp = require('./get-a-node-prop');
// var isBrowser = require('../browser/is-browser');
// var TextNode = require('./text-node');
// var SlotNode = require('./slot-node');
// var ForNode = require('./for-node');
// var IfNode = require('./if-node');
// var TemplateNode = require('./template-node');
// var Element = require('./element');
/**
* ANode预热，分析的数据引用等信息
*
* @param {Object} aNode 要预热的ANode
*/
function preheatANode(aNode) {
var stack = [];
function recordHotspotData(expr, notContentData) {
var refs = analyseExprDataHotspot(expr);
if (refs.length) {
for (var i = 0, len = stack.length; i < len; i++) {
if (!notContentData || i !== len - 1) {
var data = stack[i].hotspot.data;
if (!data) {
data = stack[i].hotspot.data = {};
}
each(refs, function (ref) {
data[ref] = 1;
});
}
}
}
}
function analyseANodeHotspot(aNode) {
if (!aNode.hotspot) {
stack.push(aNode);
if (aNode.textExpr) {
aNode.hotspot = {};
aNode.Clazz = TextNode;
recordHotspotData(aNode.textExpr);
}
else {
var sourceNode;
if (isBrowser && aNode.tagName
&& aNode.tagName.indexOf('-') < 0
&& !/^(template|slot|select|input|option|button|video|audio|canvas|img|embed|object|iframe)$/i.test(aNode.tagName)
) {
sourceNode = createEl(aNode.tagName);
}
aNode.hotspot = {
dynamicProps: [],
xProps: [],
props: {},
binds: [],
sourceNode: sourceNode
};
// === analyse hotspot data: start
each(aNode.vars, function (varItem) {
recordHotspotData(varItem.expr);
});
each(aNode.props, function (prop) {
aNode.hotspot.binds.push({
name: kebab2camel(prop.name),
expr: prop.raw != null ? prop.expr : {
type: 3,
value: true
},
x: prop.x,
raw: prop.raw
});
recordHotspotData(prop.expr);
});
for (var key in aNode.directives) {
/* istanbul ignore else */
if (aNode.directives.hasOwnProperty(key)) {
var directive = aNode.directives[key];
recordHotspotData(
directive.value,
!/^(html|bind)$/.test(key)
);
// init trackBy getKey function
if (key === 'for') {
var trackBy = directive.trackBy;
if (trackBy
&& trackBy.type === 4
&& trackBy.paths[0].value === directive.item
) {
aNode.hotspot.getForKey = new Function(
directive.item,
'return ' + trackBy.raw
);
}
}
}
}
each(aNode.elses, function (child) {
analyseANodeHotspot(child);
});
each(aNode.children, function (child) {
analyseANodeHotspot(child);
});
// === analyse hotspot data: end
// === analyse hotspot props: start
each(aNode.props, function (prop, index) {
aNode.hotspot.props[prop.name] = index;
prop.handler = getPropHandler(aNode.tagName, prop.name);
if (prop.name === 'id') {
prop.id = true;
aNode.hotspot.idProp = prop;
aNode.hotspot.dynamicProps.push(prop);
}
else if (prop.expr.value != null) {
if (sourceNode) {
prop.handler(sourceNode, prop.expr.value, prop.name, aNode);
}
}
else {
if (prop.x) {
aNode.hotspot.xProps.push(prop);
}
aNode.hotspot.dynamicProps.push(prop);
}
});
// ie 下，如果 option 没有 value 属性，select.value = xx 操作不会选中 option
// 所以没有设置 value 时，默认把 option 的内容作为 value
if (aNode.tagName === 'option'
&& !getANodeProp(aNode, 'value')
&& aNode.children[0]
) {
var valueProp = {
name: 'value',
expr: aNode.children[0].textExpr,
handler: getPropHandler(aNode.tagName, 'value')
};
aNode.props.push(valueProp);
aNode.hotspot.dynamicProps.push(valueProp);
aNode.hotspot.props.value = aNode.props.length - 1;
}
if (aNode.directives['if']) { // eslint-disable-line dot-notation
aNode.ifRinsed = {
children: aNode.children,
props: aNode.props,
events: aNode.events,
tagName: aNode.tagName,
vars: aNode.vars,
hotspot: aNode.hotspot,
directives: extend({}, aNode.directives)
};
aNode.hotspot.hasRootNode = true;
aNode.Clazz = IfNode;
aNode = aNode.ifRinsed;
aNode.directives['if'] = null; // eslint-disable-line dot-notation
}
if (aNode.directives['for']) { // eslint-disable-line dot-notation
aNode.forRinsed = {
children: aNode.children,
props: aNode.props,
events: aNode.events,
tagName: aNode.tagName,
vars: aNode.vars,
hotspot: aNode.hotspot,
directives: extend({}, aNode.directives)
};
aNode.hotspot.hasRootNode = true;
aNode.Clazz = ForNode;
aNode.forRinsed.directives['for'] = null; // eslint-disable-line dot-notation
aNode = aNode.forRinsed;
}
if (hotTags[aNode.tagName]) {
aNode.Clazz = Element;
}
else {
switch (aNode.tagName) {
case 'slot':
aNode.Clazz = SlotNode;
break;
case 'template':
case 'fragment':
aNode.hotspot.hasRootNode = true;
aNode.Clazz = TemplateNode;
}
}
// === analyse hotspot props: end
}
stack.pop();
}
}
if (aNode) {
analyseANodeHotspot(aNode);
}
}
/**
* 分析表达式的数据引用
*
* @param {Object} expr 要分析的表达式
* @return {Array}
*/
function analyseExprDataHotspot(expr, accessorMeanDynamic) {
var refs = [];
var isDynamic;
function analyseExprs(exprs, accessorMeanDynamic) {
for (var i = 0, l = exprs.length; i < l; i++) {
refs = refs.concat(analyseExprDataHotspot(exprs[i], accessorMeanDynamic));
isDynamic = isDynamic || exprs[i].dynamic;
}
}
switch (expr.type) {
case 4:
isDynamic = accessorMeanDynamic;
var paths = expr.paths;
refs.push(paths[0].value);
if (paths.length > 1) {
refs.push(paths[0].value + '.' + (paths[1].value || '*'));
}
analyseExprs(paths.slice(1), 1);
break;
case 9:
refs = analyseExprDataHotspot(expr.expr, accessorMeanDynamic);
isDynamic = expr.expr.dynamic;
break;
case 7:
case 8:
case 10:
analyseExprs(expr.segs, accessorMeanDynamic);
break;
case 5:
refs = analyseExprDataHotspot(expr.expr);
isDynamic = expr.expr.dynamic;
each(expr.filters, function (filter) {
analyseExprs(filter.name.paths);
analyseExprs(filter.args);
});
break;
case 6:
analyseExprs(expr.name.paths);
analyseExprs(expr.args);
break;
case 12:
case 11:
for (var i = 0; i < expr.items.length; i++) {
refs = refs.concat(analyseExprDataHotspot(expr.items[i].expr));
isDynamic = isDynamic || expr.items[i].expr.dynamic;
}
break;
}
isDynamic && (expr.dynamic = true);
return refs;
}
// exports = module.exports = preheatANode;
/**
* Copyright (c) Baidu Inc. All rights reserved.
*
* This source code is licensed under the MIT license.
* See LICENSE file in the project root for license information.
*
* @file 创建组件Loader
*/
// var ComponentLoader = require('./component-loader');
/**
* 创建组件Loader
*
* @param {Object|Function} options 创建组件Loader的参数。为Object时参考下方描述，为Function时代表load方法。
* @param {Function} options.load load方法
* @param {Function=} options.placeholder loading过程中渲染的占位组件
* @param {Function=} options.fallback load失败时渲染的组件
* @return {ComponentLoader}
*/
function createComponentLoader(options) {
var placeholder = options.placeholder;
var fallback = options.fallback;
var load = typeof options === 'function' ? options : options.load;
return new ComponentLoader(load, placeholder, fallback);
}
// exports = module.exports = createComponentLoader;
/* eslint-disable no-unused-vars */
// var nextTick = require('./util/next-tick');
// var inherits = require('./util/inherits');
// var parseTemplate = require('./parser/parse-template');
// var parseExpr = require('./parser/parse-expr');
// var ExprType = require('./parser/expr-type');
// var LifeCycle = require('./view/life-cycle');
// var NodeType = require('./view/node-type');
// var Component = require('./view/component');
// var compileComponent = require('./view/compile-component');
// var defineComponent = require('./view/define-component');
// var createComponentLoader = require('./view/create-component-loader');
// var emitDevtool = require('./util/emit-devtool');
// var Data = require('./runtime/data');
// var evalExpr = require('./runtime/eval-expr');
// var DataTypes = require('./util/data-types');
var san = {
/**
* san版本号
*
* @type {string}
*/
version: '3.8.3',
// #[begin] devtool
// /**
// * 是否开启调试。开启调试时 devtool 会工作
// *
// * @type {boolean}
// */
// debug: true,
// #[end]
/**
* 组件基类
*
* @type {Function}
*/
Component: Component,
/**
* 创建组件类
*
* @param {Object} proto 组件类的方法表
* @return {Function}
*/
defineComponent: defineComponent,
/**
* 创建组件Loader
*
* @param {Object|Function} options 创建组件Loader的参数。为Object时参考下方描述，为Function时代表load方法。
* @param {Function} options.load load方法
* @param {Function=} options.placeholder loading过程中渲染的占位组件
* @param {Function=} options.fallback load失败时渲染的组件
* @return {ComponentLoader}
*/
createComponentLoader: createComponentLoader,
/**
* 编译组件类。预解析template和components
*
* @param {Function} ComponentClass 组件类
*/
compileComponent: compileComponent,
/**
* 解析 template
*
* @inner
* @param {string} source template 源码
* @return {ANode}
*/
parseTemplate: parseTemplate,
/**
* 解析表达式
*
* @param {string} source 源码
* @return {Object}
*/
parseExpr: parseExpr,
/**
* 表达式类型枚举
*
* @const
* @type {Object}
*/
ExprType: ExprType,
/**
* 生命周期
*/
LifeCycle: LifeCycle,
/**
* 节点类型
*
* @const
* @type {Object}
*/
NodeType: NodeType,
/**
* 在下一个更新周期运行函数
*
* @param {Function} fn 要运行的函数
*/
nextTick: nextTick,
/**
* 数据类
*
* @class
* @param {Object?} data 初始数据
* @param {Data?} parent 父级数据对象
*/
Data: Data,
/**
* 计算表达式的值
*
* @param {Object} expr 表达式对象
* @param {Data} data 数据对象
* @param {Component=} owner 组件对象，用于表达式中filter的执行
* @return {*}
*/
evalExpr: evalExpr,
/**
* 构建类之间的继承关系
*
* @param {Function} subClass 子类函数
* @param {Function} superClass 父类函数
*/
inherits: inherits,
/**
* DataTypes
*
* @type {Object}
*/
DataTypes: DataTypes
};
// export
if (typeof exports === 'object' && typeof module === 'object') {
// For CommonJS
exports = module.exports = san;
}
else if (typeof define === 'function' && define.amd) {
// For AMD
define('san', [], san);
}
else {
// For <script src="..."
root.san = san;
}
// #[begin] devtool
// emitDevtool.start(san);
// #[end]
})(this);
//@ sourceMappingURL=san.modern.js.map | cdnjs/cdnjs | ajax/libs/san/3.8.3/san.modern.js | JavaScript | mit | 268,004 |
const electron = require('electron')
// Module to control application life.
const app = electron.app
// Module to create native browser window.
const BrowserWindow = electron.BrowserWindow
const path = require('path')
const url = require('url')
// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let mainWindow
function createWindow () {
// Create the browser window.
mainWindow = new BrowserWindow({
fullscreen: true,
icon: __dirname + '/img/icon.png'
})
mainWindow.setMenu(null);
// and load the index.html of the app.
mainWindow.loadURL(url.format({
pathname: path.join(__dirname, 'index.html'),
protocol: 'file:',
slashes: true
}))
// Open the DevTools.
mainWindow.webContents.openDevTools()
// Emitted when the window is closed.
mainWindow.on('closed', function () {
// Dereference the window object, usually you would store windows
// in an array if your app supports multi windows, this is the time
// when you should delete the corresponding element.
mainWindow = null
})
}
// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', createWindow)
// Quit when all windows are closed.
app.on('window-all-closed', function () {
// On OS X it is common for applications and their menu bar
// to stay active until the user quits explicitly with Cmd + Q
if (process.platform !== 'darwin') {
app.quit()
}
})
app.on('activate', function () {
// On OS X it's common to re-create a window in the app when the
// dock icon is clicked and there are no other windows open.
if (mainWindow === null) {
createWindow()
}
})
// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.
| BroGrammerStastic/DashBoard-Application | main.js | JavaScript | cc0-1.0 | 1,990 |
jsonp({"cep":"70863500","logradouro":"Quadra CLN 211","bairro":"Asa Norte","cidade":"Bras\u00edlia","uf":"DF","estado":"Distrito Federal"});
| lfreneda/cepdb | api/v1/70863500.jsonp.js | JavaScript | cc0-1.0 | 141 |
jsonp({"cep":"54777166","logradouro":"Rua Dezesses","bairro":"Jo\u00e3o Paulo II","cidade":"Camaragibe","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/54777166.jsonp.js | JavaScript | cc0-1.0 | 139 |
jsonp({"cep":"85806580","logradouro":"Rua Aventurina","bairro":"Esmeralda","cidade":"Cascavel","uf":"PR","estado":"Paran\u00e1"});
| lfreneda/cepdb | api/v1/85806580.jsonp.js | JavaScript | cc0-1.0 | 131 |
jsonp({"cep":"58064070","logradouro":"Rua Adalberto Florentino de Castro","bairro":"Valentina de Figueiredo","cidade":"Jo\u00e3o Pessoa","uf":"PB","estado":"Para\u00edba"});
| lfreneda/cepdb | api/v1/58064070.jsonp.js | JavaScript | cc0-1.0 | 174 |
jsonp({"cep":"31720240","logradouro":"Rua Major \u00c1vila Goulart","bairro":"Planalto","cidade":"Belo Horizonte","uf":"MG","estado":"Minas Gerais"});
| lfreneda/cepdb | api/v1/31720240.jsonp.js | JavaScript | cc0-1.0 | 151 |
jsonp({"cep":"12050713","logradouro":"Rua Edvaldo Monteiro","bairro":"Residencial Vila Velha","cidade":"Taubat\u00e9","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/12050713.jsonp.js | JavaScript | cc0-1.0 | 157 |
jsonp({"cep":"22725150","logradouro":"Rua Ant\u00f4nio de Oliveira Pantoja","bairro":"Taquara","cidade":"Rio de Janeiro","uf":"RJ","estado":"Rio de Janeiro"});
| lfreneda/cepdb | api/v1/22725150.jsonp.js | JavaScript | cc0-1.0 | 160 |
jsonp({"cep":"09972312","logradouro":"Passagem da Cidadania","bairro":"Eldorado","cidade":"Diadema","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/09972312.jsonp.js | JavaScript | cc0-1.0 | 139 |
jsonp({"cep":"88132151","logradouro":"Rua Luca","bairro":"Passa Vinte","cidade":"Palho\u00e7a","uf":"SC","estado":"Santa Catarina"});
| lfreneda/cepdb | api/v1/88132151.jsonp.js | JavaScript | cc0-1.0 | 134 |
jsonp({"cep":"13083200","logradouro":"Rua Professor Celso Ferraz de Camargo","bairro":"Cidade Universit\u00e1ria","cidade":"Campinas","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/13083200.jsonp.js | JavaScript | cc0-1.0 | 173 |
jsonp({"cep":"36030560","logradouro":"Rua Elvira Bellei","bairro":"Jardim de Al\u00e1","cidade":"Juiz de Fora","uf":"MG","estado":"Minas Gerais"});
| lfreneda/cepdb | api/v1/36030560.jsonp.js | JavaScript | cc0-1.0 | 148 |
jsonp({"cep":"70878120","logradouro":"Quadra SQN 415 Bloco L","bairro":"Asa Norte","cidade":"Bras\u00edlia","uf":"DF","estado":"Distrito Federal"});
| lfreneda/cepdb | api/v1/70878120.jsonp.js | JavaScript | cc0-1.0 | 149 |
jsonp({"cep":"02076045","logradouro":"Pra\u00e7a Alegria Nova","bairro":"Vila Guilherme","cidade":"S\u00e3o Paulo","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/02076045.jsonp.js | JavaScript | cc0-1.0 | 154 |
jsonp({"cep":"58429035","logradouro":"Rua S\u00e3o Geraldo","bairro":"Universit\u00e1rio","cidade":"Campina Grande","uf":"PB","estado":"Para\u00edba"});
| lfreneda/cepdb | api/v1/58429035.jsonp.js | JavaScript | cc0-1.0 | 153 |
jsonp({"cep":"18078680","logradouro":"Rua Oswaldo Stefani J\u00fanior","bairro":"Jardim Santa Marina","cidade":"Sorocaba","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/18078680.jsonp.js | JavaScript | cc0-1.0 | 161 |
jsonp({"cep":"75125200","logradouro":"Rua Dona Sandra","bairro":"Jardim Ana Paula","cidade":"An\u00e1polis","uf":"GO","estado":"Goi\u00e1s"});
| lfreneda/cepdb | api/v1/75125200.jsonp.js | JavaScript | cc0-1.0 | 143 |
jsonp({"cep":"53441120","logradouro":"Rua Cento e Vinte e Tr\u00eas","bairro":"Maranguape I","cidade":"Paulista","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/53441120.jsonp.js | JavaScript | cc0-1.0 | 148 |
jsonp({"cep":"13486335","logradouro":"Rua Manoel Queiroz","bairro":"Jardim Boa Vista","cidade":"Limeira","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/13486335.jsonp.js | JavaScript | cc0-1.0 | 144 |
jsonp({"cep":"88060360","logradouro":"Servid\u00e3o Ana Cardoso","bairro":"S\u00e3o Jo\u00e3o do Rio Vermelho","cidade":"Florian\u00f3polis","uf":"SC","estado":"Santa Catarina"});
| lfreneda/cepdb | api/v1/88060360.jsonp.js | JavaScript | cc0-1.0 | 180 |
jsonp({"cep":"12285280","logradouro":"Rua Joaquim Quirino Carvalho","bairro":"Parque Residencial Maria Elmira","cidade":"Ca\u00e7apava","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/12285280.jsonp.js | JavaScript | cc0-1.0 | 175 |
jsonp({"cep":"13632020","logradouro":"Rua Benedito da Silva Pinto","bairro":"Vila Braz","cidade":"Pirassununga","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/13632020.jsonp.js | JavaScript | cc0-1.0 | 151 |
jsonp({"cep":"74961660","logradouro":"Rua Beira Rio","bairro":"Nova Cidade","cidade":"Aparecida de Goi\u00e2nia","uf":"GO","estado":"Goi\u00e1s"});
| lfreneda/cepdb | api/v1/74961660.jsonp.js | JavaScript | cc0-1.0 | 148 |
jsonp({"cep":"41340710","logradouro":"Caminho 11-Setor 03","bairro":"Cajazeiras","cidade":"Salvador","uf":"BA","estado":"Bahia"});
| lfreneda/cepdb | api/v1/41340710.jsonp.js | JavaScript | cc0-1.0 | 131 |
jsonp({"cep":"78135615","logradouro":"Rua Aragar\u00e7a","bairro":"Nova V\u00e1rzea Grande","cidade":"V\u00e1rzea Grande","uf":"MT","estado":"Mato Grosso"});
| lfreneda/cepdb | api/v1/78135615.jsonp.js | JavaScript | cc0-1.0 | 158 |
jsonp({"cep":"31365310","logradouro":"Rua Maestro Francisco Buzelin","bairro":"Bandeirantes (Pampulha)","cidade":"Belo Horizonte","uf":"MG","estado":"Minas Gerais"});
| lfreneda/cepdb | api/v1/31365310.jsonp.js | JavaScript | cc0-1.0 | 167 |
jsonp({"cep":"72865010","logradouro":"Quadra Quadra 10","bairro":"Jardim Lago Azul","cidade":"Novo Gama","uf":"GO","estado":"Goi\u00e1s"});
| lfreneda/cepdb | api/v1/72865010.jsonp.js | JavaScript | cc0-1.0 | 140 |
jsonp({"cep":"71710510","logradouro":"Avenida Central Blocos 379/505","bairro":"N\u00facleo Bandeirante","cidade":"Bras\u00edlia","uf":"DF","estado":"Distrito Federal"});
| lfreneda/cepdb | api/v1/71710510.jsonp.js | JavaScript | cc0-1.0 | 171 |
jsonp({"cep":"65066433","logradouro":"Rua Salvador","bairro":"Planalto Turu","cidade":"S\u00e3o Lu\u00eds","uf":"MA","estado":"Maranh\u00e3o"});
| lfreneda/cepdb | api/v1/65066433.jsonp.js | JavaScript | cc0-1.0 | 145 |
jsonp({"cep":"27343090","logradouro":"Rua Recife","bairro":"Monte Cristo","cidade":"Barra Mansa","uf":"RJ","estado":"Rio de Janeiro"});
| lfreneda/cepdb | api/v1/27343090.jsonp.js | JavaScript | cc0-1.0 | 136 |
jsonp({"cep":"14071650","logradouro":"Rua Chafica Salom\u00e3o Assed","bairro":"Adelino Simioni","cidade":"Ribeir\u00e3o Preto","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/14071650.jsonp.js | JavaScript | cc0-1.0 | 167 |
jsonp({"cep":"51240590","logradouro":"Rua Gr\u00e3o Par\u00e1","bairro":"Ibura","cidade":"Recife","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/51240590.jsonp.js | JavaScript | cc0-1.0 | 133 |
jsonp({"cep":"96810274","logradouro":"Rua Santo Ant\u00f4nio","bairro":"Goi\u00e1s","cidade":"Santa Cruz do Sul","uf":"RS","estado":"Rio Grande do Sul"});
| lfreneda/cepdb | api/v1/96810274.jsonp.js | JavaScript | cc0-1.0 | 155 |
jsonp({"cep":"95044060","logradouro":"Rua Jos\u00e9 Bressan","bairro":"Nossa Senhora da Sa\u00fade","cidade":"Caxias do Sul","uf":"RS","estado":"Rio Grande do Sul"});
| lfreneda/cepdb | api/v1/95044060.jsonp.js | JavaScript | cc0-1.0 | 167 |
jsonp({"cep":"13453580","logradouro":"Rua Vereador Jos\u00e9 M\u00e1rio da Silva","bairro":"Conjunto Habitacional Angelo Giubina","cidade":"Santa B\u00e1rbara D'Oeste","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/13453580.jsonp.js | JavaScript | cc0-1.0 | 207 |
jsonp({"cep":"22010122","logradouro":"Avenida Nossa Senhora de Copacabana","bairro":"Leme","cidade":"Rio de Janeiro","uf":"RJ","estado":"Rio de Janeiro"});
| lfreneda/cepdb | api/v1/22010122.jsonp.js | JavaScript | cc0-1.0 | 156 |
jsonp({"cep":"13253021","logradouro":"Rua Luiz Trevine","bairro":"Jardim Tereza","cidade":"Itatiba","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/13253021.jsonp.js | JavaScript | cc0-1.0 | 139 |
jsonp({"cep":"85022604","logradouro":"Rua Herculano Ribeiro Fonseca","bairro":"Boqueir\u00e3o","cidade":"Guarapuava","uf":"PR","estado":"Paran\u00e1"});
| lfreneda/cepdb | api/v1/85022604.jsonp.js | JavaScript | cc0-1.0 | 153 |
jsonp({"cep":"72006341","logradouro":"Rua Rua 4 Ch\u00e1cara 300","bairro":"Setor Habitacional Vicente Pires (Taguatinga)","cidade":"Bras\u00edlia","uf":"DF","estado":"Distrito Federal"});
| lfreneda/cepdb | api/v1/72006341.jsonp.js | JavaScript | cc0-1.0 | 189 |
jsonp({"cep":"56312801","logradouro":"Avenida Um","bairro":"Rio Claro","cidade":"Petrolina","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/56312801.jsonp.js | JavaScript | cc0-1.0 | 127 |
jsonp({"cep":"41706210","logradouro":"Rua Ver\u00edssimo de Freitas","bairro":"Boca do Rio","cidade":"Salvador","uf":"BA","estado":"Bahia"});
| lfreneda/cepdb | api/v1/41706210.jsonp.js | JavaScript | cc0-1.0 | 142 |
jsonp({"cep":"53280240","logradouro":"Rua Campos","bairro":"Sapucaia","cidade":"Olinda","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/53280240.jsonp.js | JavaScript | cc0-1.0 | 123 |
jsonp({"cep":"55022390","logradouro":"Rua Ant\u00f4nio F\u00e9lix Rodrigues","bairro":"Rendeiras","cidade":"Caruaru","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/55022390.jsonp.js | JavaScript | cc0-1.0 | 152 |
jsonp({"cep":"66822720","logradouro":"Alameda Bom Jesus","bairro":"\u00c1guas Negras (Icoaraci)","cidade":"Bel\u00e9m","uf":"PA","estado":"Par\u00e1"});
| lfreneda/cepdb | api/v1/66822720.jsonp.js | JavaScript | cc0-1.0 | 153 |
jsonp({"cep":"26465230","logradouro":"Rua Jaci","bairro":"Parque Santo Ant\u00f4nio","cidade":"Japeri","uf":"RJ","estado":"Rio de Janeiro"});
| lfreneda/cepdb | api/v1/26465230.jsonp.js | JavaScript | cc0-1.0 | 142 |
jsonp({"cep":"11704530","logradouro":"Rua Reinaldo Marsilli","bairro":"Cidade Ocian","cidade":"Praia Grande","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/11704530.jsonp.js | JavaScript | cc0-1.0 | 148 |
jsonp({"cep":"12340540","logradouro":"Estrada S\u00e3o Jos\u00e9 Oper\u00e1rio","bairro":"Ch\u00e1caras Rurais de Guararema","cidade":"Jacare\u00ed","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/12340540.jsonp.js | JavaScript | cc0-1.0 | 188 |
jsonp({"cep":"74692003","logradouro":"Rua Bernardo Elis","bairro":"Priv\u00ea Residencial Elza Fronza","cidade":"Goi\u00e2nia","uf":"GO","estado":"Goi\u00e1s"});
| lfreneda/cepdb | api/v1/74692003.jsonp.js | JavaScript | cc0-1.0 | 162 |
jsonp({"cep":"49037050","logradouro":"Avenida Ant\u00f4nio Alves","bairro":"Atalaia","cidade":"Aracaju","uf":"SE","estado":"Sergipe"});
| lfreneda/cepdb | api/v1/49037050.jsonp.js | JavaScript | cc0-1.0 | 136 |
jsonp({"cep":"65083411","logradouro":"Travessa Perimetral","bairro":"Cidade Nova","cidade":"S\u00e3o Lu\u00eds","uf":"MA","estado":"Maranh\u00e3o"});
| lfreneda/cepdb | api/v1/65083411.jsonp.js | JavaScript | cc0-1.0 | 150 |
jsonp({"cep":"58408052","logradouro":"Travessa S\u00e3o Jos\u00e9","bairro":"Vila Cabral","cidade":"Campina Grande","uf":"PB","estado":"Para\u00edba"});
| lfreneda/cepdb | api/v1/58408052.jsonp.js | JavaScript | cc0-1.0 | 153 |
jsonp({"cep":"67145270","logradouro":"Rua Primeira","bairro":"Maguari","cidade":"Ananindeua","uf":"PA","estado":"Par\u00e1"});
| lfreneda/cepdb | api/v1/67145270.jsonp.js | JavaScript | cc0-1.0 | 127 |
jsonp({"cep":"88817550","logradouro":"Rua Manoel Jo\u00e3o de Oliveira","bairro":"Vila Isabel","cidade":"Crici\u00fama","uf":"SC","estado":"Santa Catarina"});
| lfreneda/cepdb | api/v1/88817550.jsonp.js | JavaScript | cc0-1.0 | 159 |
jsonp({"cep":"89021132","logradouro":"Rua Igarap\u00e9","bairro":"Garcia","cidade":"Blumenau","uf":"SC","estado":"Santa Catarina"});
| lfreneda/cepdb | api/v1/89021132.jsonp.js | JavaScript | cc0-1.0 | 133 |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ms = ms;
exports.size = size;
exports.tx = tx;
exports.heading = heading;
exports.vmin = vmin;
exports.modularScale = modularScale;
var _ramda = require('ramda');
var _ramda2 = _interopRequireDefault(_ramda);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// export function vmin(size) {
// return `${size}vmin`;
// }
// Modular scale function for sizing text
function ms(base, ratio, value) {
return base * Math.pow(ratio, value);
}
var Sizer = {};
window.addEventListener('resize', function (e) {
Sizer.width = e.target.innerWidth;
// console.log(e.target.innerWidth);
});
var base = 1;
var scaleRatio = 1.25;
function size(n) {
// If we're using this for padding we don't want 0 to resolve to any non-zero value
if (n === 0) return 0;
// if (n === 1) return 1;
// if (n === 2) return 2;
// return ms(8 * scale, 1.25, n - 1);
// Subtract 1 so size(1) is the start size (scale)
return ms(base, scaleRatio, n - 1);
}
function tx(n) {
return ms(base, scaleRatio, n - 1);
// return ms(16 * scale, scaleRatio, n);
}
function heading(n) {
// if (window.innerWidth < 600) return '16px';
return ms(tx(2) * base, scaleRatio, n);
}
function vmin(n) {
return n + 'vmin';
}
var _ms = _ramda2.default.curry(ms);
function modularScale(ratio) {
// let savedI = 0;
// function msFunc (i) {
// savedI = i;
// return Math.pow(ratio, i);
// }
// msFunc.offset = function (offsetI) {
// return offsetI => msFunc(offsetI + savedI);
// };
var bla = _ms(base, ratio);
bla.offset = function (i) {
return function (j) {
return bla(i + j);
};
};
return bla;
} | markmiro/ui-experiments | lib/Size.js | JavaScript | cc0-1.0 | 1,757 |
jsonp({"cep":"11750000","cidade":"Peru\u00edbe","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/11750000.jsonp.js | JavaScript | cc0-1.0 | 87 |
jsonp({"cep":"58309510","logradouro":"Rua Rui Barbosa","bairro":"Imaculada","cidade":"Bayeux","uf":"PB","estado":"Para\u00edba"});
| lfreneda/cepdb | api/v1/58309510.jsonp.js | JavaScript | cc0-1.0 | 131 |
jsonp({"cep":"11663347","logradouro":"Rua Virg\u00ednia Ferreira","bairro":"Jardim Olaria","cidade":"Caraguatatuba","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/11663347.jsonp.js | JavaScript | cc0-1.0 | 155 |
jsonp({"cep":"93120050","logradouro":"Rua Presidente Lucena","bairro":"Scharlau","cidade":"S\u00e3o Leopoldo","uf":"RS","estado":"Rio Grande do Sul"});
| lfreneda/cepdb | api/v1/93120050.jsonp.js | JavaScript | cc0-1.0 | 152 |
jsonp({"cep":"29047105","logradouro":"Avenida Marechal Campos","bairro":"Bonfim","cidade":"Vit\u00f3ria","uf":"ES","estado":"Esp\u00edrito Santo"});
| lfreneda/cepdb | api/v1/29047105.jsonp.js | JavaScript | cc0-1.0 | 149 |
jsonp({"cep":"35432078","logradouro":"Rodovia MG-329","bairro":"Ana Flor\u00eancia","cidade":"Ponte Nova","uf":"MG","estado":"Minas Gerais"});
| lfreneda/cepdb | api/v1/35432078.jsonp.js | JavaScript | cc0-1.0 | 143 |
jsonp({"cep":"32675640","logradouro":"Rua Ant\u00f4nio Dias","bairro":"S\u00e3o Luiz","cidade":"Betim","uf":"MG","estado":"Minas Gerais"});
| lfreneda/cepdb | api/v1/32675640.jsonp.js | JavaScript | cc0-1.0 | 140 |
jsonp({"cep":"52020210","logradouro":"Rua Doutor Bandeira Filho","bairro":"Gra\u00e7as","cidade":"Recife","uf":"PE","estado":"Pernambuco"});
| lfreneda/cepdb | api/v1/52020210.jsonp.js | JavaScript | cc0-1.0 | 141 |
jsonp({"cep":"14808253","logradouro":"Rua Romano Peron","bairro":"Parque Residencial Iguatemi","cidade":"Araraquara","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/14808253.jsonp.js | JavaScript | cc0-1.0 | 156 |
jsonp({"cep":"08545240","logradouro":"Rua Du\u00edlio Dainezi","bairro":"Jardim S\u00e3o Jo\u00e3o","cidade":"Ferraz de Vasconcelos","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/08545240.jsonp.js | JavaScript | cc0-1.0 | 172 |
jsonp({"cep":"06290110","logradouro":"Rua Giuseppe Gheraldine","bairro":"Ayrosa","cidade":"Osasco","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/06290110.jsonp.js | JavaScript | cc0-1.0 | 138 |
jsonp({"cep":"18602230","logradouro":"Rua Manoel Deodoro Pinheiro Machado","bairro":"Vila Santa Therezinha de Menino Jesus","cidade":"Botucatu","uf":"SP","estado":"S\u00e3o Paulo"});
| lfreneda/cepdb | api/v1/18602230.jsonp.js | JavaScript | cc0-1.0 | 183 |
jsonp({"cep":"38700326","logradouro":"Rua Santana","bairro":"Santa Terezinha","cidade":"Patos de Minas","uf":"MG","estado":"Minas Gerais"});
| lfreneda/cepdb | api/v1/38700326.jsonp.js | JavaScript | cc0-1.0 | 141 |
jsonp({"cep":"24812380","logradouro":"Rua Q","bairro":"Santo Expedito","cidade":"Itabora\u00ed","uf":"RJ","estado":"Rio de Janeiro"});
| lfreneda/cepdb | api/v1/24812380.jsonp.js | JavaScript | cc0-1.0 | 135 |
jsonp({"cep":"20950290","logradouro":"Travessa Coronel Soares","bairro":"Sampaio","cidade":"Rio de Janeiro","uf":"RJ","estado":"Rio de Janeiro"});
| lfreneda/cepdb | api/v1/20950290.jsonp.js | JavaScript | cc0-1.0 | 147 |
jsonp({"cep":"41351195","logradouro":"Caminho 36","bairro":"Nova Bras\u00edlia","cidade":"Salvador","uf":"BA","estado":"Bahia"});
| lfreneda/cepdb | api/v1/41351195.jsonp.js | JavaScript | cc0-1.0 | 130 |
jsonp({"cep":"72415302","logradouro":"Quadra Quadra 6 Conjunto B","bairro":"Setor Sul (Gama)","cidade":"Bras\u00edlia","uf":"DF","estado":"Distrito Federal"});
| lfreneda/cepdb | api/v1/72415302.jsonp.js | JavaScript | cc0-1.0 | 160 |
jsonp({"cep":"40730107","logradouro":"Rua Jo\u00e3o Val\u00e9rio","bairro":"Fazenda Coutos","cidade":"Salvador","uf":"BA","estado":"Bahia"});
| lfreneda/cepdb | api/v1/40730107.jsonp.js | JavaScript | cc0-1.0 | 142 |
jsonp({"cep":"60767723","logradouro":"Rua 13","bairro":"Mondubim","cidade":"Fortaleza","uf":"CE","estado":"Cear\u00e1"});
| lfreneda/cepdb | api/v1/60767723.jsonp.js | JavaScript | cc0-1.0 | 122 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.