code stringlengths 2 1.05M |
|---|
import filter from "filter-object"
import { createToken, decryptToken } from "../utils/jwt.js"
import { handleError, NotFoundError, AlreadyExistingAccount, UndefinedPassword, ValidationError } from "../utils/errors.js"
import { profilePhotoPath } from "../constants/profilePictures"
import mailer from "../utils/mailer.js"
import fs from "fs"
import request from "request"
const permitted = '{email,password,nickname,firstname,lastname,photoExtension}'
const handlePasswordAssignation = (email, password) => {
const passwordToken = createToken(password)
const confirmationUrl = `${Config.urls.front}/assert/${email}/${passwordToken}`
RedisClient.set(email, passwordToken)
Logger.debug(`Sending token ${confirmationUrl} to ${email}`)
const mailOptions = {
from: '"Hypertube" <hypertube@oxynux.xyz>', // sender address
to: email, // list of receivers
subject: 'Your Hypertube\'s confirmation link',
html: `<p>Hey !</p><p>You have recently set your password, please follow this link to confirm the assignation: ${confirmationUrl}</p>`,
}
return mailer(mailOptions)
}
export const basicOauthController = (req, res) => {
Logger.silly('Received from oauth:', req.user)
User.findOne({ email: req.user.email })
.then((foundUser) => {
if (!foundUser) {
return new User(filter(req.user, permitted)).save()
.then((user) => {
request(req.user.profilePhoto)
.pipe(fs.createWriteStream(`public/${profilePhotoPath}${user._id.toString()}.${req.user.photoExtension}`))
return Promise.resolve(user)
})
}
return Promise.resolve(foundUser)
})
.then((user) => {
const userData = {
token: createToken({id: user._id}),
user: user.serialize,
}
Logger.silly(userData);
res.redirect(`${Config.urls.front}/auth?data=${JSON.stringify(userData)}`);
})
.catch((err) => {
Logger.error(err)
res.redirect(`${Config.urls.front}`)
})
}
export async function signUp (req, res) {
try {
let user = await User.findOne({ email: req.body.email })
if (user) {
if (user.password) {
throw new AlreadyExistingAccount
} else {
throw new UndefinedPassword
}
}
user = await new User({}).save()
fs.writeFileSync(`public/${profilePhotoPath}${user._id.toString()}.${req.body.photoExtension}`,
req.body.profilePhoto)
await handlePasswordAssignation(req.body.email, req.body.password)
user = Object.assign(filter(req.body, permitted))
user = await User.findOneAndUpdate(user._id, filter(req.body, permitted), { new: true })
res.json({
results: user.serialize,
message: 'User successfully created',
})
} catch (err) {
Logger.silly(err)
Logger.silly('Mongo error')
handleError(err, res, 'Error while creating user')
}
}
export async function signIn (req, res) {
try {
let user = await User.findOne({ email: req.body.email })
if (!user) { throw new NotFoundError('User') }
if (!user.password) { throw new UndefinedPassword }
if (!user.isPasswordValid) {
return res.status(401).json({ results: null, message: 'Password is not verified' })
}
if (user.password !== req.body.password) {
return res.json({ results: null, message: 'Password and email are not matching' })
}
res.json({
results: {
user: user.serialize,
token: createToken({ id: user._id }),
},
message: 'User successfully logged in',
})
}
catch (err) {
handleError(err, res, 'Error while signing in')
}
}
export const assignPassword = (req, res) => {
let user
User.findOne({ email: req.body.email })
.then((foundUser) => {
if (!foundUser) { return Promise.reject(NotFoundError('User')) }
foundUser.isPasswordValid = false
return foundUser.save()
})
.then((updatedUser) => {
user = updatedUser
return handlePasswordAssignation(req.body.email, req.body.password)
})
.then(() => res.json({
results: user.serialize,
message: 'Change password procedure launched',
}))
.catch((err) => handleError(err, res, 'Error while changing user password. Try again later'))
}
export const assertPassword = (req, res) => {
RedisClient.get(req.body.email)
.then((token) => {
if (!token) { return Promise.reject(new NotFoundError('Reset password token')) }
if (token !== req.body.token) { return Promise.reject(new ValidationError('token', 'invalid')) }
RedisClient.del(req.body.email)
const newPassword = decryptToken(token)
return User.findOneAndUpdate(
{ email: req.body.email },
{
password: newPassword,
isPasswordValid: true,
},
{
new: true,
}
)
})
.then((updatedUser) => {
if (!updatedUser) { return Promise.reject(new NotFoundError('User')) }
res.json({
results: updatedUser.serialize,
message: 'Password successfully set',
})
})
.catch((err) => handleError(err, res, 'Error while asserting password'))
}
|
App.Question4View = App.BaseView.extend({
// Automatically inherits animations
}); |
// All material copyright ESRI, All Rights Reserved, unless otherwise specified.
// See https://js.arcgis.com/4.16/esri/copyright.txt for details.
//>>built
define("require exports ../core/tsSupport/declareExtendsHelper ../core/tsSupport/decorateHelper ../core/maybe ../core/accessorSupport/decorators ./Symbol3DLayer ./edges/utils ./support/Symbol3DMaterial".split(" "),function(m,n,f,c,g,b,h,k,l){return function(e){function a(a){a=e.call(this,a)||this;a.type="extrude";a.size=void 0;a.material=null;a.castShadows=!0;a.edges=null;return a}f(a,e);d=a;a.prototype.clone=function(){return new d({edges:this.edges&&this.edges.clone(),enabled:this.enabled,material:g.isSome(this.material)?
this.material.clone():null,castShadows:this.castShadows,size:this.size})};var d;c([b.enumeration.serializable()({Extrude:"extrude"})],a.prototype,"type",void 0);c([b.property({type:Number,json:{write:!0}})],a.prototype,"size",void 0);c([b.property({type:l.default,json:{write:!0}})],a.prototype,"material",void 0);c([b.property({type:Boolean,nonNullable:!0,json:{write:!0,default:!0}})],a.prototype,"castShadows",void 0);c([b.property(k.symbol3dEdgesProperty)],a.prototype,"edges",void 0);return a=d=c([b.subclass("esri.symbols.ExtrudeSymbol3DLayer")],
a)}(b.declared(h))}); |
import React, { PropTypes } from 'react';
import { connect } from 'react-redux';
import * as rocketActions from '../actions/rocketActions';
import RocketList from '../components/RocketList';
class App extends React.Component {
componentWillMount() {
this.props.fetchRockets();
}
render(){
const { rockets } = this.props;
rockets.sort(function(a, b){
let rocketA = a.name;
let rocketB = b.name;
let sortLaunch = 0;
if(rocketA > rocketB){
sortLaunch = 1;
}
else if (rocketA < rocketB){
sortLaunch = -1;
}
return sortLaunch;
});
return (
<div>
<h1>HelloSign</h1>
<RocketList rocketList={rockets}/>
</div>
);
}
}
App.propTypes = {
fetchRockets: PropTypes.func,
rockets: PropTypes.array
};
// Maps state from store to props
const mapStateProps = (state) => {
return {
rockets: state.rockets
};
};
const mapDispatchToProps = (dispatch) => {
return {
fetchRockets: () => dispatch(rocketActions.fetchRockets())
// actions mappings here
};
};
export default connect(mapStateProps, mapDispatchToProps)(App);
|
import React, { Component } from 'react';
import { View, Text, SectionList } from 'react-native';
export default class SectionListComponent extends Component {
render() {
let sectionData = [
{
key: 'A',
title: 'A',
data: [{ key: 'Alexander' }, { key: 'Alan Turing' }]
},
{
key: 'B',
title: 'B',
data: [{ key: 'Brooke' }, { key: 'Barbara' }, { key: 'Brenda' }]
},
{
key: 'C',
title: 'D',
data: [
{ key: 'David' },
{ key: 'Dylan' },
{ key: 'Diego' },
{ key: 'Dakota' }
]
}
];
return (
<View style={{ flex: 1, paddingTop: 30 }}>
<SectionList
sections={sectionData}
renderItem={({ item }) =>
<Text style={{ padding: 10, color: 'green' }}>
{item.key}
</Text>}
renderSectionHeader={({ section }) =>
<Text style={{ padding: 10, color: 'blue', fontSize: 20 }}>
{section.title}
</Text>}
/>
</View>
);
}
}
|
/* globals SIP,user,moment, Stopwatch */
var ctxSip;
$(document).ready(function() {
if (typeof(user) === 'undefined') {
user = JSON.parse(localStorage.getItem('SIPCreds'));
}
ctxSip = {
config : {
password : user.Pass,
displayName : user.Display,
uri : 'sip:'+user.User+'@'+user.Realm,
wsServers : user.WSServer,
registerExpires : 30,
traceSip : true,
log : {
level : 0,
}
},
ringtone : document.getElementById('ringtone'),
ringbacktone : document.getElementById('ringbacktone'),
dtmfTone : document.getElementById('dtmfTone'),
Sessions : [],
callTimers : {},
callActiveID : null,
callVolume : 1,
Stream : null,
/**
* Parses a SIP uri and returns a formatted US phone number.
*
* @param {string} phone number or uri to format
* @return {string} formatted number
*/
formatPhone : function(phone) {
var num;
if (phone.indexOf('@')) {
num = phone.split('@')[0];
} else {
num = phone;
}
num = num.toString().replace(/[^0-9]/g, '');
if (num.length === 10) {
return '(' + num.substr(0, 3) + ') ' + num.substr(3, 3) + '-' + num.substr(6,4);
} else if (num.length === 11) {
return '(' + num.substr(1, 3) + ') ' + num.substr(4, 3) + '-' + num.substr(7,4);
} else {
return num;
}
},
// Sound methods
startRingTone : function() {
try { ctxSip.ringtone.play(); } catch (e) { }
},
stopRingTone : function() {
try { ctxSip.ringtone.pause(); } catch (e) { }
},
startRingbackTone : function() {
try { ctxSip.ringbacktone.play(); } catch (e) { }
},
stopRingbackTone : function() {
try { ctxSip.ringbacktone.pause(); } catch (e) { }
},
// Genereates a rendom string to ID a call
getUniqueID : function() {
return Math.random().toString(36).substr(2, 9);
},
newSession : function(newSess) {
newSess.displayName = newSess.remoteIdentity.displayName || newSess.remoteIdentity.uri.user;
newSess.ctxid = ctxSip.getUniqueID();
var status;
if (newSess.direction === 'incoming') {
status = "Incoming: "+ newSess.displayName;
ctxSip.startRingTone();
} else {
status = "Trying: "+ newSess.displayName;
ctxSip.startRingbackTone();
}
ctxSip.logCall(newSess, 'ringing');
ctxSip.setCallSessionStatus(status);
// EVENT CALLBACKS
newSess.on('progress',function(e) {
if (e.direction === 'outgoing') {
ctxSip.setCallSessionStatus('Calling...');
}
});
newSess.on('connecting',function(e) {
if (e.direction === 'outgoing') {
ctxSip.setCallSessionStatus('Connecting...');
}
});
newSess.on('accepted',function(e) {
// If there is another active call, hold it
if (ctxSip.callActiveID && ctxSip.callActiveID !== newSess.ctxid) {
ctxSip.phoneHoldButtonPressed(ctxSip.callActiveID);
}
ctxSip.stopRingbackTone();
ctxSip.stopRingTone();
ctxSip.setCallSessionStatus('Answered');
ctxSip.logCall(newSess, 'answered');
ctxSip.callActiveID = newSess.ctxid;
});
newSess.on('hold', function(e) {
ctxSip.callActiveID = null;
ctxSip.logCall(newSess, 'holding');
});
newSess.on('unhold', function(e) {
ctxSip.logCall(newSess, 'resumed');
ctxSip.callActiveID = newSess.ctxid;
});
newSess.on('muted', function(e) {
ctxSip.Sessions[newSess.ctxid].isMuted = true;
ctxSip.setCallSessionStatus("Muted");
});
newSess.on('unmuted', function(e) {
ctxSip.Sessions[newSess.ctxid].isMuted = false;
ctxSip.setCallSessionStatus("Answered");
});
newSess.on('cancel', function(e) {
ctxSip.stopRingTone();
ctxSip.stopRingbackTone();
ctxSip.setCallSessionStatus("Canceled");
if (this.direction === 'outgoing') {
ctxSip.callActiveID = null;
newSess = null;
ctxSip.logCall(this, 'ended');
}
});
newSess.on('bye', function(e) {
ctxSip.stopRingTone();
ctxSip.stopRingbackTone();
ctxSip.setCallSessionStatus("");
ctxSip.logCall(newSess, 'ended');
ctxSip.callActiveID = null;
newSess = null;
});
newSess.on('failed',function(e) {
ctxSip.stopRingTone();
ctxSip.stopRingbackTone();
ctxSip.setCallSessionStatus('Terminated');
});
newSess.on('rejected',function(e) {
ctxSip.stopRingTone();
ctxSip.stopRingbackTone();
ctxSip.setCallSessionStatus('Rejected');
ctxSip.callActiveID = null;
ctxSip.logCall(this, 'ended');
newSess = null;
});
ctxSip.Sessions[newSess.ctxid] = newSess;
},
// getUser media request refused or device was not present
getUserMediaFailure : function(e) {
window.console.error('getUserMedia failed:', e);
ctxSip.setError(true, 'Media Error.', 'You must allow access to your microphone. Check the address bar.', true);
},
getUserMediaSuccess : function(stream) {
ctxSip.Stream = stream;
},
/**
* sets the ui call status field
*
* @param {string} status
*/
setCallSessionStatus : function(status) {
$('#txtCallStatus').html(status);
},
/**
* sets the ui connection status field
*
* @param {string} status
*/
setStatus : function(status) {
$("#txtRegStatus").html('<i class="fa fa-signal"></i> '+status);
},
/**
* logs a call to localstorage
*
* @param {object} session
* @param {string} status Enum 'ringing', 'answered', 'ended', 'holding', 'resumed'
*/
logCall : function(session, status) {
var log = {
clid : session.displayName,
uri : session.remoteIdentity.uri.toString(),
id : session.ctxid,
time : new Date().getTime()
},
calllog = JSON.parse(localStorage.getItem('sipCalls'));
if (!calllog) { calllog = {}; }
if (!calllog.hasOwnProperty(session.ctxid)) {
calllog[log.id] = {
id : log.id,
clid : log.clid,
uri : log.uri,
start : log.time,
flow : session.direction
};
}
if (status === 'ended') {
calllog[log.id].stop = log.time;
}
if (status === 'ended' && calllog[log.id].status === 'ringing') {
calllog[log.id].status = 'missed';
} else {
calllog[log.id].status = status;
}
localStorage.setItem('sipCalls', JSON.stringify(calllog));
ctxSip.logShow();
},
/**
* adds a ui item to the call log
*
* @param {object} item log item
*/
logItem : function(item) {
var callActive = (item.status !== 'ended' && item.status !== 'missed'),
callLength = (item.status !== 'ended')? '<span id="'+item.id+'"></span>': moment.duration(item.stop - item.start).humanize(),
callClass = '',
callIcon,
i;
switch (item.status) {
case 'ringing' :
callClass = 'list-group-item-success';
callIcon = 'fa-bell';
break;
case 'missed' :
callClass = 'list-group-item-danger';
if (item.flow === "incoming") { callIcon = 'fa-chevron-left'; }
if (item.flow === "outgoing") { callIcon = 'fa-chevron-right'; }
break;
case 'holding' :
callClass = 'list-group-item-warning';
callIcon = 'fa-pause';
break;
case 'answered' :
case 'resumed' :
callClass = 'list-group-item-info';
callIcon = 'fa-phone-square';
break;
case 'ended' :
if (item.flow === "incoming") { callIcon = 'fa-chevron-left'; }
if (item.flow === "outgoing") { callIcon = 'fa-chevron-right'; }
break;
}
i = '<div class="list-group-item sip-logitem clearfix '+callClass+'" data-uri="'+item.uri+'" data-sessionid="'+item.id+'" title="Double Click to Call">';
i += '<div class="clearfix"><div class="pull-left">';
i += '<i class="fa fa-fw '+callIcon+' fa-fw"></i> <strong>'+ctxSip.formatPhone(item.uri)+'</strong><br><small>'+moment(item.start).format('MM/DD hh:mm:ss a')+'</small>';
i += '</div>';
i += '<div class="pull-right text-right"><em>'+item.clid+'</em><br>' + callLength+'</div></div>';
if (callActive) {
i += '<div class="btn-group btn-group-xs pull-right">';
if (item.status === 'ringing' && item.flow === 'incoming') {
i += '<button class="btn btn-xs btn-success btnCall" title="Call"><i class="fa fa-phone"></i></button>';
} else {
i += '<button class="btn btn-xs btn-primary btnHoldResume" title="Hold"><i class="fa fa-pause"></i></button>';
i += '<button class="btn btn-xs btn-info btnTransfer" title="Transfer"><i class="fa fa-random"></i></button>';
i += '<button class="btn btn-xs btn-warning btnMute" title="Mute"><i class="fa fa-fw fa-microphone"></i></button>';
}
i += '<button class="btn btn-xs btn-danger btnHangUp" title="Hangup"><i class="fa fa-stop"></i></button>';
i += '</div>';
}
i += '</div>';
$('#sip-logitems').append(i);
// Start call timer on answer
if (item.status === 'answered') {
var tEle = document.getElementById(item.id);
ctxSip.callTimers[item.id] = new Stopwatch(tEle);
ctxSip.callTimers[item.id].start();
}
if (callActive && item.status !== 'ringing') {
ctxSip.callTimers[item.id].start({startTime : item.start});
}
$('#sip-logitems').scrollTop(0);
},
/**
* updates the call log ui
*/
logShow : function() {
var calllog = JSON.parse(localStorage.getItem('sipCalls')),
x = [];
if (calllog !== null) {
$('#sip-splash').addClass('hide');
$('#sip-log').removeClass('hide');
// empty existing logs
$('#sip-logitems').empty();
// JS doesn't guarantee property order so
// create an array with the start time as
// the key and sort by that.
// Add start time to array
$.each(calllog, function(k,v) {
x.push(v);
});
// sort descending
x.sort(function(a, b) {
return b.start - a.start;
});
$.each(x, function(k, v) {
ctxSip.logItem(v);
});
} else {
$('#sip-splash').removeClass('hide');
$('#sip-log').addClass('hide');
}
},
/**
* removes log items from localstorage and updates the UI
*/
logClear : function() {
localStorage.removeItem('sipCalls');
ctxSip.logShow();
},
sipCall : function(target) {
try {
var s = ctxSip.phone.invite(target, {
media : {
stream : ctxSip.Stream,
constraints : { audio : true, video : false },
render : {
remote : $('#audioRemote').get()[0]
},
RTCConstraints : { "optional": [{ 'DtlsSrtpKeyAgreement': 'true'} ]}
}
});
s.direction = 'outgoing';
ctxSip.newSession(s);
} catch(e) {
throw(e);
}
},
sipTransfer : function(sessionid) {
var s = ctxSip.Sessions[sessionid],
target = window.prompt('Enter destination number', '');
ctxSip.setCallSessionStatus('<i>Transfering the call...</i>');
s.refer(target);
},
sipHangUp : function(sessionid) {
var s = ctxSip.Sessions[sessionid];
// s.terminate();
if (!s) {
return;
} else if (s.startTime) {
s.bye();
} else if (s.reject) {
s.reject();
} else if (s.cancel) {
s.cancel();
}
},
sipSendDTMF : function(digit) {
try { ctxSip.dtmfTone.play(); } catch(e) { }
var a = ctxSip.callActiveID;
if (a) {
var s = ctxSip.Sessions[a];
s.dtmf(digit);
}
},
phoneCallButtonPressed : function(sessionid) {
var s = ctxSip.Sessions[sessionid],
target = $("#numDisplay").val();
if (!s) {
$("#numDisplay").val("");
ctxSip.sipCall(target);
} else if (s.accept && !s.startTime) {
s.accept({
media : {
stream : ctxSip.Stream,
constraints : { audio : true, video : false },
render : {
remote : { audio: $('#audioRemote').get()[0] }
},
RTCConstraints : { "optional": [{ 'DtlsSrtpKeyAgreement': 'true'} ]}
}
});
}
},
phoneMuteButtonPressed : function (sessionid) {
var s = ctxSip.Sessions[sessionid];
if (!s.isMuted) {
s.mute();
} else {
s.unmute();
}
},
phoneHoldButtonPressed : function(sessionid) {
var s = ctxSip.Sessions[sessionid];
if (s.isOnHold().local === true) {
s.unhold();
} else {
s.hold();
}
},
setError : function(err, title, msg, closable) {
// Show modal if err = true
if (err === true) {
$("#mdlError p").html(msg);
$("#mdlError").modal('show');
if (closable) {
var b = '<button type="button" class="close" data-dismiss="modal">×</button>';
$("#mdlError .modal-header").find('button').remove();
$("#mdlError .modal-header").prepend(b);
$("#mdlError .modal-title").html(title);
$("#mdlError").modal({ keyboard : true });
} else {
$("#mdlError .modal-header").find('button').remove();
$("#mdlError .modal-title").html(title);
$("#mdlError").modal({ keyboard : false });
}
$('#numDisplay').prop('disabled', 'disabled');
} else {
$('#numDisplay').removeProp('disabled');
$("#mdlError").modal('hide');
}
},
/**
* Tests for a capable browser, return bool, and shows an
* error modal on fail.
*/
hasWebRTC : function() {
if (navigator.webkitGetUserMedia) {
return true;
} else if (navigator.mozGetUserMedia) {
return true;
} else if (navigator.getUserMedia) {
return true;
} else {
ctxSip.setError(true, 'Unsupported Browser.', 'Your browser does not support the features required for this phone.');
window.console.error("WebRTC support not found");
return false;
}
}
};
// Throw an error if the browser can't hack it.
if (!ctxSip.hasWebRTC()) {
return true;
}
ctxSip.phone = new SIP.UA(ctxSip.config);
ctxSip.phone.on('connected', function(e) {
ctxSip.setStatus("Connected");
});
ctxSip.phone.on('disconnected', function(e) {
ctxSip.setStatus("Disconnected");
// disable phone
ctxSip.setError(true, 'Websocket Disconnected.', 'An Error occurred connecting to the websocket.');
// remove existing sessions
$("#sessions > .session").each(function(i, session) {
ctxSip.removeSession(session, 500);
});
});
ctxSip.phone.on('registered', function(e) {
var closeEditorWarning = function() {
return 'If you close this window, you will not be able to make or receive calls from your browser.';
};
var closePhone = function() {
// stop the phone on unload
localStorage.removeItem('ctxPhone');
ctxSip.phone.stop();
};
window.onbeforeunload = closeEditorWarning;
window.onunload = closePhone;
// This key is set to prevent multiple windows.
localStorage.setItem('ctxPhone', 'true');
$("#mldError").modal('hide');
ctxSip.setStatus("Ready");
// Get the userMedia and cache the stream
if (SIP.WebRTC.isSupported()) {
SIP.WebRTC.getUserMedia({ audio : true, video : false }, ctxSip.getUserMediaSuccess, ctxSip.getUserMediaFailure);
}
});
ctxSip.phone.on('registrationFailed', function(e) {
ctxSip.setError(true, 'Registration Error.', 'An Error occurred registering your phone. Check your settings.');
ctxSip.setStatus("Error: Registration Failed");
});
ctxSip.phone.on('unregistered', function(e) {
ctxSip.setError(true, 'Registration Error.', 'An Error occurred registering your phone. Check your settings.');
ctxSip.setStatus("Error: Registration Failed");
});
ctxSip.phone.on('invite', function (incomingSession) {
var s = incomingSession;
s.direction = 'incoming';
ctxSip.newSession(s);
});
// Auto-focus number input on backspace.
$('#sipClient').keydown(function(event) {
if (event.which === 8) {
$('#numDisplay').focus();
}
});
$('#numDisplay').keypress(function(e) {
// Enter pressed? so Dial.
if (e.which === 13) {
ctxSip.phoneCallButtonPressed();
}
});
$('.digit').click(function(event) {
event.preventDefault();
var num = $('#numDisplay').val(),
dig = $(this).data('digit');
$('#numDisplay').val(num+dig);
ctxSip.sipSendDTMF(dig);
return false;
});
$('#phoneUI .dropdown-menu').click(function(e) {
e.preventDefault();
});
$('#phoneUI').delegate('.btnCall', 'click', function(event) {
ctxSip.phoneCallButtonPressed();
// to close the dropdown
return true;
});
$('.sipLogClear').click(function(event) {
event.preventDefault();
ctxSip.logClear();
});
$('#sip-logitems').delegate('.sip-logitem .btnCall', 'click', function(event) {
var sessionid = $(this).closest('.sip-logitem').data('sessionid');
ctxSip.phoneCallButtonPressed(sessionid);
return false;
});
$('#sip-logitems').delegate('.sip-logitem .btnHoldResume', 'click', function(event) {
var sessionid = $(this).closest('.sip-logitem').data('sessionid');
ctxSip.phoneHoldButtonPressed(sessionid);
return false;
});
$('#sip-logitems').delegate('.sip-logitem .btnHangUp', 'click', function(event) {
var sessionid = $(this).closest('.sip-logitem').data('sessionid');
ctxSip.sipHangUp(sessionid);
return false;
});
$('#sip-logitems').delegate('.sip-logitem .btnTransfer', 'click', function(event) {
var sessionid = $(this).closest('.sip-logitem').data('sessionid');
ctxSip.sipTransfer(sessionid);
return false;
});
$('#sip-logitems').delegate('.sip-logitem .btnMute', 'click', function(event) {
var sessionid = $(this).closest('.sip-logitem').data('sessionid');
ctxSip.phoneMuteButtonPressed(sessionid);
return false;
});
$('#sip-logitems').delegate('.sip-logitem', 'dblclick', function(event) {
event.preventDefault();
var uri = $(this).data('uri');
$('#numDisplay').val(uri);
ctxSip.phoneCallButtonPressed();
});
$('#sldVolume').on('change', function() {
var v = $(this).val() / 100,
// player = $('audio').get()[0],
btn = $('#btnVol'),
icon = $('#btnVol').find('i'),
active = ctxSip.callActiveID;
// Set the object and media stream volumes
if (ctxSip.Sessions[active]) {
ctxSip.Sessions[active].player.volume = v;
ctxSip.callVolume = v;
}
// Set the others
$('audio').each(function() {
$(this).get()[0].volume = v;
});
if (v < 0.1) {
btn.removeClass(function (index, css) {
return (css.match (/(^|\s)btn\S+/g) || []).join(' ');
})
.addClass('btn btn-sm btn-danger');
icon.removeClass().addClass('fa fa-fw fa-volume-off');
} else if (v < 0.8) {
btn.removeClass(function (index, css) {
return (css.match (/(^|\s)btn\S+/g) || []).join(' ');
}).addClass('btn btn-sm btn-info');
icon.removeClass().addClass('fa fa-fw fa-volume-down');
} else {
btn.removeClass(function (index, css) {
return (css.match (/(^|\s)btn\S+/g) || []).join(' ');
}).addClass('btn btn-sm btn-primary');
icon.removeClass().addClass('fa fa-fw fa-volume-up');
}
return false;
});
// Hide the spalsh after 3 secs.
setTimeout(function() {
ctxSip.logShow();
}, 3000);
/**
* Stopwatch object used for call timers
*
* @param {dom element} elem
* @param {[object]} options
*/
var Stopwatch = function(elem, options) {
// private functions
function createTimer() {
return document.createElement("span");
}
var timer = createTimer(),
offset,
clock,
interval;
// default options
options = options || {};
options.delay = options.delay || 1000;
options.startTime = options.startTime || Date.now();
// append elements
elem.appendChild(timer);
function start() {
if (!interval) {
offset = options.startTime;
interval = setInterval(update, options.delay);
}
}
function stop() {
if (interval) {
clearInterval(interval);
interval = null;
}
}
function reset() {
clock = 0;
render();
}
function update() {
clock += delta();
render();
}
function render() {
timer.innerHTML = moment(clock).format('mm:ss');
}
function delta() {
var now = Date.now(),
d = now - offset;
offset = now;
return d;
}
// initialize
reset();
// public API
this.start = start; //function() { start; }
this.stop = stop; //function() { stop; }
};
});
|
import React from 'react';
import AppState from '/imports/api/appState';
import Colors from '/imports/api/colors';
import Sizes from '/imports/api/sizes';
import PathSimplifier from '/imports/api/pathSimplifier';
import StickyNotes from '/imports/api/stickyNotes';
import Drawing from '/imports/ui/app/components/notes/Drawing.jsx';
import Text from '/imports/ui/app/components/notes/Text.jsx';
import Line from '/imports/ui/app/components/notes/Line.jsx';
import Arrow from '/imports/ui/app/components/notes/Arrow.jsx';
import Box from '/imports/ui/app/components/notes/Box.jsx';
import Circle from '/imports/ui/app/components/notes/Circle.jsx';
const cursorOffset = 10;
const notes = {
drawing: Drawing,
text: Text,
line: Line,
arrow: Arrow,
circle: Circle,
box: Box,
};
const captures = {
drawing: (event) => captureNote(event, ['points']),
text: (event) => captureNote(event, ['end-point']),
line: (event) => captureNote(event, ['end-point']),
arrow: (event) => captureNote(event, ['end-point']),
circle: (event) => captureNote(event, ['end-point']),
box: (event) => captureNote(event, ['end-point']),
};
export default NotesLayer = {
fetchNoteData() {
const data = AppState.get('note_data');
return {
type: AppState.get('note_type'),
data: AppState.get('note_data'),
color: AppState.get('note_color'),
size: AppState.get('note_size'),
};
},
fetchNote(note) {
const Note = notes[note.type];
return <Note {...note} key={note._id}/>;
},
startTaking(event) {
const note = AppState.get('note_type');
initNote(event);
},
takeNote(event) {
const note = AppState.get('note_type');
captures[note](event);
},
stopTaking(noteType) {
AppState.set('note_displaying', false);
const note = NotesLayer.fetchNoteData();
const insertNote = `${note.type}.insert`;
Meteor.call(insertNote, note, StickyNotes.handler);
},
};
// remove function
const generateCoords = (event) => {
let coords = {
x: (event.nativeEvent.offsetX || event.nativeEvent.touches[0].clientX),
y: (event.nativeEvent.offsetY || event.nativeEvent.touches[0].clientY),
}
coords.x += cursorOffset;
coords.y += cursorOffset;
return coords;
};
const captureNote = (event, data) => {
const note = data.reduce((data, datum) => {
return Object.assign(data, Capture[datum](event));
}, {});
AppState.set('note_data', note)
}
const initNote = (coords) => {
const initial = {
'x': coords.x,
'y': coords.y,
};
AppState.set({
'note_displaying': true,
'note_data': {
coords: [initial, initial],
}
});
}
const Capture = {
'end-point' (coords) {
const data = AppState.get('note_data');
data.coords[1] = {
x: coords.x,
y: coords.y,
}
return data;
},
points(coords) {
const data = AppState.get('note_data');
data.coords.push({
x: coords.x,
y: coords.y,
});
data.coords = PathSimplifier(data.coords, 0.9, true);
return data;
},
} |
import React from "react"
import Slider from "rc-slider"
import ReactTooltip from "react-tooltip"
export default class extends React.PureComponent {
static defaultProps = {
defaultValue: 50,
name: "testName",
marks: {
0: "",
50: "",
100: ""
},
showVal: true,
onChange: val => {
console.log(val)
}
}
constructor(props) {
super(props)
this.state = {
val: this.props.defaultValue
}
}
handleChange(val) {
this.setState({
val: val
})
this.props.onChange(name, val)
}
render() {
return (
<div className="m-step-slider">
{this.props.showLabel && (
<div className="m-slider-val">{this.state.val}</div>
)}
<Slider
marks={this.props.marks}
step={null}
onChange={this.handleChange.bind(this)}
defaultValue={this.state.val}
/>
</div>
)
}
}
const Handle = Slider.Handle
const handle = props => {
const { value, dragging, index, ...restProps } = props
return (
<span>
<Handle data-tip={value} value={value} {...restProps} />
<ReactTooltip className="m-tooltip" />
</span>
)
}
|
"use strict";
module.exports = function(end, duration, callback) {
var start = window.performance && window.performance.now && window.performance.now();
var begin = window.pageYOffset;
var scrollX = window.pageXOffset;
var raf = window.requestAnimationFrame;
var delta = end - begin;
switch (!!raf) {
case true:
raf(function step(timestamp) {
var timePassed = timestamp - start;
if (timePassed > duration || delta === 0) {
timePassed = duration;
}
var progress = timePassed / duration;
var current = progress * delta + begin;
window.scrollTo(scrollX, current + 1); // 1px for firefox
if (timePassed < duration) {
raf(step);
} else if (callback) {
callback();
}
});
break;
case false:
window.scrollTo(scrollX, end);
if (callback) {
callback();
}
break;
}
};
|
import React, {PropTypes} from 'react';
import EventListener from 'react-event-listener';
import bowser from 'bowser';
import KeyCode from 'key-code';
import Api from './Api';
const snapLinesStyle = {pointerEvents: 'none'};
export default class Canvas extends React.Component {
static propTypes = {
api: PropTypes.instanceOf(Api),
zoom: PropTypes.number,
fixed: PropTypes.bool,
onFirstRender: PropTypes.func,
snapDistance: PropTypes.number
};
static defaultProps = {
fixed: false,
zoom: 1,
snapDistance: 5
};
static childContextTypes = {
canvas: PropTypes.object,
api: PropTypes.object
};
constructor(props, context) {
super(props, context);
this.api = props.api;
this.api.on('selectionChange', this.handleSelectionChange);
this.api.on('dataChange', this.handleDataChange);
this.snaplines = {};
this.nodes = {};
this.state = {
readyForRender: false,
width: 0,
height: 0,
selection: this.api.selection,
slide: this.api.slide,
slideLeft: 0,
slideTop: 0
};
}
getChildContext() {
return {
canvas: this,
api: this.props.api
};
}
componentWillUnmount() {
this.api.unbind('selectionChange', this.handleSelectionChange);
this.api.unbind('dataChange', this.handleDataChange);
}
componentDidMount() {
this.checkIfReadyForRender();
}
checkIfReadyForRender() {
if (!this.state.readyForRender) {
// check if DOM is ready to render
const readyForRender = this.loadingNode && this.loadingNode.offsetHeight > 0;
if (readyForRender) {
this.setState({
readyForRender: true
});
} else {
setTimeout(() => {
this.checkIfReadyForRender();
}, 50);
}
}
}
componentWillReceiveProps(nextProps) {
if (nextProps.api !== this.props.api && nextProps.api) {
this.props.api.unbind('selectionChange', this.handleSelectionChange);
this.props.api.unbind('dataChange', this.handleDataChange);
nextProps.api.bind('selectionChange', this.handleSelectionChange);
nextProps.api.bind('dataChange', this.handleDataChange);
this.handleDataChange();
this.handleSelectionChange();
}
}
componentDidUpdate(prevProps, prevState) {
if (!prevState.readyForRender && this.state.readyForRender) {
this.positionSlide();
this.props.onFirstRender && this.props.onFirstRender(this);
} else if (this.state.readyForRender && (prevProps.zoom !== this.props.zoom || this.state.slide !== prevState.slide)) {
this.positionSlide();
}
if (prevState.slideLeft !== this.state.slideLeft
|| prevState.slideTop !== this.state.slideTop
|| prevState.width !== this.state.width
|| prevState.height !== this.state.height) {
this.props.api.triggerSelectionChange();
this.centerContent();
}
}
centerContent() {
const bbox = this.svgRoot.parentNode.getBoundingClientRect();
this.wrapperNode.scrollLeft = (this.state.width - bbox.width) * 0.5;
this.wrapperNode.scrollTop = (this.state.height - bbox.height) * 0.5;
}
positionSlide() {
if (this.svgRoot) {
const bbox = this.svgRoot.parentNode.getBoundingClientRect();
const slide = this.state.slide;
const zoom = this.props.zoom;
const slideWidth = slide.width * zoom;
const slideHeight = slide.height * zoom;
const width = Math.max(slideWidth, bbox.width - 20);
const height = Math.max(slideHeight, bbox.height - 20);
const slideLeft = ((width || bbox.width) - slideWidth) * 0.5;
const slideTop = ((height || bbox.height) - slideHeight) * 0.5;
if (this.state.width !== width || this.state.height !== height || this.state.slideLeft !== slideLeft || this.state.slideTop !== slideTop) {
this.setState({
slideLeft,
slideTop,
width,
height
});
}
}
}
findSnaplines(node, snaplines) {
if (!this.possibleSnaplines) {
return {x: 0, y: 0};
}
const matchingSnaplines = [];
const matchedSnapline = {};
const diffs = {x: 0, y: 0};
// (this.state.snaplines || []).forEach(s => s.ref.highlight(false));
const maxDiff = {x: 3 * this.props.zoom, y: 3 * this.props.zoom};
(snaplines || []).forEach((tmpSnapline) => {
tmpSnapline = matchedSnapline[tmpSnapline.mode] || tmpSnapline;
this.possibleSnaplines.forEach((snapline) => {
const diff = tmpSnapline.pos - snapline.pos;
if (tmpSnapline.mode === snapline.mode && Math.abs(diff) <= maxDiff[tmpSnapline.mode]) {
maxDiff[tmpSnapline.mode] = 0;
matchingSnaplines.push(snapline);
matchedSnapline[tmpSnapline.mode] = matchedSnapline[tmpSnapline.mode] || snapline;
diffs[tmpSnapline.mode] = diffs[tmpSnapline.mode] || diff;
}
});
});
this.possibleSnaplines.map(snapline => snapline.ref).filter((elem, pos, self) => self.indexOf(elem) === pos).forEach((element) => {
element.highlight(matchingSnaplines.find(s => s.ref === element));
});
this.setState({
snaplines: matchingSnaplines
});
return diffs;
}
registerNode(node) {
if (node.props.id) {
this.nodes[node.props.id] = node;
}
}
unregisterNode(node) {
if (node.props.id) {
delete this.nodes[node.props.id];
}
}
clearSnaplines() {
this.state.snaplines && this.state.snaplines.forEach(s => s.ref.highlight(false));
this.setState({
snaplines: null
});
}
prepareSnaplines(node) {
let possibleSnaplines = [];
Object.keys(this.nodes).forEach((nodeId) => {
const oNode = this.nodes[nodeId];
if (nodeId !== node.props.id && !node.contains(oNode)) {
possibleSnaplines = possibleSnaplines.concat(oNode.getCurrentSnaplines());
}
});
this.possibleSnaplines = possibleSnaplines;
}
focus() {
if (!bowser.ios) {
this.wrapperNode && this.wrapperNode.focus();
}
}
handleResize = () => {
this._resizeTimeout && clearTimeout(this._resizeTimeout);
this._resizeTimeout = setTimeout(() => {
this.positionSlide();
}, 100);
};
handleKeyDown = (e) => {
const api = this.props.api;
if (!/input|textarea/gi.test(e.target.tagName) && !e.target.getAttribute('contenteditable')) {
const ctrlKey = (bowser.mac && e.metaKey) || !bowser.mac && e.ctrlKey;
if (e.which === KeyCode.BACKSPACE || e.which === KeyCode.DELETE) {
api.removeSelectedElements();
api.triggerDataChange();
api.triggerSelectionChange();
} else if (e.which === KeyCode.Z && e.metaKey) {
e.preventDefault();
if (!e.shiftKey) {
api.undo();
} else {
api.redo();
}
} else if(e.which === KeyCode.C && ctrlKey) {
api.copySelectedElements();
} else if(e.which === KeyCode.X && ctrlKey) {
api.cutSelectedElements();
} else if(e.which === KeyCode.V && ctrlKey) {
api.pasteClipboard();
} else {
let dx = 0;
let dy = 0;
switch (e.which) {
case 37: // left
dx = -1;
break;
case 38: // up
dy = -1;
break;
case 39: // right
dx = 1;
break;
case 40: // down
dy = 1;
break;
default:
return; // exit this handler for other keys
}
if (dx || dy) {
e.stopPropagation();
e.preventDefault();
if (!this._moveKeyDown) {
api.startChange();
this._moveKeyDown = true;
}
const elements = api.getSelectedElements();
elements.forEach((element) => {
api.updateElement(element.id, 'x', element.x + dx);
api.updateElement(element.id, 'y', element.y + dy);
api.triggerDataChange();
});
}
}
}
};
handleKeyUp = () => {
if (this._moveKeyDown) {
this._moveKeyDown = false;
this.props.api.finishChange();
}
};
handleDataChange = () => {
this.setState({
slide: this.api.slide,
selection: this.api.selection
});
};
handleSelectionChange = () => {
this.setState({
selection: this.api.selection
});
};
handleRef = (ref) => {
this.firstNode = ref;
};
handleMouseDown = () => {
this.mouseDown = true;
this.triggerSelection(null);
};
handleMouseUp = () => {
this.mouseDown = false;
};
triggerSelection() {
// todo: implement multiple selections
this.props.api.selectElement(null);
}
handleSelectionRefs = (ref) => {
this.selections = ref;
};
handleRootRef = (ref) => {
this.svgRoot = ref;
};
handleSlideRef = (ref) => {
this.slideNode = ref;
};
handleLoadingRef = (ref) => {
this.loadingNode = ref;
};
handleWrapperRef = (ref) => {
this.wrapperNode = ref;
};
render() {
if (!this.state.readyForRender) {
// TODO: implement loader
return <div ref={this.handleLoadingRef}>Loading ...</div>;
}
const wrapperStyle = {width: '100%', height: '100%', overflow: this.props.fixed ? 'hidden' : 'auto', position: 'absolute'};
return (<div style={wrapperStyle} ref={this.handleWrapperRef} tabIndex="-1">
<EventListener
target="window"
onResize={this.handleResize}
onOrientationChange={this.handleResize}
onKeyDown={this.handleKeyDown}
onKeyUp={this.handleKeyUp}
/>
<svg
xmlns="http://www.w3.org/2000/svg" version="1.1"
width={this.state.width || '100%'} height={this.state.height || '100%'}
ref={this.handleRootRef}
shapeRendering="geometricPrecision"
onTouchStart={this.handleMouseDown}
onMouseDown={this.handleMouseDown}
onMouseUp={this.handleMouseUp}
onTouchEnd={this.handleMouseUp}
>
<g ref={this.handleRef}>
<g ref={this.handleSlideRef} transform={`translate(${this.state.slideLeft}, ${this.state.slideTop}) scale(${this.props.zoom})`}>
<rect
width={this.state.slide.width}
height={this.state.slide.height}
fill={this.state.slide.background}
/>
<g className="slide-elements">
{this.state.slide.elements.map((el) => {
const factory = this.props.api.resolveFactory(el.type);
const {id, ...other} = el;
return React.createElement(factory, {key: id, id, ...other});
})}
</g>
<g className="snaplines" style={snapLinesStyle}>
{(this.state.snaplines || []).map((snapline, i) => {
if (snapline.mode === 'x') {
return <line key={i} vectorEffect="non-scaling-stroke" strokeDasharray="5 5" stroke="blue" strokeWidth="0.8" y1={0} y2={this.state.slide.height} x1={snapline.pos} x2={snapline.pos}/>
} else {
return <line key={i} vectorEffect="non-scaling-stroke" strokeDasharray="5 5" stroke="blue" strokeWidth="0.8" x1={0} x2={this.state.slide.width} y1={snapline.pos} y2={snapline.pos}/>
}
})}
</g>
</g>
<g ref={this.handleSelectionRefs} className="slide-selections">
{Object.keys(this.state.selection).filter(id => !!this.nodes[id]).map(id => this.nodes[id].renderSelection())}
</g>
</g>
</svg>
</div>);
}
}
|
import * as React from 'react';
import TextField from '@material-ui/core/TextField';
import AdapterDateFns from '@material-ui/lab/AdapterDateFns';
import Stack from '@material-ui/core/Stack';
import LocalizationProvider from '@material-ui/lab/LocalizationProvider';
import TimePicker from '@material-ui/lab/TimePicker';
export default function FormPropsTimePickers() {
const [value, setValue] = React.useState(null);
return (
<LocalizationProvider dateAdapter={AdapterDateFns}>
<Stack spacing={3}>
<TimePicker
label="disabled"
disabled
value={value}
onChange={(newValue) => {
setValue(newValue);
}}
renderInput={(params) => <TextField {...params} />}
/>
<TimePicker
label="read-only"
readOnly
value={value}
onChange={(newValue) => {
setValue(newValue);
}}
renderInput={(params) => <TextField {...params} />}
/>
</Stack>
</LocalizationProvider>
);
}
|
/* @flow */
import path from "path";
type TPathJoin = (...p: string[]) => string;
const pathJoin: TPathJoin = (...paths) =>
path.join(...paths).replace("/", path.sep);
module.exports = pathJoin;
|
class UserService {
constructor(resource) {
this._resource = resource('api/user{/id}')
}
list() {
return this._resource
.query()
.then(res => res.json())
}
save(user) {
return this._resource
.save(user)
}
update(id, user) {
return this._resource
.update({ id: id }, user)
}
show(id) {
return this._resource
.query({ id })
.then(res => res.json())
}
delete(id) {
return this._resource
.delete({ id })
}
}
export default UserService |
import './search.pcss';
import $ from 'jquery';
export default (selector) => {
$(selector).on('submit', e => {
e.preventDefault();
const packageName = e.target.package.value.trim();
if (packageName) {
window.location = `/search/${packageName}`;
}
});
};
|
var yo = require('yo-yo');
var landing = require('../landing');
var signinForm = yo`<div class="col s12 m7">
<div class="row">
<div class="signup-box">
<h1 class="platzigram">Platzigram</h1>
<form class="signup-form">
<div class="section">
<a class="btn btn-fb hide-on-small-only">Iniciar sesión con Facebook</a>
<a class="btn btn-fb hide-on-med-and-up"><i class="fa fa-facebook-official"></i> Iniciar sesión</a>
</div>
<div class="divider"></div>
<div class="section">
<input type="text" name="username" placeholder="Nombre de usuario" />
<input type="password" name="password" placeholder="Contraseña" />
<button class="btn waves-effect waves-light btn-signup" type="submit">Inicia sesión</button>
</div>
</form>
</div>
</div>
<div class="row">
<div class="login-box">
¿No tienes una cuenta? <a href="/signup">Regístrate</a>
</div>
</div>
</div>`;
module.exports = landing(signinForm);
|
'use strict';
angular.module('myApp.landing', ['ngRoute'])
.config(['$routeProvider', function($routeProvider) {
$routeProvider.when('/landing', {
templateUrl: 'landing/landing.html',
controller: 'LandingCtrl'
});
}])
.controller('LandingCtrl', ['$scope', 'Restangular', function($scope, Restangular) {
Restangular.all('landing').getList().then(function(landing) {
$scope.landing = landing;
});
$scope.deleteRecipe = function(recipeID) {
Restangular.one('landing', recipeID).customDELETE().then(function(){
$location.path('/landing');
})
}
}]); |
(function () {
'use strict';
angular
.module('expenses')
.controller('ExpensesListController', ExpensesListController);
ExpensesListController.$inject = ['ExpensesService'];
function ExpensesListController(ExpensesService) {
var vm = this;
vm.expenses = ExpensesService.query();
}
}());
|
import EmberRouter from '@ember/routing/router';
import config from 'dummy/config/environment';
export default class Router extends EmberRouter {
location = config.locationType;
rootURL = config.rootURL;
}
Router.map(function () {
this.route('transition-to', function () {
this.route('list');
});
this.route('r');
this.route('ember-concurrency');
});
|
module.exports = function (source) {
return this.safeString(source).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
|
/*
* Author: Alexandre Havrileck (Oxyno-zeta)
* Date: 06/06/16
* Licence: See Readme
*/
(function () {
'use strict';
angular
.module('libparsio.views.header', []);
})();
|
version https://git-lfs.github.com/spec/v1
oid sha256:9c126cdc1c463b60783b0d7a4fcd973d27b313882d4ad818e3516db1faa9533f
size 127572
|
/**
* Utils for generating the stuff to be appended to the last part of the
* page.
*/
(function(){
'use strict';
var genSocketScript = function (serverUri) {
var script =
'<script src="http://cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js"></script>' +
'<script>' +
"var socket = io.connect('" + serverUri + "');" +
"socket.on('code', function (data) {" +
"eval(data);" +
"});" +
"socket.on('reload', function (data) {" +
"window.location.reload();" +
"})" +
'</script>';
return script;
};
var genCssAndJsScript = function (jsFile, cssFile) {
var script =
"var d=document;var s;" +
"var h = d.getElementsByTagName('head')[0];";
if (jsFile) {
script +=
"s = d.createElement('script');" +
"s.type='text/javascript';" +
"s.async=true;" +
"s.src='" + jsFile + "';" +
"h.appendChild(s);";
}
if (cssFile) {
script +=
"s = d.createElement('link');" +
"s.href = '" + cssFile + "';" +
"s.rel = 'stylesheet';" +
"s.type = 'text/css';" +
"h.appendChild(s);";
}
return script;
}
var genLoadScript = function (jsFile, cssFile, socketIoUri) {
var onLoadEventScript = "<script>window.onload = function () {" +
genCssAndJsScript(jsFile, cssFile) + "};</script>";
return socketIoUri
? onLoadEventScript + genSocketScript(socketIoUri)
: onLoadEventScript;
};
module.exports = {
genLoadScript: genLoadScript,
};
})(); |
'use strict';
/**
* Created by CLI on 01-05-2015.
*/
exports.addWhoFields= function(model,user){
if(!(model.createdBy)){
model.createdBy=user.id;
model.createdDate=new Date();
}
model.lastUpdatedBy=user.id;
model.lastUpdatedDate=new Date();
};
|
const assert = require('chai').assert;
const common = require('./common');
const app = common.app;
const FBUser = require('../models/fb-user');
const Project = require('../models/project');
const Place = require('../models/place');
const Suggestion = require('../models/suggestion');
// TODO: remember lastPlace
describe('creating an account', () => {
var commonUser;
after(() => {
common.clear();
});
it('welcomes a new user', (done) => {
FBUser.find({ user_id: 'test' }).remove(() => {
common.fbmessage(app, {message: {text: 'hello!'}}, (err, res) => {
if (err) {
return done(err);
}
assert.include(res.text, 'Welcome to OSM City Namer');
FBUser.find({ user_id: 'test' }, (err, users) => {
if (err) {
return done(err);
}
assert.equal(users.length, 1);
commonUser = users[0];
done();
});
});
});
});
it('saves user language preference, and returns a placename', (done) => {
common.make.Place('333', done, (place) => {
common.fbmessage(app, {postback: {payload: 'rw:en:bot'}}, (err, res) => {
if (err) {
return done(err);
}
assert.include(res.text, '"' + place.name + '"');
FBUser.findById(commonUser._id, (err, refreshUser) => {
if (err) {
return done(err);
}
assert.equal(refreshUser.readLanguages.length, 1);
assert.equal(refreshUser.readLanguages[0], 'en');
assert.equal(refreshUser.writeLanguages.length, 1);
assert.equal(refreshUser.writeLanguages[0], 'bot');
// assert.equal(refreshUser.lastPlace, '201___en___test');
done();
});
});
});
});
/*
it('creates a Suggestion and asks to set user leaderboard name', (done) => {
Suggestion.find({ user_id: 'fb:test' }).remove(() => {
common.fbmessage(app, {message: {text: 'newnamedplace'}}, (err, res) => {
if (err) {
return done(err);
}
assert.include(res.text, 'What name would you like to have on the leaderboard?');
Suggestion.find({ user_id: 'fb:test', suggested: 'newnamedplace' }, (err, suggestions) => {
if (err) {
return done(err);
}
assert.equal(suggestions.length, 1);
assert.equal(suggestions[0].osm_place_id, '201');
assert.equal(suggestions[0].targetLanguage, 'en');
assert.equal(suggestions[0].originalName, 'test');
assert.equal(suggestions[0].submitted, 0);
done();
});
});
});
});
it('sets user leaderboard name', (done) => {
common.fbmessage(app, {message: {text: 'leadername'}}, (err, res) => {
if (err) {
return done(err);
}
FBUser.findById(commonUser._id, (err, refreshUser) => {
if (err) {
return done(err);
}
assert.equal(refreshUser.name, 'leadername');
done();
});
});
});
*/
it('sets up a block on an FBUser', (done) => {
commonUser.blocked = true;
commonUser.save((err) => {
if (err) {
return done(err);
}
common.fbmessage(app, {message: {text: 'rambling'}}, (err, res) => {
if (err) {
return done(err);
}
assert.include(res.text, 'echo: rambling');
done();
});
});
});
});
|
import React, { Component } from 'react';
import { Collapse, Card, CardBody, CardHeader, CardTitle } from 'reactstrap';
class Telemetry extends Component {
constructor(props) {
super(props);
this.toggle = this.toggle.bind(this);
this.state = { isOpen: false };
}
toggle() {
this.setState({ isOpen: !this.state.isOpen });
}
render() {
let cardBody = <p>These do not work until ROS is Running.</p>;
if (this.props.ROSisRunning) {
cardBody = this.props.rosTopicItems.map((entry) => {
let thisButtonClass = 'btn btn-light';
let thisButtonBadgeClass = 'badge rounded-pill bg-secondary';
if (entry.btnClass !== '') {
thisButtonClass = `btn ${entry.btnClass}`;
thisButtonBadgeClass = 'badge rounded-pill bg-dark';
}
return (
<span key={entry.rosName}>
<button type="button" className={thisButtonClass}>
{entry.fancyName}
<span className={thisButtonBadgeClass}>{`${entry.status}`}</span>
</button>
</span>
);
});
}
return (
<Card id="telemetry-card" className="card-title">
<CardHeader onClick={this.toggle}>
<CardTitle>Telemetry</CardTitle>
</CardHeader>
<Collapse id="telemetry-card-body" isOpen={this.state.isOpen}>
<CardBody>{cardBody}</CardBody>
</Collapse>
</Card>
);
}
}
export default Telemetry;
|
function findMax(arr) {
var max = arr[0];
for (var i = 1; i < arr.length; ++i) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
} |
import {test} from 'tape';
import React from 'react';
import TestUtils from 'react-addons-test-utils';
import Disabled from '../../../src/components/icons/status/Disabled';
import CSSClassnames from '../../../src/utils/CSSClassnames';
const STATUS_ICON = CSSClassnames.STATUS_ICON;
test('loads a disabled icon', (t) => {
t.plan(1);
const shallowRenderer = TestUtils.createRenderer();
shallowRenderer.render(React.createElement(Disabled));
const disabledIcon = shallowRenderer.getRenderOutput();
if (disabledIcon.props.className.indexOf(`${STATUS_ICON}-disabled`) > -1) {
t.pass('Icon has disabled class');
} else {
t.fail('Icon does not have disabled class');
}
});
test('loads a disabled icon with custom class applied', (t) => {
t.plan(1);
const shallowRenderer = TestUtils.createRenderer();
shallowRenderer.render(React.createElement(Disabled, {
className:'custom-class'
}));
const disabledIcon = shallowRenderer.getRenderOutput();
if (disabledIcon.props.className.indexOf('custom-class') > -1) {
t.pass('Disabled icon has custom class applied');
} else {
t.fail('Disabled icon does not have custom class applied');
}
});
|
"use strict";
var __extends = (this && this.__extends) || (function () {
var 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 function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Lint = require("tslint");
var sprintf_js_1 = require("sprintf-js");
var utils_1 = require("./util/utils");
var ngWalker_1 = require("./angular/ngWalker");
var recursiveAngularExpressionVisitor_1 = require("./angular/templates/recursiveAngularExpressionVisitor");
var expressionTypes_1 = require("./angular/expressionTypes");
var classDeclarationUtils_1 = require("./util/classDeclarationUtils");
var DeclarationType;
(function (DeclarationType) {
DeclarationType[DeclarationType["Property"] = 0] = "Property";
DeclarationType[DeclarationType["Method"] = 1] = "Method";
})(DeclarationType || (DeclarationType = {}));
var SymbolAccessValidator = (function (_super) {
__extends(SymbolAccessValidator, _super);
function SymbolAccessValidator() {
return _super !== null && _super.apply(this, arguments) || this;
}
SymbolAccessValidator.prototype.visitPropertyRead = function (ast, context) {
return this.doCheck(ast, DeclarationType.Property, context);
};
SymbolAccessValidator.prototype.visitMethodCall = function (ast, context) {
this.doCheck(ast, DeclarationType.Method, context);
};
SymbolAccessValidator.prototype.visitPropertyWrite = function (ast, context) {
this.doCheck(ast, DeclarationType.Property, context);
};
SymbolAccessValidator.prototype.doCheck = function (ast, type, context) {
var symbolType;
var available;
if (type === DeclarationType.Method) {
symbolType = 'method';
}
else {
symbolType = 'property';
}
available = Object.assign({}, classDeclarationUtils_1.getDeclaredMethodNames(this.context.controller), classDeclarationUtils_1.getDeclaredPropertyNames(this.context.controller), this.preDefinedVariables);
var tmp = ast;
while (tmp && !expressionTypes_1.ExpTypes.ImplicitReceiver(tmp)) {
ast = tmp;
if (expressionTypes_1.ExpTypes.KeyedRead(tmp)) {
tmp = tmp.obj;
}
else if (expressionTypes_1.ExpTypes.KeyedWrite(tmp)) {
tmp = tmp.obj;
}
else if (expressionTypes_1.ExpTypes.PropertyRead(tmp)) {
tmp = tmp.receiver;
}
else if (expressionTypes_1.ExpTypes.PropertyWrite(tmp)) {
tmp = tmp.receiver;
}
else if (expressionTypes_1.ExpTypes.SafeMethodCall(tmp)) {
tmp = tmp.receiver;
}
else if (expressionTypes_1.ExpTypes.SafePropertyRead(tmp)) {
tmp = tmp.receiver;
}
else if (expressionTypes_1.ExpTypes.MethodCall(tmp)) {
tmp = tmp.receiver;
}
else {
break;
}
}
if (ast.name && !available[ast.name]) {
var failureString = sprintf_js_1.sprintf.apply(this, [Rule.FAILURE, symbolType, ast.name]);
var top_1 = this.getTopSuggestion(Object.keys(available), ast.name);
var getSuggestion = function (list) {
if (list.length === 1) {
return "\"" + list[0] + "\"";
}
var result = "\"" + list.shift() + "\"";
while (list.length > 1) {
result += ", \"" + list.shift() + "\"";
}
result += " or \"" + list.shift() + "\"";
return result;
};
if (top_1.length && top_1[0].distance <= 2) {
failureString += " Probably you mean: " + getSuggestion(top_1.map(function (s) { return s.element; })) + ".";
}
var width = ast.name.length;
this.addFailure(this.createFailure(ast.span.start, width, failureString));
}
return null;
};
SymbolAccessValidator.prototype.getTopSuggestion = function (list, current) {
var result = [];
var tmp = list.map(function (e) {
return {
element: e,
distance: utils_1.stringDistance(e, current)
};
}).sort(function (a, b) { return a.distance - b.distance; });
var first = tmp.shift();
if (!first) {
return [];
}
else {
result.push(first);
var current_1;
while (current_1 = tmp.shift()) {
if (current_1.distance !== first.distance) {
return result;
}
else {
result.push(current_1);
}
}
return result;
}
};
return SymbolAccessValidator;
}(recursiveAngularExpressionVisitor_1.RecursiveAngularExpressionVisitor));
var Rule = (function (_super) {
__extends(Rule, _super);
function Rule() {
return _super !== null && _super.apply(this, arguments) || this;
}
Rule.prototype.apply = function (sourceFile) {
return this.applyWithWalker(new ngWalker_1.NgWalker(sourceFile, this.getOptions(), {
expressionVisitorCtrl: SymbolAccessValidator
}));
};
return Rule;
}(Lint.Rules.AbstractRule));
Rule.metadata = {
ruleName: 'no-access-missing-member',
type: 'functionality',
description: "Disallows using non-existing properties and methods from the component in templates.",
rationale: "Such occurances in code are most likely a result of a typo.",
options: null,
optionsDescription: "Not configurable.",
typescriptOnly: true,
};
Rule.FAILURE = 'The %s "%s" that you\'re trying to access does not exist in the class declaration.';
exports.Rule = Rule;
|
angular.module('myApp.filters', []);
angular.module('myApp.filters').filter('reverse', function () {
return function (input) {
return input.split('').reverse().join('');
};
}); |
const express = require('express');
const router = express.Router();
const ngoStory = require('../../controller/ngo.controller/ngoStoryController');
router
.route('/post')
.post(ngoStory.postStory);
router.route('/:storyId')
.patch(ngoStory.updateStory)
.delete(ngoStory.deleteStory);
module.exports = router; |
'use strict';
const TokendClient = require('./tokend-client');
const Immutable = require('immutable');
const isPlainObject = require('lodash.isplainobject');
const crypto = require('crypto');
/**
* Walk a properties object looking for transformable values
*
* @param {Object} properties an object to search for transformable values
* @param {Array} keyPath accumulated path of keys where transformable value was found
* @return {Array<Immutable.OrderedMap>} transformable data with injected key path
*/
function collectTransformables(properties, keyPath) {
let results = [];
// Ensure we're walking an Object.
if (!isPlainObject(properties)) {
return results;
}
// If we're walking a $tokend object, pass it to the callback.
const keys = Object.keys(properties);
if (keys.length === 1 && keys[0] === '$tokend') {
return results.concat(Immutable.OrderedMap(properties.$tokend).set('keyPath', keyPath));
}
Object.keys(properties).forEach((key) => {
const value = properties[key];
// Don't walk anything that's not an Object.
if (isPlainObject(value)) {
results = results.concat(collectTransformables(value, keyPath.concat(key)));
}
});
return results;
}
/**
* Transform properties by fetching secrets from Tokend
*/
class TokendTransformer {
/**
* Constructor
* @param {Object} options See TokendClient for options
*/
constructor(options) {
const opts = options || {};
this._client = new TokendClient(opts);
this._cache = {};
}
/**
* Start polling Tokend for secrets
*
* @return {Promise}
*/
initialize() {
return this._client.initialize();
}
/**
* Transform properties by fetching secrets from Tokend
*
* @param {Object} properties properties that may contain $tokend values
* @return {Promise<Properties>} properties that had $tokend values transformed
*/
transform(properties) {
const seenProperties = [];
const promises = collectTransformables(properties, []).map((info) => {
const keyPath = info.get('keyPath');
const propertyName = keyPath.join(".");
seenProperties.push(propertyName);
const signature = crypto
.createHash('sha1')
.update(JSON.stringify(info.toJS()))
.digest('base64');
if (this._cache.hasOwnProperty(propertyName) && this._cache[propertyName].signature === signature) {
return Promise.resolve(Immutable.Map().setIn(keyPath, this._cache[propertyName].plaintext));
}
let resolver = null,
payload = {},
method = '',
source = 'Vault';
switch (info.get('type')) {
case 'generic':
method = 'GET';
resolver = this._client.get(info.get('resource'));
break;
case 'transit':
payload = {
key: info.get('key'),
ciphertext: info.get('ciphertext')
};
method = 'POST';
resolver = this._client.post(info.get('resource'), payload);
break;
case 'kms':
source = 'KMS';
payload = {
key: source,
ciphertext: info.get('ciphertext')
};
if (info.get('region') && info.get('region') !== '') {
payload.region = info.get('region');
}
if (info.get('datakey') && info.get('datakey') !== '') {
payload.datakey = info.get('datakey');
}
method = 'POST';
resolver = this._client.post(info.get('resource'), payload);
break;
default:
Log.log('WARN', `Invalid $tokend.type ${info.get('type')} for ${keyPath.join('.')}`);
return Promise.resolve(Immutable.Map().setIn(keyPath, null));
}
let requestId = `${info.get('resource')}.${payload.key}.${payload.ciphertext}`;
// We have to strip out any undefined values to make sure that we correctly map the requestId to
// the GET request cache key.
if (method === 'GET') {
requestId = requestId.split('.').filter((f) => f !== 'undefined').join('.');
}
return resolver.then((data) => {
this._client.clearCacheAtKey(method, requestId);
if (!data.hasOwnProperty('plaintext')) {
Log.log('WARN', `No "plaintext" key found in ${source} for ${keyPath.join('.')}`);
return Promise.resolve(Immutable.Map().setIn(keyPath, null));
}
this._cache[propertyName] = {
signature,
plaintext: data.plaintext
};
return Promise.resolve(Immutable.Map().setIn(keyPath, data.plaintext));
}).catch((err) => {
Log.log('WARN', err);
this._client.clearCacheAtKey(method, requestId);
if (this._cache.hasOwnProperty(propertyName)) {
return Promise.resolve(Immutable.Map().setIn(keyPath, this._cache[propertyName].plaintext));
}
Log.log('WARN', `'${propertyName}' not found in cache, '${propertyName}' will be set to null`)
return Promise.resolve(Immutable.Map().setIn(keyPath, null));
});
});
return Promise.all(promises).then((values) => {
let transformedProperties = Immutable.Map();
values.forEach((value) => {
transformedProperties = transformedProperties.mergeDeep(value);
});
/*
* Remove entries from the cache if it has not been iterated on above
* from collectTransformables
*/
Object.keys(this._cache)
.forEach((propertyName) => {
if (seenProperties.indexOf(propertyName) === -1) {
delete this._cache[propertyName]
}
})
return transformedProperties.toJS();
});
}
/**
* Bind event listeners to the TokendClient
*
* @param {String} eventName -
* @param {Function} listener -
*/
on(eventName, listener) {
this._client.on(eventName, listener);
}
}
module.exports = TokendTransformer;
|
const sinon = require('sinon')
const React = require('react')
const Enzyme = require('enzyme')
const {assert} = require('chai')
const {shallow} = require('enzyme')
const Adapter = require('enzyme-adapter-react-16')
const {EditorResourcePure} = require('../../src/components/EditorResource')
Enzyme.configure({adapter: new Adapter()})
// Tests
describe('EditorResourcePure', () => {
it('should render', () => {
const descriptor = {}
const resourceIndex = 2
const isSettingsActive = false
const setIsSettingsActive = sinon.spy()
const onRemoveClick = sinon.spy()
const onUploadClick = sinon.spy()
const onUploadChange = sinon.spy()
const onUpdateChange = sinon.spy()
const wrapper = shallow(<EditorResourcePure
descriptor={descriptor}
resourceIndex={resourceIndex}
isSettingsActive={isSettingsActive}
setIsSettingsActive={setIsSettingsActive}
onRemoveClick={onRemoveClick}
onUploadClick={onUploadClick}
onUploadChange={onUploadChange}
onUpdateChange={onUpdateChange}
/>)
assert(wrapper.contains('Load'))
})
})
|
// Karma configuration
// Generated on Thu Aug 21 2014 10:24:39 GMT+0200 (CEST)
module.exports = function(config) {
config.set({
// base path that will be used to resolve all patterns (eg. files, exclude)
basePath: '',
// frameworks to use
// available frameworks: https://npmjs.org/browse/keyword/karma-adapter
frameworks: ['mocha', 'chai-jquery', 'jquery-1.8.3', 'sinon-chai'],
plugins: [
'karma-mocha',
'karma-chai',
'karma-sinon-chai',
'karma-chrome-launcher',
'karma-phantomjs-launcher',
'karma-jquery',
'karma-chai-jquery'
],
// list of files / patterns to load in the browser
files: [
'bower/angular/angular.js',
'bower/angular-mocks/angular-mocks.js',
'dist/ionic-letter-avatar-selector.js',
'test/unit/**/*.js'
],
// list of files to exclude
exclude: [
],
// preprocess matching files before serving them to the browser
// available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
preprocessors: {
},
// test results reporter to use
// possible values: 'dots', 'progress'
// available reporters: https://npmjs.org/browse/keyword/karma-reporter
reporters: ['progress'],
// web server port
port: 9876,
// enable / disable colors in the output (reporters and logs)
colors: true,
// level of logging
// possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
logLevel: config.LOG_INFO,
// enable / disable watching file and executing tests whenever any file changes
autoWatch: true,
// start these browsers
// available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
browsers: ['PhantomJS'],
// Continuous Integration mode
// if true, Karma captures browsers, runs the tests and exits
singleRun: false
});
};
|
var diceSelectionViewModel = function() {
var self = this;
self.AbilityDiceCount = ko.observable(0);
self.ProficiencyDiceCount = ko.observable(0);
self.BoostDiceCount = ko.observable(0);
self.DifficultyDiceCount = ko.observable(0);
self.ChallengeDiceCount = ko.observable(0);
self.SetbackDiceCount = ko.observable(0);
var abilityDie = new diceViewModel('symbol symbol-ability', rollAbilityDie);
var proficiencyDie = new diceViewModel('symbol symbol-proficiency', rollProficiencyDie);
var boostDie = new diceViewModel('symbol symbol-boost', rollBoostDie);
var difficultyDie = new diceViewModel('symbol symbol-difficulty', rollDifficultyDie);
var challengeDie = new diceViewModel('symbol symbol-challenge', rollChallengeDie);
var setbackDie = new diceViewModel('symbol symbol-setback', rollSetbackDie);
self.DicePool = ko.computed(function() {
var diceArray = [];
for(var x = 0; x < self.AbilityDiceCount(); x++){
diceArray.push(abilityDie);
}
for(var x = 0; x < self.ProficiencyDiceCount(); x++){
diceArray.push(proficiencyDie);
}
for(var x = 0; x < self.BoostDiceCount(); x++){
diceArray.push(boostDie);
}
for(var x = 0; x < self.DifficultyDiceCount(); x++){
diceArray.push(difficultyDie);
}
for(var x = 0; x < self.ChallengeDiceCount(); x++){
diceArray.push(challengeDie);
}
for(var x = 0; x < self.SetbackDiceCount(); x++){
diceArray.push(setbackDie);
}
return diceArray;
});
self.RollResults = ko.observableArray([]);
self.sumDieRolls = function(){
self.RollResults.removeAll();
var rolls = accumulateDieRolls(self.DicePool());
var passSum = rolls[DIE_SUCCESS_RESULT] + rolls[DIE_TRIUMPH_RESULT] - rolls[DIE_FAILURE_RESULT] - rolls[DIE_DESPAIR_RESULT];
if(passSum > 0){
for(var x = 0; x < passSum; x++){
self.RollResults.push("symbol symbol-success");
}
} else if(passSum < 0){
for(var x = 0; x > passSum; x--){
self.RollResults.push("symbol symbol-failure");
}
}
var sideEffectSum = rolls[DIE_ADVANTAGE_RESULT] - rolls[DIE_THREAT_RESULT];
if(sideEffectSum > 0){
for(var x = 0; x < sideEffectSum; x++){
self.RollResults.push("symbol symbol-advantage");
}
} else if(sideEffectSum < 0){
for(var x = 0; x > sideEffectSum; x--){
self.RollResults.push("symbol symbol-threat");
}
}
if(rolls[DIE_TRIUMPH_RESULT] > 0){
for(var x = 0; x < rolls[DIE_TRIUMPH_RESULT]; x++){
self.RollResults.push("symbol symbol-triumph");
}
}
if(rolls[DIE_DESPAIR_RESULT]){
for(var x = 0; x < rolls[DIE_DESPAIR_RESULT]; x++){
self.RollResults.push("symbol symbol-despair");
}
}
}
};
var diceViewModel = function(spanClass, rollFunction) {
var self = this;
self.SpanClass = spanClass;
self.Roll = rollFunction;
};
(function(){
ko.bindingHandlers.diceCount = {
init: function(element, valueAccessor) {
$(element).click(function() {
var buttonValue = parseInt($(element).text());
var value = valueAccessor();
value(buttonValue);
});
},
update: function(element, valueAccessor) {
var value = valueAccessor();
var valueUnwrapped = ko.unwrap(value);
var buttonValue = parseInt($(element).text());
if(buttonValue === valueUnwrapped) {
$(element).addClass('active');
} else {
$(element).removeClass('active');
}
}
}
})(); |
module.exports = Vue.extend({
mixins: [
require('../lib/package')
],
data: function () {
return _.extend(window.$data, {
package: {},
view: false,
updates: null,
search: '',
status: ''
})
},
ready: function () {
this.load();
},
methods: {
icon: function (pkg) {
if (pkg.extra && pkg.extra.image) {
return this.$url.static('extensions/:name/:image', {name: pkg.name, image: pkg.extra.image});
} else {
return this.$url.static('app/system/assets/images/placeholder-icon.svg');
}
},
load: function () {
this.$set('status', 'loading');
this.queryUpdates(this.packages, function (data) {
this.$set('updates', data.packages.length ? _.indexBy(data.packages, 'name') : null);
this.$set('status', '');
}).error(function () {
this.$set('status', 'error');
});
},
details: function (pkg) {
this.$set('package', pkg);
this.$.details.open();
},
settings: function (pkg) {
if (!pkg.settings) {
return;
}
var view;
_.forIn(this.$options.components, function (component, name) {
if (component.options.settings && pkg.settings === name) {
view = name;
}
});
if (view) {
this.$set('package', pkg);
this.$set('view', view);
this.$.settings.open();
} else {
window.location = pkg.settings;
}
},
enable: function (pkg) {
this.enablePackage(pkg).success(function () {
UIkit.notify(this.$trans('"%title%" enabled.', {title: pkg.title}));
}).error(this.error);
},
disable: function (pkg) {
this.disablePackage(pkg).success(function () {
UIkit.notify(this.$trans('"%title%" disabled.', {title: pkg.title}));
}).error(this.error);
},
uninstall: function (pkg) {
this.uninstallPackage(pkg, this.packages).success(function () {
UIkit.notify(this.$trans('"%title%" uninstalled.', {title: pkg.title}));
}).error(this.error);
},
update: function (pkg) {
this.installPackage(pkg, this.packages).success(function () {
UIkit.notify(this.$trans('"%title%" updated.', {title: pkg.title}));
this.load();
}).error(this.error);
},
error: function (message) {
UIkit.notify(message, 'danger');
}
},
filters: {
empty: function (packages) {
return Vue.filter('filterBy')(packages, this.search, 'title').length === 0;
}
},
components: {
'package-details': require('../components/package-details.vue'),
'package-upload': require('../components/package-upload.vue')
}
});
window.Extensions = module.exports;
$(function () {
(new module.exports).$mount('#extensions');
});
|
'use strict'
Object.defineProperty(exports, '__esModule', { value: true })
function _interopDefault (ex) {
return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex
}
var he = _interopDefault(require('he'))
/* */
var emptyObject = Object.freeze({})
// these helpers produces better vm code in JS engines due to their
// explicitness and function inlining
function isUndef (v) {
return v === undefined || v === null
}
function isDef (v) {
return v !== undefined && v !== null
}
function isTrue (v) {
return v === true
}
function isFalse (v) {
return v === false
}
/**
* Check if value is primitive
*/
function isPrimitive (value) {
return (
typeof value === 'string' ||
typeof value === 'number' ||
typeof value === 'boolean'
)
}
/**
* Quick object check - this is primarily used to tell
* Objects from primitive values when we know the value
* is a JSON-compliant type.
*/
function isObject (obj) {
return obj !== null && typeof obj === 'object'
}
/**
* Get the raw type string of a value e.g. [object Object]
*/
var _toString = Object.prototype.toString
function toRawType (value) {
return _toString.call(value).slice(8, -1)
}
/**
* Strict object type check. Only returns true
* for plain JavaScript objects.
*/
function isPlainObject (obj) {
return _toString.call(obj) === '[object Object]'
}
/**
* Check if val is a valid array index.
*/
function isValidArrayIndex (val) {
var n = parseFloat(String(val))
return n >= 0 && Math.floor(n) === n && isFinite(val)
}
/**
* Convert a value to a string that is actually rendered.
*/
function toString (val) {
return val == null
? ''
: typeof val === 'object'
? JSON.stringify(val, null, 2)
: String(val)
}
/**
* Convert a input value to a number for persistence.
* If the conversion fails, return original string.
*/
function toNumber (val) {
var n = parseFloat(val)
return isNaN(n) ? val : n
}
/**
* Make a map and return a function for checking if a key
* is in that map.
*/
function makeMap (
str,
expectsLowerCase
) {
var map = Object.create(null)
var list = str.split(',')
for (var i = 0; i < list.length; i++) {
map[list[i]] = true
}
return expectsLowerCase
? function (val) {
return map[val.toLowerCase()]
}
: function (val) {
return map[val]
}
}
/**
* Check if a tag is a built-in tag.
*/
var isBuiltInTag = makeMap('slot,component', true)
/**
* Check if a attribute is a reserved attribute.
*/
var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
/**
* Remove an item from an array
*/
function remove (arr, item) {
if (arr.length) {
var index = arr.indexOf(item)
if (index > -1) {
return arr.splice(index, 1)
}
}
}
/**
* Check whether the object has the property.
*/
var hasOwnProperty = Object.prototype.hasOwnProperty
function hasOwn (obj, key) {
return hasOwnProperty.call(obj, key)
}
/**
* Create a cached version of a pure function.
*/
function cached (fn) {
var cache = Object.create(null)
return (function cachedFn (str) {
var hit = cache[str]
return hit || (cache[str] = fn(str))
})
}
/**
* Camelize a hyphen-delimited string.
*/
var camelizeRE = /-(\w)/g
var camelize = cached(function (str) {
return str.replace(camelizeRE, function (_, c) {
return c ? c.toUpperCase() : ''
})
})
/**
* Capitalize a string.
*/
var capitalize = cached(function (str) {
return str.charAt(0).toUpperCase() + str.slice(1)
})
/**
* Hyphenate a camelCase string.
*/
var hyphenateRE = /\B([A-Z])/g
var hyphenate = cached(function (str) {
return str.replace(hyphenateRE, '-$1').toLowerCase()
})
/**
* Simple bind, faster than native
*/
/**
* Convert an Array-like object to a real Array.
*/
/**
* Mix properties into target object.
*/
function extend (to, _from) {
for (var key in _from) {
to[key] = _from[key]
}
return to
}
/**
* Merge an Array of Objects into a single Object.
*/
function toObject (arr) {
var res = {}
for (var i = 0; i < arr.length; i++) {
if (arr[i]) {
extend(res, arr[i])
}
}
return res
}
/**
* Perform no operation.
* Stubbing args to make Flow happy without leaving useless transpiled code
* with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
*/
function noop (a, b, c) {}
/**
* Always return false.
*/
var no = function (a, b, c) {
return false
}
/**
* Return same value
*/
var identity = function (_) {
return _
}
/**
* Generate a static keys string from compiler modules.
*/
function genStaticKeys (modules) {
return modules.reduce(function (keys, m) {
return keys.concat(m.staticKeys || [])
}, []).join(',')
}
/**
* Check if two values are loosely equal - that is,
* if they are plain objects, do they have the same shape?
*/
function looseEqual (a, b) {
if (a === b) {
return true
}
var isObjectA = isObject(a)
var isObjectB = isObject(b)
if (isObjectA && isObjectB) {
try {
var isArrayA = Array.isArray(a)
var isArrayB = Array.isArray(b)
if (isArrayA && isArrayB) {
return a.length === b.length && a.every(function (e, i) {
return looseEqual(e, b[i])
})
} else if (!isArrayA && !isArrayB) {
var keysA = Object.keys(a)
var keysB = Object.keys(b)
return keysA.length === keysB.length && keysA.every(function (key) {
return 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) {
for (var i = 0; i < arr.length; i++) {
if (looseEqual(arr[i], val)) {
return i
}
}
return -1
}
/**
* Ensure a function is called only once.
*/
function once (fn) {
var called = false
return function () {
if (!called) {
called = true
fn.apply(this, arguments)
}
}
}
/* */
var isAttr = makeMap(
'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
'checked,cite,class,code,codebase,color,cols,colspan,content,http-equiv,' +
'name,contenteditable,contextmenu,controls,coords,data,datetime,default,' +
'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,method,for,' +
'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
'target,title,type,usemap,value,width,wrap'
)
/* istanbul ignore next */
var isRenderableAttr = function (name) {
return (
isAttr(name) ||
name.indexOf('data-') === 0 ||
name.indexOf('aria-') === 0
)
}
var propsToAttrMap = {
acceptCharset: 'accept-charset',
className: 'class',
htmlFor: 'for',
httpEquiv: 'http-equiv'
}
var ESC = {
'<': '<',
'>': '>',
'"': '"',
'&': '&'
}
function escape (s) {
return s.replace(/[<>"&]/g, escapeChar)
}
function escapeChar (a) {
return ESC[a] || a
}
/* */
// these are reserved for web because they are directly compiled away
// during template compilation
var isReservedAttr = makeMap('style,class')
// attributes that should be using props for binding
var acceptValue = makeMap('input,textarea,option,select,progress')
var mustUseProp = function (tag, type, attr) {
return (
(attr === 'value' && acceptValue(tag)) && type !== 'button' ||
(attr === 'selected' && tag === 'option') ||
(attr === 'checked' && tag === 'input') ||
(attr === 'muted' && tag === 'video')
)
}
var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
var isBooleanAttr = makeMap(
'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
'required,reversed,scoped,seamless,selected,sortable,translate,' +
'truespeed,typemustmatch,visible'
)
var isFalsyAttrValue = function (val) {
return val == null || val === false
}
/* */
function renderAttrs (node) {
var attrs = node.data.attrs
var res = ''
var opts = node.parent && node.parent.componentOptions
if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
var parent = node.parent
while (isDef(parent)) {
if (isDef(parent.data) && isDef(parent.data.attrs)) {
attrs = extend(extend({}, attrs), parent.data.attrs)
}
parent = parent.parent
}
}
if (isUndef(attrs)) {
return res
}
for (var key in attrs) {
if (key === 'style') {
// leave it to the style module
continue
}
res += renderAttr(key, attrs[key])
}
return res
}
function renderAttr (key, value) {
if (isBooleanAttr(key)) {
if (!isFalsyAttrValue(value)) {
return (" " + key + "=\"" + key + "\"")
}
} else if (isEnumeratedAttr(key)) {
return (" " + key + "=\"" + (isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true') + "\"")
} else if (!isFalsyAttrValue(value)) {
return (" " + key + "=\"" + (escape(String(value))) + "\"")
}
return ''
}
/* */
var VNode = function VNode (
tag,
data,
children,
text,
elm,
context,
componentOptions,
asyncFactory
) {
this.tag = tag
this.data = data
this.children = children
this.text = text
this.elm = elm
this.ns = undefined
this.context = context
this.fnContext = undefined
this.fnOptions = undefined
this.fnScopeId = undefined
this.key = data && data.key
this.componentOptions = componentOptions
this.componentInstance = undefined
this.parent = undefined
this.raw = false
this.isStatic = false
this.isRootInsert = true
this.isComment = false
this.isCloned = false
this.isOnce = false
this.asyncFactory = asyncFactory
this.asyncMeta = undefined
this.isAsyncPlaceholder = false
}
var prototypeAccessors = { child: { configurable: true } }
// DEPRECATED: alias for componentInstance for backwards compat.
/* istanbul ignore next */
prototypeAccessors.child.get = function () {
return this.componentInstance
}
Object.defineProperties( VNode.prototype, prototypeAccessors )
var createEmptyVNode = function (text) {
if ( text === void 0 )
text = ''
var node = new VNode()
node.text = text
node.isComment = true
return node
}
function createTextVNode (val) {
return new VNode(undefined, undefined, undefined, String(val))
}
// optimized shallow clone
// used for static nodes and slot nodes because they may be reused across
// multiple renders, cloning them avoids errors when DOM manipulations rely
// on their elm reference.
function cloneVNode (vnode, deep) {
var componentOptions = vnode.componentOptions
var cloned = new VNode(
vnode.tag,
vnode.data,
vnode.children,
vnode.text,
vnode.elm,
vnode.context,
componentOptions,
vnode.asyncFactory
)
cloned.ns = vnode.ns
cloned.isStatic = vnode.isStatic
cloned.key = vnode.key
cloned.isComment = vnode.isComment
cloned.fnContext = vnode.fnContext
cloned.fnOptions = vnode.fnOptions
cloned.fnScopeId = vnode.fnScopeId
cloned.isCloned = true
if (deep) {
if (vnode.children) {
cloned.children = cloneVNodes(vnode.children, true)
}
if (componentOptions && componentOptions.children) {
componentOptions.children = cloneVNodes(componentOptions.children, true)
}
}
return cloned
}
function cloneVNodes (vnodes, deep) {
var len = vnodes.length
var res = new Array(len)
for (var i = 0; i < len; i++) {
res[i] = cloneVNode(vnodes[i], deep)
}
return res
}
/* */
function renderDOMProps (node) {
var props = node.data.domProps
var res = ''
var parent = node.parent
while (isDef(parent)) {
if (parent.data && parent.data.domProps) {
props = extend(extend({}, props), parent.data.domProps)
}
parent = parent.parent
}
if (isUndef(props)) {
return res
}
var attrs = node.data.attrs
for (var key in props) {
if (key === 'innerHTML') {
setText(node, props[key], true)
} else if (key === 'textContent') {
setText(node, props[key], false)
} else if (key === 'value' && node.tag === 'textarea') {
setText(node, props[key], false)
} else {
// $flow-disable-line (WTF?)
var attr = propsToAttrMap[key] || key.toLowerCase()
if (isRenderableAttr(attr) &&
// avoid rendering double-bound props/attrs twice
!(isDef(attrs) && isDef(attrs[attr]))
) {
res += renderAttr(attr, props[key])
}
}
}
return res
}
function setText (node, text, raw) {
var child = new VNode(undefined, undefined, undefined, text)
child.raw = raw
node.children = [child]
}
/* */
/**
* Check if a string starts with $ or _
*/
/**
* Define a property.
*/
function def (obj, key, val, enumerable) {
Object.defineProperty(obj, key, {
value: val,
enumerable: !!enumerable,
writable: true,
configurable: true
})
}
/**
* Parse simple path.
*/
var bailRE = /[^\w.$]/
function parsePath (path) {
if (bailRE.test(path)) {
return
}
var segments = path.split('.')
return function (obj) {
for (var i = 0; i < segments.length; i++) {
if (!obj) {
return
}
obj = obj[segments[i]]
}
return obj
}
}
/* */
// can we use __proto__?
var hasProto = '__proto__' in {}
// Browser environment sniffing
var inBrowser = typeof window !== 'undefined'
var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
var UA = inBrowser && window.navigator.userAgent.toLowerCase()
var isIE = UA && /msie|trident/.test(UA)
var isIE9 = UA && UA.indexOf('msie 9.0') > 0
var isEdge = UA && UA.indexOf('edge/') > 0
var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android')
var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios')
var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
// Firefox has a "watch" function on Object.prototype...
var nativeWatch = ({}).watch
if (inBrowser) {
try {
var opts = {}
Object.defineProperty(opts, 'passive', ({
get: function get () {
/* istanbul ignore next */
}
})) // https://github.com/facebook/flow/issues/285
window.addEventListener('test-passive', null, opts)
} catch (e) {}
}
// this needs to be lazy-evaled because vue may be required before
// vue-server-renderer can set VUE_ENV
var _isServer
var isServerRendering = function () {
if (_isServer === undefined) {
/* istanbul ignore if */
if (!inBrowser && typeof global !== 'undefined') {
// detect presence of vue-server-renderer and avoid
// Webpack shimming the process
_isServer = global['process'].env.VUE_ENV === 'server'
} else {
_isServer = false
}
}
return _isServer
}
// detect devtools
var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__
/* istanbul ignore next */
function isNative (Ctor) {
return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
}
var hasSymbol =
typeof Symbol !== 'undefined' && isNative(Symbol) &&
typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys)
var _Set
/* istanbul ignore if */ // $flow-disable-line
if (typeof Set !== 'undefined' && isNative(Set)) {
// use native Set when available.
_Set = Set
} else {
// a non-standard Set polyfill that only works with primitive keys.
_Set = (function () {
function Set () {
this.set = Object.create(null)
}
Set.prototype.has = function has (key) {
return this.set[key] === true
}
Set.prototype.add = function add (key) {
this.set[key] = true
}
Set.prototype.clear = function clear () {
this.set = Object.create(null)
}
return Set
}())
}
var SSR_ATTR = 'data-server-rendered'
var ASSET_TYPES = [
'component',
'directive',
'filter'
]
var LIFECYCLE_HOOKS = [
'beforeCreate',
'created',
'beforeMount',
'mounted',
'beforeUpdate',
'updated',
'beforeDestroy',
'destroyed',
'activated',
'deactivated',
'errorCaptured'
]
/* */
var config = ({
/**
* Option merge strategies (used in core/util/options)
*/
optionMergeStrategies: Object.create(null),
/**
* Whether to suppress warnings.
*/
silent: false,
/**
* Show production mode tip message on boot?
*/
productionTip: process.env.NODE_ENV !== 'production',
/**
* Whether to enable devtools
*/
devtools: process.env.NODE_ENV !== 'production',
/**
* Whether to record perf
*/
performance: false,
/**
* Error handler for watcher errors
*/
errorHandler: null,
/**
* Warn handler for watcher warns
*/
warnHandler: null,
/**
* Ignore certain custom elements
*/
ignoredElements: [],
/**
* Custom user key aliases for v-on
*/
keyCodes: Object.create(null),
/**
* Check if a tag is reserved so that it cannot be registered as a
* component. This is platform-dependent and may be overwritten.
*/
isReservedTag: no,
/**
* Check if an attribute is reserved so that it cannot be used as a component
* prop. This is platform-dependent and may be overwritten.
*/
isReservedAttr: no,
/**
* Check if a tag is an unknown element.
* Platform-dependent.
*/
isUnknownElement: no,
/**
* Get the namespace of an element
*/
getTagNamespace: noop,
/**
* Parse the real tag name for the specific platform.
*/
parsePlatformTagName: identity,
/**
* Check if an attribute must be bound using property, e.g. value
* Platform-dependent.
*/
mustUseProp: no,
/**
* Exposed for legacy reasons
*/
_lifecycleHooks: LIFECYCLE_HOOKS
})
/* */
var warn = noop
var tip = noop
var generateComponentTrace = (noop) // work around flow check
var formatComponentName = (noop)
if (process.env.NODE_ENV !== 'production') {
var hasConsole = typeof console !== 'undefined'
var classifyRE = /(?:^|[-_])(\w)/g
var classify = function (str) {
return str
.replace(classifyRE, function (c) {
return c.toUpperCase()
})
.replace(/[-_]/g, '')
}
warn = function (msg, vm) {
var trace = vm ? generateComponentTrace(vm) : ''
if (config.warnHandler) {
config.warnHandler.call(null, msg, vm, trace)
} else if (hasConsole && (!config.silent)) {
console.error(("[Vue warn]: " + msg + trace))
}
}
tip = function (msg, vm) {
if (hasConsole && (!config.silent)) {
console.warn("[Vue tip]: " + msg + (
vm ? generateComponentTrace(vm) : ''
))
}
}
formatComponentName = function (vm, includeFile) {
if (vm.$root === vm) {
return '<Root>'
}
var options = typeof vm === 'function' && vm.cid != null
? vm.options
: vm._isVue
? vm.$options || vm.constructor.options
: vm || {}
var name = options.name || options._componentTag
var file = options.__file
if (!name && file) {
var match = file.match(/([^/\\]+)\.vue$/)
name = match && match[1]
}
return (
(name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
(file && includeFile !== false ? (" at " + file) : '')
)
}
var repeat = function (str, n) {
var res = ''
while (n) {
if (n % 2 === 1) {
res += str
}
if (n > 1) {
str += str
}
n >>= 1
}
return res
}
generateComponentTrace = function (vm) {
if (vm._isVue && vm.$parent) {
var tree = []
var currentRecursiveSequence = 0
while (vm) {
if (tree.length > 0) {
var last = tree[tree.length - 1]
if (last.constructor === vm.constructor) {
currentRecursiveSequence++
vm = vm.$parent
continue
} else if (currentRecursiveSequence > 0) {
tree[tree.length - 1] = [last, currentRecursiveSequence]
currentRecursiveSequence = 0
}
}
tree.push(vm)
vm = vm.$parent
}
return '\n\nfound in\n\n' + tree
.map(function (vm, i) {
return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
: formatComponentName(vm)))
})
.join('\n')
} else {
return ("\n\n(found in " + (formatComponentName(vm)) + ")")
}
}
}
/* */
var uid = 0
/**
* A dep is an observable that can have multiple
* directives subscribing to it.
*/
var Dep = function Dep () {
this.id = uid++
this.subs = []
}
Dep.prototype.addSub = function addSub (sub) {
this.subs.push(sub)
}
Dep.prototype.removeSub = function removeSub (sub) {
remove(this.subs, sub)
}
Dep.prototype.depend = function depend () {
if (Dep.target) {
Dep.target.addDep(this)
}
}
Dep.prototype.notify = function notify () {
// stabilize the subscriber list first
var subs = this.subs.slice()
for (var i = 0, l = subs.length; i < l; i++) {
subs[i].update()
}
}
// the current target watcher being evaluated.
// this is globally unique because there could be only one
// watcher being evaluated at any time.
Dep.target = null
var targetStack = []
function pushTarget (_target) {
if (Dep.target) {
targetStack.push(Dep.target)
}
Dep.target = _target
}
function popTarget () {
Dep.target = targetStack.pop()
}
/*
* not type checking this file because flow doesn't play well with
* dynamically accessing methods on Array prototype
*/
var arrayProto = Array.prototype
var arrayMethods = Object.create(arrayProto);[
'push',
'pop',
'shift',
'unshift',
'splice',
'sort',
'reverse'
]
.forEach(function (method) {
// cache original method
var original = arrayProto[method]
def(arrayMethods, method, function mutator () {
var args = [], len = arguments.length
while ( len-- )
args[ len ] = arguments[ len ]
var result = original.apply(this, args)
var ob = this.__ob__
var inserted
switch (method) {
case 'push':
case 'unshift':
inserted = args
break
case 'splice':
inserted = args.slice(2)
break
}
if (inserted) {
ob.observeArray(inserted)
}
// notify change
ob.dep.notify()
return result
})
})
/* */
var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
/**
* By default, when a reactive property is set, the new value is
* also converted to become reactive. However when passing down props,
* we don't want to force conversion because the value may be a nested value
* under a frozen data structure. Converting it would defeat the optimization.
*/
var observerState = {
shouldConvert: true
}
/**
* Observer class that are attached to each observed
* object. Once attached, the observer converts target
* object's property keys into getter/setters that
* collect dependencies and dispatches updates.
*/
var Observer = function Observer (value) {
this.value = value
this.dep = new Dep()
this.vmCount = 0
def(value, '__ob__', this)
if (Array.isArray(value)) {
var augment = hasProto
? protoAugment
: copyAugment
augment(value, arrayMethods, arrayKeys)
this.observeArray(value)
} else {
this.walk(value)
}
}
/**
* Walk through each property and convert them into
* getter/setters. This method should only be called when
* value type is Object.
*/
Observer.prototype.walk = function walk (obj) {
var keys = Object.keys(obj)
for (var i = 0; i < keys.length; i++) {
defineReactive(obj, keys[i], obj[keys[i]])
}
}
/**
* Observe a list of Array items.
*/
Observer.prototype.observeArray = function observeArray (items) {
for (var i = 0, l = items.length; i < l; i++) {
observe(items[i])
}
}
// helpers
/**
* Augment an target Object or Array by intercepting
* the prototype chain using __proto__
*/
function protoAugment (target, src, keys) {
/* eslint-disable no-proto */
target.__proto__ = src
/* eslint-enable no-proto */
}
/**
* Augment an target Object or Array by defining
* hidden properties.
*/
/* istanbul ignore next */
function copyAugment (target, src, keys) {
for (var i = 0, l = keys.length; i < l; i++) {
var key = keys[i]
def(target, key, src[key])
}
}
/**
* Attempt to create an observer instance for a value,
* returns the new observer if successfully observed,
* or the existing observer if the value already has one.
*/
function observe (value, asRootData) {
if (!isObject(value) || value instanceof VNode) {
return
}
var ob
if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
ob = value.__ob__
} else if (
observerState.shouldConvert &&
!isServerRendering() &&
(Array.isArray(value) || isPlainObject(value)) &&
Object.isExtensible(value) &&
!value._isVue
) {
ob = new Observer(value)
}
if (asRootData && ob) {
ob.vmCount++
}
return ob
}
/**
* Define a reactive property on an Object.
*/
function defineReactive (
obj,
key,
val,
customSetter,
shallow
) {
var dep = new Dep()
var property = Object.getOwnPropertyDescriptor(obj, key)
if (property && property.configurable === false) {
return
}
// cater for pre-defined getter/setters
var getter = property && property.get
var setter = property && property.set
var childOb = !shallow && observe(val)
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
get: function reactiveGetter () {
var value = getter ? getter.call(obj) : val
if (Dep.target) {
dep.depend()
if (childOb) {
childOb.dep.depend()
if (Array.isArray(value)) {
dependArray(value)
}
}
}
return value
},
set: function reactiveSetter (newVal) {
var value = getter ? getter.call(obj) : val
/* eslint-disable no-self-compare */
if (newVal === value || (newVal !== newVal && value !== value)) {
return
}
/* eslint-enable no-self-compare */
if (process.env.NODE_ENV !== 'production' && customSetter) {
customSetter()
}
if (setter) {
setter.call(obj, newVal)
} else {
val = newVal
}
childOb = !shallow && observe(newVal)
dep.notify()
}
})
}
/**
* Set a property on an object. Adds the new property and
* triggers change notification if the property doesn't
* already exist.
*/
function set (target, key, val) {
if (Array.isArray(target) && isValidArrayIndex(key)) {
target.length = Math.max(target.length, key)
target.splice(key, 1, val)
return val
}
if (key in target && !(key in Object.prototype)) {
target[key] = val
return val
}
var ob = (target).__ob__
if (target._isVue || (ob && ob.vmCount)) {
process.env.NODE_ENV !== 'production' && warn(
'Avoid adding reactive properties to a Vue instance or its root $data ' +
'at runtime - declare it upfront in the data option.'
)
return val
}
if (!ob) {
target[key] = val
return val
}
defineReactive(ob.value, key, val)
ob.dep.notify()
return val
}
/**
* Delete a property and trigger change if necessary.
*/
/**
* Collect dependencies on array elements when the array is touched, since
* we cannot intercept array element access like property getters.
*/
function dependArray (value) {
for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
e = value[i]
e && e.__ob__ && e.__ob__.dep.depend()
if (Array.isArray(e)) {
dependArray(e)
}
}
}
/* */
/**
* Option overwriting strategies are functions that handle
* how to merge a parent option value and a child option
* value into the final value.
*/
var strats = config.optionMergeStrategies
/**
* Options with restrictions
*/
if (process.env.NODE_ENV !== 'production') {
strats.el = strats.propsData = function (parent, child, vm, key) {
if (!vm) {
warn(
"option \"" + key + "\" can only be used during instance " +
'creation with the `new` keyword.'
)
}
return defaultStrat(parent, child)
}
}
/**
* Helper that recursively merges two data objects together.
*/
function mergeData (to, from) {
if (!from) {
return to
}
var key, toVal, fromVal
var keys = Object.keys(from)
for (var i = 0; i < keys.length; i++) {
key = keys[i]
toVal = to[key]
fromVal = from[key]
if (!hasOwn(to, key)) {
set(to, key, fromVal)
} else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
mergeData(toVal, fromVal)
}
}
return to
}
/**
* Data
*/
function mergeDataOrFn (
parentVal,
childVal,
vm
) {
if (!vm) {
// in a Vue.extend merge, both should be functions
if (!childVal) {
return parentVal
}
if (!parentVal) {
return childVal
}
// when parentVal & childVal are both present,
// we need to return a function that returns the
// merged result of both functions... no need to
// check if parentVal is a function here because
// it has to be a function to pass previous merges.
return function mergedDataFn () {
return mergeData(
typeof childVal === 'function' ? childVal.call(this) : childVal,
typeof parentVal === 'function' ? parentVal.call(this) : parentVal
)
}
} else {
return function mergedInstanceDataFn () {
// instance merge
var instanceData = typeof childVal === 'function'
? childVal.call(vm)
: childVal
var defaultData = typeof parentVal === 'function'
? parentVal.call(vm)
: parentVal
if (instanceData) {
return mergeData(instanceData, defaultData)
} else {
return defaultData
}
}
}
}
strats.data = function (
parentVal,
childVal,
vm
) {
if (!vm) {
if (childVal && typeof childVal !== 'function') {
process.env.NODE_ENV !== 'production' && warn(
'The "data" option should be a function ' +
'that returns a per-instance value in component ' +
'definitions.',
vm
)
return parentVal
}
return mergeDataOrFn(parentVal, childVal)
}
return mergeDataOrFn(parentVal, childVal, vm)
}
/**
* Hooks and props are merged as arrays.
*/
function mergeHook (
parentVal,
childVal
) {
return childVal
? parentVal
? parentVal.concat(childVal)
: Array.isArray(childVal)
? childVal
: [childVal]
: parentVal
}
LIFECYCLE_HOOKS.forEach(function (hook) {
strats[hook] = mergeHook
})
/**
* Assets
*
* When a vm is present (instance creation), we need to do
* a three-way merge between constructor options, instance
* options and parent options.
*/
function mergeAssets (
parentVal,
childVal,
vm,
key
) {
var res = Object.create(parentVal || null)
if (childVal) {
process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm)
return extend(res, childVal)
} else {
return res
}
}
ASSET_TYPES.forEach(function (type) {
strats[type + 's'] = mergeAssets
})
/**
* Watchers.
*
* Watchers hashes should not overwrite one
* another, so we merge them as arrays.
*/
strats.watch = function (
parentVal,
childVal,
vm,
key
) {
// work around Firefox's Object.prototype.watch...
if (parentVal === nativeWatch) {
parentVal = undefined
}
if (childVal === nativeWatch) {
childVal = undefined
}
/* istanbul ignore if */
if (!childVal) {
return Object.create(parentVal || null)
}
if (process.env.NODE_ENV !== 'production') {
assertObjectType(key, childVal, vm)
}
if (!parentVal) {
return childVal
}
var ret = {}
extend(ret, parentVal)
for (var key$1 in childVal) {
var parent = ret[key$1]
var child = childVal[key$1]
if (parent && !Array.isArray(parent)) {
parent = [parent]
}
ret[key$1] = parent
? parent.concat(child)
: Array.isArray(child) ? child : [child]
}
return ret
}
/**
* Other object hashes.
*/
strats.props =
strats.methods =
strats.inject =
strats.computed = function (
parentVal,
childVal,
vm,
key
) {
if (childVal && process.env.NODE_ENV !== 'production') {
assertObjectType(key, childVal, vm)
}
if (!parentVal) {
return childVal
}
var ret = Object.create(null)
extend(ret, parentVal)
if (childVal) {
extend(ret, childVal)
}
return ret
}
strats.provide = mergeDataOrFn
/**
* Default strategy.
*/
var defaultStrat = function (parentVal, childVal) {
return childVal === undefined
? parentVal
: childVal
}
/**
* Validate component names
*/
function checkComponents (options) {
for (var key in options.components) {
var lower = key.toLowerCase()
if (isBuiltInTag(lower) || config.isReservedTag(lower)) {
warn(
'Do not use built-in or reserved HTML elements as component ' +
'id: ' + key
)
}
}
}
/**
* Ensure all props option syntax are normalized into the
* Object-based format.
*/
function normalizeProps (options, vm) {
var props = options.props
if (!props) {
return
}
var res = {}
var i, val, name
if (Array.isArray(props)) {
i = props.length
while (i--) {
val = props[i]
if (typeof val === 'string') {
name = camelize(val)
res[name] = { type: null }
} else if (process.env.NODE_ENV !== 'production') {
warn('props must be strings when using array syntax.')
}
}
} else if (isPlainObject(props)) {
for (var key in props) {
val = props[key]
name = camelize(key)
res[name] = isPlainObject(val)
? val
: { type: val }
}
} else if (process.env.NODE_ENV !== 'production') {
warn(
"Invalid value for option \"props\": expected an Array or an Object, " +
"but got " + (toRawType(props)) + ".",
vm
)
}
options.props = res
}
/**
* Normalize all injections into Object-based format
*/
function normalizeInject (options, vm) {
var inject = options.inject
var normalized = options.inject = {}
if (Array.isArray(inject)) {
for (var i = 0; i < inject.length; i++) {
normalized[inject[i]] = { from: inject[i] }
}
} else if (isPlainObject(inject)) {
for (var key in inject) {
var val = inject[key]
normalized[key] = isPlainObject(val)
? extend({ from: key }, val)
: { from: val }
}
} else if (process.env.NODE_ENV !== 'production' && inject) {
warn(
"Invalid value for option \"inject\": expected an Array or an Object, " +
"but got " + (toRawType(inject)) + ".",
vm
)
}
}
/**
* Normalize raw function directives into object format.
*/
function normalizeDirectives (options) {
var dirs = options.directives
if (dirs) {
for (var key in dirs) {
var def = dirs[key]
if (typeof def === 'function') {
dirs[key] = { bind: def, update: def }
}
}
}
}
function assertObjectType (name, value, vm) {
if (!isPlainObject(value)) {
warn(
"Invalid value for option \"" + name + "\": expected an Object, " +
"but got " + (toRawType(value)) + ".",
vm
)
}
}
/**
* Merge two option objects into a new one.
* Core utility used in both instantiation and inheritance.
*/
function mergeOptions (
parent,
child,
vm
) {
if (process.env.NODE_ENV !== 'production') {
checkComponents(child)
}
if (typeof child === 'function') {
child = child.options
}
normalizeProps(child, vm)
normalizeInject(child, vm)
normalizeDirectives(child)
var extendsFrom = child.extends
if (extendsFrom) {
parent = mergeOptions(parent, extendsFrom, vm)
}
if (child.mixins) {
for (var i = 0, l = child.mixins.length; i < l; i++) {
parent = mergeOptions(parent, child.mixins[i], vm)
}
}
var options = {}
var key
for (key in parent) {
mergeField(key)
}
for (key in child) {
if (!hasOwn(parent, key)) {
mergeField(key)
}
}
function mergeField (key) {
var strat = strats[key] || defaultStrat
options[key] = strat(parent[key], child[key], vm, key)
}
return options
}
/**
* Resolve an asset.
* This function is used because child instances need access
* to assets defined in its ancestor chain.
*/
function resolveAsset (
options,
type,
id,
warnMissing
) {
/* istanbul ignore if */
if (typeof id !== 'string') {
return
}
var assets = options[type]
// check local registration variations first
if (hasOwn(assets, id)) {
return assets[id]
}
var camelizedId = camelize(id)
if (hasOwn(assets, camelizedId)) {
return assets[camelizedId]
}
var PascalCaseId = capitalize(camelizedId)
if (hasOwn(assets, PascalCaseId)) {
return assets[PascalCaseId]
}
// fallback to prototype chain
var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
warn(
'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
options
)
}
return res
}
/* */
function validateProp (
key,
propOptions,
propsData,
vm
) {
var prop = propOptions[key]
var absent = !hasOwn(propsData, key)
var value = propsData[key]
// handle boolean props
if (isType(Boolean, prop.type)) {
if (absent && !hasOwn(prop, 'default')) {
value = false
} else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
value = true
}
}
// check default value
if (value === undefined) {
value = getPropDefaultValue(vm, prop, key)
// since the default value is a fresh copy,
// make sure to observe it.
var prevShouldConvert = observerState.shouldConvert
observerState.shouldConvert = true
observe(value)
observerState.shouldConvert = prevShouldConvert
}
if (process.env.NODE_ENV !== 'production') {
assertProp(prop, key, value, vm, absent)
}
return value
}
/**
* Get the default value of a prop.
*/
function getPropDefaultValue (vm, prop, key) {
// no default, return undefined
if (!hasOwn(prop, 'default')) {
return undefined
}
var def = prop.default
// warn against non-factory defaults for Object & Array
if (process.env.NODE_ENV !== 'production' && isObject(def)) {
warn(
'Invalid default value for prop "' + key + '": ' +
'Props with type Object/Array must use a factory function ' +
'to return the default value.',
vm
)
}
// the raw prop value was also undefined from previous render,
// return previous default value to avoid unnecessary watcher trigger
if (vm && vm.$options.propsData &&
vm.$options.propsData[key] === undefined &&
vm._props[key] !== undefined
) {
return vm._props[key]
}
// call factory function for non-Function types
// a value is Function if its prototype is function even across different execution context
return typeof def === 'function' && getType(prop.type) !== 'Function'
? def.call(vm)
: def
}
/**
* Assert whether a prop is valid.
*/
function assertProp (
prop,
name,
value,
vm,
absent
) {
if (prop.required && absent) {
warn(
'Missing required prop: "' + name + '"',
vm
)
return
}
if (value == null && !prop.required) {
return
}
var type = prop.type
var valid = !type || type === true
var expectedTypes = []
if (type) {
if (!Array.isArray(type)) {
type = [type]
}
for (var i = 0; i < type.length && !valid; i++) {
var assertedType = assertType(value, type[i])
expectedTypes.push(assertedType.expectedType || '')
valid = assertedType.valid
}
}
if (!valid) {
warn(
"Invalid prop: type check failed for prop \"" + name + "\"." +
" Expected " + (expectedTypes.map(capitalize).join(', ')) +
", got " + (toRawType(value)) + ".",
vm
)
return
}
var validator = prop.validator
if (validator) {
if (!validator(value)) {
warn(
'Invalid prop: custom validator check failed for prop "' + name + '".',
vm
)
}
}
}
var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/
function assertType (value, type) {
var valid
var expectedType = getType(type)
if (simpleCheckRE.test(expectedType)) {
var t = typeof value
valid = t === expectedType.toLowerCase()
// for primitive wrapper objects
if (!valid && t === 'object') {
valid = value instanceof type
}
} else if (expectedType === 'Object') {
valid = isPlainObject(value)
} else if (expectedType === 'Array') {
valid = Array.isArray(value)
} else {
valid = value instanceof type
}
return {
valid: valid,
expectedType: expectedType
}
}
/**
* Use function string name to check built-in types,
* because a simple equality check will fail when running
* across different vms / iframes.
*/
function getType (fn) {
var match = fn && fn.toString().match(/^\s*function (\w+)/)
return match ? match[1] : ''
}
function isType (type, fn) {
if (!Array.isArray(fn)) {
return getType(fn) === getType(type)
}
for (var i = 0, len = fn.length; i < len; i++) {
if (getType(fn[i]) === getType(type)) {
return true
}
}
/* istanbul ignore next */
return false
}
/* */
function handleError (err, vm, info) {
if (vm) {
var cur = vm
while ((cur = cur.$parent)) {
var hooks = cur.$options.errorCaptured
if (hooks) {
for (var i = 0; i < hooks.length; i++) {
try {
var capture = hooks[i].call(cur, err, vm, info) === false
if (capture) {
return
}
} catch (e) {
globalHandleError(e, cur, 'errorCaptured hook')
}
}
}
}
}
globalHandleError(err, vm, info)
}
function globalHandleError (err, vm, info) {
if (config.errorHandler) {
try {
return config.errorHandler.call(null, err, vm, info)
} catch (e) {
logError(e, null, 'config.errorHandler')
}
}
logError(err, vm, info)
}
function logError (err, vm, info) {
if (process.env.NODE_ENV !== 'production') {
warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm)
}
/* istanbul ignore else */
if ((inBrowser || inWeex) && typeof console !== 'undefined') {
console.error(err)
} else {
throw err
}
}
/* */
/* globals MessageChannel */
var callbacks = []
var pending = false
function flushCallbacks () {
pending = false
var copies = callbacks.slice(0)
callbacks.length = 0
for (var i = 0; i < copies.length; i++) {
copies[i]()
}
}
// Here we have async deferring wrappers using both micro and macro tasks.
// In < 2.4 we used micro tasks everywhere, but there are some scenarios where
// micro tasks have too high a priority and fires in between supposedly
// sequential events (e.g. #4521, #6690) or even between bubbling of the same
// event (#6566). However, using macro tasks everywhere also has subtle problems
// when state is changed right before repaint (e.g. #6813, out-in transitions).
// Here we use micro task by default, but expose a way to force macro task when
// needed (e.g. in event handlers attached by v-on).
var microTimerFunc
var macroTimerFunc
var useMacroTask = false
// Determine (macro) Task defer implementation.
// Technically setImmediate should be the ideal choice, but it's only available
// in IE. The only polyfill that consistently queues the callback after all DOM
// events triggered in the same loop is by using MessageChannel.
/* istanbul ignore if */
if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
macroTimerFunc = function () {
setImmediate(flushCallbacks)
}
} else if (typeof MessageChannel !== 'undefined' && (
isNative(MessageChannel) ||
// PhantomJS
MessageChannel.toString() === '[object MessageChannelConstructor]'
)) {
var channel = new MessageChannel()
var port = channel.port2
channel.port1.onmessage = flushCallbacks
macroTimerFunc = function () {
port.postMessage(1)
}
} else {
/* istanbul ignore next */
macroTimerFunc = function () {
setTimeout(flushCallbacks, 0)
}
}
// Determine MicroTask defer implementation.
/* istanbul ignore next, $flow-disable-line */
if (typeof Promise !== 'undefined' && isNative(Promise)) {
var p = Promise.resolve()
microTimerFunc = function () {
p.then(flushCallbacks)
// in problematic UIWebViews, Promise.then doesn't completely break, but
// it can get stuck in a weird state where callbacks are pushed into the
// microtask queue but the queue isn't being flushed, until the browser
// needs to do some other work, e.g. handle a timer. Therefore we can
// "force" the microtask queue to be flushed by adding an empty timer.
if (isIOS) {
setTimeout(noop)
}
}
} else {
// fallback to macro
microTimerFunc = macroTimerFunc
}
/**
* Wrap a function so that if any code inside triggers state change,
* the changes are queued using a Task instead of a MicroTask.
*/
function nextTick (cb, ctx) {
var _resolve
callbacks.push(function () {
if (cb) {
try {
cb.call(ctx)
} catch (e) {
handleError(e, ctx, 'nextTick')
}
} else if (_resolve) {
_resolve(ctx)
}
})
if (!pending) {
pending = true
if (useMacroTask) {
macroTimerFunc()
} else {
microTimerFunc()
}
}
// $flow-disable-line
if (!cb && typeof Promise !== 'undefined') {
return new Promise(function (resolve) {
_resolve = resolve
})
}
}
/* */
/* */
function genClassForVnode (vnode) {
var data = vnode.data
var parentNode = vnode
var childNode = vnode
while (isDef(childNode.componentInstance)) {
childNode = childNode.componentInstance._vnode
if (childNode.data) {
data = mergeClassData(childNode.data, data)
}
}
while (isDef(parentNode = parentNode.parent)) {
if (parentNode.data) {
data = mergeClassData(data, parentNode.data)
}
}
return renderClass$1(data.staticClass, data.class)
}
function mergeClassData (child, parent) {
return {
staticClass: concat(child.staticClass, parent.staticClass),
class: isDef(child.class)
? [child.class, parent.class]
: parent.class
}
}
function renderClass$1 (
staticClass,
dynamicClass
) {
if (isDef(staticClass) || isDef(dynamicClass)) {
return concat(staticClass, stringifyClass(dynamicClass))
}
/* istanbul ignore next */
return ''
}
function concat (a, b) {
return a ? b ? (a + ' ' + b) : a : (b || '')
}
function stringifyClass (value) {
if (Array.isArray(value)) {
return stringifyArray(value)
}
if (isObject(value)) {
return stringifyObject(value)
}
if (typeof value === 'string') {
return value
}
/* istanbul ignore next */
return ''
}
function stringifyArray (value) {
var res = ''
var stringified
for (var i = 0, l = value.length; i < l; i++) {
if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
if (res) {
res += ' '
}
res += stringified
}
}
return res
}
function stringifyObject (value) {
var res = ''
for (var key in value) {
if (value[key]) {
if (res) {
res += ' '
}
res += key
}
}
return res
}
/* */
var isHTMLTag = makeMap(
'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'
)
// this map is intentionally selective, only covering SVG elements that may
// contain child elements.
var isSVG = makeMap(
'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
true
)
var isPreTag = function (tag) {
return tag === 'pre'
}
var isReservedTag = function (tag) {
return isHTMLTag(tag) || isSVG(tag)
}
function getTagNamespace (tag) {
if (isSVG(tag)) {
return 'svg'
}
// basic support for MathML
// note it doesn't support other MathML elements being component roots
if (tag === 'math') {
return 'math'
}
}
var isTextInputType = makeMap('text,number,password,search,email,tel,url')
/* */
/**
* Query an element selector if it's not an element already.
*/
/* */
function renderClass (node) {
var classList = genClassForVnode(node)
if (classList !== '') {
return (" class=\"" + (escape(classList)) + "\"")
}
}
/* */
var parseStyleText = cached(function (cssText) {
var res = {}
var listDelimiter = /;(?![^(]*\))/g
var propertyDelimiter = /:(.+)/
cssText.split(listDelimiter).forEach(function (item) {
if (item) {
var tmp = item.split(propertyDelimiter)
tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim())
}
})
return res
})
// merge static and dynamic style data on the same vnode
function normalizeStyleData (data) {
var style = normalizeStyleBinding(data.style)
// static style is pre-processed into an object during compilation
// and is always a fresh object, so it's safe to merge into it
return data.staticStyle
? extend(data.staticStyle, style)
: style
}
// normalize possible array / string values into Object
function normalizeStyleBinding (bindingStyle) {
if (Array.isArray(bindingStyle)) {
return toObject(bindingStyle)
}
if (typeof bindingStyle === 'string') {
return parseStyleText(bindingStyle)
}
return bindingStyle
}
/**
* parent component style should be after child's
* so that parent component's style could override it
*/
function getStyle (vnode, checkChild) {
var res = {}
var styleData
if (checkChild) {
var childNode = vnode
while (childNode.componentInstance) {
childNode = childNode.componentInstance._vnode
if (childNode.data && (styleData = normalizeStyleData(childNode.data))) {
extend(res, styleData)
}
}
}
if ((styleData = normalizeStyleData(vnode.data))) {
extend(res, styleData)
}
var parentNode = vnode
while ((parentNode = parentNode.parent)) {
if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
extend(res, styleData)
}
}
return res
}
/* */
function genStyle (style) {
var styleText = ''
for (var key in style) {
var value = style[key]
var hyphenatedKey = hyphenate(key)
if (Array.isArray(value)) {
for (var i = 0, len = value.length; i < len; i++) {
styleText += hyphenatedKey + ":" + (value[i]) + ";"
}
} else {
styleText += hyphenatedKey + ":" + value + ";"
}
}
return styleText
}
function renderStyle (vnode) {
var styleText = genStyle(getStyle(vnode, false))
if (styleText !== '') {
return (" style=" + (JSON.stringify(escape(styleText))))
}
}
var modules = [
renderAttrs,
renderDOMProps,
renderClass,
renderStyle
]
/* */
function show (node, dir) {
if (!dir.value) {
var style = node.data.style || (node.data.style = {})
style.display = 'none'
}
}
/* */
// this is only applied for <select v-model> because it is the only edge case
// that must be done at runtime instead of compile time.
function model (node, dir) {
if (!node.children) {
return
}
var value = dir.value
var isMultiple = node.data.attrs && node.data.attrs.multiple
for (var i = 0, l = node.children.length; i < l; i++) {
var option = node.children[i]
if (option.tag === 'option') {
if (isMultiple) {
var selected =
Array.isArray(value) &&
(looseIndexOf(value, getValue(option)) > -1)
if (selected) {
setSelected(option)
}
} else {
if (looseEqual(value, getValue(option))) {
setSelected(option)
return
}
}
}
}
}
function getValue (option) {
var data = option.data || {}
return (
(data.attrs && data.attrs.value) ||
(data.domProps && data.domProps.value) ||
(option.children && option.children[0] && option.children[0].text)
)
}
function setSelected (option) {
var data = option.data || (option.data = {})
var attrs = data.attrs || (data.attrs = {})
attrs.selected = ''
}
var baseDirectives = {
show: show,
model: model
}
/* */
var isUnaryTag = makeMap(
'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
'link,meta,param,source,track,wbr'
)
// Elements that you can, intentionally, leave open
// (and which close themselves)
var canBeLeftOpenTag = makeMap(
'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
)
// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
var isNonPhrasingTag = makeMap(
'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
'title,tr,track'
)
/* */
var MAX_STACK_DEPTH = 1000
var noop$1 = function (_) {
return _
}
var defer = typeof process !== 'undefined' && process.nextTick
? process.nextTick
: typeof Promise !== 'undefined'
? function (fn) {
return Promise.resolve().then(fn)
}
: typeof setTimeout !== 'undefined'
? setTimeout
: noop$1
if (defer === noop$1) {
throw new Error(
'Your JavaScript runtime does not support any asynchronous primitives ' +
'that are required by vue-server-renderer. Please use a polyfill for ' +
'either Promise or setTimeout.'
)
}
function createWriteFunction (
write,
onError
) {
var stackDepth = 0
var cachedWrite = function (text, next) {
if (text && cachedWrite.caching) {
cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text
}
var waitForNext = write(text, next)
if (waitForNext !== true) {
if (stackDepth >= MAX_STACK_DEPTH) {
defer(function () {
try {
next()
} catch (e) {
onError(e)
}
})
} else {
stackDepth++
next()
stackDepth--
}
}
}
cachedWrite.caching = false
cachedWrite.cacheBuffer = []
cachedWrite.componentBuffer = []
return cachedWrite
}
/* */
/**
* Original RenderStream implementation by Sasha Aickin (@aickin)
* Licensed under the Apache License, Version 2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Modified by Evan You (@yyx990803)
*/
var stream = require('stream')
var RenderStream = (function (superclass) {
function RenderStream (render) {
var this$1 = this
superclass.call(this)
this.buffer = ''
this.render = render
this.expectedSize = 0
this.write = createWriteFunction(function (text, next) {
var n = this$1.expectedSize
this$1.buffer += text
if (this$1.buffer.length >= n) {
this$1.next = next
this$1.pushBySize(n)
return true // we will decide when to call next
}
return false
}, function (err) {
this$1.emit('error', err)
})
this.end = function () {
// the rendering is finished; we should push out the last of the buffer.
this$1.done = true
this$1.push(this$1.buffer)
}
}
if ( superclass )
RenderStream.__proto__ = superclass
RenderStream.prototype = Object.create( superclass && superclass.prototype )
RenderStream.prototype.constructor = RenderStream
RenderStream.prototype.pushBySize = function pushBySize (n) {
var bufferToPush = this.buffer.substring(0, n)
this.buffer = this.buffer.substring(n)
this.push(bufferToPush)
}
RenderStream.prototype.tryRender = function tryRender () {
try {
this.render(this.write, this.end)
} catch (e) {
this.emit('error', e)
}
}
RenderStream.prototype.tryNext = function tryNext () {
try {
this.next()
} catch (e) {
this.emit('error', e)
}
}
RenderStream.prototype._read = function _read (n) {
this.expectedSize = n
// it's possible that the last chunk added bumped the buffer up to > 2 * n,
// which means we will need to go through multiple read calls to drain it
// down to < n.
if (isTrue(this.done)) {
this.push(null)
return
}
if (this.buffer.length >= n) {
this.pushBySize(n)
return
}
if (isUndef(this.next)) {
// start the rendering chain.
this.tryRender()
} else {
// continue with the rendering.
this.tryNext()
}
}
return RenderStream
}(stream.Readable))
/* */
var validDivisionCharRE = /[\w).+\-_$\]]/
function parseFilters (exp) {
var inSingle = false
var inDouble = false
var inTemplateString = false
var inRegex = false
var curly = 0
var square = 0
var paren = 0
var lastFilterIndex = 0
var c, prev, i, expression, filters
for (i = 0; i < exp.length; i++) {
prev = c
c = exp.charCodeAt(i)
if (inSingle) {
if (c === 0x27 && prev !== 0x5C) {
inSingle = false
}
} else if (inDouble) {
if (c === 0x22 && prev !== 0x5C) {
inDouble = false
}
} else if (inTemplateString) {
if (c === 0x60 && prev !== 0x5C) {
inTemplateString = false
}
} else if (inRegex) {
if (c === 0x2f && prev !== 0x5C) {
inRegex = false
}
} else if (
c === 0x7C && // pipe
exp.charCodeAt(i + 1) !== 0x7C &&
exp.charCodeAt(i - 1) !== 0x7C &&
!curly && !square && !paren
) {
if (expression === undefined) {
// first filter, end of expression
lastFilterIndex = i + 1
expression = exp.slice(0, i).trim()
} else {
pushFilter()
}
} else {
switch (c) {
case 0x22: inDouble = true; break // "
case 0x27: inSingle = true; break // '
case 0x60: inTemplateString = true; break // `
case 0x28: paren++; break // (
case 0x29: paren--; break // )
case 0x5B: square++; break // [
case 0x5D: square--; break // ]
case 0x7B: curly++; break // {
case 0x7D: curly--; break // }
}
if (c === 0x2f) { // /
var j = i - 1
var p = (void 0)
// find first non-whitespace prev char
for (; j >= 0; j--) {
p = exp.charAt(j)
if (p !== ' ') {
break
}
}
if (!p || !validDivisionCharRE.test(p)) {
inRegex = true
}
}
}
}
if (expression === undefined) {
expression = exp.slice(0, i).trim()
} else if (lastFilterIndex !== 0) {
pushFilter()
}
function pushFilter () {
(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
lastFilterIndex = i + 1
}
if (filters) {
for (i = 0; i < filters.length; i++) {
expression = wrapFilter(expression, filters[i])
}
}
return expression
}
function wrapFilter (exp, filter) {
var i = filter.indexOf('(')
if (i < 0) {
// _f: resolveFilter
return ("_f(\"" + filter + "\")(" + exp + ")")
} else {
var name = filter.slice(0, i)
var args = filter.slice(i + 1)
return ("_f(\"" + name + "\")(" + exp + "," + args)
}
}
/* */
var defaultTagRE = /\{\{((?:.|\n)+?)\}\}/g
var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
var buildRegex = cached(function (delimiters) {
var open = delimiters[0].replace(regexEscapeRE, '\\$&')
var close = delimiters[1].replace(regexEscapeRE, '\\$&')
return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
})
function parseText (
text,
delimiters
) {
var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
if (!tagRE.test(text)) {
return
}
var tokens = []
var lastIndex = tagRE.lastIndex = 0
var match, index
while ((match = tagRE.exec(text))) {
index = match.index
// push text token
if (index > lastIndex) {
tokens.push(JSON.stringify(text.slice(lastIndex, index)))
}
// tag token
var exp = parseFilters(match[1].trim())
tokens.push(("_s(" + exp + ")"))
lastIndex = index + match[0].length
}
if (lastIndex < text.length) {
tokens.push(JSON.stringify(text.slice(lastIndex)))
}
return tokens.join('+')
}
/* */
function baseWarn (msg) {
console.error(("[Vue compiler]: " + msg))
}
function pluckModuleFunction (
modules,
key
) {
return modules
? modules.map(function (m) {
return m[key]
}).filter(function (_) {
return _
})
: []
}
function addProp (el, name, value) {
(el.props || (el.props = [])).push({ name: name, value: value })
}
function addAttr (el, name, value) {
(el.attrs || (el.attrs = [])).push({ name: name, value: value })
}
function addDirective (
el,
name,
rawName,
value,
arg,
modifiers
) {
(el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers })
}
function addHandler (
el,
name,
value,
modifiers,
important,
warn
) {
modifiers = modifiers || emptyObject
// warn prevent and passive modifier
/* istanbul ignore if */
if (
process.env.NODE_ENV !== 'production' && warn &&
modifiers.prevent && modifiers.passive
) {
warn(
'passive and prevent can\'t be used together. ' +
'Passive handler can\'t prevent default event.'
)
}
// check capture modifier
if (modifiers.capture) {
delete modifiers.capture
name = '!' + name // mark the event as captured
}
if (modifiers.once) {
delete modifiers.once
name = '~' + name // mark the event as once
}
/* istanbul ignore if */
if (modifiers.passive) {
delete modifiers.passive
name = '&' + name // mark the event as passive
}
// normalize click.right and click.middle since they don't actually fire
// this is technically browser-specific, but at least for now browsers are
// the only target envs that have right/middle clicks.
if (name === 'click') {
if (modifiers.right) {
name = 'contextmenu'
delete modifiers.right
} else if (modifiers.middle) {
name = 'mouseup'
}
}
var events
if (modifiers.native) {
delete modifiers.native
events = el.nativeEvents || (el.nativeEvents = {})
} else {
events = el.events || (el.events = {})
}
var newHandler = { value: value }
if (modifiers !== emptyObject) {
newHandler.modifiers = modifiers
}
var handlers = events[name]
/* istanbul ignore if */
if (Array.isArray(handlers)) {
important ? handlers.unshift(newHandler) : handlers.push(newHandler)
} else if (handlers) {
events[name] = important ? [newHandler, handlers] : [handlers, newHandler]
} else {
events[name] = newHandler
}
}
function getBindingAttr (
el,
name,
getStatic
) {
var dynamicValue =
getAndRemoveAttr(el, ':' + name) ||
getAndRemoveAttr(el, 'v-bind:' + name)
if (dynamicValue != null) {
return parseFilters(dynamicValue)
} else if (getStatic !== false) {
var staticValue = getAndRemoveAttr(el, name)
if (staticValue != null) {
return JSON.stringify(staticValue)
}
}
}
// note: this only removes the attr from the Array (attrsList) so that it
// doesn't get processed by processAttrs.
// By default it does NOT remove it from the map (attrsMap) because the map is
// needed during codegen.
function getAndRemoveAttr (
el,
name,
removeFromMap
) {
var val
if ((val = el.attrsMap[name]) != null) {
var list = el.attrsList
for (var i = 0, l = list.length; i < l; i++) {
if (list[i].name === name) {
list.splice(i, 1)
break
}
}
}
if (removeFromMap) {
delete el.attrsMap[name]
}
return val
}
/* */
function transformNode (el, options) {
var warn = options.warn || baseWarn
var staticClass = getAndRemoveAttr(el, 'class')
if (process.env.NODE_ENV !== 'production' && staticClass) {
var expression = parseText(staticClass, options.delimiters)
if (expression) {
warn(
"class=\"" + staticClass + "\": " +
'Interpolation inside attributes has been removed. ' +
'Use v-bind or the colon shorthand instead. For example, ' +
'instead of <div class="{{ val }}">, use <div :class="val">.'
)
}
}
if (staticClass) {
el.staticClass = JSON.stringify(staticClass)
}
var classBinding = getBindingAttr(el, 'class', false /* getStatic */)
if (classBinding) {
el.classBinding = classBinding
}
}
function genData (el) {
var data = ''
if (el.staticClass) {
data += "staticClass:" + (el.staticClass) + ","
}
if (el.classBinding) {
data += "class:" + (el.classBinding) + ","
}
return data
}
var klass = {
staticKeys: ['staticClass'],
transformNode: transformNode,
genData: genData
}
/* */
function transformNode$1 (el, options) {
var warn = options.warn || baseWarn
var staticStyle = getAndRemoveAttr(el, 'style')
if (staticStyle) {
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production') {
var expression = parseText(staticStyle, options.delimiters)
if (expression) {
warn(
"style=\"" + staticStyle + "\": " +
'Interpolation inside attributes has been removed. ' +
'Use v-bind or the colon shorthand instead. For example, ' +
'instead of <div style="{{ val }}">, use <div :style="val">.'
)
}
}
el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
}
var styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
if (styleBinding) {
el.styleBinding = styleBinding
}
}
function genData$1 (el) {
var data = ''
if (el.staticStyle) {
data += "staticStyle:" + (el.staticStyle) + ","
}
if (el.styleBinding) {
data += "style:(" + (el.styleBinding) + "),"
}
return data
}
var style = {
staticKeys: ['staticStyle'],
transformNode: transformNode$1,
genData: genData$1
}
/**
* Not type-checking this file because it's mostly vendor code.
*/
/* !
* HTML Parser By John Resig (ejohn.org)
* Modified by Juriy "kangax" Zaytsev
* Original code by Erik Arvidsson, Mozilla Public License
* http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
*/
// Regular Expressions for parsing tags and attributes
var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName
// but for Vue templates we can enforce a simple charset
var ncname = '[a-zA-Z_][\\w\\-\\.]*'
var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")"
var startTagOpen = new RegExp(("^<" + qnameCapture))
var startTagClose = /^\s*(\/?)>/
var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"))
var doctype = /^<!DOCTYPE [^>]+>/i
var comment = /^<!--/
var conditionalComment = /^<!\[/
var IS_REGEX_CAPTURING_BROKEN = false
'x'.replace(/x(.)?/g, function (m, g) {
IS_REGEX_CAPTURING_BROKEN = g === ''
})
// Special Elements (can contain anything)
var isPlainTextElement = makeMap('script,style,textarea', true)
var reCache = {}
var decodingMap = {
'<': '<',
'>': '>',
'"': '"',
'&': '&',
' ': '\n',
'	': '\t'
}
var encodedAttr = /&(?:lt|gt|quot|amp);/g
var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10|#9);/g
// #5992
var isIgnoreNewlineTag = makeMap('pre,textarea', true)
var shouldIgnoreFirstNewline = function (tag, html) {
return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
}
function decodeAttr (value, shouldDecodeNewlines) {
var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
return value.replace(re, function (match) {
return decodingMap[match]
})
}
function parseHTML (html, options) {
var stack = []
var expectHTML = options.expectHTML
var isUnaryTag$$1 = options.isUnaryTag || no
var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no
var index = 0
var last, lastTag
while (html) {
last = html
// Make sure we're not in a plaintext content element like script/style
if (!lastTag || !isPlainTextElement(lastTag)) {
var textEnd = html.indexOf('<')
if (textEnd === 0) {
// Comment:
if (comment.test(html)) {
var commentEnd = html.indexOf('-->')
if (commentEnd >= 0) {
if (options.shouldKeepComment) {
options.comment(html.substring(4, commentEnd))
}
advance(commentEnd + 3)
continue
}
}
// http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
if (conditionalComment.test(html)) {
var conditionalEnd = html.indexOf(']>')
if (conditionalEnd >= 0) {
advance(conditionalEnd + 2)
continue
}
}
// Doctype:
var doctypeMatch = html.match(doctype)
if (doctypeMatch) {
advance(doctypeMatch[0].length)
continue
}
// End tag:
var endTagMatch = html.match(endTag)
if (endTagMatch) {
var curIndex = index
advance(endTagMatch[0].length)
parseEndTag(endTagMatch[1], curIndex, index)
continue
}
// Start tag:
var startTagMatch = parseStartTag()
if (startTagMatch) {
handleStartTag(startTagMatch)
if (shouldIgnoreFirstNewline(lastTag, html)) {
advance(1)
}
continue
}
}
var text = (void 0), rest = (void 0), next = (void 0)
if (textEnd >= 0) {
rest = html.slice(textEnd)
while (
!endTag.test(rest) &&
!startTagOpen.test(rest) &&
!comment.test(rest) &&
!conditionalComment.test(rest)
) {
// < in plain text, be forgiving and treat it as text
next = rest.indexOf('<', 1)
if (next < 0) {
break
}
textEnd += next
rest = html.slice(textEnd)
}
text = html.substring(0, textEnd)
advance(textEnd)
}
if (textEnd < 0) {
text = html
html = ''
}
if (options.chars && text) {
options.chars(text)
}
} else {
var endTagLength = 0
var stackedTag = lastTag.toLowerCase()
var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'))
var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
endTagLength = endTag.length
if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
text = text
.replace(/<!--([\s\S]*?)-->/g, '$1')
.replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')
}
if (shouldIgnoreFirstNewline(stackedTag, text)) {
text = text.slice(1)
}
if (options.chars) {
options.chars(text)
}
return ''
})
index += html.length - rest$1.length
html = rest$1
parseEndTag(stackedTag, index - endTagLength, index)
}
if (html === last) {
options.chars && options.chars(html)
if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
options.warn(("Mal-formatted tag at end of template: \"" + html + "\""))
}
break
}
}
// Clean up any remaining tags
parseEndTag()
function advance (n) {
index += n
html = html.substring(n)
}
function parseStartTag () {
var start = html.match(startTagOpen)
if (start) {
var match = {
tagName: start[1],
attrs: [],
start: index
}
advance(start[0].length)
var end, attr
while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {
advance(attr[0].length)
match.attrs.push(attr)
}
if (end) {
match.unarySlash = end[1]
advance(end[0].length)
match.end = index
return match
}
}
}
function handleStartTag (match) {
var tagName = match.tagName
var unarySlash = match.unarySlash
if (expectHTML) {
if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
parseEndTag(lastTag)
}
if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
parseEndTag(tagName)
}
}
var unary = isUnaryTag$$1(tagName) || !!unarySlash
var l = match.attrs.length
var attrs = new Array(l)
for (var i = 0; i < l; i++) {
var args = match.attrs[i]
// hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
if (args[3] === '') {
delete args[3]
}
if (args[4] === '') {
delete args[4]
}
if (args[5] === '') {
delete args[5]
}
}
var value = args[3] || args[4] || args[5] || ''
var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
? options.shouldDecodeNewlinesForHref
: options.shouldDecodeNewlines
attrs[i] = {
name: args[1],
value: decodeAttr(value, shouldDecodeNewlines)
}
}
if (!unary) {
stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs })
lastTag = tagName
}
if (options.start) {
options.start(tagName, attrs, unary, match.start, match.end)
}
}
function parseEndTag (tagName, start, end) {
var pos, lowerCasedTagName
if (start == null) {
start = index
}
if (end == null) {
end = index
}
if (tagName) {
lowerCasedTagName = tagName.toLowerCase()
}
// Find the closest opened tag of the same type
if (tagName) {
for (pos = stack.length - 1; pos >= 0; pos--) {
if (stack[pos].lowerCasedTag === lowerCasedTagName) {
break
}
}
} else {
// If no tag name is provided, clean shop
pos = 0
}
if (pos >= 0) {
// Close all the open elements, up the stack
for (var i = stack.length - 1; i >= pos; i--) {
if (process.env.NODE_ENV !== 'production' &&
(i > pos || !tagName) &&
options.warn
) {
options.warn(
("tag <" + (stack[i].tag) + "> has no matching end tag.")
)
}
if (options.end) {
options.end(stack[i].tag, start, end)
}
}
// Remove the open elements from the stack
stack.length = pos
lastTag = pos && stack[pos - 1].tag
} else if (lowerCasedTagName === 'br') {
if (options.start) {
options.start(tagName, [], true, start, end)
}
} else if (lowerCasedTagName === 'p') {
if (options.start) {
options.start(tagName, [], false, start, end)
}
if (options.end) {
options.end(tagName, start, end)
}
}
}
}
/* */
/**
* Cross-platform code generation for component v-model
*/
function genComponentModel (
el,
value,
modifiers
) {
var ref = modifiers || {}
var number = ref.number
var trim = ref.trim
var baseValueExpression = '$$v'
var valueExpression = baseValueExpression
if (trim) {
valueExpression =
"(typeof " + baseValueExpression + " === 'string'" +
"? " + baseValueExpression + ".trim()" +
": " + baseValueExpression + ")"
}
if (number) {
valueExpression = "_n(" + valueExpression + ")"
}
var assignment = genAssignmentCode(value, valueExpression)
el.model = {
value: ("(" + value + ")"),
expression: ("\"" + value + "\""),
callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
}
}
/**
* Cross-platform codegen helper for generating v-model value assignment code.
*/
function genAssignmentCode (
value,
assignment
) {
var res = parseModel(value)
if (res.key === null) {
return (value + "=" + assignment)
} else {
return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
}
}
/**
* Parse a v-model expression into a base path and a final key segment.
* Handles both dot-path and possible square brackets.
*
* Possible cases:
*
* - test
* - test[key]
* - test[test1[key]]
* - test["a"][key]
* - xxx.test[a[a].test1[key]]
* - test.xxx.a["asa"][test1[key]]
*
*/
var len
var str
var chr
var index
var expressionPos
var expressionEndPos
function parseModel (val) {
len = val.length
if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
index = val.lastIndexOf('.')
if (index > -1) {
return {
exp: val.slice(0, index),
key: '"' + val.slice(index + 1) + '"'
}
} else {
return {
exp: val,
key: null
}
}
}
str = val
index = expressionPos = expressionEndPos = 0
while (!eof()) {
chr = next()
/* istanbul ignore if */
if (isStringStart(chr)) {
parseString(chr)
} else if (chr === 0x5B) {
parseBracket(chr)
}
}
return {
exp: val.slice(0, expressionPos),
key: val.slice(expressionPos + 1, expressionEndPos)
}
}
function next () {
return str.charCodeAt(++index)
}
function eof () {
return index >= len
}
function isStringStart (chr) {
return chr === 0x22 || chr === 0x27
}
function parseBracket (chr) {
var inBracket = 1
expressionPos = index
while (!eof()) {
chr = next()
if (isStringStart(chr)) {
parseString(chr)
continue
}
if (chr === 0x5B) {
inBracket++
}
if (chr === 0x5D) {
inBracket--
}
if (inBracket === 0) {
expressionEndPos = index
break
}
}
}
function parseString (chr) {
var stringQuote = chr
while (!eof()) {
chr = next()
if (chr === stringQuote) {
break
}
}
}
/* */
var onRE = /^@|^v-on:/
var dirRE = /^v-|^@|^:/
var forAliasRE = /(.*?)\s+(?:in|of)\s+(.*)/
var forIteratorRE = /\((\{[^}]*\}|[^,{]*),([^,]*)(?:,([^,]*))?\)/
var stripParensRE = /^\(|\)$/g
var argRE = /:(.*)$/
var bindRE = /^:|^v-bind:/
var modifierRE = /\.[^.]+/g
var decodeHTMLCached = cached(he.decode)
// configurable state
var warn$1
var delimiters
var transforms
var preTransforms
var postTransforms
var platformIsPreTag
var platformMustUseProp
var platformGetTagNamespace
function createASTElement (
tag,
attrs,
parent
) {
return {
type: 1,
tag: tag,
attrsList: attrs,
attrsMap: makeAttrsMap(attrs),
parent: parent,
children: []
}
}
/**
* Convert HTML string to AST.
*/
function parse (
template,
options
) {
warn$1 = options.warn || baseWarn
platformIsPreTag = options.isPreTag || no
platformMustUseProp = options.mustUseProp || no
platformGetTagNamespace = options.getTagNamespace || no
transforms = pluckModuleFunction(options.modules, 'transformNode')
preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
delimiters = options.delimiters
var stack = []
var preserveWhitespace = options.preserveWhitespace !== false
var root
var currentParent
var inVPre = false
var inPre = false
var warned = false
function warnOnce (msg) {
if (!warned) {
warned = true
warn$1(msg)
}
}
function endPre (element) {
// check pre state
if (element.pre) {
inVPre = false
}
if (platformIsPreTag(element.tag)) {
inPre = false
}
}
parseHTML(template, {
warn: warn$1,
expectHTML: options.expectHTML,
isUnaryTag: options.isUnaryTag,
canBeLeftOpenTag: options.canBeLeftOpenTag,
shouldDecodeNewlines: options.shouldDecodeNewlines,
shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
shouldKeepComment: options.comments,
start: function start (tag, attrs, unary) {
// check namespace.
// inherit parent ns if there is one
var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
// handle IE svg bug
/* istanbul ignore if */
if (isIE && ns === 'svg') {
attrs = guardIESVGBug(attrs)
}
var element = createASTElement(tag, attrs, currentParent)
if (ns) {
element.ns = ns
}
if (isForbiddenTag(element) && !isServerRendering()) {
element.forbidden = true
process.env.NODE_ENV !== 'production' && warn$1(
'Templates should only be responsible for mapping the state to the ' +
'UI. Avoid placing tags with side-effects in your templates, such as ' +
"<" + tag + ">" + ', as they will not be parsed.'
)
}
// apply pre-transforms
for (var i = 0; i < preTransforms.length; i++) {
element = preTransforms[i](element, options) || element
}
if (!inVPre) {
processPre(element)
if (element.pre) {
inVPre = true
}
}
if (platformIsPreTag(element.tag)) {
inPre = true
}
if (inVPre) {
processRawAttrs(element)
} else if (!element.processed) {
// structural directives
processFor(element)
processIf(element)
processOnce(element)
// element-scope stuff
processElement(element, options)
}
function checkRootConstraints (el) {
if (process.env.NODE_ENV !== 'production') {
if (el.tag === 'slot' || el.tag === 'template') {
warnOnce(
"Cannot use <" + (el.tag) + "> as component root element because it may " +
'contain multiple nodes.'
)
}
if (el.attrsMap.hasOwnProperty('v-for')) {
warnOnce(
'Cannot use v-for on stateful component root element because ' +
'it renders multiple elements.'
)
}
}
}
// tree management
if (!root) {
root = element
checkRootConstraints(root)
} else if (!stack.length) {
// allow root elements with v-if, v-else-if and v-else
if (root.if && (element.elseif || element.else)) {
checkRootConstraints(element)
addIfCondition(root, {
exp: element.elseif,
block: element
})
} else if (process.env.NODE_ENV !== 'production') {
warnOnce(
"Component template should contain exactly one root element. " +
"If you are using v-if on multiple elements, " +
"use v-else-if to chain them instead."
)
}
}
if (currentParent && !element.forbidden) {
if (element.elseif || element.else) {
processIfConditions(element, currentParent)
} else if (element.slotScope) { // scoped slot
currentParent.plain = false
var name = element.slotTarget || '"default"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element
} else {
currentParent.children.push(element)
element.parent = currentParent
}
}
if (!unary) {
currentParent = element
stack.push(element)
} else {
endPre(element)
}
// apply post-transforms
for (var i$1 = 0; i$1 < postTransforms.length; i$1++) {
postTransforms[i$1](element, options)
}
},
end: function end () {
// remove trailing whitespace
var element = stack[stack.length - 1]
var lastNode = element.children[element.children.length - 1]
if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) {
element.children.pop()
}
// pop stack
stack.length -= 1
currentParent = stack[stack.length - 1]
endPre(element)
},
chars: function chars (text) {
if (!currentParent) {
if (process.env.NODE_ENV !== 'production') {
if (text === template) {
warnOnce(
'Component template requires a root element, rather than just text.'
)
} else if ((text = text.trim())) {
warnOnce(
("text \"" + text + "\" outside root element will be ignored.")
)
}
}
return
}
// IE textarea placeholder bug
/* istanbul ignore if */
if (isIE &&
currentParent.tag === 'textarea' &&
currentParent.attrsMap.placeholder === text
) {
return
}
var children = currentParent.children
text = inPre || text.trim()
? isTextTag(currentParent) ? text : decodeHTMLCached(text)
// only preserve whitespace if its not right after a starting tag
: preserveWhitespace && children.length ? ' ' : ''
if (text) {
var expression
if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) {
children.push({
type: 2,
expression: expression,
text: text
})
} else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
children.push({
type: 3,
text: text
})
}
}
},
comment: function comment (text) {
currentParent.children.push({
type: 3,
text: text,
isComment: true
})
}
})
return root
}
function processPre (el) {
if (getAndRemoveAttr(el, 'v-pre') != null) {
el.pre = true
}
}
function processRawAttrs (el) {
var l = el.attrsList.length
if (l) {
var attrs = el.attrs = new Array(l)
for (var i = 0; i < l; i++) {
attrs[i] = {
name: el.attrsList[i].name,
value: JSON.stringify(el.attrsList[i].value)
}
}
} else if (!el.pre) {
// non root node in pre blocks with no attributes
el.plain = true
}
}
function processElement (element, options) {
processKey(element)
// determine whether this is a plain element after
// removing structural attributes
element.plain = !element.key && !element.attrsList.length
processRef(element)
processSlot(element)
processComponent(element)
for (var i = 0; i < transforms.length; i++) {
element = transforms[i](element, options) || element
}
processAttrs(element)
}
function processKey (el) {
var exp = getBindingAttr(el, 'key')
if (exp) {
if (process.env.NODE_ENV !== 'production' && el.tag === 'template') {
warn$1("<template> cannot be keyed. Place the key on real elements instead.")
}
el.key = exp
}
}
function processRef (el) {
var ref = getBindingAttr(el, 'ref')
if (ref) {
el.ref = ref
el.refInFor = checkInFor(el)
}
}
function processFor (el) {
var exp
if ((exp = getAndRemoveAttr(el, 'v-for'))) {
var inMatch = exp.match(forAliasRE)
if (!inMatch) {
process.env.NODE_ENV !== 'production' && warn$1(
("Invalid v-for expression: " + exp)
)
return
}
el.for = inMatch[2].trim()
var alias = inMatch[1].trim()
var iteratorMatch = alias.match(forIteratorRE)
if (iteratorMatch) {
el.alias = iteratorMatch[1].trim()
el.iterator1 = iteratorMatch[2].trim()
if (iteratorMatch[3]) {
el.iterator2 = iteratorMatch[3].trim()
}
} else {
el.alias = alias.replace(stripParensRE, '')
}
}
}
function processIf (el) {
var exp = getAndRemoveAttr(el, 'v-if')
if (exp) {
el.if = exp
addIfCondition(el, {
exp: exp,
block: el
})
} else {
if (getAndRemoveAttr(el, 'v-else') != null) {
el.else = true
}
var elseif = getAndRemoveAttr(el, 'v-else-if')
if (elseif) {
el.elseif = elseif
}
}
}
function processIfConditions (el, parent) {
var prev = findPrevElement(parent.children)
if (prev && prev.if) {
addIfCondition(prev, {
exp: el.elseif,
block: el
})
} else if (process.env.NODE_ENV !== 'production') {
warn$1(
"v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
"used on element <" + (el.tag) + "> without corresponding v-if."
)
}
}
function findPrevElement (children) {
var i = children.length
while (i--) {
if (children[i].type === 1) {
return children[i]
} else {
if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
warn$1(
"text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
"will be ignored."
)
}
children.pop()
}
}
}
function addIfCondition (el, condition) {
if (!el.ifConditions) {
el.ifConditions = []
}
el.ifConditions.push(condition)
}
function processOnce (el) {
var once$$1 = getAndRemoveAttr(el, 'v-once')
if (once$$1 != null) {
el.once = true
}
}
function processSlot (el) {
if (el.tag === 'slot') {
el.slotName = getBindingAttr(el, 'name')
if (process.env.NODE_ENV !== 'production' && el.key) {
warn$1(
"`key` does not work on <slot> because slots are abstract outlets " +
"and can possibly expand into multiple elements. " +
"Use the key on a wrapping element instead."
)
}
} else {
var slotScope
if (el.tag === 'template') {
slotScope = getAndRemoveAttr(el, 'scope')
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production' && slotScope) {
warn$1(
"the \"scope\" attribute for scoped slots have been deprecated and " +
"replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
"can also be used on plain elements in addition to <template> to " +
"denote scoped slots.",
true
)
}
el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
} else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
warn$1(
"Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
"(v-for takes higher priority). Use a wrapper <template> for the " +
"scoped slot to make it clearer.",
true
)
}
el.slotScope = slotScope
}
var slotTarget = getBindingAttr(el, 'slot')
if (slotTarget) {
el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
// preserve slot as an attribute for native shadow DOM compat
// only for non-scoped slots.
if (el.tag !== 'template' && !el.slotScope) {
addAttr(el, 'slot', slotTarget)
}
}
}
}
function processComponent (el) {
var binding
if ((binding = getBindingAttr(el, 'is'))) {
el.component = binding
}
if (getAndRemoveAttr(el, 'inline-template') != null) {
el.inlineTemplate = true
}
}
function processAttrs (el) {
var list = el.attrsList
var i, l, name, rawName, value, modifiers, isProp
for (i = 0, l = list.length; i < l; i++) {
name = rawName = list[i].name
value = list[i].value
if (dirRE.test(name)) {
// mark element as dynamic
el.hasBindings = true
// modifiers
modifiers = parseModifiers(name)
if (modifiers) {
name = name.replace(modifierRE, '')
}
if (bindRE.test(name)) { // v-bind
name = name.replace(bindRE, '')
value = parseFilters(value)
isProp = false
if (modifiers) {
if (modifiers.prop) {
isProp = true
name = camelize(name)
if (name === 'innerHtml') {
name = 'innerHTML'
}
}
if (modifiers.camel) {
name = camelize(name)
}
if (modifiers.sync) {
addHandler(
el,
("update:" + (camelize(name))),
genAssignmentCode(value, "$event")
)
}
}
if (isProp || (
!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
)) {
addProp(el, name, value)
} else {
addAttr(el, name, value)
}
} else if (onRE.test(name)) { // v-on
name = name.replace(onRE, '')
addHandler(el, name, value, modifiers, false, warn$1)
} else { // normal directives
name = name.replace(dirRE, '')
// parse arg
var argMatch = name.match(argRE)
var arg = argMatch && argMatch[1]
if (arg) {
name = name.slice(0, -(arg.length + 1))
}
addDirective(el, name, rawName, value, arg, modifiers)
if (process.env.NODE_ENV !== 'production' && name === 'model') {
checkForAliasModel(el, value)
}
}
} else {
// literal attribute
if (process.env.NODE_ENV !== 'production') {
var expression = parseText(value, delimiters)
if (expression) {
warn$1(
name + "=\"" + value + "\": " +
'Interpolation inside attributes has been removed. ' +
'Use v-bind or the colon shorthand instead. For example, ' +
'instead of <div id="{{ val }}">, use <div :id="val">.'
)
}
}
addAttr(el, name, JSON.stringify(value))
// #6887 firefox doesn't update muted state if set via attribute
// even immediately after element creation
if (!el.component &&
name === 'muted' &&
platformMustUseProp(el.tag, el.attrsMap.type, name)) {
addProp(el, name, 'true')
}
}
}
}
function checkInFor (el) {
var parent = el
while (parent) {
if (parent.for !== undefined) {
return true
}
parent = parent.parent
}
return false
}
function parseModifiers (name) {
var match = name.match(modifierRE)
if (match) {
var ret = {}
match.forEach(function (m) {
ret[m.slice(1)] = true
})
return ret
}
}
function makeAttrsMap (attrs) {
var map = {}
for (var i = 0, l = attrs.length; i < l; i++) {
if (
process.env.NODE_ENV !== 'production' &&
map[attrs[i].name] && !isIE && !isEdge
) {
warn$1('duplicate attribute: ' + attrs[i].name)
}
map[attrs[i].name] = attrs[i].value
}
return map
}
// for script (e.g. type="x/template") or style, do not decode content
function isTextTag (el) {
return el.tag === 'script' || el.tag === 'style'
}
function isForbiddenTag (el) {
return (
el.tag === 'style' ||
(el.tag === 'script' && (
!el.attrsMap.type ||
el.attrsMap.type === 'text/javascript'
))
)
}
var ieNSBug = /^xmlns:NS\d+/
var ieNSPrefix = /^NS\d+:/
/* istanbul ignore next */
function guardIESVGBug (attrs) {
var res = []
for (var i = 0; i < attrs.length; i++) {
var attr = attrs[i]
if (!ieNSBug.test(attr.name)) {
attr.name = attr.name.replace(ieNSPrefix, '')
res.push(attr)
}
}
return res
}
function checkForAliasModel (el, value) {
var _el = el
while (_el) {
if (_el.for && _el.alias === value) {
warn$1(
"<" + (el.tag) + " v-model=\"" + value + "\">: " +
"You are binding v-model directly to a v-for iteration alias. " +
"This will not be able to modify the v-for source array because " +
"writing to the alias is like modifying a function local variable. " +
"Consider using an array of objects and use v-model on an object property instead."
)
}
_el = _el.parent
}
}
/* */
/**
* Expand input[v-model] with dyanmic type bindings into v-if-else chains
* Turn this:
* <input v-model="data[type]" :type="type">
* into this:
* <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
* <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
* <input v-else :type="type" v-model="data[type]">
*/
function preTransformNode (el, options) {
if (el.tag === 'input') {
var map = el.attrsMap
if (map['v-model'] && (map['v-bind:type'] || map[':type'])) {
var typeBinding = getBindingAttr(el, 'type')
var ifCondition = getAndRemoveAttr(el, 'v-if', true)
var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : ""
var hasElse = getAndRemoveAttr(el, 'v-else', true) != null
var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
// 1. checkbox
var branch0 = cloneASTElement(el)
// process for on the main node
processFor(branch0)
addRawAttr(branch0, 'type', 'checkbox')
processElement(branch0, options)
branch0.processed = true // prevent it from double-processed
branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra
addIfCondition(branch0, {
exp: branch0.if,
block: branch0
})
// 2. add radio else-if condition
var branch1 = cloneASTElement(el)
getAndRemoveAttr(branch1, 'v-for', true)
addRawAttr(branch1, 'type', 'radio')
processElement(branch1, options)
addIfCondition(branch0, {
exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
block: branch1
})
// 3. other
var branch2 = cloneASTElement(el)
getAndRemoveAttr(branch2, 'v-for', true)
addRawAttr(branch2, ':type', typeBinding)
processElement(branch2, options)
addIfCondition(branch0, {
exp: ifCondition,
block: branch2
})
if (hasElse) {
branch0.else = true
} else if (elseIfCondition) {
branch0.elseif = elseIfCondition
}
return branch0
}
}
}
function cloneASTElement (el) {
return createASTElement(el.tag, el.attrsList.slice(), el.parent)
}
function addRawAttr (el, name, value) {
el.attrsMap[name] = value
el.attrsList.push({ name: name, value: value })
}
var model$1 = {
preTransformNode: preTransformNode
}
var modules$1 = [
klass,
style,
model$1
]
/* */
var warn$2
// in some cases, the event used has to be determined at runtime
// so we used some reserved tokens during compile.
var RANGE_TOKEN = '__r'
function model$2 (
el,
dir,
_warn
) {
warn$2 = _warn
var value = dir.value
var modifiers = dir.modifiers
var tag = el.tag
var type = el.attrsMap.type
if (process.env.NODE_ENV !== 'production') {
// inputs with type="file" are read only and setting the input's
// value will throw an error.
if (tag === 'input' && type === 'file') {
warn$2(
"<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
"File inputs are read only. Use a v-on:change listener instead."
)
}
}
if (el.component) {
genComponentModel(el, value, modifiers)
// component v-model doesn't need extra runtime
return false
} else if (tag === 'select') {
genSelect(el, value, modifiers)
} else if (tag === 'input' && type === 'checkbox') {
genCheckboxModel(el, value, modifiers)
} else if (tag === 'input' && type === 'radio') {
genRadioModel(el, value, modifiers)
} else if (tag === 'input' || tag === 'textarea') {
genDefaultModel(el, value, modifiers)
} else if (!config.isReservedTag(tag)) {
genComponentModel(el, value, modifiers)
// component v-model doesn't need extra runtime
return false
} else if (process.env.NODE_ENV !== 'production') {
warn$2(
"<" + (el.tag) + " v-model=\"" + value + "\">: " +
"v-model is not supported on this element type. " +
'If you are working with contenteditable, it\'s recommended to ' +
'wrap a library dedicated for that purpose inside a custom component.'
)
}
// ensure runtime directive metadata
return true
}
function genCheckboxModel (
el,
value,
modifiers
) {
var number = modifiers && modifiers.number
var valueBinding = getBindingAttr(el, 'value') || 'null'
var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
addProp(el, 'checked',
"Array.isArray(" + value + ")" +
"?_i(" + value + "," + valueBinding + ")>-1" + (
trueValueBinding === 'true'
? (":(" + value + ")")
: (":_q(" + value + "," + trueValueBinding + ")")
)
)
addHandler(el, 'change',
"var $$a=" + value + "," +
'$$el=$event.target,' +
"$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
'if(Array.isArray($$a)){' +
"var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
'$$i=_i($$a,$$v);' +
"if($$el.checked){$$i<0&&(" + value + "=$$a.concat([$$v]))}" +
"else{$$i>-1&&(" + value + "=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}" +
"}else{" + (genAssignmentCode(value, '$$c')) + "}",
null, true
)
}
function genRadioModel (
el,
value,
modifiers
) {
var number = modifiers && modifiers.number
var valueBinding = getBindingAttr(el, 'value') || 'null'
valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding
addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"))
addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
}
function genSelect (
el,
value,
modifiers
) {
var number = modifiers && modifiers.number
var selectedVal = "Array.prototype.filter" +
".call($event.target.options,function(o){return o.selected})" +
".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
"return " + (number ? '_n(val)' : 'val') + "})"
var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
var code = "var $$selectedVal = " + selectedVal + ";"
code = code + " " + (genAssignmentCode(value, assignment))
addHandler(el, 'change', code, null, true)
}
function genDefaultModel (
el,
value,
modifiers
) {
var type = el.attrsMap.type
// warn if v-bind:value conflicts with v-model
if (process.env.NODE_ENV !== 'production') {
var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
if (value$1) {
var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
warn$2(
binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
'because the latter already expands to a value binding internally'
)
}
}
var ref = modifiers || {}
var lazy = ref.lazy
var number = ref.number
var trim = ref.trim
var needCompositionGuard = !lazy && type !== 'range'
var event = lazy
? 'change'
: type === 'range'
? RANGE_TOKEN
: 'input'
var valueExpression = '$event.target.value'
if (trim) {
valueExpression = "$event.target.value.trim()"
}
if (number) {
valueExpression = "_n(" + valueExpression + ")"
}
var code = genAssignmentCode(value, valueExpression)
if (needCompositionGuard) {
code = "if($event.target.composing)return;" + code
}
addProp(el, 'value', ("(" + value + ")"))
addHandler(el, event, code, null, true)
if (trim || number) {
addHandler(el, 'blur', '$forceUpdate()')
}
}
/* */
function text (el, dir) {
if (dir.value) {
addProp(el, 'textContent', ("_s(" + (dir.value) + ")"))
}
}
/* */
function html (el, dir) {
if (dir.value) {
addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"))
}
}
var directives = {
model: model$2,
text: text,
html: html
}
/* */
var baseOptions = {
expectHTML: true,
modules: modules$1,
directives: directives,
isPreTag: isPreTag,
isUnaryTag: isUnaryTag,
mustUseProp: mustUseProp,
canBeLeftOpenTag: canBeLeftOpenTag,
isReservedTag: isReservedTag,
getTagNamespace: getTagNamespace,
staticKeys: genStaticKeys(modules$1)
}
/* */
var fnExpRE = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/
var simplePathRE = /^\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?']|\[".*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*\s*$/
// keyCode aliases
var keyCodes = {
esc: 27,
tab: 9,
enter: 13,
space: 32,
up: 38,
left: 37,
right: 39,
down: 40,
'delete': [8, 46]
}
// #4868: modifiers that prevent the execution of the listener
// need to explicitly return null so that we can determine whether to remove
// the listener for .once
var genGuard = function (condition) {
return ("if(" + condition + ")return null;")
}
var modifierCode = {
stop: '$event.stopPropagation();',
prevent: '$event.preventDefault();',
self: genGuard("$event.target !== $event.currentTarget"),
ctrl: genGuard("!$event.ctrlKey"),
shift: genGuard("!$event.shiftKey"),
alt: genGuard("!$event.altKey"),
meta: genGuard("!$event.metaKey"),
left: genGuard("'button' in $event && $event.button !== 0"),
middle: genGuard("'button' in $event && $event.button !== 1"),
right: genGuard("'button' in $event && $event.button !== 2")
}
function genHandlers (
events,
isNative,
warn
) {
var res = isNative ? 'nativeOn:{' : 'on:{'
for (var name in events) {
res += "\"" + name + "\":" + (genHandler(name, events[name])) + ","
}
return res.slice(0, -1) + '}'
}
function genHandler (
name,
handler
) {
if (!handler) {
return 'function(){}'
}
if (Array.isArray(handler)) {
return ("[" + (handler.map(function (handler) {
return genHandler(name, handler)
}).join(',')) + "]")
}
var isMethodPath = simplePathRE.test(handler.value)
var isFunctionExpression = fnExpRE.test(handler.value)
if (!handler.modifiers) {
return isMethodPath || isFunctionExpression
? handler.value
: ("function($event){" + (handler.value) + "}") // inline statement
} else {
var code = ''
var genModifierCode = ''
var keys = []
for (var key in handler.modifiers) {
if (modifierCode[key]) {
genModifierCode += modifierCode[key]
// left/right
if (keyCodes[key]) {
keys.push(key)
}
} else if (key === 'exact') {
var modifiers = (handler.modifiers)
genModifierCode += genGuard(
['ctrl', 'shift', 'alt', 'meta']
.filter(function (keyModifier) {
return !modifiers[keyModifier]
})
.map(function (keyModifier) {
return ("$event." + keyModifier + "Key")
})
.join('||')
)
} else {
keys.push(key)
}
}
if (keys.length) {
code += genKeyFilter(keys)
}
// Make sure modifiers like prevent and stop get executed after key filtering
if (genModifierCode) {
code += genModifierCode
}
var handlerCode = isMethodPath
? handler.value + '($event)'
: isFunctionExpression
? ("(" + (handler.value) + ")($event)")
: handler.value
return ("function($event){" + code + handlerCode + "}")
}
}
function genKeyFilter (keys) {
return ("if(!('button' in $event)&&" + (keys.map(genFilterCode).join('&&')) + ")return null;")
}
function genFilterCode (key) {
var keyVal = parseInt(key, 10)
if (keyVal) {
return ("$event.keyCode!==" + keyVal)
}
var code = keyCodes[key]
return (
"_k($event.keyCode," +
(JSON.stringify(key)) + "," +
(JSON.stringify(code)) + "," +
"$event.key)"
)
}
/* */
function on (el, dir) {
if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
warn("v-on without argument does not support modifiers.")
}
el.wrapListeners = function (code) {
return ("_g(" + code + "," + (dir.value) + ")")
}
}
/* */
function bind$1 (el, dir) {
el.wrapData = function (code) {
return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
}
}
/* */
var baseDirectives$1 = {
on: on,
bind: bind$1,
cloak: noop
}
/* */
var CodegenState = function CodegenState (options) {
this.options = options
this.warn = options.warn || baseWarn
this.transforms = pluckModuleFunction(options.modules, 'transformCode')
this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
this.directives = extend(extend({}, baseDirectives$1), options.directives)
var isReservedTag = options.isReservedTag || no
this.maybeComponent = function (el) {
return !isReservedTag(el.tag)
}
this.onceId = 0
this.staticRenderFns = []
}
function generate$1 (
ast,
options
) {
var state = new CodegenState(options)
var code = ast ? genElement(ast, state) : '_c("div")'
return {
render: ("with(this){return " + code + "}"),
staticRenderFns: state.staticRenderFns
}
}
function genElement (el, state) {
if (el.staticRoot && !el.staticProcessed) {
return genStatic(el, state)
} else if (el.once && !el.onceProcessed) {
return genOnce(el, state)
} else if (el.for && !el.forProcessed) {
return genFor(el, state)
} else if (el.if && !el.ifProcessed) {
return genIf(el, state)
} else if (el.tag === 'template' && !el.slotTarget) {
return genChildren(el, state) || 'void 0'
} else if (el.tag === 'slot') {
return genSlot(el, state)
} else {
// component or element
var code
if (el.component) {
code = genComponent(el.component, el, state)
} else {
var data = el.plain ? undefined : genData$2(el, state)
var children = el.inlineTemplate ? null : genChildren(el, state, true)
code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")"
}
// module transforms
for (var i = 0; i < state.transforms.length; i++) {
code = state.transforms[i](el, code)
}
return code
}
}
// hoist static sub-trees out
function genStatic (el, state, once$$1) {
el.staticProcessed = true
state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"))
return ("_m(" + (state.staticRenderFns.length - 1) + "," + (el.staticInFor ? 'true' : 'false') + "," + (once$$1 ? 'true' : 'false') + ")")
}
// v-once
function genOnce (el, state) {
el.onceProcessed = true
if (el.if && !el.ifProcessed) {
return genIf(el, state)
} else if (el.staticInFor) {
var key = ''
var parent = el.parent
while (parent) {
if (parent.for) {
key = parent.key
break
}
parent = parent.parent
}
if (!key) {
process.env.NODE_ENV !== 'production' && state.warn(
"v-once can only be used inside v-for that is keyed. "
)
return genElement(el, state)
}
return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
} else {
return genStatic(el, state, true)
}
}
function genIf (
el,
state,
altGen,
altEmpty
) {
el.ifProcessed = true // avoid recursion
return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
}
function genIfConditions (
conditions,
state,
altGen,
altEmpty
) {
if (!conditions.length) {
return altEmpty || '_e()'
}
var condition = conditions.shift()
if (condition.exp) {
return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
} else {
return ("" + (genTernaryExp(condition.block)))
}
// v-if with v-once should generate code like (a)?_m(0):_m(1)
function genTernaryExp (el) {
return altGen
? altGen(el, state)
: el.once
? genOnce(el, state)
: genElement(el, state)
}
}
function genFor (
el,
state,
altGen,
altHelper
) {
var exp = el.for
var alias = el.alias
var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''
var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''
if (process.env.NODE_ENV !== 'production' &&
state.maybeComponent(el) &&
el.tag !== 'slot' &&
el.tag !== 'template' &&
!el.key
) {
state.warn(
"<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
"v-for should have explicit keys. " +
"See https://vuejs.org/guide/list.html#key for more info.",
true /* tip */
)
}
el.forProcessed = true // avoid recursion
return (altHelper || '_l') + "((" + exp + ")," +
"function(" + alias + iterator1 + iterator2 + "){" +
"return " + ((altGen || genElement)(el, state)) +
'})'
}
function genData$2 (el, state) {
var data = '{'
// directives first.
// directives may mutate the el's other properties before they are generated.
var dirs = genDirectives(el, state)
if (dirs) {
data += dirs + ','
}
// key
if (el.key) {
data += "key:" + (el.key) + ","
}
// ref
if (el.ref) {
data += "ref:" + (el.ref) + ","
}
if (el.refInFor) {
data += "refInFor:true,"
}
// pre
if (el.pre) {
data += "pre:true,"
}
// record original tag name for components using "is" attribute
if (el.component) {
data += "tag:\"" + (el.tag) + "\","
}
// module data generation functions
for (var i = 0; i < state.dataGenFns.length; i++) {
data += state.dataGenFns[i](el)
}
// attributes
if (el.attrs) {
data += "attrs:{" + (genProps(el.attrs)) + "},"
}
// DOM props
if (el.props) {
data += "domProps:{" + (genProps(el.props)) + "},"
}
// event handlers
if (el.events) {
data += (genHandlers(el.events, false, state.warn)) + ","
}
if (el.nativeEvents) {
data += (genHandlers(el.nativeEvents, true, state.warn)) + ","
}
// slot target
// only for non-scoped slots
if (el.slotTarget && !el.slotScope) {
data += "slot:" + (el.slotTarget) + ","
}
// scoped slots
if (el.scopedSlots) {
data += (genScopedSlots(el.scopedSlots, state)) + ","
}
// component v-model
if (el.model) {
data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},"
}
// inline-template
if (el.inlineTemplate) {
var inlineTemplate = genInlineTemplate(el, state)
if (inlineTemplate) {
data += inlineTemplate + ","
}
}
data = data.replace(/,$/, '') + '}'
// v-bind data wrap
if (el.wrapData) {
data = el.wrapData(data)
}
// v-on data wrap
if (el.wrapListeners) {
data = el.wrapListeners(data)
}
return data
}
function genDirectives (el, state) {
var dirs = el.directives
if (!dirs) {
return
}
var res = 'directives:['
var hasRuntime = false
var i, l, dir, needRuntime
for (i = 0, l = dirs.length; i < l; i++) {
dir = dirs[i]
needRuntime = true
var gen = state.directives[dir.name]
if (gen) {
// compile-time directive that manipulates AST.
// returns true if it also needs a runtime counterpart.
needRuntime = !!gen(el, dir, state.warn)
}
if (needRuntime) {
hasRuntime = true
res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:\"" + (dir.arg) + "\"") : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},"
}
}
if (hasRuntime) {
return res.slice(0, -1) + ']'
}
}
function genInlineTemplate (el, state) {
var ast = el.children[0]
if (process.env.NODE_ENV !== 'production' && (
el.children.length !== 1 || ast.type !== 1
)) {
state.warn('Inline-template components must have exactly one child element.')
}
if (ast.type === 1) {
var inlineRenderFns = generate$1(ast, state.options)
return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) {
return ("function(){" + code + "}")
}).join(',')) + "]}")
}
}
function genScopedSlots (
slots,
state
) {
return ("scopedSlots:_u([" + (Object.keys(slots).map(function (key) {
return genScopedSlot(key, slots[key], state)
}).join(',')) + "])")
}
function genScopedSlot (
key,
el,
state
) {
if (el.for && !el.forProcessed) {
return genForScopedSlot(key, el, state)
}
var fn = "function(" + (String(el.slotScope)) + "){" +
"return " + (el.tag === 'template'
? el.if
? ((el.if) + "?" + (genChildren(el, state) || 'undefined') + ":undefined")
: genChildren(el, state) || 'undefined'
: genElement(el, state)) + "}"
return ("{key:" + key + ",fn:" + fn + "}")
}
function genForScopedSlot (
key,
el,
state
) {
var exp = el.for
var alias = el.alias
var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''
var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''
el.forProcessed = true // avoid recursion
return "_l((" + exp + ")," +
"function(" + alias + iterator1 + iterator2 + "){" +
"return " + (genScopedSlot(key, el, state)) +
'})'
}
function genChildren (
el,
state,
checkSkip,
altGenElement,
altGenNode
) {
var children = el.children
if (children.length) {
var el$1 = children[0]
// optimize single v-for
if (children.length === 1 &&
el$1.for &&
el$1.tag !== 'template' &&
el$1.tag !== 'slot'
) {
return (altGenElement || genElement)(el$1, state)
}
var normalizationType = checkSkip
? getNormalizationType(children, state.maybeComponent)
: 0
var gen = altGenNode || genNode
return ("[" + (children.map(function (c) {
return gen(c, state)
}).join(',')) + "]" + (normalizationType ? ("," + normalizationType) : ''))
}
}
// determine the normalization needed for the children array.
// 0: no normalization needed
// 1: simple normalization needed (possible 1-level deep nested array)
// 2: full normalization needed
function getNormalizationType (
children,
maybeComponent
) {
var res = 0
for (var i = 0; i < children.length; i++) {
var el = children[i]
if (el.type !== 1) {
continue
}
if (needsNormalization(el) ||
(el.ifConditions && el.ifConditions.some(function (c) {
return needsNormalization(c.block)
}))) {
res = 2
break
}
if (maybeComponent(el) ||
(el.ifConditions && el.ifConditions.some(function (c) {
return maybeComponent(c.block)
}))) {
res = 1
}
}
return res
}
function needsNormalization (el) {
return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
}
function genNode (node, state) {
if (node.type === 1) {
return genElement(node, state)
}
if (node.type === 3 && node.isComment) {
return genComment(node)
} else {
return genText(node)
}
}
function genText (text) {
return ("_v(" + (text.type === 2
? text.expression // no need for () because already wrapped in _s()
: transformSpecialNewlines(JSON.stringify(text.text))) + ")")
}
function genComment (comment) {
return ("_e(" + (JSON.stringify(comment.text)) + ")")
}
function genSlot (el, state) {
var slotName = el.slotName || '"default"'
var children = genChildren(el, state)
var res = "_t(" + slotName + (children ? ("," + children) : '')
var attrs = el.attrs && ("{" + (el.attrs.map(function (a) {
return ((camelize(a.name)) + ":" + (a.value))
}).join(',')) + "}")
var bind$$1 = el.attrsMap['v-bind']
if ((attrs || bind$$1) && !children) {
res += ",null"
}
if (attrs) {
res += "," + attrs
}
if (bind$$1) {
res += (attrs ? '' : ',null') + "," + bind$$1
}
return res + ')'
}
// componentName is el.component, take it as argument to shun flow's pessimistic refinement
function genComponent (
componentName,
el,
state
) {
var children = el.inlineTemplate ? null : genChildren(el, state, true)
return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
}
function genProps (props) {
var res = ''
for (var i = 0; i < props.length; i++) {
var prop = props[i]
res += "\"" + (prop.name) + "\":" + (transformSpecialNewlines(prop.value)) + ","
}
return res.slice(0, -1)
}
// #3895, #4268
function transformSpecialNewlines (text) {
return text
.replace(/\u2028/g, '\\u2028')
.replace(/\u2029/g, '\\u2029')
}
/* */
var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
// let the model AST transform translate v-model into appropriate
// props bindings
function applyModelTransform (el, state) {
if (el.directives) {
for (var i = 0; i < el.directives.length; i++) {
var dir = el.directives[i]
if (dir.name === 'model') {
state.directives.model(el, dir, state.warn)
// remove value for textarea as its converted to text
if (el.tag === 'textarea' && el.props) {
el.props = el.props.filter(function (p) {
return p.name !== 'value'
})
}
break
}
}
}
}
function genAttrSegments (
attrs
) {
return attrs.map(function (ref) {
var name = ref.name
var value = ref.value
return genAttrSegment(name, value)
})
}
function genDOMPropSegments (
props,
attrs
) {
var segments = []
props.forEach(function (ref) {
var name = ref.name
var value = ref.value
name = propsToAttrMap[name] || name.toLowerCase()
if (isRenderableAttr(name) &&
!(attrs && attrs.some(function (a) {
return a.name === name
}))
) {
segments.push(genAttrSegment(name, value))
}
})
return segments
}
function genAttrSegment (name, value) {
if (plainStringRE.test(value)) {
// force double quote
value = value.replace(/^'|'$/g, '"')
// force enumerated attr to "true"
if (isEnumeratedAttr(name) && value !== "\"false\"") {
value = "\"true\""
}
return {
type: RAW,
value: isBooleanAttr(name)
? (" " + name + "=\"" + name + "\"")
: value === '""'
? (" " + name)
: (" " + name + "=" + value)
}
} else {
return {
type: EXPRESSION,
value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
}
}
}
function genClassSegments (
staticClass,
classBinding
) {
if (staticClass && !classBinding) {
return [{ type: RAW, value: (" class=" + staticClass) }]
} else {
return [{
type: EXPRESSION,
value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
}]
}
}
function genStyleSegments (
staticStyle,
parsedStaticStyle,
styleBinding,
vShowExpression
) {
if (staticStyle && !styleBinding && !vShowExpression) {
return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
} else {
return [{
type: EXPRESSION,
value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
: 'null') + ")")
}]
}
}
/* */
/**
* In SSR, the vdom tree is generated only once and never patched, so
* we can optimize most element / trees into plain string render functions.
* The SSR optimizer walks the AST tree to detect optimizable elements and trees.
*
* The criteria for SSR optimizability is quite a bit looser than static tree
* detection (which is designed for client re-render). In SSR we bail only for
* components/slots/custom directives.
*/
// optimizability constants
var optimizability = {
FALSE: 0, // whole sub tree un-optimizable
FULL: 1, // whole sub tree optimizable
SELF: 2, // self optimizable but has some un-optimizable children
CHILDREN: 3, // self un-optimizable but have fully optimizable children
PARTIAL: 4 // self un-optimizable with some un-optimizable children
}
var isPlatformReservedTag
function optimize (root, options) {
if (!root) {
return
}
isPlatformReservedTag = options.isReservedTag || no
walk(root, true)
}
function walk (node, isRoot) {
if (isUnOptimizableTree(node)) {
node.ssrOptimizability = optimizability.FALSE
return
}
// root node or nodes with custom directives should always be a VNode
var selfUnoptimizable = isRoot || hasCustomDirective(node)
var check = function (child) {
if (child.ssrOptimizability !== optimizability.FULL) {
node.ssrOptimizability = selfUnoptimizable
? optimizability.PARTIAL
: optimizability.SELF
}
}
if (selfUnoptimizable) {
node.ssrOptimizability = optimizability.CHILDREN
}
if (node.type === 1) {
for (var i = 0, l = node.children.length; i < l; i++) {
var child = node.children[i]
walk(child)
check(child)
}
if (node.ifConditions) {
for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
var block = node.ifConditions[i$1].block
walk(block, isRoot)
check(block)
}
}
if (node.ssrOptimizability == null ||
(!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
) {
node.ssrOptimizability = optimizability.FULL
} else {
node.children = optimizeSiblings(node)
}
} else {
node.ssrOptimizability = optimizability.FULL
}
}
function optimizeSiblings (el) {
var children = el.children
var optimizedChildren = []
var currentOptimizableGroup = []
var pushGroup = function () {
if (currentOptimizableGroup.length) {
optimizedChildren.push({
type: 1,
parent: el,
tag: 'template',
attrsList: [],
attrsMap: {},
children: currentOptimizableGroup,
ssrOptimizability: optimizability.FULL
})
}
currentOptimizableGroup = []
}
for (var i = 0; i < children.length; i++) {
var c = children[i]
if (c.ssrOptimizability === optimizability.FULL) {
currentOptimizableGroup.push(c)
} else {
// wrap fully-optimizable adjacent siblings inside a template tag
// so that they can be optimized into a single ssrNode by codegen
pushGroup()
optimizedChildren.push(c)
}
}
pushGroup()
return optimizedChildren
}
function isUnOptimizableTree (node) {
if (node.type === 2 || node.type === 3) { // text or expression
return false
}
return (
isBuiltInTag(node.tag) || // built-in (slot, component)
!isPlatformReservedTag(node.tag) || // custom component
!!node.component || // "is" component
isSelectWithModel(node) // <select v-model> requires runtime inspection
)
}
var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
function hasCustomDirective (node) {
return (
node.type === 1 &&
node.directives &&
node.directives.some(function (d) {
return !isBuiltInDir(d.name)
})
)
}
// <select v-model> cannot be optimized because it requires a runtime check
// to determine proper selected option
function isSelectWithModel (node) {
return (
node.type === 1 &&
node.tag === 'select' &&
node.directives != null &&
node.directives.some(function (d) {
return d.name === 'model'
})
)
}
/* */
// The SSR codegen is essentially extending the default codegen to handle
// SSR-optimizable nodes and turn them into string render fns. In cases where
// a node is not optimizable it simply falls back to the default codegen.
// segment types
var RAW = 0
var INTERPOLATION = 1
var EXPRESSION = 2
function generate (
ast,
options
) {
var state = new CodegenState(options)
var code = ast ? genSSRElement(ast, state) : '_c("div")'
return {
render: ("with(this){return " + code + "}"),
staticRenderFns: state.staticRenderFns
}
}
function genSSRElement (el, state) {
if (el.for && !el.forProcessed) {
return genFor(el, state, genSSRElement)
} else if (el.if && !el.ifProcessed) {
return genIf(el, state, genSSRElement)
} else if (el.tag === 'template' && !el.slotTarget) {
return el.ssrOptimizability === optimizability.FULL
? genChildrenAsStringNode(el, state)
: genSSRChildren(el, state) || 'void 0'
}
switch (el.ssrOptimizability) {
case optimizability.FULL:
// stringify whole tree
return genStringElement(el, state)
case optimizability.SELF:
// stringify self and check children
return genStringElementWithChildren(el, state)
case optimizability.CHILDREN:
// generate self as VNode and stringify children
return genNormalElement(el, state, true)
case optimizability.PARTIAL:
// generate self as VNode and check children
return genNormalElement(el, state, false)
default:
// bail whole tree
return genElement(el, state)
}
}
function genNormalElement (el, state, stringifyChildren) {
var data = el.plain ? undefined : genData$2(el, state)
var children = stringifyChildren
? ("[" + (genChildrenAsStringNode(el, state)) + "]")
: genSSRChildren(el, state, true)
return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
}
function genSSRChildren (el, state, checkSkip) {
return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
}
function genSSRNode (el, state) {
return el.type === 1
? genSSRElement(el, state)
: genText(el)
}
function genChildrenAsStringNode (el, state) {
return el.children.length
? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
: ''
}
function genStringElement (el, state) {
return ("_ssrNode(" + (elementToString(el, state)) + ")")
}
function genStringElementWithChildren (el, state) {
var children = genSSRChildren(el, state, true)
return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
}
function elementToString (el, state) {
return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
}
function elementToSegments (el, state) {
// v-for / v-if
if (el.for && !el.forProcessed) {
el.forProcessed = true
return [{
type: EXPRESSION,
value: genFor(el, state, elementToString, '_ssrList')
}]
} else if (el.if && !el.ifProcessed) {
el.ifProcessed = true
return [{
type: EXPRESSION,
value: genIf(el, state, elementToString, '"<!---->"')
}]
} else if (el.tag === 'template') {
return childrenToSegments(el, state)
}
var openSegments = elementToOpenTagSegments(el, state)
var childrenSegments = childrenToSegments(el, state)
var ref = state.options
var isUnaryTag = ref.isUnaryTag
var close = (isUnaryTag && isUnaryTag(el.tag))
? []
: [{ type: RAW, value: ("</" + (el.tag) + ">") }]
return openSegments.concat(childrenSegments, close)
}
function elementToOpenTagSegments (el, state) {
applyModelTransform(el, state)
var binding
var segments = [{ type: RAW, value: ("<" + (el.tag)) }]
// attrs
if (el.attrs) {
segments.push.apply(segments, genAttrSegments(el.attrs))
}
// domProps
if (el.props) {
segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs))
}
// v-bind="object"
if ((binding = el.attrsMap['v-bind'])) {
segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") })
}
// v-bind.prop="object"
if ((binding = el.attrsMap['v-bind.prop'])) {
segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") })
}
// class
if (el.staticClass || el.classBinding) {
segments.push.apply(
segments,
genClassSegments(el.staticClass, el.classBinding)
)
}
// style & v-show
if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
segments.push.apply(
segments,
genStyleSegments(
el.attrsMap.style,
el.staticStyle,
el.styleBinding,
el.attrsMap['v-show']
)
)
}
// _scopedId
if (state.options.scopeId) {
segments.push({ type: RAW, value: (" " + (state.options.scopeId)) })
}
segments.push({ type: RAW, value: ">" })
return segments
}
function childrenToSegments (el, state) {
var binding
if ((binding = el.attrsMap['v-html'])) {
return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
}
if ((binding = el.attrsMap['v-text'])) {
return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
}
if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
}
return el.children
? nodesToSegments(el.children, state)
: []
}
function nodesToSegments (
children,
state
) {
var segments = []
for (var i = 0; i < children.length; i++) {
var c = children[i]
if (c.type === 1) {
segments.push.apply(segments, elementToSegments(c, state))
} else if (c.type === 2) {
segments.push({ type: INTERPOLATION, value: c.expression })
} else if (c.type === 3) {
segments.push({ type: RAW, value: escape(c.text) })
}
}
return segments
}
function flattenSegments (segments) {
var mergedSegments = []
var textBuffer = ''
var pushBuffer = function () {
if (textBuffer) {
mergedSegments.push(JSON.stringify(textBuffer))
textBuffer = ''
}
}
for (var i = 0; i < segments.length; i++) {
var s = segments[i]
if (s.type === RAW) {
textBuffer += s.value
} else if (s.type === INTERPOLATION) {
pushBuffer()
mergedSegments.push(("_ssrEscape(" + (s.value) + ")"))
} else if (s.type === EXPRESSION) {
pushBuffer()
mergedSegments.push(("(" + (s.value) + ")"))
}
}
pushBuffer()
return mergedSegments.join('+')
}
/* */
// these keywords should not appear inside expressions, but operators like
// typeof, instanceof and in are allowed
var 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'
).split(',').join('\\b|\\b') + '\\b')
// these unary operators should not be used as property/method names
var unaryOperatorsRE = new RegExp('\\b' + (
'delete,typeof,void'
).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)')
// strip strings in expressions
var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
// detect problematic expressions in a template
function detectErrors (ast) {
var errors = []
if (ast) {
checkNode(ast, errors)
}
return errors
}
function checkNode (node, errors) {
if (node.type === 1) {
for (var name in node.attrsMap) {
if (dirRE.test(name)) {
var value = node.attrsMap[name]
if (value) {
if (name === 'v-for') {
checkFor(node, ("v-for=\"" + value + "\""), errors)
} else if (onRE.test(name)) {
checkEvent(value, (name + "=\"" + value + "\""), errors)
} else {
checkExpression(value, (name + "=\"" + value + "\""), errors)
}
}
}
}
if (node.children) {
for (var i = 0; i < node.children.length; i++) {
checkNode(node.children[i], errors)
}
}
} else if (node.type === 2) {
checkExpression(node.expression, node.text, errors)
}
}
function checkEvent (exp, text, errors) {
var stipped = exp.replace(stripStringRE, '')
var keywordMatch = stipped.match(unaryOperatorsRE)
if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {
errors.push(
"avoid using JavaScript unary operator as property name: " +
"\"" + (keywordMatch[0]) + "\" in expression " + (text.trim())
)
}
checkExpression(exp, text, errors)
}
function checkFor (node, text, errors) {
checkExpression(node.for || '', text, errors)
checkIdentifier(node.alias, 'v-for alias', text, errors)
checkIdentifier(node.iterator1, 'v-for iterator', text, errors)
checkIdentifier(node.iterator2, 'v-for iterator', text, errors)
}
function checkIdentifier (
ident,
type,
text,
errors
) {
if (typeof ident === 'string') {
try {
new Function(("var " + ident + "=_"))
} catch (e) {
errors.push(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())))
}
}
}
function checkExpression (exp, text, errors) {
try {
new Function(("return " + exp))
} catch (e) {
var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE)
if (keywordMatch) {
errors.push(
"avoid using JavaScript keyword as property name: " +
"\"" + (keywordMatch[0]) + "\"\n Raw expression: " + (text.trim())
)
} else {
errors.push(
"invalid expression: " + (e.message) + " in\n\n" +
" " + exp + "\n\n" +
" Raw expression: " + (text.trim()) + "\n"
)
}
}
}
/* */
function createFunction (code, errors) {
try {
return new Function(code)
} catch (err) {
errors.push({ err: err, code: code })
return noop
}
}
function createCompileToFunctionFn (compile) {
var cache = Object.create(null)
return function compileToFunctions (
template,
options,
vm
) {
options = extend({}, options)
var warn$$1 = options.warn || warn
delete options.warn
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production') {
// detect possible CSP restriction
try {
new Function('return 1')
} catch (e) {
if (e.toString().match(/unsafe-eval|CSP/)) {
warn$$1(
'It seems you are using the standalone build of Vue.js in an ' +
'environment with Content Security Policy that prohibits unsafe-eval. ' +
'The template compiler cannot work in this environment. Consider ' +
'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
'templates into render functions.'
)
}
}
}
// check cache
var key = options.delimiters
? String(options.delimiters) + template
: template
if (cache[key]) {
return cache[key]
}
// compile
var compiled = compile(template, options)
// check compilation errors/tips
if (process.env.NODE_ENV !== 'production') {
if (compiled.errors && compiled.errors.length) {
warn$$1(
"Error compiling template:\n\n" + template + "\n\n" +
compiled.errors.map(function (e) {
return ("- " + e)
}).join('\n') + '\n',
vm
)
}
if (compiled.tips && compiled.tips.length) {
compiled.tips.forEach(function (msg) {
return tip(msg, vm)
})
}
}
// turn code into functions
var res = {}
var fnGenErrors = []
res.render = createFunction(compiled.render, fnGenErrors)
res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
return createFunction(code, fnGenErrors)
})
// check function generation errors.
// this should only happen if there is a bug in the compiler itself.
// mostly for codegen development use
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production') {
if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
warn$$1(
"Failed to generate render function:\n\n" +
fnGenErrors.map(function (ref) {
var err = ref.err
var code = ref.code
return ((err.toString()) + " in\n\n" + code + "\n")
}).join('\n'),
vm
)
}
}
return (cache[key] = res)
}
}
/* */
function createCompilerCreator (baseCompile) {
return function createCompiler (baseOptions) {
function compile (
template,
options
) {
var finalOptions = Object.create(baseOptions)
var errors = []
var tips = []
finalOptions.warn = function (msg, tip) {
(tip ? tips : errors).push(msg)
}
if (options) {
// merge custom modules
if (options.modules) {
finalOptions.modules =
(baseOptions.modules || []).concat(options.modules)
}
// merge custom directives
if (options.directives) {
finalOptions.directives = extend(
Object.create(baseOptions.directives),
options.directives
)
}
// copy other options
for (var key in options) {
if (key !== 'modules' && key !== 'directives') {
finalOptions[key] = options[key]
}
}
}
var compiled = baseCompile(template, finalOptions)
if (process.env.NODE_ENV !== 'production') {
errors.push.apply(errors, detectErrors(compiled.ast))
}
compiled.errors = errors
compiled.tips = tips
return compiled
}
return {
compile: compile,
compileToFunctions: createCompileToFunctionFn(compile)
}
}
}
/* */
var createCompiler = createCompilerCreator(function baseCompile (
template,
options
) {
var ast = parse(template.trim(), options)
optimize(ast, options)
var code = generate(ast, options)
return {
ast: ast,
render: code.render,
staticRenderFns: code.staticRenderFns
}
})
/* */
var ref = createCompiler(baseOptions)
var compileToFunctions = ref.compileToFunctions
/* */
// The template compiler attempts to minimize the need for normalization by
// statically analyzing the template at compile time.
//
// For plain HTML markup, normalization can be completely skipped because the
// generated render function is guaranteed to return Array<VNode>. There are
// two cases where extra normalization is needed:
// 1. When the children contains components - because a functional component
// may return an Array instead of a single root. In this case, just a simple
// normalization is needed - if any child is an Array, we flatten the whole
// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
// because functional components already normalize their own children.
function simpleNormalizeChildren (children) {
for (var i = 0; i < children.length; i++) {
if (Array.isArray(children[i])) {
return Array.prototype.concat.apply([], children)
}
}
return children
}
// 2. When the children contains constructs that always generated nested Arrays,
// e.g. <template>, <slot>, v-for, or when the children is provided by user
// with hand-written render functions / JSX. In such cases a full normalization
// is needed to cater to all possible types of children values.
function normalizeChildren (children) {
return isPrimitive(children)
? [createTextVNode(children)]
: Array.isArray(children)
? normalizeArrayChildren(children)
: undefined
}
function isTextNode (node) {
return isDef(node) && isDef(node.text) && isFalse(node.isComment)
}
function normalizeArrayChildren (children, nestedIndex) {
var res = []
var i, c, lastIndex, last
for (i = 0; i < children.length; i++) {
c = children[i]
if (isUndef(c) || typeof c === 'boolean') {
continue
}
lastIndex = res.length - 1
last = res[lastIndex]
// nested
if (Array.isArray(c)) {
if (c.length > 0) {
c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i))
// merge adjacent text nodes
if (isTextNode(c[0]) && isTextNode(last)) {
res[lastIndex] = createTextVNode(last.text + (c[0]).text)
c.shift()
}
res.push.apply(res, c)
}
} else if (isPrimitive(c)) {
if (isTextNode(last)) {
// merge adjacent text nodes
// this is necessary for SSR hydration because text nodes are
// essentially merged when rendered to HTML strings
res[lastIndex] = createTextVNode(last.text + c)
} else if (c !== '') {
// convert primitive to vnode
res.push(createTextVNode(c))
}
} else {
if (isTextNode(c) && isTextNode(last)) {
// merge adjacent text nodes
res[lastIndex] = createTextVNode(last.text + c.text)
} else {
// default key for nested array children (likely generated by v-for)
if (isTrue(children._isVList) &&
isDef(c.tag) &&
isUndef(c.key) &&
isDef(nestedIndex)) {
c.key = "__vlist" + nestedIndex + "_" + i + "__"
}
res.push(c)
}
}
}
return res
}
/* */
function installSSRHelpers (vm) {
if (vm._ssrNode) {
return
}
var Ctor = vm.constructor
while (Ctor.super) {
Ctor = Ctor.super
}
extend(Ctor.prototype, {
_ssrEscape: escape,
_ssrNode: renderStringNode$1,
_ssrList: renderStringList,
_ssrAttr: renderAttr,
_ssrAttrs: renderAttrs$1,
_ssrDOMProps: renderDOMProps$1,
_ssrClass: renderSSRClass,
_ssrStyle: renderSSRStyle
})
}
var StringNode = function StringNode (
open,
close,
children,
normalizationType
) {
this.isString = true
this.open = open
this.close = close
if (children) {
this.children = normalizationType === 1
? simpleNormalizeChildren(children)
: normalizationType === 2
? normalizeChildren(children)
: children
} else {
this.children = void 0
}
}
function renderStringNode$1 (
open,
close,
children,
normalizationType
) {
return new StringNode(open, close, children, normalizationType)
}
function renderStringList (
val,
render
) {
var ret = ''
var i, l, keys, key
if (Array.isArray(val) || typeof val === 'string') {
for (i = 0, l = val.length; i < l; i++) {
ret += render(val[i], i)
}
} else if (typeof val === 'number') {
for (i = 0; i < val; i++) {
ret += render(i + 1, i)
}
} else if (isObject(val)) {
keys = Object.keys(val)
for (i = 0, l = keys.length; i < l; i++) {
key = keys[i]
ret += render(val[key], key, i)
}
}
return ret
}
function renderAttrs$1 (obj) {
var res = ''
for (var key in obj) {
res += renderAttr(key, obj[key])
}
return res
}
function renderDOMProps$1 (obj) {
var res = ''
for (var key in obj) {
var attr = propsToAttrMap[key] || key.toLowerCase()
if (isRenderableAttr(attr)) {
res += renderAttr(attr, obj[key])
}
}
return res
}
function renderSSRClass (
staticClass,
dynamic
) {
var res = renderClass$1(staticClass, dynamic)
return res === '' ? res : (" class=\"" + (escape(res)) + "\"")
}
function renderSSRStyle (
staticStyle,
dynamic,
extra
) {
var style = {}
if (staticStyle) {
extend(style, staticStyle)
}
if (dynamic) {
extend(style, normalizeStyleBinding(dynamic))
}
if (extra) {
extend(style, extra)
}
var res = genStyle(style)
return res === '' ? res : (" style=" + (JSON.stringify(escape(res))))
}
/* not type checking this file because flow doesn't play well with Proxy */
if (process.env.NODE_ENV !== 'production') {
var allowedGlobals = makeMap(
'Infinity,undefined,NaN,isFinite,isNaN,' +
'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
'require' // for Webpack/Browserify
)
var hasProxy =
typeof Proxy !== 'undefined' &&
Proxy.toString().match(/native code/)
if (hasProxy) {
var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact')
config.keyCodes = new Proxy(config.keyCodes, {
set: function set (target, key, value) {
if (isBuiltInModifier(key)) {
warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key))
return false
} else {
target[key] = value
return true
}
}
})
}
}
/* */
var seenObjects = new _Set()
/**
* Recursively traverse an object to evoke all converted
* getters, so that every nested property inside the object
* is collected as a "deep" dependency.
*/
function traverse (val) {
_traverse(val, seenObjects)
seenObjects.clear()
}
function _traverse (val, seen) {
var i, keys
var isA = Array.isArray(val)
if ((!isA && !isObject(val)) || Object.isFrozen(val)) {
return
}
if (val.__ob__) {
var depId = val.__ob__.dep.id
if (seen.has(depId)) {
return
}
seen.add(depId)
}
if (isA) {
i = val.length
while (i--) {
_traverse(val[i], seen)
}
} else {
keys = Object.keys(val)
i = keys.length
while (i--) {
_traverse(val[keys[i]], seen)
}
}
}
/* */
var normalizeEvent = cached(function (name) {
var passive = name.charAt(0) === '&'
name = passive ? name.slice(1) : name
var once$$1 = name.charAt(0) === '~' // Prefixed last, checked first
name = once$$1 ? name.slice(1) : name
var capture = name.charAt(0) === '!'
name = capture ? name.slice(1) : name
return {
name: name,
once: once$$1,
capture: capture,
passive: passive
}
})
function createFnInvoker (fns) {
function invoker () {
var arguments$1 = arguments
var fns = invoker.fns
if (Array.isArray(fns)) {
var cloned = fns.slice()
for (var i = 0; i < cloned.length; i++) {
cloned[i].apply(null, arguments$1)
}
} else {
// return handler return value for single handlers
return fns.apply(null, arguments)
}
}
invoker.fns = fns
return invoker
}
function updateListeners (
on,
oldOn,
add,
remove$$1,
vm
) {
var name, cur, old, event
for (name in on) {
cur = on[name]
old = oldOn[name]
event = normalizeEvent(name)
if (isUndef(cur)) {
process.env.NODE_ENV !== 'production' && warn(
"Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
vm
)
} else if (isUndef(old)) {
if (isUndef(cur.fns)) {
cur = on[name] = createFnInvoker(cur)
}
add(event.name, cur, event.once, event.capture, event.passive)
} else if (cur !== old) {
old.fns = cur
on[name] = old
}
}
for (name in oldOn) {
if (isUndef(on[name])) {
event = normalizeEvent(name)
remove$$1(event.name, oldOn[name], event.capture)
}
}
}
/* */
/* */
function extractPropsFromVNodeData (
data,
Ctor,
tag
) {
// we are only extracting raw values here.
// validation and default values are handled in the child
// component itself.
var propOptions = Ctor.options.props
if (isUndef(propOptions)) {
return
}
var res = {}
var attrs = data.attrs
var props = data.props
if (isDef(attrs) || isDef(props)) {
for (var key in propOptions) {
var altKey = hyphenate(key)
if (process.env.NODE_ENV !== 'production') {
var keyInLowerCase = key.toLowerCase()
if (
key !== keyInLowerCase &&
attrs && hasOwn(attrs, keyInLowerCase)
) {
tip(
"Prop \"" + keyInLowerCase + "\" is passed to component " +
(formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
" \"" + key + "\". " +
"Note that HTML attributes are case-insensitive and camelCased " +
"props need to use their kebab-case equivalents when using in-DOM " +
"templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
)
}
}
checkProp(res, props, key, altKey, true) ||
checkProp(res, attrs, key, altKey, false)
}
}
return res
}
function checkProp (
res,
hash,
key,
altKey,
preserve
) {
if (isDef(hash)) {
if (hasOwn(hash, key)) {
res[key] = hash[key]
if (!preserve) {
delete hash[key]
}
return true
} else if (hasOwn(hash, altKey)) {
res[key] = hash[altKey]
if (!preserve) {
delete hash[altKey]
}
return true
}
}
return false
}
/* */
function ensureCtor (comp, base) {
if (
comp.__esModule ||
(hasSymbol && comp[Symbol.toStringTag] === 'Module')
) {
comp = comp.default
}
return isObject(comp)
? base.extend(comp)
: comp
}
function createAsyncPlaceholder (
factory,
data,
context,
children,
tag
) {
var node = createEmptyVNode()
node.asyncFactory = factory
node.asyncMeta = { data: data, context: context, children: children, tag: tag }
return node
}
function resolveAsyncComponent (
factory,
baseCtor,
context
) {
if (isTrue(factory.error) && isDef(factory.errorComp)) {
return factory.errorComp
}
if (isDef(factory.resolved)) {
return factory.resolved
}
if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
return factory.loadingComp
}
if (isDef(factory.contexts)) {
// already pending
factory.contexts.push(context)
} else {
var contexts = factory.contexts = [context]
var sync = true
var forceRender = function () {
for (var i = 0, l = contexts.length; i < l; i++) {
contexts[i].$forceUpdate()
}
}
var resolve = once(function (res) {
// cache resolved
factory.resolved = ensureCtor(res, baseCtor)
// invoke callbacks only if this is not a synchronous resolve
// (async resolves are shimmed as synchronous during SSR)
if (!sync) {
forceRender()
}
})
var reject = once(function (reason) {
process.env.NODE_ENV !== 'production' && warn(
"Failed to resolve async component: " + (String(factory)) +
(reason ? ("\nReason: " + reason) : '')
)
if (isDef(factory.errorComp)) {
factory.error = true
forceRender()
}
})
var res = factory(resolve, reject)
if (isObject(res)) {
if (typeof res.then === 'function') {
// () => Promise
if (isUndef(factory.resolved)) {
res.then(resolve, reject)
}
} else if (isDef(res.component) && typeof res.component.then === 'function') {
res.component.then(resolve, reject)
if (isDef(res.error)) {
factory.errorComp = ensureCtor(res.error, baseCtor)
}
if (isDef(res.loading)) {
factory.loadingComp = ensureCtor(res.loading, baseCtor)
if (res.delay === 0) {
factory.loading = true
} else {
setTimeout(function () {
if (isUndef(factory.resolved) && isUndef(factory.error)) {
factory.loading = true
forceRender()
}
}, res.delay || 200)
}
}
if (isDef(res.timeout)) {
setTimeout(function () {
if (isUndef(factory.resolved)) {
reject(
process.env.NODE_ENV !== 'production'
? ("timeout (" + (res.timeout) + "ms)")
: null
)
}
}, res.timeout)
}
}
}
sync = false
// return in case resolved synchronously
return factory.loading
? factory.loadingComp
: factory.resolved
}
}
/* */
/* */
/* */
/* */
var target
function add (event, fn, once) {
if (once) {
target.$once(event, fn)
} else {
target.$on(event, fn)
}
}
function remove$1 (event, fn) {
target.$off(event, fn)
}
function updateComponentListeners (
vm,
listeners,
oldListeners
) {
target = vm
updateListeners(listeners, oldListeners || {}, add, remove$1, vm)
target = undefined
}
/* */
/**
* Runtime helper for resolving raw children VNodes into a slot object.
*/
function resolveSlots (
children,
context
) {
var slots = {}
if (!children) {
return slots
}
for (var i = 0, l = children.length; i < l; i++) {
var child = children[i]
var data = child.data
// remove slot attribute if the node is resolved as a Vue slot node
if (data && data.attrs && data.attrs.slot) {
delete data.attrs.slot
}
// named slots should only be respected if the vnode was rendered in the
// same context.
if ((child.context === context || child.fnContext === context) &&
data && data.slot != null
) {
var name = child.data.slot
var slot = (slots[name] || (slots[name] = []))
if (child.tag === 'template') {
slot.push.apply(slot, child.children)
} else {
slot.push(child)
}
} else {
(slots.default || (slots.default = [])).push(child)
}
}
// ignore slots that contains only whitespace
for (var name$1 in slots) {
if (slots[name$1].every(isWhitespace)) {
delete slots[name$1]
}
}
return slots
}
function isWhitespace (node) {
return (node.isComment && !node.asyncFactory) || node.text === ' '
}
function resolveScopedSlots (
fns, // see flow/vnode
res
) {
res = res || {}
for (var i = 0; i < fns.length; i++) {
if (Array.isArray(fns[i])) {
resolveScopedSlots(fns[i], res)
} else {
res[fns[i].key] = fns[i].fn
}
}
return res
}
/* */
var activeInstance = null
function updateChildComponent (
vm,
propsData,
listeners,
parentVnode,
renderChildren
) {
var hasChildren = !!(
renderChildren || // has new static slots
vm.$options._renderChildren || // has old static slots
parentVnode.data.scopedSlots || // has new scoped slots
vm.$scopedSlots !== emptyObject // has old scoped slots
)
vm.$options._parentVnode = parentVnode
vm.$vnode = parentVnode // update vm's placeholder node without re-render
if (vm._vnode) { // update child tree's parent
vm._vnode.parent = parentVnode
}
vm.$options._renderChildren = renderChildren
// update $attrs and $listeners hash
// these are also reactive so they may trigger child update if the child
// used them during render
vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject
vm.$listeners = listeners || emptyObject
// update props
if (propsData && vm.$options.props) {
observerState.shouldConvert = false
var props = vm._props
var propKeys = vm.$options._propKeys || []
for (var i = 0; i < propKeys.length; i++) {
var key = propKeys[i]
props[key] = validateProp(key, vm.$options.props, propsData, vm)
}
observerState.shouldConvert = true
// keep a copy of raw propsData
vm.$options.propsData = propsData
}
// update listeners
if (listeners) {
var oldListeners = vm.$options._parentListeners
vm.$options._parentListeners = listeners
updateComponentListeners(vm, listeners, oldListeners)
}
// resolve slots + force update if has children
if (hasChildren) {
vm.$slots = resolveSlots(renderChildren, parentVnode.context)
vm.$forceUpdate()
}
}
function isInInactiveTree (vm) {
while (vm && (vm = vm.$parent)) {
if (vm._inactive) {
return true
}
}
return false
}
function activateChildComponent (vm, direct) {
if (direct) {
vm._directInactive = false
if (isInInactiveTree(vm)) {
return
}
} else if (vm._directInactive) {
return
}
if (vm._inactive || vm._inactive === null) {
vm._inactive = false
for (var i = 0; i < vm.$children.length; i++) {
activateChildComponent(vm.$children[i])
}
callHook(vm, 'activated')
}
}
function deactivateChildComponent (vm, direct) {
if (direct) {
vm._directInactive = true
if (isInInactiveTree(vm)) {
return
}
}
if (!vm._inactive) {
vm._inactive = true
for (var i = 0; i < vm.$children.length; i++) {
deactivateChildComponent(vm.$children[i])
}
callHook(vm, 'deactivated')
}
}
function callHook (vm, hook) {
var handlers = vm.$options[hook]
if (handlers) {
for (var i = 0, j = handlers.length; i < j; i++) {
try {
handlers[i].call(vm)
} catch (e) {
handleError(e, vm, (hook + " hook"))
}
}
}
if (vm._hasHookEvent) {
vm.$emit('hook:' + hook)
}
}
/* */
var MAX_UPDATE_COUNT = 100
var queue = []
var activatedChildren = []
var has = {}
var circular = {}
var waiting = false
var flushing = false
var index$1 = 0
/**
* Reset the scheduler's state.
*/
function resetSchedulerState () {
index$1 = queue.length = activatedChildren.length = 0
has = {}
if (process.env.NODE_ENV !== 'production') {
circular = {}
}
waiting = flushing = false
}
/**
* Flush both queues and run the watchers.
*/
function flushSchedulerQueue () {
flushing = true
var watcher, id
// Sort queue before flush.
// This ensures that:
// 1. Components are updated from parent to child. (because parent is always
// created before the child)
// 2. A component's user watchers are run before its render watcher (because
// user watchers are created before the render watcher)
// 3. If a component is destroyed during a parent component's watcher run,
// its watchers can be skipped.
queue.sort(function (a, b) {
return a.id - b.id
})
// do not cache length because more watchers might be pushed
// as we run existing watchers
for (index$1 = 0; index$1 < queue.length; index$1++) {
watcher = queue[index$1]
id = watcher.id
has[id] = null
watcher.run()
// in dev build, check and stop circular updates.
if (process.env.NODE_ENV !== 'production' && has[id] != null) {
circular[id] = (circular[id] || 0) + 1
if (circular[id] > MAX_UPDATE_COUNT) {
warn(
'You may have an infinite update loop ' + (
watcher.user
? ("in watcher with expression \"" + (watcher.expression) + "\"")
: "in a component render function."
),
watcher.vm
)
break
}
}
}
// keep copies of post queues before resetting state
var activatedQueue = activatedChildren.slice()
var updatedQueue = queue.slice()
resetSchedulerState()
// call component updated and activated hooks
callActivatedHooks(activatedQueue)
callUpdatedHooks(updatedQueue)
// devtool hook
/* istanbul ignore if */
if (devtools && config.devtools) {
devtools.emit('flush')
}
}
function callUpdatedHooks (queue) {
var i = queue.length
while (i--) {
var watcher = queue[i]
var vm = watcher.vm
if (vm._watcher === watcher && vm._isMounted) {
callHook(vm, 'updated')
}
}
}
/**
* Queue a kept-alive component that was activated during patch.
* The queue will be processed after the entire tree has been patched.
*/
function queueActivatedComponent (vm) {
// setting _inactive to false here so that a render function can
// rely on checking whether it's in an inactive tree (e.g. router-view)
vm._inactive = false
activatedChildren.push(vm)
}
function callActivatedHooks (queue) {
for (var i = 0; i < queue.length; i++) {
queue[i]._inactive = true
activateChildComponent(queue[i], true /* true */)
}
}
/**
* Push a watcher into the watcher queue.
* Jobs with duplicate IDs will be skipped unless it's
* pushed when the queue is being flushed.
*/
function queueWatcher (watcher) {
var id = watcher.id
if (has[id] == null) {
has[id] = true
if (!flushing) {
queue.push(watcher)
} else {
// if already flushing, splice the watcher based on its id
// if already past its id, it will be run next immediately.
var i = queue.length - 1
while (i > index$1 && queue[i].id > watcher.id) {
i--
}
queue.splice(i + 1, 0, watcher)
}
// queue the flush
if (!waiting) {
waiting = true
nextTick(flushSchedulerQueue)
}
}
}
/* */
var uid$2 = 0
/**
* A watcher parses an expression, collects dependencies,
* and fires callback when the expression value changes.
* This is used for both the $watch() api and directives.
*/
var Watcher = function Watcher (
vm,
expOrFn,
cb,
options,
isRenderWatcher
) {
this.vm = vm
if (isRenderWatcher) {
vm._watcher = this
}
vm._watchers.push(this)
// options
if (options) {
this.deep = !!options.deep
this.user = !!options.user
this.lazy = !!options.lazy
this.sync = !!options.sync
} else {
this.deep = this.user = this.lazy = this.sync = false
}
this.cb = cb
this.id = ++uid$2 // uid for batching
this.active = true
this.dirty = this.lazy // for lazy watchers
this.deps = []
this.newDeps = []
this.depIds = new _Set()
this.newDepIds = new _Set()
this.expression = process.env.NODE_ENV !== 'production'
? expOrFn.toString()
: ''
// parse expression for getter
if (typeof expOrFn === 'function') {
this.getter = expOrFn
} else {
this.getter = parsePath(expOrFn)
if (!this.getter) {
this.getter = function () {}
process.env.NODE_ENV !== 'production' && warn(
"Failed watching path: \"" + expOrFn + "\" " +
'Watcher only accepts simple dot-delimited paths. ' +
'For full control, use a function instead.',
vm
)
}
}
this.value = this.lazy
? undefined
: this.get()
}
/**
* Evaluate the getter, and re-collect dependencies.
*/
Watcher.prototype.get = function get () {
pushTarget(this)
var value
var vm = this.vm
try {
value = this.getter.call(vm, vm)
} catch (e) {
if (this.user) {
handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""))
} else {
throw e
}
} finally {
// "touch" every property so they are all tracked as
// dependencies for deep watching
if (this.deep) {
traverse(value)
}
popTarget()
this.cleanupDeps()
}
return value
}
/**
* Add a dependency to this directive.
*/
Watcher.prototype.addDep = function addDep (dep) {
var id = dep.id
if (!this.newDepIds.has(id)) {
this.newDepIds.add(id)
this.newDeps.push(dep)
if (!this.depIds.has(id)) {
dep.addSub(this)
}
}
}
/**
* Clean up for dependency collection.
*/
Watcher.prototype.cleanupDeps = function cleanupDeps () {
var this$1 = this
var i = this.deps.length
while (i--) {
var dep = this$1.deps[i]
if (!this$1.newDepIds.has(dep.id)) {
dep.removeSub(this$1)
}
}
var tmp = this.depIds
this.depIds = this.newDepIds
this.newDepIds = tmp
this.newDepIds.clear()
tmp = this.deps
this.deps = this.newDeps
this.newDeps = tmp
this.newDeps.length = 0
}
/**
* Subscriber interface.
* Will be called when a dependency changes.
*/
Watcher.prototype.update = function update () {
/* istanbul ignore else */
if (this.lazy) {
this.dirty = true
} else if (this.sync) {
this.run()
} else {
queueWatcher(this)
}
}
/**
* Scheduler job interface.
* Will be called by the scheduler.
*/
Watcher.prototype.run = function run () {
if (this.active) {
var value = this.get()
if (
value !== this.value ||
// Deep watchers and watchers on Object/Arrays should fire even
// when the value is the same, because the value may
// have mutated.
isObject(value) ||
this.deep
) {
// set new value
var oldValue = this.value
this.value = value
if (this.user) {
try {
this.cb.call(this.vm, value, oldValue)
} catch (e) {
handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""))
}
} else {
this.cb.call(this.vm, value, oldValue)
}
}
}
}
/**
* Evaluate the value of the watcher.
* This only gets called for lazy watchers.
*/
Watcher.prototype.evaluate = function evaluate () {
this.value = this.get()
this.dirty = false
}
/**
* Depend on all deps collected by this watcher.
*/
Watcher.prototype.depend = function depend () {
var this$1 = this
var i = this.deps.length
while (i--) {
this$1.deps[i].depend()
}
}
/**
* Remove self from all dependencies' subscriber list.
*/
Watcher.prototype.teardown = function teardown () {
var this$1 = this
if (this.active) {
// remove self from vm's watcher list
// this is a somewhat expensive operation so we skip it
// if the vm is being destroyed.
if (!this.vm._isBeingDestroyed) {
remove(this.vm._watchers, this)
}
var i = this.deps.length
while (i--) {
this$1.deps[i].removeSub(this$1)
}
this.active = false
}
}
/* */
/* */
var SIMPLE_NORMALIZE = 1
var ALWAYS_NORMALIZE = 2
// wrapper function for providing a more flexible interface
// without getting yelled at by flow
function createElement (
context,
tag,
data,
children,
normalizationType,
alwaysNormalize
) {
if (Array.isArray(data) || isPrimitive(data)) {
normalizationType = children
children = data
data = undefined
}
if (isTrue(alwaysNormalize)) {
normalizationType = ALWAYS_NORMALIZE
}
return _createElement(context, tag, data, children, normalizationType)
}
function _createElement (
context,
tag,
data,
children,
normalizationType
) {
if (isDef(data) && isDef((data).__ob__)) {
process.env.NODE_ENV !== 'production' && warn(
"Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
'Always create fresh vnode data objects in each render!',
context
)
return createEmptyVNode()
}
// object syntax in v-bind
if (isDef(data) && isDef(data.is)) {
tag = data.is
}
if (!tag) {
// in case of component :is set to falsy value
return createEmptyVNode()
}
// warn against non-primitive key
if (process.env.NODE_ENV !== 'production' &&
isDef(data) && isDef(data.key) && !isPrimitive(data.key)
) {
warn(
'Avoid using non-primitive value as key, ' +
'use string/number value instead.',
context
)
}
// support single function children as default scoped slot
if (Array.isArray(children) &&
typeof children[0] === 'function'
) {
data = data || {}
data.scopedSlots = { default: children[0] }
children.length = 0
}
if (normalizationType === ALWAYS_NORMALIZE) {
children = normalizeChildren(children)
} else if (normalizationType === SIMPLE_NORMALIZE) {
children = simpleNormalizeChildren(children)
}
var vnode, ns
if (typeof tag === 'string') {
var Ctor
ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
if (config.isReservedTag(tag)) {
// platform built-in elements
vnode = new VNode(
config.parsePlatformTagName(tag), data, children,
undefined, undefined, context
)
} else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
// component
vnode = createComponent(Ctor, data, context, children, tag)
} else {
// unknown or unlisted namespaced elements
// check at runtime because it may get assigned a namespace when its
// parent normalizes children
vnode = new VNode(
tag, data, children,
undefined, undefined, context
)
}
} else {
// direct component options / constructor
vnode = createComponent(tag, data, context, children)
}
if (isDef(vnode)) {
if (ns) {
applyNS(vnode, ns)
}
return vnode
} else {
return createEmptyVNode()
}
}
function applyNS (vnode, ns, force) {
vnode.ns = ns
if (vnode.tag === 'foreignObject') {
// use default namespace inside foreignObject
ns = undefined
force = true
}
if (isDef(vnode.children)) {
for (var i = 0, l = vnode.children.length; i < l; i++) {
var child = vnode.children[i]
if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) {
applyNS(child, ns, force)
}
}
}
}
/* */
/**
* Runtime helper for rendering v-for lists.
*/
function renderList (
val,
render
) {
var ret, i, l, keys, key
if (Array.isArray(val) || typeof val === 'string') {
ret = new Array(val.length)
for (i = 0, l = val.length; i < l; i++) {
ret[i] = render(val[i], i)
}
} else if (typeof val === 'number') {
ret = new Array(val)
for (i = 0; i < val; i++) {
ret[i] = render(i + 1, i)
}
} else if (isObject(val)) {
keys = Object.keys(val)
ret = new Array(keys.length)
for (i = 0, l = keys.length; i < l; i++) {
key = keys[i]
ret[i] = render(val[key], key, i)
}
}
if (isDef(ret)) {
(ret)._isVList = true
}
return ret
}
/* */
/**
* Runtime helper for rendering <slot>
*/
function renderSlot (
name,
fallback,
props,
bindObject
) {
var scopedSlotFn = this.$scopedSlots[name]
var nodes
if (scopedSlotFn) { // scoped slot
props = props || {}
if (bindObject) {
if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
warn(
'slot v-bind without argument expects an Object',
this
)
}
props = extend(extend({}, bindObject), props)
}
nodes = scopedSlotFn(props) || fallback
} else {
var slotNodes = this.$slots[name]
// warn duplicate slot usage
if (slotNodes) {
if (process.env.NODE_ENV !== 'production' && slotNodes._rendered) {
warn(
"Duplicate presence of slot \"" + name + "\" found in the same render tree " +
"- this will likely cause render errors.",
this
)
}
slotNodes._rendered = true
}
nodes = slotNodes || fallback
}
var target = props && props.slot
if (target) {
return this.$createElement('template', { slot: target }, nodes)
} else {
return nodes
}
}
/* */
/**
* Runtime helper for resolving filters
*/
function resolveFilter (id) {
return resolveAsset(this.$options, 'filters', id, true) || identity
}
/* */
/**
* Runtime helper for checking keyCodes from config.
* exposed as Vue.prototype._k
* passing in eventKeyName as last argument separately for backwards compat
*/
function checkKeyCodes (
eventKeyCode,
key,
builtInAlias,
eventKeyName
) {
var keyCodes = config.keyCodes[key] || builtInAlias
if (keyCodes) {
if (Array.isArray(keyCodes)) {
return keyCodes.indexOf(eventKeyCode) === -1
} else {
return keyCodes !== eventKeyCode
}
} else if (eventKeyName) {
return hyphenate(eventKeyName) !== key
}
}
/* */
/**
* Runtime helper for merging v-bind="object" into a VNode's data.
*/
function bindObjectProps (
data,
tag,
value,
asProp,
isSync
) {
if (value) {
if (!isObject(value)) {
process.env.NODE_ENV !== 'production' && warn(
'v-bind without argument expects an Object or Array value',
this
)
} else {
if (Array.isArray(value)) {
value = toObject(value)
}
var hash
var loop = function ( key ) {
if (
key === 'class' ||
key === 'style' ||
isReservedAttribute(key)
) {
hash = data
} else {
var type = data.attrs && data.attrs.type
hash = asProp || config.mustUseProp(tag, type, key)
? data.domProps || (data.domProps = {})
: data.attrs || (data.attrs = {})
}
if (!(key in hash)) {
hash[key] = value[key]
if (isSync) {
var on = data.on || (data.on = {})
on[("update:" + key)] = function ($event) {
value[key] = $event
}
}
}
}
for (var key in value)
loop( key )
}
}
return data
}
/* */
/**
* Runtime helper for rendering static trees.
*/
function renderStatic (
index,
isInFor,
isOnce
) {
// render fns generated by compiler < 2.5.4 does not provide v-once
// information to runtime so be conservative
var isOldVersion = arguments.length < 3
// if a static tree is generated by v-once, it is cached on the instance;
// otherwise it is purely static and can be cached on the shared options
// across all instances.
var renderFns = this.$options.staticRenderFns
var cached = isOldVersion || isOnce
? (this._staticTrees || (this._staticTrees = []))
: (renderFns.cached || (renderFns.cached = []))
var tree = cached[index]
// if has already-rendered static tree and not inside v-for,
// we can reuse the same tree by doing a shallow clone.
if (tree && !isInFor) {
return Array.isArray(tree)
? cloneVNodes(tree)
: cloneVNode(tree)
}
// otherwise, render a fresh tree.
tree = cached[index] = renderFns[index].call(this._renderProxy, null, this)
markStatic(tree, ("__static__" + index), false)
return tree
}
/**
* Runtime helper for v-once.
* Effectively it means marking the node as static with a unique key.
*/
function markOnce (
tree,
index,
key
) {
markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true)
return tree
}
function markStatic (
tree,
key,
isOnce
) {
if (Array.isArray(tree)) {
for (var i = 0; i < tree.length; i++) {
if (tree[i] && typeof tree[i] !== 'string') {
markStaticNode(tree[i], (key + "_" + i), isOnce)
}
}
} else {
markStaticNode(tree, key, isOnce)
}
}
function markStaticNode (node, key, isOnce) {
node.isStatic = true
node.key = key
node.isOnce = isOnce
}
/* */
function bindObjectListeners (data, value) {
if (value) {
if (!isPlainObject(value)) {
process.env.NODE_ENV !== 'production' && warn(
'v-on without argument expects an Object value',
this
)
} else {
var on = data.on = data.on ? extend({}, data.on) : {}
for (var key in value) {
var existing = on[key]
var ours = value[key]
on[key] = existing ? [].concat(existing, ours) : ours
}
}
}
return data
}
/* */
function installRenderHelpers (target) {
target._o = markOnce
target._n = toNumber
target._s = toString
target._l = renderList
target._t = renderSlot
target._q = looseEqual
target._i = looseIndexOf
target._m = renderStatic
target._f = resolveFilter
target._k = checkKeyCodes
target._b = bindObjectProps
target._v = createTextVNode
target._e = createEmptyVNode
target._u = resolveScopedSlots
target._g = bindObjectListeners
}
/* */
/* */
function resolveInject (inject, vm) {
if (inject) {
// inject is :any because flow is not smart enough to figure out cached
var result = Object.create(null)
var keys = hasSymbol
? Reflect.ownKeys(inject).filter(function (key) {
/* istanbul ignore next */
return Object.getOwnPropertyDescriptor(inject, key).enumerable
})
: Object.keys(inject)
for (var i = 0; i < keys.length; i++) {
var key = keys[i]
var provideKey = inject[key].from
var source = vm
while (source) {
if (source._provided && provideKey in source._provided) {
result[key] = source._provided[provideKey]
break
}
source = source.$parent
}
if (!source) {
if ('default' in inject[key]) {
var provideDefault = inject[key].default
result[key] = typeof provideDefault === 'function'
? provideDefault.call(vm)
: provideDefault
} else if (process.env.NODE_ENV !== 'production') {
warn(("Injection \"" + key + "\" not found"), vm)
}
}
}
return result
}
}
/* */
function resolveConstructorOptions (Ctor) {
var options = Ctor.options
if (Ctor.super) {
var superOptions = resolveConstructorOptions(Ctor.super)
var cachedSuperOptions = Ctor.superOptions
if (superOptions !== cachedSuperOptions) {
// super option changed,
// need to resolve new options.
Ctor.superOptions = superOptions
// check if there are any late-modified/attached options (#4976)
var modifiedOptions = resolveModifiedOptions(Ctor)
// update base extend options
if (modifiedOptions) {
extend(Ctor.extendOptions, modifiedOptions)
}
options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)
if (options.name) {
options.components[options.name] = Ctor
}
}
}
return options
}
function resolveModifiedOptions (Ctor) {
var modified
var latest = Ctor.options
var extended = Ctor.extendOptions
var sealed = Ctor.sealedOptions
for (var key in latest) {
if (latest[key] !== sealed[key]) {
if (!modified) {
modified = {}
}
modified[key] = dedupe(latest[key], extended[key], sealed[key])
}
}
return modified
}
function dedupe (latest, extended, sealed) {
// compare latest and sealed to ensure lifecycle hooks won't be duplicated
// between merges
if (Array.isArray(latest)) {
var res = []
sealed = Array.isArray(sealed) ? sealed : [sealed]
extended = Array.isArray(extended) ? extended : [extended]
for (var i = 0; i < latest.length; i++) {
// push original options and not sealed options to exclude duplicated options
if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {
res.push(latest[i])
}
}
return res
} else {
return latest
}
}
/* */
function FunctionalRenderContext (
data,
props,
children,
parent,
Ctor
) {
var options = Ctor.options
this.data = data
this.props = props
this.children = children
this.parent = parent
this.listeners = data.on || emptyObject
this.injections = resolveInject(options.inject, parent)
this.slots = function () {
return resolveSlots(children, parent)
}
// ensure the createElement function in functional components
// gets a unique context - this is necessary for correct named slot check
var contextVm = Object.create(parent)
var isCompiled = isTrue(options._compiled)
var needNormalization = !isCompiled
// support for compiled functional template
if (isCompiled) {
// exposing $options for renderStatic()
this.$options = options
// pre-resolve slots for renderSlot()
this.$slots = this.slots()
this.$scopedSlots = data.scopedSlots || emptyObject
}
if (options._scopeId) {
this._c = function (a, b, c, d) {
var vnode = createElement(contextVm, a, b, c, d, needNormalization)
if (vnode) {
vnode.fnScopeId = options._scopeId
vnode.fnContext = parent
}
return vnode
}
} else {
this._c = function (a, b, c, d) {
return createElement(contextVm, a, b, c, d, needNormalization)
}
}
}
installRenderHelpers(FunctionalRenderContext.prototype)
function createFunctionalComponent (
Ctor,
propsData,
data,
contextVm,
children
) {
var options = Ctor.options
var props = {}
var propOptions = options.props
if (isDef(propOptions)) {
for (var key in propOptions) {
props[key] = validateProp(key, propOptions, propsData || emptyObject)
}
} else {
if (isDef(data.attrs)) {
mergeProps(props, data.attrs)
}
if (isDef(data.props)) {
mergeProps(props, data.props)
}
}
var renderContext = new FunctionalRenderContext(
data,
props,
children,
contextVm,
Ctor
)
var vnode = options.render.call(null, renderContext._c, renderContext)
if (vnode instanceof VNode) {
vnode.fnContext = contextVm
vnode.fnOptions = options
if (data.slot) {
(vnode.data || (vnode.data = {})).slot = data.slot
}
}
return vnode
}
function mergeProps (to, from) {
for (var key in from) {
to[camelize(key)] = from[key]
}
}
/* */
// hooks to be invoked on component VNodes during patch
var componentVNodeHooks = {
init: function init (
vnode,
hydrating,
parentElm,
refElm
) {
if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
var child = vnode.componentInstance = createComponentInstanceForVnode(
vnode,
activeInstance,
parentElm,
refElm
)
child.$mount(hydrating ? vnode.elm : undefined, hydrating)
} else if (vnode.data.keepAlive) {
// kept-alive components, treat as a patch
var mountedNode = vnode // work around flow
componentVNodeHooks.prepatch(mountedNode, mountedNode)
}
},
prepatch: function prepatch (oldVnode, vnode) {
var options = vnode.componentOptions
var child = vnode.componentInstance = oldVnode.componentInstance
updateChildComponent(
child,
options.propsData, // updated props
options.listeners, // updated listeners
vnode, // new parent vnode
options.children // new children
)
},
insert: function insert (vnode) {
var context = vnode.context
var componentInstance = vnode.componentInstance
if (!componentInstance._isMounted) {
componentInstance._isMounted = true
callHook(componentInstance, 'mounted')
}
if (vnode.data.keepAlive) {
if (context._isMounted) {
// vue-router#1212
// During updates, a kept-alive component's child components may
// change, so directly walking the tree here may call activated hooks
// on incorrect children. Instead we push them into a queue which will
// be processed after the whole patch process ended.
queueActivatedComponent(componentInstance)
} else {
activateChildComponent(componentInstance, true /* direct */)
}
}
},
destroy: function destroy (vnode) {
var componentInstance = vnode.componentInstance
if (!componentInstance._isDestroyed) {
if (!vnode.data.keepAlive) {
componentInstance.$destroy()
} else {
deactivateChildComponent(componentInstance, true /* direct */)
}
}
}
}
var hooksToMerge = Object.keys(componentVNodeHooks)
function createComponent (
Ctor,
data,
context,
children,
tag
) {
if (isUndef(Ctor)) {
return
}
var baseCtor = context.$options._base
// plain options object: turn it into a constructor
if (isObject(Ctor)) {
Ctor = baseCtor.extend(Ctor)
}
// if at this stage it's not a constructor or an async component factory,
// reject.
if (typeof Ctor !== 'function') {
if (process.env.NODE_ENV !== 'production') {
warn(("Invalid Component definition: " + (String(Ctor))), context)
}
return
}
// async component
var asyncFactory
if (isUndef(Ctor.cid)) {
asyncFactory = Ctor
Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context)
if (Ctor === undefined) {
// return a placeholder node for async component, which is rendered
// as a comment node but preserves all the raw information for the node.
// the information will be used for async server-rendering and hydration.
return createAsyncPlaceholder(
asyncFactory,
data,
context,
children,
tag
)
}
}
data = data || {}
// resolve constructor options in case global mixins are applied after
// component constructor creation
resolveConstructorOptions(Ctor)
// transform component v-model data into props & events
if (isDef(data.model)) {
transformModel(Ctor.options, data)
}
// extract props
var propsData = extractPropsFromVNodeData(data, Ctor, tag)
// functional component
if (isTrue(Ctor.options.functional)) {
return createFunctionalComponent(Ctor, propsData, data, context, children)
}
// extract listeners, since these needs to be treated as
// child component listeners instead of DOM listeners
var listeners = data.on
// replace with listeners with .native modifier
// so it gets processed during parent component patch.
data.on = data.nativeOn
if (isTrue(Ctor.options.abstract)) {
// abstract components do not keep anything
// other than props & listeners & slot
// work around flow
var slot = data.slot
data = {}
if (slot) {
data.slot = slot
}
}
// merge component management hooks onto the placeholder node
mergeHooks(data)
// return a placeholder vnode
var name = Ctor.options.name || tag
var vnode = new VNode(
("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
data, undefined, undefined, undefined, context,
{ Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
asyncFactory
)
return vnode
}
function createComponentInstanceForVnode (
vnode, // we know it's MountedComponentVNode but flow doesn't
parent, // activeInstance in lifecycle state
parentElm,
refElm
) {
var vnodeComponentOptions = vnode.componentOptions
var options = {
_isComponent: true,
parent: parent,
propsData: vnodeComponentOptions.propsData,
_componentTag: vnodeComponentOptions.tag,
_parentVnode: vnode,
_parentListeners: vnodeComponentOptions.listeners,
_renderChildren: vnodeComponentOptions.children,
_parentElm: parentElm || null,
_refElm: refElm || null
}
// check inline-template render functions
var inlineTemplate = vnode.data.inlineTemplate
if (isDef(inlineTemplate)) {
options.render = inlineTemplate.render
options.staticRenderFns = inlineTemplate.staticRenderFns
}
return new vnodeComponentOptions.Ctor(options)
}
function mergeHooks (data) {
if (!data.hook) {
data.hook = {}
}
for (var i = 0; i < hooksToMerge.length; i++) {
var key = hooksToMerge[i]
var fromParent = data.hook[key]
var ours = componentVNodeHooks[key]
data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours
}
}
function mergeHook$1 (one, two) {
return function (a, b, c, d) {
one(a, b, c, d)
two(a, b, c, d)
}
}
// transform component v-model info (value and callback) into
// prop and event handler respectively.
function transformModel (options, data) {
var prop = (options.model && options.model.prop) || 'value'
var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value
var on = data.on || (data.on = {})
if (isDef(on[event])) {
on[event] = [data.model.callback].concat(on[event])
} else {
on[event] = data.model.callback
}
}
/* */
var warned = Object.create(null)
var warnOnce = function (msg) {
if (!warned[msg]) {
warned[msg] = true
console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"))
}
}
var onCompilationError = function (err, vm) {
var trace = vm ? generateComponentTrace(vm) : ''
throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"))
}
var normalizeRender = function (vm) {
var ref = vm.$options
var render = ref.render
var template = ref.template
var _scopeId = ref._scopeId
if (isUndef(render)) {
if (template) {
var compiled = compileToFunctions(template, {
scopeId: _scopeId,
warn: onCompilationError
}, vm)
vm.$options.render = compiled.render
vm.$options.staticRenderFns = compiled.staticRenderFns
} else {
throw new Error(
("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'))
)
}
}
}
function renderNode (node, isRoot, context) {
if (node.isString) {
renderStringNode(node, context)
} else if (isDef(node.componentOptions)) {
renderComponent(node, isRoot, context)
} else if (isDef(node.tag)) {
renderElement(node, isRoot, context)
} else if (isTrue(node.isComment)) {
if (isDef(node.asyncFactory)) {
// async component
renderAsyncComponent(node, isRoot, context)
} else {
context.write(("<!--" + (node.text) + "-->"), context.next)
}
} else {
context.write(
node.raw ? node.text : escape(String(node.text)),
context.next
)
}
}
function registerComponentForCache (options, write) {
// exposed by vue-loader, need to call this if cache hit because
// component lifecycle hooks will not be called.
var register = options._ssrRegister
if (write.caching && isDef(register)) {
write.componentBuffer[write.componentBuffer.length - 1].add(register)
}
return register
}
const deepmerge = require('deepmerge')
function handleComponentMetaData(node, context) {
if(node.componentOptions.Ctor.options.metaInfo || node.context.$options.metaInfo) {
const tagIDKeyName = 'vmid'
var meta = node.componentOptions.Ctor.options.metaInfo || node.context.$options.metaInfo
if (typeof(meta) === 'function')
meta = meta.call(node.context)
context.meta = deepmerge(context.meta, meta, {
arrayMerge(target, source) {
// we concat the arrays without merging objects contained in,
// but we check for a `vmid` property on each object in the array
// using an O(1) lookup associative array exploit
// note the use of "for in" - we are looping through arrays here, not
// plain objects
const destination = []
for (let targetIndex in target) {
const targetItem = target[targetIndex]
let shared = false
for (let sourceIndex in source) {
const sourceItem = source[sourceIndex]
if (targetItem[tagIDKeyName] && targetItem[tagIDKeyName] === sourceItem[tagIDKeyName]) {
shared = true
break
}
}
if (!shared) {
destination.push(targetItem)
}
}
return destination.concat(source)
}
})
}
}
function renderComponent (node, isRoot, context) {
var write = context.write
var next = context.next
var userContext = context.userContext
// check cache hit
var Ctor = node.componentOptions.Ctor
var getKey = Ctor.options.serverCacheKey
var name = Ctor.options.name
var cache = context.cache
var registerComponent = registerComponentForCache(Ctor, write)
handleComponentMetaData(node, context)
if (isDef(getKey) && isDef(cache) && isDef(name)) {
var key = name + '::' + getKey(node.componentOptions.propsData)
var has = context.has
var get = context.get
if (isDef(has)) {
has(key, function (hit) {
if (hit === true && isDef(get)) {
get(key, function (res) {
if (isDef(registerComponent)) {
registerComponent(userContext)
}
res.components.forEach(function (register) {
return register(userContext)
})
write(res.html, next)
})
} else {
renderComponentWithCache(node, isRoot, key, context)
}
})
} else if (isDef(get)) {
get(key, function (res) {
if (isDef(res)) {
if (isDef(registerComponent)) {
registerComponent(userContext)
}
res.components.forEach(function (register) {
return register(userContext)
})
write(res.html, next)
} else {
renderComponentWithCache(node, isRoot, key, context)
}
})
}
} else {
if (isDef(getKey) && isUndef(cache)) {
warnOnce(
"[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
'but no cache was provided to the renderer.'
)
}
if (isDef(getKey) && isUndef(name)) {
warnOnce(
"[vue-server-renderer] Components that implement \"serverCacheKey\" " +
"must also define a unique \"name\" option."
)
}
renderComponentInner(node, isRoot, context)
}
}
function renderComponentWithCache (node, isRoot, key, context) {
var write = context.write
write.caching = true
var buffer = write.cacheBuffer
var bufferIndex = buffer.push('') - 1
var componentBuffer = write.componentBuffer
componentBuffer.push(new Set())
context.renderStates.push({
type: 'ComponentWithCache',
key: key,
buffer: buffer,
bufferIndex: bufferIndex,
componentBuffer: componentBuffer
})
renderComponentInner(node, isRoot, context)
}
function renderComponentInner (node, isRoot, context) {
var prevActive = context.activeInstance
// expose userContext on vnode
node.ssrContext = context.userContext
var child = context.activeInstance = createComponentInstanceForVnode(
node,
context.activeInstance
)
normalizeRender(child)
var childNode = child._render()
childNode.parent = node
context.renderStates.push({
type: 'Component',
prevActive: prevActive
})
renderNode(childNode, isRoot, context)
}
function renderAsyncComponent (node, isRoot, context) {
var factory = node.asyncFactory
var resolve = function (comp) {
if (comp.__esModule && comp.default) {
comp = comp.default
}
var ref = node.asyncMeta
var data = ref.data
var children = ref.children
var tag = ref.tag
var nodeContext = node.asyncMeta.context
var resolvedNode = createComponent(
comp,
data,
nodeContext,
children,
tag
)
if (resolvedNode) {
renderComponent(resolvedNode, isRoot, context)
} else {
reject()
}
}
var reject = function (err) {
console.error("[vue-server-renderer] error when rendering async component:\n")
if (err) {
console.error(err.stack)
}
context.write(("<!--" + (node.text) + "-->"), context.next)
}
if (factory.resolved) {
resolve(factory.resolved)
return
}
var res
try {
res = factory(resolve, reject)
} catch (e) {
reject(e)
}
if (res) {
if (typeof res.then === 'function') {
res.then(resolve, reject).catch(reject)
} else {
// new syntax in 2.3
var comp = res.component
if (comp && typeof comp.then === 'function') {
comp.then(resolve, reject).catch(reject)
}
}
}
}
function renderStringNode (el, context) {
var write = context.write
var next = context.next
if (isUndef(el.children) || el.children.length === 0) {
write(el.open + (el.close || ''), next)
} else {
var children = el.children
context.renderStates.push({
type: 'Element',
rendered: 0,
total: children.length,
endTag: el.close, children: children
})
write(el.open, next)
}
}
function renderElement (el, isRoot, context) {
var write = context.write
var next = context.next
if (isTrue(isRoot)) {
if (!el.data) {
el.data = {}
}
if (!el.data.attrs) {
el.data.attrs = {}
}
el.data.attrs[SSR_ATTR] = 'true'
}
if (el.fnOptions) {
registerComponentForCache(el.fnOptions, write)
}
var startTag = renderStartingTag(el, context)
var endTag = "</" + (el.tag) + ">"
if (context.isUnaryTag(el.tag)) {
write(startTag, next)
} else if (isUndef(el.children) || el.children.length === 0) {
write(startTag + endTag, next)
} else {
var children = el.children
context.renderStates.push({
type: 'Element',
rendered: 0,
total: children.length,
endTag: endTag, children: children
})
write(startTag, next)
}
}
function hasAncestorData (node) {
var parentNode = node.parent
return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
}
function getVShowDirectiveInfo (node) {
var dir
var tmp
while (isDef(node)) {
if (node.data && node.data.directives) {
tmp = node.data.directives.find(function (dir) {
return dir.name === 'show'
})
if (tmp) {
dir = tmp
}
}
node = node.parent
}
return dir
}
function renderStartingTag (node, context) {
var markup = "<" + (node.tag)
var directives = context.directives
var modules = context.modules
// construct synthetic data for module processing
// because modules like style also produce code by parent VNode data
if (isUndef(node.data) && hasAncestorData(node)) {
node.data = {}
}
if (isDef(node.data)) {
// check directives
var dirs = node.data.directives
if (dirs) {
for (var i = 0; i < dirs.length; i++) {
var name = dirs[i].name
var dirRenderer = directives[name]
if (dirRenderer && name !== 'show') {
// directives mutate the node's data
// which then gets rendered by modules
dirRenderer(node, dirs[i])
}
}
}
// v-show directive needs to be merged from parent to child
var vshowDirectiveInfo = getVShowDirectiveInfo(node)
if (vshowDirectiveInfo) {
directives.show(node, vshowDirectiveInfo)
}
// apply other modules
for (var i$1 = 0; i$1 < modules.length; i$1++) {
var res = modules[i$1](node)
if (res) {
markup += res
}
}
}
// attach scoped CSS ID
var scopeId
var activeInstance = context.activeInstance
if (isDef(activeInstance) &&
activeInstance !== node.context &&
isDef(scopeId = activeInstance.$options._scopeId)
) {
markup += " " + ((scopeId))
}
if (isDef(node.fnScopeId)) {
markup += " " + (node.fnScopeId)
} else {
while (isDef(node)) {
if (isDef(scopeId = node.context.$options._scopeId)) {
markup += " " + scopeId
}
node = node.parent
}
}
return markup + '>'
}
/* */
var isJS = function (file) {
return /\.js(\?[^.]+)?$/.test(file)
}
var isCSS = function (file) {
return /\.css(\?[^.]+)?$/.test(file)
}
function createPromiseCallback () {
var resolve, reject
var promise = new Promise(function (_resolve, _reject) {
resolve = _resolve
reject = _reject
})
var cb = function (err, res) {
if (err) {
return reject(err)
}
resolve(res || '')
}
return { promise: promise, cb: cb }
}
/* */
var Transform = require('stream').Transform
var TemplateStream = (function (Transform) {
function TemplateStream (
renderer,
template,
context
) {
Transform.call(this)
this.started = false
this.renderer = renderer
this.template = template
this.context = context || {}
this.inject = renderer.inject
}
if ( Transform )
TemplateStream.__proto__ = Transform
TemplateStream.prototype = Object.create( Transform && Transform.prototype )
TemplateStream.prototype.constructor = TemplateStream
TemplateStream.prototype._transform = function _transform (data, encoding, done) {
if (!this.started) {
this.emit('beforeStart')
this.start()
}
this.push(data)
done()
}
TemplateStream.prototype.start = function start () {
this.started = true
this.push(this.template.head(this.context))
if (this.inject) {
// inline server-rendered head meta information
if (this.context.head) {
this.push(this.context.head)
}
// inline preload/prefetch directives for initial/async chunks
var links = this.renderer.renderResourceHints(this.context)
if (links) {
this.push(links)
}
// CSS files and inline server-rendered CSS collected by vue-style-loader
var styles = this.renderer.renderStyles(this.context)
if (styles) {
this.push(styles)
}
}
this.push(this.template.neck(this.context))
}
TemplateStream.prototype._flush = function _flush (done) {
this.emit('beforeEnd')
if (this.inject) {
// inline initial store state
var state = this.renderer.renderState(this.context)
if (state) {
this.push(state)
}
// embed scripts needed
var scripts = this.renderer.renderScripts(this.context)
if (scripts) {
this.push(scripts)
}
}
this.push(this.template.tail(this.context))
done()
}
return TemplateStream
}(Transform))
/* */
/**
* Creates a mapper that maps components used during a server-side render
* to async chunk files in the client-side build, so that we can inline them
* directly in the rendered HTML to avoid waterfall requests.
*/
function createMapper (
clientManifest
) {
var map = createMap(clientManifest)
// map server-side moduleIds to client-side files
return function mapper (moduleIds) {
var res = new Set()
for (var i = 0; i < moduleIds.length; i++) {
var mapped = map.get(moduleIds[i])
if (mapped) {
for (var j = 0; j < mapped.length; j++) {
res.add(mapped[j])
}
}
}
return Array.from(res)
}
}
function createMap (clientManifest) {
var map = new Map()
Object.keys(clientManifest.modules).forEach(function (id) {
map.set(id, mapIdToFile(id, clientManifest))
})
return map
}
function mapIdToFile (id, clientManifest) {
var files = []
var fileIndices = clientManifest.modules[id]
if (fileIndices) {
fileIndices.forEach(function (index) {
var file = clientManifest.all[index]
// only include async files or non-js assets
if (clientManifest.async.indexOf(file) > -1 || !(/\.js($|\?)/.test(file))) {
files.push(file)
}
})
}
return files
}
// The render bundle can either be a string (single bundled file)
// or a bundle manifest object generated by vue-ssr-webpack-plugin.
process.env.VUE_ENV = 'server'
exports.createWriteFunction = createWriteFunction
exports.isUndef = isUndef
exports.warned = warned
exports.renderNode = renderNode
exports.installSSRHelpers = installSSRHelpers
exports.normalizeRender = normalizeRender
exports.renderAttrs = renderAttrs
exports.renderDOMProps = renderDOMProps
exports.renderClass = renderClass
exports.renderStyle = renderStyle |
angular.module('application', ['ui.scroll'])
.factory('Server', function($timeout, $q) {
return {
default: {
first: 0,
max: 99,
delay: 100
},
data: [],
init: function(settings = {}) {
this.first = settings.hasOwnProperty('first') ? settings.first : this.default.first;
this.max = settings.hasOwnProperty('max') ? settings.max : this.default.max;
this.delay = settings.hasOwnProperty('delay') ? settings.delay : this.default.delay;
for (var i = this.first; i <= this.max; i++) {
this.data[i] = {
index: i,
content: 'Item #' + i
};
}
},
request: function(index, count) {
var self = this;
var deferred = $q.defer();
var start = index;
var end = index + count - 1;
$timeout(function() {
var item, result = [];
if (start <= end) {
for (var i = start; i <= end; i++) {
if (item = self.data[i]) {
result.push(item);
}
}
}
deferred.resolve(result);
}, self.delay);
return deferred.promise;
}
};
})
.controller('mainController', function($scope, Server) {
$scope.firstIndex = 1;
Server.init({
first: $scope.firstIndex,
max: 100,
delay: 40
});
$scope.datasource = {
get: function(index, count, success) {
console.log('requested index = ' + index + ', count = ' + count);
Server.request(index, count).then(function(result) {
console.log('resolved ' + result.length + ' items');
success(result);
});
}
};
}); |
import "day";
import "dayofweekcount";
import "dayofweek";
import "dayofyear";
import "hour";
import "minute";
import "month";
import "second";
import "time";
import "weekofmonth";
import "weekofyear";
import "year";
import "fulldate"; |
function Collection(collection, specs) {
"use strict";
if (typeof specs !== 'object' || typeof specs.factory !== 'string' || !specs.server) {
console.log('collection specs:', specs);
throw new Error('Invalid collection specification');
}
var base = new ModelBase(collection);
base.properties.expose(['entries', 'error']);
new CollectionFetch(base, specs);
}
|
'use strict';
/**
* A functionality context for operating within Angular.
* @param $http the Angular HTTP service
* @param $timeout the Angular timeout service
* @param $q the Angular promises service
* @constructor
*/
function Context($http, $timeout, $q) {
/**
* Performs an HTTP request.
* @param method the request method, e.g. 'GET', 'POST', etc.
* @param url the url of the JSRO server
* @param [data] optional data to send with the request
* @returns {promise} a promise for the request result; the promise
* will also have a function property, 'abort' which will cause
* the request to be aborted
*/
this.request = function(method, url, data) {
// configure the request
var deferredTimeout = $q.defer();
var requestConfig = {
method: method,
url: url,
timeout: deferredTimeout.promise
};
if (data) {
requestConfig.data = data;
}
// perform the request
var requestPromise = $http(requestConfig).then(function(response) {
return response.data;
});
// add an abort function to the request promise
requestPromise.abort = deferredTimeout.resolve;
return requestPromise;
};
/**
* Schedules a function to be called after the specified delay.
* @param fn the callback function
* @param delay the delay in milliseconds
* @returns {*} a token which can be passed to clearTimeout()
* to cancel the timeout
*/
this.setTimeout = function(fn, delay) {
return $timeout(fn, delay);
};
/**
* Cancels a previously scheduled timeout.
* @param token a token provided by a call to setTimeout()
*/
this.clearTimeout = function(token) {
$timeout.cancel(token);
};
/**
* Creates and returns a deferred promise object.
*/
this.defer = $q.defer;
return this;
}
// register the jsro angular module and service
angular.module('jsro', []).factory('jsroService', [
'$http',
'$timeout',
'$q',
function($http, $timeout, $q) {
// create context
var context = new Context($http, $timeout, $q);
// going to need connection module
var connection = require('./connection.js');
/**
* Creates a connection to a JSRO server.
* @param url the url of the JSRO server
* @param [pollTimeout] the poll timeout in milliseconds; if a poll
* request has not received a response in this amount of time, a
* new poll request will be issued
* @returns {promise} a promise for a connection to the JSRO server
*/
function connect(url, pollTimeout) {
return connection.establish(url, context, pollTimeout);
}
// provide the connect function
return connect;
}
]);
|
var gulp = require('gulp');
var plugins = require('gulp-load-plugins')();
var paths = {
scripts: './app/**/*.js',
styles: './app/styles/template.sass',
stylesWatch: './app/styles/**/*',
adminStyles: './app/styles/admin.sass',
images: './app/images/**/*',
index: './app/index.html',
favicon: './app/favicon.ico',
partials: ['./app/**/*.html', '!app/index.html'],
fonts: ['./node_modules/bootstrap-sass/assets/fonts/**/*', './app/fonts/**/*'],
php: ['./api/**/*', './api/**/.*'],
phpVendor: './vendor/**/*',
dev : './dev',
prod: './prod'
};
function getTask(taskName) {
return require('./gulptasks/' + taskName)(gulp, plugins, paths);
}
gulp.task('dev', getTask('buildDev'));
gulp.task('watchDev', function() {
gulp.watch([paths.scripts, paths.images, paths.index], getTask('buildDev'));
}); |
/**
* Created by sheldon on 2016/5/30.
*/
define(function (require, exports, module) {
module.exports = function (app) {
app.register.controller('TreasureNewCtrl', ['$scope',
function ($scope) {
console.log('new');
}])
}
});
|
// All code points with the `Other_Uppercase` property as per Unicode v6.1.0:
[
0x2160,
0x2161,
0x2162,
0x2163,
0x2164,
0x2165,
0x2166,
0x2167,
0x2168,
0x2169,
0x216A,
0x216B,
0x216C,
0x216D,
0x216E,
0x216F,
0x24B6,
0x24B7,
0x24B8,
0x24B9,
0x24BA,
0x24BB,
0x24BC,
0x24BD,
0x24BE,
0x24BF,
0x24C0,
0x24C1,
0x24C2,
0x24C3,
0x24C4,
0x24C5,
0x24C6,
0x24C7,
0x24C8,
0x24C9,
0x24CA,
0x24CB,
0x24CC,
0x24CD,
0x24CE,
0x24CF
]; |
// All symbols in the Supplemental Punctuation block as per Unicode v6.3.0:
[
'\u2E00',
'\u2E01',
'\u2E02',
'\u2E03',
'\u2E04',
'\u2E05',
'\u2E06',
'\u2E07',
'\u2E08',
'\u2E09',
'\u2E0A',
'\u2E0B',
'\u2E0C',
'\u2E0D',
'\u2E0E',
'\u2E0F',
'\u2E10',
'\u2E11',
'\u2E12',
'\u2E13',
'\u2E14',
'\u2E15',
'\u2E16',
'\u2E17',
'\u2E18',
'\u2E19',
'\u2E1A',
'\u2E1B',
'\u2E1C',
'\u2E1D',
'\u2E1E',
'\u2E1F',
'\u2E20',
'\u2E21',
'\u2E22',
'\u2E23',
'\u2E24',
'\u2E25',
'\u2E26',
'\u2E27',
'\u2E28',
'\u2E29',
'\u2E2A',
'\u2E2B',
'\u2E2C',
'\u2E2D',
'\u2E2E',
'\u2E2F',
'\u2E30',
'\u2E31',
'\u2E32',
'\u2E33',
'\u2E34',
'\u2E35',
'\u2E36',
'\u2E37',
'\u2E38',
'\u2E39',
'\u2E3A',
'\u2E3B',
'\u2E3C',
'\u2E3D',
'\u2E3E',
'\u2E3F',
'\u2E40',
'\u2E41',
'\u2E42',
'\u2E43',
'\u2E44',
'\u2E45',
'\u2E46',
'\u2E47',
'\u2E48',
'\u2E49',
'\u2E4A',
'\u2E4B',
'\u2E4C',
'\u2E4D',
'\u2E4E',
'\u2E4F',
'\u2E50',
'\u2E51',
'\u2E52',
'\u2E53',
'\u2E54',
'\u2E55',
'\u2E56',
'\u2E57',
'\u2E58',
'\u2E59',
'\u2E5A',
'\u2E5B',
'\u2E5C',
'\u2E5D',
'\u2E5E',
'\u2E5F',
'\u2E60',
'\u2E61',
'\u2E62',
'\u2E63',
'\u2E64',
'\u2E65',
'\u2E66',
'\u2E67',
'\u2E68',
'\u2E69',
'\u2E6A',
'\u2E6B',
'\u2E6C',
'\u2E6D',
'\u2E6E',
'\u2E6F',
'\u2E70',
'\u2E71',
'\u2E72',
'\u2E73',
'\u2E74',
'\u2E75',
'\u2E76',
'\u2E77',
'\u2E78',
'\u2E79',
'\u2E7A',
'\u2E7B',
'\u2E7C',
'\u2E7D',
'\u2E7E',
'\u2E7F'
]; |
const holes = document.querySelectorAll('.hole');
const scoreBoard = document.querySelector('.score');
const moles = document.querySelectorAll('.mole');
let lastHole;
let timeUp = false;
let score = 0;
function randomTime(min, max) {
return Math.round(Math.random() * (max - min) + min);
}
function randomHole(holes) {
const idx = Math.floor(Math.random() * holes.length);
const hole = holes[idx];
if(hole === lastHole) {
console.log('same hole as last one. time to select a new hole!');
return randomHole(holes);
}
lastHole = hole;
return hole;
}
function peep() {
const time = randomTime(200, 1000);
const hole = randomHole(holes);
hole.classList.add('up');
setTimeout(() => {
hole.classList.remove('up');
if (!timeUp) peep();
}, time);
}
function startGame() {
scoreBoard.textContent = 0;
timeUp = false;
score = 0;
peep();
setTimeout(() => timeUp = true, 10000);
}
function bonk(e) {
if(!e.isTrusted) return; // cheater!
score++;
this.classList.remove('up');
scoreBoard.textContent = score;
}
moles.forEach(mole => mole.addEventListener('click', bonk)); |
import React from "react";
import PropTypes from "prop-types";
export default class StateHolder extends React.Component {
state = {};
render() {
return this.props.onRender({
state: this.state,
setState: this.setState.bind(this)
});
}
}
StateHolder.propTypes = {
onRender: PropTypes.func.isRequired
};
|
#!/usr/bin/env node
const ps = require('process')
const process = require('./commandLineProcessor')
const errors = process(ps.argv[2], ps.argv.slice(3))
if (errors.length > 0) {
console.error(`Done with ${errors.length} error${errors.length === 1 ? '' : 's'}.`)
ps.exit(1)
} |
// <nowiki>
(function() {
var msgprefix = 'gadget-TranslateVariants-';
var messages = {
'translate-btn': '轉換變體',
'translate-doing': '正在從 $1 轉換至 $2', // fromlang, tolang
'translate-done': '從 $1 轉換至 $2 已完成', // fromlang, tolang
'translate-error': '發生錯誤：$1', // error
'summary': '從[[$1/$2|/$2]]進行轉換', // basepagename, fromlang
};
for (const key in messages) {
if (!mw.messages.exists(msgprefix + key)) {
mw.messages.set(msgprefix + key, messages[key]);
}
}
var TranslateVariants = function(text, lang) {
return new Promise(function(resolve, reject) {
var zhwpapi = new mw.ForeignApi(
'//zh.wikipedia.org/w/api.php',
{ anonymous: true }
);
text = text.replace(/[[\]{}<>|:*'_#&\s]/gim, function(s) {
return "&#" + s.charCodeAt(0) + ";";
});
text = text.replace(/([[)((?:(?!|)(?!]).)+?)(|(?:(?!]).)+?]])/g, '$1-{$2}-$3');
text = text.replace(/-{(.+?)}-/g, function(s) {
return s
.replace('-{', '-{')
.replace('}-', '}-')
.replace(/|/g, '|')
.replace(/ /g, ' ')
.replace(/=/g, '=')
.replace(/>/g, '>')
.replace(/:/g, ':')
});
zhwpapi.parse(
'{{NoteTA|G1=IT|G2=MediaWiki}}<div id="TVcontent">' + text + '</div>',
{
'uselang': lang,
'prop': 'text'
}
).then(function(data) {
var newtext = $('<div/>').html(data).find('#TVcontent').text();
resolve(newtext);
}, function(err) {
reject(err);
});
});
};
var main = function() {
var currentlang = mw.config.get('wgPageName').match(/\/(zh-hans|zh-hant|zh-hk)$/);
if (!currentlang) {
return;
}
currentlang = currentlang[1];
var reallangmap = {
'zh-hans': 'zh-cn',
'zh-hant': 'zh-tw',
'zh-hk': 'zh-hk',
};
var tolang = reallangmap[currentlang];
var basepagename = mw.config.get('wgPageName').replace(/\/(zh-hans|zh-hant|zh-hk)$/, '');
$('.mw-translate-adder').each(function(i, btn) {
var otherlink = btn.getAttribute('onclick').match(/"(#other-(zh-hans|zh-hant|zh-hk)-.+?)"/);
if (!otherlink) {
return;
}
var text = $(otherlink[1]).text();
var fromlang = otherlink[2];
var newlink = $('<a>')
.text(mw.msg(msgprefix + 'translate-btn'))
.attr('class', 'mw-translate-adder mw-translate-adder-ltr');
newlink.on('click', function() {
mw.notify(mw.msg(msgprefix + 'translate-doing', fromlang, tolang), { tag: 'TranslateVariants' });
TranslateVariants(text, tolang).then(function(newtext) {
$('#wpTextbox1').val(newtext);
var summary = mw.msg(msgprefix + 'summary', basepagename, fromlang);
$('#wpSummary').val(summary);
$('#wpDiff').click();
mw.notify(mw.msg(msgprefix + 'translate-done', fromlang, tolang), { tag: 'TranslateVariants' });
}, function(err) {
mw.notify(mw.msg(msgprefix + 'translate-error', err));
});
});
$(btn).after(newlink);
})
};
mw.loader.using(['mediawiki.ForeignApi']).then(function() {
main();
});
})();
// </nowiki>
|
module.exports = {
name: "scale",
ns: "canvas",
async: true,
title: "Scale",
description: "Scale",
phrases: {
active: "Scaling"
},
ports: {
input: {
context: {
title: "Context",
type: "CanvasRenderingContext2D",
required: true
},
"in": {
title: "Scaling factor x/y",
async: true,
type: "array",
required: true,
items: [{
type: "number",
title: "X"
},
{
type: "number",
title: "Y"
}
],
minItems: 2,
maxItems: 2,
fn: function __IN__(data, source, state, input, $, output) {
var r = function() {
$.context.scale($.in[0], $.in[1]);
output({
context: $.get('context')
});
}.call(this);
return {
state: state,
return: r
};
}
}
},
output: {
context: {
title: "Context",
type: "CanvasRenderingContext2D"
}
}
},
state: {}
} |
var vkDataViews = {};
module.exports = vkDataViews;
vkDataViews.Abstract = require('../abstract');
vkDataViews.Bookmarks = require('./lib/bookmarks');
vkDataViews.Friend = require('./lib/friend');
vkDataViews.Friends = require('./lib/friends');
vkDataViews.Group = require('./lib/group');
vkDataViews.Groups = require('./lib/groups');
vkDataViews.News = require('./lib/news');
vkDataViews.NewsItem = require('./lib/news-item');
vkDataViews.Playlist = require('./lib/playlist');
vkDataViews.Playlists = require('./lib/playlists');
|
angular.module('app').controller('classes', [ '$scope', function($scope) {
$scope.technologies = [ 'jQuery', 'AngularJS' ];
} ]);
|
// !LOCNS:galactic_war
define(['shared/gw_common'], function (GW) {
return {
visible: function(params) { return true; },
describe: function(params) {
return '!LOC:Bot Armor Tech increases health of all bots by 50%';
},
summarize: function(params) {
return '!LOC:Bot Armor Tech';
},
icon: function(params) {
return 'coui://ui/main/game/galactic_war/gw_play/img/tech/gwc_bot_combat.png';
},
audio: function (parms) {
return {
found: '/VO/Computer/gw/board_tech_available_armor'
}
},
getContext: function (galaxy) {
return {
totalSize: galaxy.stars().length
};
},
deal: function (system, context, inventory) {
var chance = 0;
if( inventory.hasCard('gwc_enable_bots_t1') || inventory.hasCard('gwc_enable_bots_all') || inventory.hasCard('gwc_start_bots') )
chance = 70;
return { chance: chance };
},
buff: function(inventory, params) {
var units = [
'/pa/units/land/fabrication_bot/fabrication_bot.json',
'/pa/units/land/fabrication_bot_combat/fabrication_bot_combat.json',
'/pa/units/land/assault_bot/assault_bot.json',
'/pa/units/land/bot_grenadier/bot_grenadier.json',
'/pa/units/land/bot_tactical_missile/bot_tactical_missile.json',
'/pa/units/land/bot_bomb/bot_bomb.json',
'/pa/units/land/fabrication_bot_adv/fabrication_bot_adv.json',
'/pa/units/land/fabrication_bot_combat_adv/fabrication_bot_combat_adv.json',
'/pa/units/land/assault_bot_adv/assault_bot_adv.json',
'/pa/units/land/bot_sniper/bot_sniper.json',
'/pa/units/land/bot_tesla/bot_tesla.json',
'/pa/units/land/bot_nanoswarm/bot_nanoswarm.json',
'/pa/units/land/bot_support_commander/bot_support_commander.json'
];
var mods = [];
var modUnit = function(unit) {
mods.push({
file: unit,
path: 'max_health',
op: 'multiply',
value: 1.5
});
};
_.forEach(units, modUnit);
inventory.addMods(mods);
},
dull: function(inventory) {
}
};
});
|
module.exports = {
description: "",
ns: "react-material-ui",
type: "ReactNode",
dependencies: {
npm: {
"material-ui/svg-icons/navigation/cancel": require('material-ui/svg-icons/navigation/cancel')
}
},
name: "NavigationCancel",
ports: {
input: {},
output: {
component: {
title: "NavigationCancel",
type: "Component"
}
}
}
} |
// integrate socket
import socketIO from 'socket.io';
const socketThings = (server) => {
// connect socket to the server
const appSocket = socketIO(server);
appSocket.on('connection', (socket) => {
// respond to document update
socket.on('documentUpdate', (documentID) => {
socket.emit('ReloadDocument', { documentID });
});
// when use join room
socket.on('room', (data) => {
socket.join(data.room);
});
// when a document is updated
socket.on('coding event', (data) => {
socket.broadcast
.to(data.room)
.emit('receive code',data);
});
// when users leave a room
socket.on('leave room', (data) => {
socket.leave(data.room)
});
socket.on('disconnect', () => {
console.log('user disconnected');
});
});
};
export default socketThings;
|
define(["require", "exports", "../_.contribution"], function (require, exports, __contribution_1) {
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
// Allow for running under nodejs/requirejs in tests
var _monaco = (typeof monaco === 'undefined' ? self.monaco : monaco);
__contribution_1.registerLanguage({
id: 'redshift',
extensions: [],
aliases: ['Redshift', 'redshift'],
loader: function () { return _monaco.Promise.wrap(new Promise(function (resolve_1, reject_1) { require(['./redshift'], resolve_1, reject_1); })); }
});
});
|
import React, {Component} from 'react';
import {connect} from 'react-redux';
import {withRouter} from 'react-router'
import Drawer from 'material-ui/Drawer';
import Paper from 'material-ui/Paper';
import HomeIcon from 'material-ui/svg-icons/action/home';
import { SIDEBAR_ACTUAL_STATE } from './../../constants/reducers/sidebar'
import MenuItem from 'material-ui/MenuItem';
class Sidebar extends Component {
render() {
const { history, sidebar, onRequestChangeByDocument } = this.props;
return (
<Paper>
<Drawer open={ sidebar.visible } docked={ false } onRequestChange={() => onRequestChangeByDocument(!sidebar.visible)}>
<MenuItem onClick={() => { onRequestChangeByDocument(false); history.push("/")}} primaryText="Home" leftIcon={<HomeIcon/>} />
</Drawer>
</Paper>
);
}
}
function mapStateToProps(state) {
const { sidebar } = state;
return {
sidebar
}
}
export default connect(
mapStateToProps,
dispatch => ({
onRequestChangeByDocument : (RightIconMenuEventClick) => {
const payload = {
sidebar : {
visible : RightIconMenuEventClick
}
};
dispatch({ type: SIDEBAR_ACTUAL_STATE , payload})
}
})
)(withRouter(Sidebar));
|
export { default } from 'ember-flexberry-gis/map-tools/measure-coordinates';
|
'use strict';
// simulant library needs polyfills for IE8
require('./util/polyfill');
/* eslint-disable vars-on-top */
var simulant = require('simulant');
var snippet = require('tui-code-snippet');
var placeholder = require('../src/js/placeholder');
var util = require('../src/js/util');
var browser = snippet.browser;
var supportIE = browser.msie && browser.version <= 11;
var otherBrowser = browser.others;
var supportPlaceholder = 'placeholder' in document.createElement('input') &&
'placeholder' in document.createElement('textarea');
var supportPropertychange = browser.msie && browser.version < 11;
var generatePlaceholder = supportIE || (!supportIE && !supportPlaceholder) ||
(otherBrowser && !supportPlaceholder);
/* eslint-enable vars-on-top */
jasmine.getFixtures().fixturesPath = 'base/test/fixtures';
describe('placeholder.js', function() {
beforeEach(function() {
loadFixtures('placeholder.html');
placeholder.generate();
});
it('Create and append the <style> element for adding css rule on IE9 to IE11.', function() {
var styleTagLen = $('style').length;
var expected = (browser.msie && (browser.version > 9 && browser.version <= 11)) ? 1 : 0;
expect(styleTagLen).toEqual(expected);
});
it('When placeholder property is not supported on the browser, generating the virtual placeholder.', function() {
var $placeholder = $('span > span');
expect($placeholder.length).toEqual(generatePlaceholder ? 5 : 0);
});
describe('When the virtual placeholder is generated,', function() {
it('elements have an inline style.', function() {
var $placeholder = $('span > span[style]');
expect($placeholder.length).toEqual(generatePlaceholder ? 5 : 0);
});
it('elements that have already value are hidden.', function() {
var $placeholder = $('span > span:hidden');
expect($placeholder.length).toEqual(generatePlaceholder ? 2 : 0);
});
it('elements set the special attribute that don\'t copy and drag.', function() {
var $placeholder = $('span > span[unselectable="on"]');
expect($placeholder.length).toEqual(generatePlaceholder ? 5 : 0);
});
});
it('When call add api with arguments, the virtual placeholder append on dynamically created elements.', function() {
var $parent = $('#jasmine-fixtures');
var i = 0;
var len = 3;
var expected = generatePlaceholder ? len : 0;
for (; i < len; i += 1) {
$parent.append('<input type="text" class="addon" placeholder="test" />');
}
placeholder.generate($('.addon'));
expect($('span > .addon').length).toEqual(expected);
});
describe('remove(): ', function() {
it('If called without arguments, removes all generated virtual elements', function() {
placeholder.remove();
expect($('span > span').length).toEqual(0);
});
it('If called with arguments, removes virtual elements related to given elements', function() {
var $targets = $('input').slice(0, 2); // first two input elements
placeholder.remove($targets.toArray());
expect($('span > span').length).toEqual(generatePlaceholder ? 3 : 0);
});
});
});
if (generatePlaceholder) {
/* eslint-disable max-nested-callbacks */
describe('placeholder.js', function() {
describe('generate(): ', function() {
var DEF_VALUE = 'Holding Value';
var $input;
beforeEach(function() {
$input = $('<input placeholder="' + DEF_VALUE + '" />');
jasmine.getFixtures().set($input);
});
it('If called with wrapperClassName option, add given className to the wrapper', function() {
placeholder.generate(null, {
wrapperClassName: 'my-custom-class'
});
expect($input.parent()).toHaveClass('my-custom-class');
});
it('holder element has a placeholder value', function() {
placeholder.generate();
expect($input.prev().text()).toBe(DEF_VALUE);
});
describe('holder element should be visible if input does not have a value ', function() {
var $holder;
beforeEach(function() {
placeholder.generate();
$holder = $input.prev();
});
it('initially', function() {
expect($holder).toBeVisible();
});
it('and blur event occurs on the input element', function() {
$holder.hide();
simulant.fire($input[0], 'blur');
expect($holder).toBeVisible();
});
it('and keyup event occurs on the input element', function() {
$holder.hide();
simulant.fire($input[0], 'keyup');
expect($holder).toBeVisible();
});
});
describe('holder element should not be visible if input has a value ', function() {
var $holder;
beforeEach(function() {
$input.val('Some value');
placeholder.generate();
$holder = $input.prev();
});
it('initially', function() {
expect($holder).not.toBeVisible();
});
it('and blur event occurs on the input element', function() {
simulant.fire($input[0], 'blur');
expect($holder).not.toBeVisible();
});
it('and keyup event occurs on the input element', function() {
simulant.fire($input[0], 'keyup');
expect($holder).not.toBeVisible();
});
});
it('should focus to input element when click holder element', function() {
placeholder.generate();
simulant.fire($input.prev()[0], 'click');
expect($input[0]).toBe(document.activeElement);
});
it('holder should be hidden when keydown event occurs on the input element', function() {
placeholder.generate();
simulant.fire($input[0], 'keydown', {
which: 65,
keyCode: 65
});
expect($input.prev()).not.toBeVisible();
});
});
describe('remove(): ', function() {
it('should restore original state', function() {
var $input = $('<input placeholder="Holding Value" />');
var $prevEl = $('<span>');
var $nextEl = $('<span>');
var $parentEl = $('<div>');
$parentEl.append([$prevEl, $input, $nextEl]);
jasmine.getFixtures().set($parentEl);
placeholder.generate();
placeholder.remove();
expect($input.prev()[0]).toBe($prevEl[0]);
expect($input.next()[0]).toBe($nextEl[0]);
expect($input.parent()[0]).toBe($parentEl[0]);
});
// It's impossible to test if handlers are actually unbound, so test this spec just by
// confirming util.bindEvent and util.unbindEvent is called with specific events
it('should unbind events', function() {
var $input = $('<input placeholder="Holding Value" />');
var events = (supportPropertychange) ? ['keydown', 'keyup', 'blur', 'propertychange'] : ['keydown', 'keyup', 'blur', 'change'];
var callArgs;
spyOn(util, 'bindEvent');
spyOn(util, 'unbindEvent');
jasmine.getFixtures().set($input);
placeholder.generate();
// test if bindEvent is called with [keydown, keyup, blur] event
callArgs = util.bindEvent.calls.allArgs();
callArgs = snippet.filter(callArgs, function(args) {
return args[0] === $input[0];
});
snippet.forEach(callArgs, function(args) {
expect(events).toContain(args[1]);
});
placeholder.remove();
// test if unbindEvent is called with [keydown, keyup, blur] event
callArgs = util.unbindEvent.calls.allArgs();
callArgs = snippet.filter(callArgs, function(args) {
return args[0] === $input[0];
});
snippet.forEach(callArgs, function(args) {
expect(events).toContain(args[1]);
});
});
});
});
describe('Using "usageStatistics" option', function() {
beforeEach(function() {
spyOn(snippet, 'sendHostname');
});
it('when the value set to true by default, the host name is send to server.', function() {
placeholder.generate();
expect(snippet.sendHostname).toHaveBeenCalled();
});
it('when the value set to false, the host name is not send to server.', function() {
placeholder.generate(null, {
usageStatistics: false
});
expect(snippet.sendHostname).not.toHaveBeenCalled();
});
});
/* eslint-enable max-nested-callbacks */
}
|
'use strict';
import React from 'react';
import { Link } from 'react-router';
/*
* Component to display of the page doesn't exists
*/
export default class NotFoundPage extends React.Component {
render() {
return (
<div className="not-found">
<h1>404</h1>
<h2>Page not found!</h2>
<p>
<Link to="/">Go back to the main page</Link>
</p>
</div>
);
}
}
|
// @flow
import fetch from 'isomorphic-fetch';
function checkStatus(response: FetchErrorResponse): FetchErrorResponse {
if (response.status >= 200 && response.status < 300) {
return response;
} else {
const error: FetchError = new Error(response.statusText);
error.response = response;
throw error;
}
}
function failingFetch(url: string): Promise<Array<APIRepository>> {
return fetch(url)
.catch(error => {
throw new Error('Network error, check your internet connection.');
})
.then(checkStatus)
.then(response => response.json());
}
export default failingFetch;
|
module.exports={
get:function(id, device, callback)
{
var command=id;
var socket=$('net').createConnection({port:8102, allowHalfOpen:true, host:device}, function(){ console.log('connected'); });
var responseSent=false;
var commandSent=false;
var firstRReceived=false;
socket.on('data', function(data){
if(!commandSent || responseSent)
console.log(data);
else
{
if(!firstRReceived && data=='R\r\n')
{
firstRReceived=true;
}
else
{
responseSent=true;
if(!firstRReceived)
data=data.replace(/R/, '');
data=data.replace(/[\r\n]+/g, '');
console.log(new Buffer(data, 'ASCII'));
callback(data);
socket.end();
}
}
});
socket.setEncoding('ASCII');
socket.on('error', callback);
socket.write('\r');
setTimeout(function(){
socket.write('\r'+command+'\r');
commandSent=true;
},100);
},
VL:function(id, device, callback)
{
var volume=(id*185/100);
volume='000'.substring(0,volume.toString().length)+volume;
module.exports.get.command(volume+'VL', device, function(error, data){
if(error)
{
console.log(error);
callback(500);
}
else
callback(data);
});
}
}; |
"use strict";
let datafire = require('datafire');
let openapi = require('./openapi.json');
module.exports = datafire.Integration.fromOpenAPI(openapi, "docusign"); |
const fs = require('fs')
const cat = require('../')
const streams = []
function fnStream () {
return fs.createReadStream(__filename)
}
for (let i = 0; i < 1000; i++) {
streams.push(fnStream)
}
cat(streams).pipe(process.stdout)
/* run with:
* node thousand.js | egrep "^let fs" | wc -l
* #> 1000
*/
|
define([
'require',
'../inheritance',
'../component',
'../event',
'../view',
'../async',
'../component.interaction',
'preload|../loader.css',
'!scrollpanel.css'
//todo:
/*
Implement scrollTo call to bring scrolled items into view
*/
],function(require,inheritance,component,event,view,async,interaction){
var scope = {}
var isTouch = false
, isMobile = false;
var Class = inheritance.Class
, factory = component.ComponentFactory(require,scope)
, DragAndDrop = interaction.DragAndDrop
, Positioning = view.Positioning;
var ScrollPanel = Class(function ScrollPanelController(args){
this.base(args);
event.attach(this,{
onScroll : event.MulticastEvent
});
this.horizontalDisable = this.isDisableHorizontal;
var self = this;
/* Current scroll offset */
this.currentScrollTop = 0;
/* scroll content by default */
this.isScrollClient = true;
/* Setup touch events on touch enabled platforms */
if(isTouch && !isMobile){
this.elements.clippingArea.addEventListener( 'touchstart', function(e){self.onTouchStart(e);}, false );
this.elements.clippingArea.addEventListener( 'touchend', function(e){self.onTouchEnd(e);}, false );
this.elements.clippingArea.addEventListener( 'touchmove', function(e){self.onTouchMove(e);}, false );
}
}).extend(component.ComponentBase);
ScrollPanel.prototype.onLoaded = function(){
this.domRoot = this.elements.root;
/* Scrollable content client */
this.client = this.elements.scrollClient;
/* */
this.clippingArea = this.elements.clippingArea;
}
ScrollPanel.prototype.onInit = function(){
};
ScrollPanel.prototype.onDisplay = function(){
this.reflow();
console.log('displaying scroll panel');
};
ScrollPanel.prototype.onChildChanged = function(){
console.log('reflowing');
this.reflow();
};
ScrollPanel.prototype.onTouchStart = function(e){
this.touchStart = {x:e.touches[0].pageX, y:e.touches[0].pageY};
e.preventDefault();
this.pVector = null;
};
ScrollPanel.prototype.onTouchEnd = function(e){
this.currentScrollTop = this.client.scrollTop;
/*
var self = this;
new _.StoryBoard([
new _.Animation(this.currentScrollTop, this.currentScrollTop+20*-1*this.endMagnitude, 1000, _.Animation.easeOut,
function(value){
self.client.scrollTop = value;
},
function(){
self.currentScrollTop = self.client.scrollTop;
self.endMagnitude = 0;
})
]).animate();
*/
};
ScrollPanel.prototype.onTouchMove = function(e){
this.touchEnd = {x:e.touches[0].pageX, y:e.touches[0].pageY};
e.preventDefault();
var vector = [
this.touchEnd.x - this.touchStart.x,
this.touchEnd.y - this.touchStart.y
];
this.client.scrollTop = this.currentScrollTop + (-1*vector[1]);
if(this.pVector){
this.endMagnitude = vector[1] - this.pVector[1];
}
this.pVector = vector;
};
ScrollPanel.prototype.reflow = function(args){
//this.reflowChildren(null,null,true);
/* nothing to reflow on mobile platforms*/
if(isMobile) return;
if(args && args.height){
this.domRoot.style.height = args.height + 'px';
this.ref.scrollClient.style.height = args.height + 'px';
}
/* careful its a prototype call */
var scrollBar = ScrollPanel.prototype.attachScrollBars.call(
this,
this.elements.root,{
scrollClient:this.elements.scrollClient,
horizontalDisable:this.horizontalDisable
}
);
if(scrollBar.vertical) {
/*
this.views.scrollClient.className = 'client -splicejs-scrolling-vertical';
this.views.staticContainer.className = 'static -splicejs-scrolling-vertical';
*/
//this.views.clippingArea.className = 'clipping -splicejs-scrolling-vertical';
}
else {
this.elements.clippingArea.className = 'clipping';
/*
this.views.scrollClient.className = 'client';
this.views.staticContainer.className = 'static';
*/
}
};
ScrollPanel.prototype.attachScrollBars = function(parent,args){
if(!parent) return;
var parent = parent.node;
parent.style.overflow = 'hidden';
var self = this;
var client = this.elements.scrollClient.node;
var staticContainer = this.elements.staticContainer.node;
var content = this.elements.scroll.node;
var size = { width:client.clientWidth, height:client.clientHeight};
var cSize = { width: Math.max(content.clientWidth,content.scrollWidth, content.offsetWidth),
height: Math.max(content.clientHeight, content.scrollHeight, content.offsetHeight)};
var thumb = {horizontal: parent._scroll_bar_horizontal,
vertical: parent._scroll_bar_vertical
};
/*
* Check is scroll bars already exist
* create new ones if not
* */
if(!thumb.vertical) {
thumb.vertical = view.create('div').appendClass('-scroll-bar-thumb-vertical').node;
parent._scroll_bar_vertical = thumb.vertical;
}
if(!thumb.horizontal) {
thumb.horizontal = view.create('div').appendClass('-scroll-bar-thumb-horizontal').node;
parent._scroll_bar_horizontal = thumb.horizontal;
}
/*
* Scroll bars may not be required
* */
var status = {vertical:true, horizontal:true};
if(size.height >= cSize.height ) {
thumb.vertical.style.display = 'none';
status.vertical = false;
} else {
thumb.vertical.style.display = 'block';
}
if(size.width >= cSize.width-2 || (args.horizontalDisable === true)) {
thumb.horizontal.style.display = 'none';
status.horizontal = false;
} else {
thumb.horizontal.style.display = 'block';
}
var thumbSizes = {
vertical:{size:0, scale:0},
horizontal:{size:0, scale:0}
};
/*
* Calculate vertical thumb size
* */
var h = size.height - 20 - Math.round(0.3*(cSize.height - size.height));
if(h < 30) h = 30;
thumbSizes.vertical.size = h;
thumbSizes.vertical.scale = (cSize.height - size.height)/(size.height - 20 - h);
/*
* Calculate horizontal thumb size
* */
var w = size.width - 20 - Math.round(0.3*(cSize.width - size.width));
if(w < 30) w = 30;
thumbSizes.horizontal.size = w;
thumbSizes.horizontal.scale = (cSize.width - size.width)/(size.width - 20 - w);
/*
* Assign styles
* */
thumb.vertical.style.height = thumbSizes.vertical.size + 'px';
thumb.horizontal.style.width = thumbSizes.horizontal.size + 'px';
/*
* Append dom
* */
parent.appendChild(thumb.vertical);
parent.appendChild(thumb.horizontal);
thumb.vertical.onclick = function(e){
if(!e) e = window.event;
e.cancelBubble = true;
if (e.stopPropagation) e.stopPropagation();
};
thumb.horizontal.onclick = function(e){
if(!e) e = window.event;
e.cancelBubble = true;
if (e.stopPropagation) e.stopPropagation();
};
var scale = thumbSizes.vertical.scale;
thumb.vertical.onmousedown = function(e){
if(!e) e = window.event;
e.cancelBubble = true;
if (e.stopPropagation) e.stopPropagation();
DragAndDrop.startDrag(this,e);
var top = this.offsetTop - parent.scrollTop ;
DragAndDrop.ondrag = function(position,offset){
var t = (top + position.y-offset.y);
if(t <=10) t = 10;
if((thumbSizes.vertical.size + t) > size.height - 20) t = size.height - thumbSizes.vertical.size - 10;
//!!!!whats with the magic number??? rework.
var scrollPosition = (t-10)*scale;
//some scroll panel including controls may not want automatic client scroll
if(self.isScrollClient) {
client.scrollTop = scrollPosition;
// keep scrolling thumbs in their positions
//thumb.horizontal.style.bottom = (-1*parent.scrollTop + 10 ) + 'px';
}
thumb.vertical.style.top = (parent.scrollTop + t) + 'px';
var eargs = { vector: (position.y-offset.y),
scaled: scrollPosition,
position: t-10,
height: size.height,
isVertical:true
};
self.onScroll(eargs);
};
};
thumb.horizontal.onmousedown = function(e){
if(!e) e = window.event;
if(!e) e = window.event;
e.cancelBubble = true;
if (e.stopPropagation) e.stopPropagation();
DragAndDrop.startDrag(this,e);
var left = this.offsetLeft - parent.scrollLeft ;
var scale = thumbSizes.horizontal.scale;
DragAndDrop.ondrag = function(position,offset){
var t = (left + position.x-offset.x);
if(t <=10) t = 10;
if((thumbSizes.horizontal.size+t) > size.width - 20) t = size.width - thumbSizes.horizontal.size - 10;
var scrollPosition = (t-10)*scale;
client.scrollLeft = scrollPosition;
staticContainer.scrollLeft = scrollPosition;
// keep scrolling thumbs in their positions
thumb.horizontal.style.left = (parent.scrollLeft + t) + 'px';
//thumb.vertical.style.right = (-1*parent.scrollLeft + 10) + 'px';
var eargs = {vector:(position.y-offset.y), position:scrollPosition, isHorizontal:true};
self.onScroll(eargs);
};
};
client.onwheel = function(e){
if(!e) e = window.event;
client.scrollTop = client.scrollTop + e.wheelDeltaY*scale * 0.05;
// keep scrolling thumbs in their positions
//thumb.vertical.style.top = (parent.scrollTop + t) + 'px';
//thumb.horizontal.style.bottom = (-1*parent.scrollTop + 10 ) + 'px';
e.preventDefault ? e.preventDefault() : e.returnValue = false;
e.cancelBubble = true;
if (e.stopPropagation) e.stopPropagation();
//_.debug.log(e);
};
return status;
}; //end attach scrollbars
return factory.define('ScrollPanel:scrollpanel.html',ScrollPanel);
});
|
import _defineProperty from 'babel-runtime/helpers/defineProperty';
import _classCallCheck from 'babel-runtime/helpers/classCallCheck';
import _createClass from 'babel-runtime/helpers/createClass';
import _possibleConstructorReturn from 'babel-runtime/helpers/possibleConstructorReturn';
import _inherits from 'babel-runtime/helpers/inherits';
import React from 'react';
import { findDOMNode } from 'react-dom';
import classNames from 'classnames';
import Animate from 'rc-animate';
import PureRenderMixin from 'rc-util/es/PureRenderMixin';
import assign from 'object-assign';
import Checkbox from '../checkbox';
import Search from './search';
import Item from './item';
import triggerEvent from '../_util/triggerEvent';
function noop() {}
function isRenderResultPlainObject(result) {
return result && !React.isValidElement(result) && Object.prototype.toString.call(result) === '[object Object]';
}
var TransferList = function (_React$Component) {
_inherits(TransferList, _React$Component);
function TransferList(props) {
_classCallCheck(this, TransferList);
var _this = _possibleConstructorReturn(this, (TransferList.__proto__ || Object.getPrototypeOf(TransferList)).call(this, props));
_this.handleSelect = function (selectedItem) {
var checkedKeys = _this.props.checkedKeys;
var result = checkedKeys.some(function (key) {
return key === selectedItem.key;
});
_this.props.handleSelect(selectedItem, !result);
};
_this.handleFilter = function (e) {
_this.props.handleFilter(e);
if (!e.target.value) {
return;
}
// Manually trigger scroll event for lazy search bug
// https://github.com/ant-design/ant-design/issues/5631
_this.triggerScrollTimer = setTimeout(function () {
var listNode = findDOMNode(_this).querySelectorAll('.ant-transfer-list-content')[0];
if (listNode) {
triggerEvent(listNode, 'scroll');
}
}, 0);
};
_this.handleClear = function () {
_this.props.handleClear();
};
_this.matchFilter = function (text, item) {
var _this$props = _this.props,
filter = _this$props.filter,
filterOption = _this$props.filterOption;
if (filterOption) {
return filterOption(filter, item);
}
return text.indexOf(filter) >= 0;
};
_this.renderItem = function (item) {
var _this$props$render = _this.props.render,
render = _this$props$render === undefined ? noop : _this$props$render;
var renderResult = render(item);
var isRenderResultPlain = isRenderResultPlainObject(renderResult);
return {
renderedText: isRenderResultPlain ? renderResult.value : renderResult,
renderedEl: isRenderResultPlain ? renderResult.label : renderResult
};
};
_this.state = {
mounted: false
};
return _this;
}
_createClass(TransferList, [{
key: 'componentDidMount',
value: function componentDidMount() {
var _this2 = this;
this.timer = setTimeout(function () {
_this2.setState({
mounted: true
});
}, 0);
}
}, {
key: 'componentWillUnmount',
value: function componentWillUnmount() {
clearTimeout(this.timer);
clearTimeout(this.triggerScrollTimer);
}
}, {
key: 'shouldComponentUpdate',
value: function shouldComponentUpdate() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return PureRenderMixin.shouldComponentUpdate.apply(this, args);
}
}, {
key: 'getCheckStatus',
value: function getCheckStatus(filteredDataSource) {
var checkedKeys = this.props.checkedKeys;
if (checkedKeys.length === 0) {
return 'none';
} else if (filteredDataSource.every(function (item) {
return checkedKeys.indexOf(item.key) >= 0;
})) {
return 'all';
}
return 'part';
}
}, {
key: 'render',
value: function render() {
var _this3 = this;
var _props = this.props,
prefixCls = _props.prefixCls,
dataSource = _props.dataSource,
titleText = _props.titleText,
checkedKeys = _props.checkedKeys,
lazy = _props.lazy,
_props$body = _props.body,
body = _props$body === undefined ? noop : _props$body,
_props$footer = _props.footer,
footer = _props$footer === undefined ? noop : _props$footer,
showSearch = _props.showSearch,
style = _props.style,
filter = _props.filter,
searchPlaceholder = _props.searchPlaceholder,
notFoundContent = _props.notFoundContent,
itemUnit = _props.itemUnit,
itemsUnit = _props.itemsUnit,
onScroll = _props.onScroll;
// Custom Layout
var footerDom = footer(assign({}, this.props));
var bodyDom = body(assign({}, this.props));
var listCls = classNames(prefixCls, _defineProperty({}, prefixCls + '-with-footer', !!footerDom));
var filteredDataSource = [];
var totalDataSource = [];
var showItems = dataSource.map(function (item) {
var _renderItem = _this3.renderItem(item),
renderedText = _renderItem.renderedText,
renderedEl = _renderItem.renderedEl;
if (filter && filter.trim() && !_this3.matchFilter(renderedText, item)) {
return null;
}
// all show items
totalDataSource.push(item);
if (!item.disabled) {
// response to checkAll items
filteredDataSource.push(item);
}
var checked = checkedKeys.indexOf(item.key) >= 0;
return React.createElement(Item, { key: item.key, item: item, lazy: lazy, renderedText: renderedText, renderedEl: renderedEl, checked: checked, prefixCls: prefixCls, onClick: _this3.handleSelect });
});
var unit = dataSource.length > 1 ? itemsUnit : itemUnit;
var search = showSearch ? React.createElement(
'div',
{ className: prefixCls + '-body-search-wrapper' },
React.createElement(Search, { prefixCls: prefixCls + '-search', onChange: this.handleFilter, handleClear: this.handleClear, placeholder: searchPlaceholder, value: filter })
) : null;
var listBody = bodyDom || React.createElement(
'div',
{ className: showSearch ? prefixCls + '-body ' + prefixCls + '-body-with-search' : prefixCls + '-body' },
search,
React.createElement(
Animate,
{ component: 'ul', componentProps: { onScroll: onScroll }, className: prefixCls + '-content', transitionName: this.state.mounted ? prefixCls + '-content-item-highlight' : '', transitionLeave: false },
showItems
),
React.createElement(
'div',
{ className: prefixCls + '-body-not-found' },
notFoundContent
)
);
var listFooter = footerDom ? React.createElement(
'div',
{ className: prefixCls + '-footer' },
footerDom
) : null;
var checkStatus = this.getCheckStatus(filteredDataSource);
var checkedAll = checkStatus === 'all';
var checkAllCheckbox = React.createElement(Checkbox, { ref: 'checkbox', checked: checkedAll, indeterminate: checkStatus === 'part', onChange: function onChange() {
return _this3.props.handleSelectAll(filteredDataSource, checkedAll);
} });
return React.createElement(
'div',
{ className: listCls, style: style },
React.createElement(
'div',
{ className: prefixCls + '-header' },
checkAllCheckbox,
React.createElement(
'span',
{ className: prefixCls + '-header-selected' },
React.createElement(
'span',
null,
(checkedKeys.length > 0 ? checkedKeys.length + '/' : '') + totalDataSource.length,
' ',
unit
),
React.createElement(
'span',
{ className: prefixCls + '-header-title' },
titleText
)
)
),
listBody,
listFooter
);
}
}]);
return TransferList;
}(React.Component);
export default TransferList;
TransferList.defaultProps = {
dataSource: [],
titleText: '',
showSearch: false,
render: noop,
lazy: {}
}; |
console.log('second js file')
|
(function($) {
"use strict"; // Start of use strict
// Smooth scrolling using jQuery easing
$('a[href*="#"]:not([href="#"])').click(function() {
if (location.pathname.replace(/^\//, '') == this.pathname.replace(/^\//, '') && location.hostname == this.hostname) {
var target = $(this.hash);
target = target.length ? target : $('[name=' + this.hash.slice(1) + ']');
if (target.length) {
$('html, body').animate({
scrollTop: (target.offset().top - 54)
}, 1000, "easeInOutExpo");
return false;
}
}
});
// Activate scrollspy to add active class to navbar items on scroll
$('body').scrollspy({
target: '#mainNav',
offset: 54
});
// Closes responsive menu when a link is clicked
$('.navbar-collapse>ul>li>a').click(function() {
$('.navbar-collapse').collapse('hide');
});
// Collapse the navbar when page is scrolled
$(window).scroll(function() {
if ($("#mainNav").offset().top > 100) {
$("#mainNav").addClass("navbar-shrink");
} else {
$("#mainNav").removeClass("navbar-shrink");
}
});
})(jQuery); // End of use strict
|
/// <reference path="angular.js" />
/// <reference path="jquery-1.10.2.intellisense.js" />
/// <reference path="ngDraggable.js" />
angular.module('GameApp',[]).
controller('MainCtrl', function ($scope) {
$scope.GamesList = [];
var gameList = $.getJSON("/Home/GameList").success(function (data, status, headers, config) {
$scope.GamesList = data;
$scope.$apply();
});
});
|
'use strict';
var mongoose = require('mongoose'),
passport = require('passport'),
Admin;
Admin = mongoose.model('Admin');
exports.signUp = function (req, res, next) {
Admin.find({}).exec(function (err, collection) {
if(collection.length === 0) {
var admin = new Admin();
admin.username = req.body.username;
admin.salt = admin.createSalt();
admin.hashed_pwd = admin.hashPwd(admin.salt, req.body.password);
admin.save();
req.logIn(admin, function (err) {
if(err) {return next(err);}
});
}
res.redirect('/');
});
};
exports.authenticate = function (req, res, next) {
var auth = passport.authenticate('local', function (err, user) {
if(err) {
return next(err);
}
if(!user) {
res.send('Wrong password or username');
}
req.logIn(user, function (err) {
if(err) {return next(err);}
res.redirect('/');
});
});
auth(req, res, next);
}; |
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M9 19l1.41-1.41L5.83 13H22v-2H5.83l4.59-4.59L9 5l-7 7 7 7z" />
, 'WestOutlined');
|
var standardGeometry = new THREE.PlaneGeometry(1, 1, 1, 1);
function CameraDisplayObject3D(options) {
var _width = options.width || window.innerWidth;
var _height = options.height || window.innerHeight;
var _resolutionWidth = options.resolutionWidth || 100;
var _resolutionHeight = options.resolutionHeight || 100;
var _prescale = options.prescale || 1;
var _geometry = options.geometry || standardGeometry;
var _renderTargetOptions = options.renderTargetOptions;
var _generateMipmaps = options.generateMipmaps || false;
var _transparent = options.transparent || false;
var _material = options.material || new THREE.MeshBasicMaterial({
// side: THREE.DoubleSide,
// color: 0xff0000
transparent: _transparent
});
var _maintainAspect = options.maintainAspect !== undefined ? options.maintainAspect : true;
var _renderer = options.renderer;
_setCamera(options.camera);
_setScene.call(this, options.scene);
var _render,
_camera,
_scene,
_renderTarget,
_backupAspect;
THREE.Mesh.call(this, _geometry, _material);
_setResolution(_resolutionWidth, _resolutionHeight);
_setSize.call(this, _width, _height);
function _update() {
_prerender();
_render();
_postrender();
}
function _updateRaw() {
_render();
}
function _prerender() {
_backupAspect = _camera.aspect;
_camera.aspect = _width / _height;
_camera.updateProjectionMatrix();
}
function _postrender() {
_camera.aspect = _backupAspect;
_camera.updateProjectionMatrix();
}
function _renderOneScene() {
_renderer.render(_scene, _camera, _renderTarget);
}
function _renderManyScenes() {
_renderer.render(_scene[0], _camera, _renderTarget);
_renderer.autoClear = false;
for (var i = 1; i < _scene.length; i++) {
_renderer.render(_scene[i], _camera, _renderTarget);
}
_renderer.autoClear = true;
}
function _setSize(width, height) {
_width = width;
_height = height;
this.scale.x = _width * _prescale;
this.scale.y = _height * _prescale;
}
function _setResolution(width, height) {
if(_renderTarget) _renderTarget.dispose();
_resolutionWidth = width;
_resolutionHeight = height;
_renderTarget = new THREE.WebGLRenderTarget(_resolutionWidth, _resolutionHeight, _renderTargetOptions);
_renderTarget.generateMipmaps = _generateMipmaps;
_material.map = _renderTarget;
}
function _setScene(scene) {
_scene = scene;
if(scene instanceof THREE.Scene) {
_render = _renderOneScene;
} else if(scene instanceof Array) {
_render = _renderManyScenes;
}
}
function _setCamera(camera) {
_camera = camera;
}
function _getCamera() {
return _camera;
}
function _destroy() {
if(this.parent) this.parent.remove(this);
_renderTarget.dispose();
_renderer = null;
_material.dispose();
_material = null;
_camera = null;
_scene = null;
}
//public
this.update = _maintainAspect ? _update : _updateRaw;
this.setSize = _setSize;
this.setResolution = _setResolution;
this.setScene = _setScene;
this.setCamera = _setCamera;
this.getCamera = _getCamera;
this.destroy = _destroy;
}
CameraDisplayObject3D.prototype = Object.create(THREE.Mesh.prototype);
module.exports = CameraDisplayObject3D; |
/*
*
*
*
* AirCold JS UI Library v1.0
* https://aircold.org/
* Includes ac.js
* https://aircold.org/
*
* Date: 2016-03-20T18:02Z
*
*
*
Copyright 2015,2016 AirCold Misha Landau
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*
*
*/
ac.prototype.extend( {
c_progress_bar: function( options ) {
var $this = this,
isOptions = typeof options === 'object',
animationDuration = 1000,
max = 100,
percent = true,
max_percent = 100,
text = '',
strokeColorA = '#cccccc',
strokeColorB = '#676767',
strokewidthA = '2',
strokewidthB = '2',
textColor = '#b4b4b4',
progress = function(){},
success = function(){},
reverse = false;
var setting = {
radius: 60
},
stroke_dasharray = ( 2 * Math.PI ) * setting.radius;
if( isOptions ) {
animationDuration = options.duration || animationDuration;
max = options.max || max
max_percent = options.max_percent || max_percent;
if( max > 100 && !options.max_percent )
max_percent = max;
text = options.text || text;
strokeColorA = options.strokeColorA || strokeColorA;
strokeColorB = options.strokeColorB || strokeColorB;
strokewidthA = options.strokewidthA || strokewidthA;
strokewidthB = options.strokewidthB || strokewidthB;
textColor = options.textColor || textColor;
progress = options.progress || progress;
success = options.success || success;
reverse = options.reverse || reverse
}
var animationStartTime = Date.now() || 0;
function update( el ) {
var currentTime = Date.now();
var positionInAnimation = ( currentTime - animationStartTime ) / animationDuration;
var count = positionInAnimation * max;
var count_reverse,
bindStroke,
percent_s = Math.round( ( count / max ) * 100 ),
percent_o_s = Math.round( ( count / max_percent ) * 100 );
if( reverse ) {
count = max_percent - count;
count_reverse = stroke_dasharray - positionInAnimation * ( stroke_dasharray * max / max_percent );
if( count_reverse <= 0 ) count_reverse = 0;
if( max + count <= max_percent ) count = max_percent - max;
bindStroke = count_reverse;
percent_s = Math.round( ( ( max_percent - count ) / max ) * 100 );
percent_o_s = Math.round( ( ( max_percent - count ) / max_percent ) * 100 );
} else {
if( count >= max ) count = max;
bindStroke = count * ( stroke_dasharray / max_percent );
}
ac( '#' + el.id + ' #ac-c-progress' ).attr( "stroke-dasharray", bindStroke + ", " + stroke_dasharray );
ac( '#' + el.id + ' #ac-c-text' ).html( Math.floor( count ) + text );
if ( positionInAnimation <= 1 ) {
requestAnimationFrame( function() {
update( el );
} );
progress.call( el, percent_s, percent_o_s );
} else {
success.call( el );
}
};
$this.each( function() {
var el = this;
if( ac( '#' + el.id + ' svg' ).length == 0 ) {
ac( el ).append( '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" viewBox="0 0 200 200" preserveAspectRatio="none" class="ac-bar-progress"><circle cx="100" cy="100" r="' + setting.radius + '" id="ac-c-bar" fill="none" stroke="' + strokeColorA + '" stroke-width="' + strokewidthA + '" stroke-dasharray="' + stroke_dasharray + ', ' + stroke_dasharray + '" transform="rotate(-90,100,100)"></circle><circle cx="100" cy="100" r="' + setting.radius + '" id="ac-c-progress" fill="none" stroke="' + strokeColorB + '" stroke-width="' + strokewidthB + '" stroke-dasharray="0, ' + stroke_dasharray + '" transform="rotate(-90,100,100)"></circle><text id="ac-c-text" text-anchor="middle" x="100" y="110" fill="' + textColor + '">0' + text +'</text></svg>' );
}
requestAnimationFrame( function() {
update( el );
} );
} );
},
fixed_menu: function( options ) {
var $this = this[ 0 ],
isOptions = typeof options === 'object',
arr_position = new Array(),
top = $this.getClientRects()[ 0 ].top || $this.getBoundingClientRect().top,
bottom = $this.getClientRects()[ 0 ].bottom || $this.getBoundingClientRect().bottom,
offsetTop = $this.offsetTop,
bodyTop = document.body.getClientRects()[ 0 ].top || document.body.getBoundingClientRect().top;
var firstTop = offsetTop,
isChange = false;
// options
var change = function(){},
position_start = function(){};
if( isOptions ) {
change = options.change || change;
position_start = options.position_start || position_start;
}
var scrollTop = ac.scrollTop();
var scrollLeft = ac.scrollLeft();
window.scrollTo( scrollLeft, 0 );
window.scrollTo( scrollLeft, scrollTop );
var topScroll = function() {
if( top <= 0 ) {
change.call( $this );
isChange = true;
$this.style.top = '0px';
$this.style.position = 'fixed';
}
if( !isChange )
firstTop = $this.offsetTop;
if( firstTop + bodyTop > 0 ) {
if( isChange ) {
position_start.call( $this );
$this.style.top = '';
$this.style.position = '';
isChange = false;
}
}
};
window.addEventListener( 'scroll', function() {
top = $this.getClientRects()[ 0 ].top || $this.getBoundingClientRect().top;
bottom = $this.getClientRects()[ 0 ].bottom || $this.getBoundingClientRect().bottom;
offsetTop = $this.offsetTop;
bodyTop = document.body.getClientRects()[ 0 ].top || document.body.getBoundingClientRect().top;
topScroll();
} );
}
} );
|
var gulp = require('gulp');
var plugins = require('gulp-load-plugins')({camelize: true});
var config = require('../config');
var handleErrors = require('../util/handleErrors');
var browserSync = require('browser-sync').create();
gulp.task('images', function() {
return gulp.src(config.images.globs)
.pipe(plugins.cache(plugins.imagemin(config.images.settings)))
.on('error', handleErrors)
.pipe(plugins.debug({title: 'images:'}))
.pipe(gulp.dest(config.images.dest))
.pipe(browserSync.stream());
});
|
version https://git-lfs.github.com/spec/v1
oid sha256:fa8dca3b648a99779220228491bf3effda2ead72f201a8358966d385a481fef7
size 4451
|
/**
* Problem: https://leetcode.com/problems/longest-continuous-increasing-subsequence/description/
*/
/**
* @param {number[]} nums
* @return {number}
*/
var findLengthOfLCIS = function(nums) {
if (!nums.length) return 0;
let result = 1;
let dp = [1];
for (let i = 1; i < nums.length; ++i) {
dp[i] = nums[i] > nums[i - 1] ? dp[i - 1] + 1 : 1;
result = Math.max(result, dp[i]);
}
return result;
};
module.exports = findLengthOfLCIS;
|
const pkg = require("../package.json");
module.exports = {
startLog: () => {
console.log("");
console.log(" " + pkg.name + " v" + pkg.version);
console.log("");
console.log(" " + pkg.description);
console.log("");
console.log("----------------------------------------------------------");
},
complete: () => {
console.log("");
console.log(" OK!");
console.log("");
},
getMessages: (user) => {
console.log(" User " + user + " get messages");
},
sendMessage: (user, encMessage) => {
console.log(' User ' + user + ' sends ' + encMessage);
},
connection: (req) => {
paths = {
url: req.url,
ip: req.connection.remoteAddress.split(":")[3]
};
console.log("from: " + paths.ip);
console.log("to: " + paths.url);
console.log("----");
},
apiConnect: () => {
console.log(" API Connection query");
},
apiConnected: () => {
console.log(" API Connected");
},
apiAuth: (hash, user) => {
console.log(" Authenification...");
console.log("");
console.log(" user - " + user);
console.log(" hash - " + hash);
},
version: () => {
console.log("v" + pkg.version);
},
root: () => {
console.log("");
console.log("Send root");
console.log("");
},
fileNotFound: () => {
console.log("");
console.log("File not found");
console.log("");
},
chat: () => {
console.log("");
console.log("Send chat");
console.log("");
},
listen: (port, ip) => {
console.log("");
console.log("Listen on port " + port);
console.log("");
console.log(" Please, check http://" + ip + ":" + port + "/chat in browser");
console.log("");
},
help: () => {
console.log();
console.log(" " + pkg.name + " v" + pkg.version);
console.log("");
console.log(" Usage: c-chat [command]");
console.log("");
console.log(" h, help - help");
console.log(" v, version - version this programm");
console.log(" start - start this chat");
console.log(" set-port=NUMBER_PORT - set port for server");
console.log("");
},
notFound: () => {
console.log("");
console.log(" c-chat: command not found");
console.log("");
}
}
|
(window.webpackJsonp=window.webpackJsonp||[]).push([[48],{118:function(n){n.exports=JSON.parse('{"allTagsPath":"/tags","slug":"npm","name":"npm","count":2,"permalink":"/tags/npm"}')}}]); |
import Roles from './Roles';
describe('init', () => {
it('throws error if db driver not provided', () => {
expect(() => Roles.init()).toThrowError('A database driver is required');
});
it('throws error if user resolver not provided', () => {
expect(() => Roles.init({}, {})).toThrowError('A user resolver is required');
});
});
describe('addUserToRoles', () => {
it('throw error if no user id provided', async () => {
try {
await Roles.addUserToRoles();
throw Error();
} catch (err) {
expect(err).toEqual(new Error('userId is required'));
}
});
it('throw error if no roles are provided', async () => {
try {
await Roles.addUserToRoles('123');
throw Error();
} catch (err) {
expect(err).toEqual(new Error('roles are required'));
}
});
it('throw error if no groups are provided', async () => {
try {
await Roles.addUserToRoles('123', ['create'], null);
throw Error();
} catch (err) {
expect(err).toEqual(new Error('group is required'));
}
});
it('throw error if user id is not found', async () => {
const findUserById = jest.fn(() => false);
Roles.init({}, {}, {
findUserById,
});
try {
await Roles.addUserToRoles('123', ['create']);
throw Error();
} catch (err) {
expect(err).toEqual(new Error('userId 123 not found'));
}
});
it('calls db.addUserToRoles', async () => {
const findUserById = jest.fn(() => Promise.resolve({}));
const addUserToRoles = jest.fn();
Roles.init({}, {
addUserToRoles,
}, {
findUserById,
});
await Roles.addUserToRoles(['123', '456'], ['create']);
expect(addUserToRoles.mock.calls.length).toEqual(2);
});
});
describe('createRole', () => {
it('throw error if no role is provided', async () => {
try {
await Roles.createRole();
throw Error();
} catch (err) {
expect(err).toEqual(new Error('role is required'));
}
});
it('throw error if no group is provided', async () => {
try {
await Roles.createRole('role', null);
throw Error();
} catch (err) {
expect(err).toEqual(new Error('group is required'));
}
});
it('throw error if role already exists', async () => {
Roles.init({}, {
roleExists: () => Promise.resolve(true),
}, {});
try {
await Roles.createRole('role');
throw Error();
} catch (err) {
expect(err).toEqual(new Error('role already exists'));
}
});
it('calls db.createRole', async () => {
const createRole = jest.fn(() => Promise.resolve({
roleId: 'roleId',
groupId: 'groupId',
}));
Roles.init({}, {
roleExists: () => Promise.resolve(false),
createRole,
}, {});
const res = await Roles.createRole('role');
expect(res).toEqual({
roleId: 'roleId',
groupId: 'groupId',
});
expect(createRole.mock.calls.length).toEqual(1);
});
});
describe('deleteRole', () => {
it('calls db.deleteRole', () => {
const deleteRole = jest.fn();
Roles.init({}, {
deleteRole,
}, {});
Roles.deleteRole('role', 'group');
expect(deleteRole.mock.calls.length).toEqual(1);
expect(deleteRole.mock.calls[0][0]).toEqual('role');
expect(deleteRole.mock.calls[0][1]).toEqual('group');
});
});
describe('deleteGroup', () => {
it('calls db.deleteGroup', () => {
const deleteGroup = jest.fn();
Roles.init({}, {
deleteGroup,
}, {});
Roles.deleteGroup('group');
expect(deleteGroup.mock.calls.length).toEqual(1);
expect(deleteGroup.mock.calls[0][0]).toEqual('group');
});
});
describe('getAll', () => {
it('calls db.getAll', async () => {
const getAll = jest.fn();
Roles.init({}, {
getAll,
}, {});
await Roles.getAll();
expect(getAll.mock.calls.length).toEqual(1);
});
});
describe('getGroupsForUser', () => {
it('throws error if user not found', async () => {
Roles.init({}, {
}, {
findUserById: () => Promise.resolve(false),
});
try {
await Roles.getGroupsForUser('123');
throw new Error();
} catch (err) {
expect(err).toEqual(new Error('userId 123 not found'));
}
});
it('calls db.getGroupsForUser', async () => {
Roles.init({}, {
getGroupsForUser: () => Promise.resolve(['group']),
}, {
findUserById: () => Promise.resolve(true),
});
const groups = await Roles.getGroupsForUser('123');
expect(groups).toEqual(['group']);
});
});
describe('getGroupsForUser', () => {
it('throws error if user not found', async () => {
Roles.init({}, {
}, {
findUserById: () => Promise.resolve(false),
});
try {
await Roles.getRolesForUser('123');
throw new Error();
} catch (err) {
expect(err).toEqual(new Error('userId 123 not found'));
}
});
it('calls db.getRolesForUser', async () => {
Roles.init({}, {
getRolesForUser: () => Promise.resolve(['role']),
}, {
findUserById: () => Promise.resolve(true),
});
const roles = await Roles.getRolesForUser('123');
expect(roles).toEqual(['role']);
});
});
describe('getUsersInRole', () => {
it('calls db.getUsersInRole', async () => {
const getUsersInRole = jest.fn(() => Promise.resolve(['user']));
Roles.init({}, {
getUsersInRole,
}, {});
const res = await Roles.getUsersInRole('role');
expect(res).toEqual(['user']);
expect(getUsersInRole.mock.calls.length).toEqual(1);
});
});
describe('getUsersInGroup', () => {
it('calls db.getUsersInGroup', async () => {
const getUsersInGroup = jest.fn(() => Promise.resolve(['user']));
Roles.init({}, {
getUsersInGroup,
}, {});
const res = await Roles.getUsersInGroup('group');
expect(res).toEqual(['user']);
expect(getUsersInGroup.mock.calls.length).toEqual(1);
});
});
describe('removeUserFromRoles', () => {
it('throw error if no user id provided', async () => {
try {
await Roles.removeUserFromRoles();
throw Error();
} catch (err) {
expect(err).toEqual(new Error('userId is required'));
}
});
it('throw error if no roles are provided', async () => {
try {
await Roles.removeUserFromRoles('123');
throw Error();
} catch (err) {
expect(err).toEqual(new Error('roles are required'));
}
});
it('throw error if no groups are provided', async () => {
try {
await Roles.removeUserFromRoles('123', ['create'], null);
throw Error();
} catch (err) {
expect(err).toEqual(new Error('group is required'));
}
});
it('throw error if user id is not found', async () => {
const findUserById = jest.fn(() => false);
Roles.init({}, {}, {
findUserById,
});
try {
await Roles.removeUserFromRoles('123', ['create']);
throw Error();
} catch (err) {
expect(err).toEqual(new Error('userId 123 not found'));
}
});
it('calls db.removeUserFromRoles', async () => {
const findUserById = jest.fn(() => Promise.resolve({}));
const removeUserFromRoles = jest.fn();
Roles.init({}, {
removeUserFromRoles,
}, {
findUserById,
});
await Roles.removeUserFromRoles(['123', '456'], ['create']);
expect(removeUserFromRoles.mock.calls.length).toEqual(2);
});
})
;
describe('removeUserFromGroup', () => {
it('throw error if no user id provided', async () => {
try {
await Roles.removeUserFromGroup();
throw Error();
} catch (err) {
expect(err).toEqual(new Error('userId is required'));
}
});
it('throw error if no group is provided', async () => {
try {
await Roles.removeUserFromGroup('123', null);
throw Error();
} catch (err) {
expect(err).toEqual(new Error('group is required'));
}
});
it('throw error if user id is not found', async () => {
const findUserById = jest.fn(() => false);
Roles.init({}, {}, {
findUserById,
});
try {
await Roles.removeUserFromGroup('123', 'admin');
throw Error();
} catch (err) {
expect(err).toEqual(new Error('userId 123 not found'));
}
});
it('calls db.removeUserFromGroup', async () => {
const findUserById = jest.fn(() => Promise.resolve({}));
const removeUserFromGroup = jest.fn();
Roles.init({}, {
removeUserFromGroup,
}, {
findUserById,
});
await Roles.removeUserFromGroup(['123', '456'], 'create');
expect(removeUserFromGroup.mock.calls.length).toEqual(2);
});
});
describe('userIsInRole', () => {
it('calls db.userIsInRole', async () => {
const userIsInRole = jest.fn(() => Promise.resolve(true));
Roles.init({}, {
userIsInRole,
}, {});
const res = await Roles.userIsInRole('123', 'create', 'admin');
expect(res).toEqual(true);
expect(userIsInRole.mock.calls.length).toEqual(1);
});
});
describe('userIsInGroup', () => {
it('calls db.userIsInGroup', async () => {
const userIsInGroup = jest.fn(() => Promise.resolve(true));
Roles.init({}, {
userIsInGroup,
}, {});
const res = await Roles.userIsInGroup('123', 'admin');
expect(res).toEqual(true);
expect(userIsInGroup.mock.calls.length).toEqual(1);
});
});
describe('userIsSuperUser', () => {
it('calls db.userIsSuperUser', async () => {
const userIsSuperUser = jest.fn(() => Promise.resolve(true));
Roles.init({}, {
userIsSuperUser,
}, {});
const res = await Roles.userIsSuperUser('123');
expect(res).toEqual(true);
expect(userIsSuperUser.mock.calls.length).toEqual(1);
});
});
describe('addSuperUser', () => {
it('calls db.addSuperUser', async () => {
const addSuperUser = jest.fn(() => Promise.resolve(true));
Roles.init({}, {
addSuperUser,
}, {});
const res = await Roles.addSuperUser('123');
expect(res).toEqual(true);
expect(addSuperUser.mock.calls.length).toEqual(1);
});
});
describe('removeSuperUser', () => {
it('calls db.removeSuperUser', async () => {
const removeSuperUser = jest.fn(() => Promise.resolve(true));
Roles.init({}, {
removeSuperUser,
}, {});
const res = await Roles.removeSuperUser('123');
expect(res).toEqual(true);
expect(removeSuperUser.mock.calls.length).toEqual(1);
});
});
describe('findById', () => {
it('calls db.findById', async () => {
const findById = jest.fn(() => Promise.resolve(true));
Roles.init({}, {
findById,
}, {});
const res = await Roles.findById('123');
expect(res).toEqual(true);
expect(findById.mock.calls.length).toEqual(1);
});
it('throws error if no role id provided', async () => {
try {
await Roles.findById();
throw Error();
} catch (err) {
expect(err).toEqual(new Error('roleId is required'));
}
});
});
|
import { TagCompiler } from './tag';
export class MixinDefinitionCompiler extends TagCompiler {
compile (context, tag) {
if (!tag.hash) {
throw new Error('Hash property is required for block definition. eg. @mixin#name');
}
if (tag.indent !== 0) {
throw new Error('Block definition must be placed in top level(the indent of it must be 0)');
}
const ctx = context.sub(tag, -2);
ctx.compileChildren();
const result = ctx.getOutput(true);
result.shift(); // remove the leading \n
const group = tag.attributeGroups.length && tag.attributeGroups[0].attributes;
const replacement = {};
group && group.forEach(item => {
const value = context.getCompiler(item).getValue(context, item.value, item, group, tag);
item.name ? replacement[item.name] = value : replacement[value] = null;
});
context.root.getNote('mixin').set(tag.hash, { result, replacement });
}
}
|
var _ = require('lodash');
var Q = require('q');
var elasticsearch = require('elasticsearch');
module.exports = function (client) {
var rubber = {};
rubber.index = function (fig) {
var bulkIndex = function (rows) {
if(rows.length) {
var bulkFig = [];
_.each(rows, function (row) {
var indexFig = { _index: row.index, _type: row.type };
if(row.id) {
indexFig._id = row.id;
}
bulkFig.push({ index: indexFig });
bulkFig.push(row.body);
});
return Q(client.bulk({ body: bulkFig }));
}
else {
return Q();
}
};
return _.isArray(fig) ? bulkIndex(fig) : Q(client.index(fig));
};
return rubber;
};
|
/*jslint node: true */
/*global module, require*/
'use strict';
var newEvent = require('./../construct/newEvent.js'),
isValidObject = require('./../bool/isValidObject.js'),
newScapeObject = require('./../construct/newScapeObject.js');
/**
* This method creates {@link ScapeMenu} objects, which are the api interfaces that developers interact with.
*
* @function newScapeMenu
* @memberof socioscapes
* @param {Object} scapeObject - A valid {@link ScapeObject}.
* @param {Object} socioscapesPrototype - The {@link socioscapes} api prototype.
* @return {Object} - A {@link socioscapes} {@link ScapeMenu} object.
*/
var newScapeMenu = function newScapeMenu(scapeObject, socioscapesPrototype) {
var newChildMenu = function newChildMenu(thisMenu, myObject, mySchema, myChild) {
var myChildIsContainer = myChild.class.match(/\[(.*?)]/g) ? true : false, // is the child item an array that contains layers or views? [signified by schema classes in square brackets]
myChildClass = myChildIsContainer ? /\[(.*?)]/g.exec(myChild.class)[1] : myChild.class, // strip the [square brackets]
myChildSchema = myChildIsContainer ? mySchema[myChildClass][0]:mySchema[myChildClass]; // child item datastructure
if (myChildSchema.menu) { // if the datastructure defines a menu stub
Object.defineProperty(thisMenu, myChildClass, { // "myChildClass" evaluates to a classname string (eg. 'state' or 'view' or 'config')
value: function (command, config, callback) {
var myArguments = [],
myCallback = ((typeof command === 'function') && !config && !callback) ? command // test to see if the first argument is the only one provided and a function. if it is, assume it's a callback
: ((typeof config === 'function') && !callback) ? config // otherwise, if the second argument is a function and there's no third argument, assume it's a callback
: ((typeof callback === 'function') ? callback : function() { }), // otherwise, if the third argument is a function, assume it's a callback or create an empty one
myContext = { // this object points to several important references
"object": myObject[myChildClass], // this is the object that the menu calls will manipulate
"schema": myChildSchema, // this is the datastructure of the above object
"that": myObject // this is the parent object of the above object (to be used as the "this" return object to facilitate method chaining)
},
myCommand,
myFunction = myChildSchema.menu,
myReturn = thisMenu; // default return value (to facilitate method chaining in the api)
if (myChildSchema.menu.name === 'menuClass') { // if the object we need to create is of class 'menuClass' (which means it will be an api menu object)
myObject = myChildSchema.menu(myContext, command, config); // just generate it on the fly since it's not async
myReturn = newScapeMenu(myObject, socioscapesPrototype); // trigger the callback (so that method chaining works even for synchronous api calls)
myCallback(myReturn); // and set the return value to be the new api menu object
} else { // otherwise, it might produce an asynchronous call so queue to the dispatcher so it can be evaluated sequentially
if (command) { // setup the myArguments array for the dispatcher
myCommand = socioscapesPrototype[command] || // if command matches a full command name
socioscapesPrototype.schema.alias[command] || // or an alias
((typeof command === 'function') ? command: false); // or if it's a function, then let it be equal to itself; otherwise, false
myArguments.push(myCommand); // if a command arg was provided, push it to the myArguments array
if (typeof config !== 'function') { // do the same for config
myArguments.push(config);
}
}
myObject.dispatch({
"myArguments": myArguments,
"myCallback": myCallback,
"myContext": myContext,
"myFunction": myFunction
});
}
return myReturn;
}
});
}
},
/**
* Represents a {@link ScapeMenu} (the actual api menu interface that users interact with).
* @namespace ScapeMenu
* @constructor
* @param {Object} myObject - An object of type {@link ScapeObject}.
*/
ScapeMenu = function(myObject) {
var mySchema = myObject.meta.schema,
myClass = mySchema.class,
myParent = mySchema.parent,
myType = mySchema.type,
thisMenu = this;
myObject.meta.thisMenu = thisMenu;
myObject.meta.thisObject = myObject;
/**
* The metadata of the {@link ScapeObject} that this {@link ScapeMenu} is linked to.
*
* @memberof ScapeMenu#
* @member {Object} meta
* */
Object.defineProperty(this, 'meta', {
value: myObject.meta
});
/**
* Creates and returns a new object of this type (which is stored in the parent container).
*
* @memberof ScapeMenu#
* @function new
* */
Object.defineProperty(this, 'new', {
value: function (name) {
var myMenu = thisMenu,
myNew;
if (name) {
myNew = newScapeObject(name, myParent, myType);
myMenu = myNew ? new ScapeMenu(myNew) : thisMenu;
}
return myMenu;
}
});
for (var i = 0; i < mySchema.children.length; i++) {
newChildMenu(this, myObject, mySchema, mySchema.children[i]);
}
newEvent('socioscapes.newScapeMenu', this);
return this;
};
if (isValidObject(scapeObject)) {
return new ScapeMenu(scapeObject);
}
};
module.exports = newScapeMenu; |
import { connect } from 'react-redux';
import { hideNotification, pushNotification } from '../actions/NotificationAction';
import { remapButtons } from '../actions/ButtonAction';
const NotificationContainer = (popup) => {
const mapStateToProps = (state) => {
if (state.NotificationReducer) {
return {
text: state.NotificationReducer.text,
show: state.NotificationReducer.show,
};
}
return {
text: 'default text',
show: false,
};
};
const mapDispatchToProps = (dispatch) => {
return {
remapButtons: (newButtonConfigs) => {
dispatch(remapButtons(newButtonConfigs));
},
hideNotification: () => {
dispatch(hideNotification());
},
pushNotification: (notification) => {
dispatch(pushNotification(notification));
},
};
};
return connect(mapStateToProps, mapDispatchToProps)(popup);
};
export default NotificationContainer;
|
'use strict';
/**
* Gets autocompletions.
* @kind internal
* Usage:
* <%= executable %>
* # press tab key to get completions
*/
module.exports = ({ argv, logger, sub }) => {
return new Promise((resolve, reject) => {
sub.get().then((commands) => {
commands.forEach((s) => logger.bare(s));
resolve();
}, reject);
});
};
|
/*
This module keeps self.currentNumber and self.isAsked variables
It can:
Save and restore this variables from cookies
Check if currentNumber > MaxNumber -> in this case we should ask for a mark
*/
function MarkCounterBool(maxNumber, daysToKeep) {
this.MaxNumber = maxNumber; // the limit for self.currentNumber to increase
var cookieDomain = "";//"appiens.com"; // the cookie domain
var cookiePath = "/Appiens/daybyday_chrome"; // the cookie path
var cookieUrl = "https://"+ cookieDomain + cookiePath + "/trololo"; // the cookie url
var self = this;
self.isReadOk = false; // values was restored from cookies without error
self.cookieArray = []; // the cookie array for cookieDomain, cookiePath
self.currentNumber = 0; // the current number, that is seeking to maxNumber
self.isAsked = 0; // if 1 we have asked for mark already and we don`t need doing it again
self.counterName = chrome.runtime.id; // cookie name for currentNamber
self.isAskedName = self.counterName + "_asked"; // cookie name for isAsked
self.daysToKeep = daysToKeep; // the number of days to keep cookie
/*Reads currentNumber and isAsked from cookies
* callback - the callback function*/
this.Read = function(callback) {
self.currentNumber = 0;
self.isAsked = 0;
self.isReadOk = false;
chrome.storage.local.get([self.counterName, self.isAskedName] , function (result) {
if (chrome.extension.lastError || chrome.runtime.lastError) {
LogMsg("chrome.storage.local.get error:" + chrome.extension.lastError.message);
LogMsg("chrome.storage.local.get error:" + chrome.runtime.lastError.message);
return;
}
LogMsg(JSON.stringify(result));
var flOk = true;
if (result[self.counterName]) {
LogMsg("!!!" + result[self.counterName]);
self.currentNumber = parseInt(result[self.counterName]);
}
else {
flOk = false;
}
if (result[self.isAskedName]) {
LogMsg("!!!" + result[self.isAskedName]);
self.isAsked = parseInt(result[self.isAskedName]);
}
else {
flOk = false;
}
self.isReadOk = flOk;
callback();
});
/* chrome.storage.local.get(self.counterName, function (result) {
LogMsg(result);
});*/
/* chrome.cookies.getAll({
"domain": cookieDomain,
"path": cookiePath
}, function (cookies) {
if (chrome.extension.lastError || chrome.runtime.lastError) {
LogMsg(chrome.extension.lastError.message);
LogMsg(chrome.runtime.lastError.message);
self.isReadOk = false;
callback();
return;
}
LogMsg(JSON.stringify(cookies));
self.cookieArray = cookies;
try {
self.isAsked = parseInt(searchEl(self.isAskedName));
self.currentNumber = parseInt(searchEl(self.counterName));
LogMsg("isAsked = " + self.isAsked + ", currentNumber = " + self.currentNumber);
self.isReadOk = true;
callback();
}
catch (e) {
LogMsg(e);
self.isReadOk = false;
callback();
}
}
);*/
}
/* Saves isAsked if isAsked = 1, or currentNumber if isAsked = 0*/
this.Save = function() {
if (self.isAsked > 0) {
// writeValueToCookie(self.isAskedName, self.isAsked.toString());
writeValueToLocalStorage(self.isAskedName, self.isAsked.toString());
}
else {
// writeValueToCookie(self.counterName, self.currentNumber.toString());
writeValueToLocalStorage(self.counterName, self.currentNumber.toString());
writeValueToLocalStorage(self.isAskedName, self.isAsked.toString());
}
}
/*returns true if cookies was read sucessfully*/
this.checkReadOk = function() {
return self.isReadOk;
}
/*returns currentNumber value*/
this.CurrentNumber = function() {
return self.currentNumber;
}
/*Adds value to currentNumber
* int value - value to add*/
this.addToCurr = function(value) {
self.currentNumber += value;
}
/*returns True, if we should ask for a mark*/
this.checkMaximum = function() {
return self.currentNumber > this.MaxNumber && self.isAsked == 0;
}
/*Sets isAsked = 1. We have asked for a mark*/
this.stop = function() {
self.isAsked = 1;
}
this.resetCounter = function() {
self.currentNumber = 0;
self.isAsked = 0;
}
/*Writes value to cookie
* string cookieName - the cookie name,
* string cookieValue - the cookie value*/
var writeValueToCookie = function(cookieName, cookieValue) {
var date = new Date();
var expiresSec = Math.ceil(date.getTime()/1000 + (self.daysToKeep * 24 * 60 * 60));
LogMsg(cookieName + "=" + cookieValue);
chrome.cookies.set({
"name": cookieName,
"url": cookieUrl,
"value": cookieValue,
"expirationDate": expiresSec
}, function (cookie) {
if (chrome.extension.lastError || chrome.runtime.lastError) {
LogMsg(chrome.extension.lastError.message);
LogMsg(chrome.runtime.lastError.message);
return;
}
LogMsg(JSON.stringify(cookie));
});
}
var writeValueToLocalStorage = function(name, value) {
var item = {};
item [name] = value;
chrome.storage.local.set(item, function() {
// Notify that we saved.
if (chrome.extension.lastError || chrome.runtime.lastError) {
LogMsg("chrome.storage.local.set error:" + chrome.extension.lastError.message);
LogMsg("chrome.storage.local.set error:" + chrome.runtime.lastError.message);
return;
}
});
}
/* Searches element with name in cookies Array
string name - the name to search for
*/
var searchEl = function(name) {
for (var i=0; i < self.cookieArray.length; i++) {
if (self.cookieArray[i].name == name) {
return self.cookieArray[i].value;
}
}
return 0;
}
}
|
const paths = require("../paths");
const gulp = require("gulp");
const babel = require("gulp-babel");
const babelOptions = require("../babel-options");
const concat = require("gulp-concat");
const plumber = require("gulp-plumber");
gulp.task("buildJavascript", function () {
return gulp.src(paths.files)
.pipe(plumber())
//vs.pipe(babel(babelOptions))
.pipe(concat("app.js"))
.pipe(gulp.dest("built/scripts"));
});
|
import test from 'ava';
import stripUrlAuth from './index.js';
test('main', t => {
t.is(stripUrlAuth('http://user:pass@sindresorhus.com'), 'http://sindresorhus.com');
t.is(stripUrlAuth('https://user:pass@sindresorhus.com'), 'https://sindresorhus.com');
t.is(stripUrlAuth('//user:pass@sindresorhus.com'), '//sindresorhus.com');
t.is(stripUrlAuth('http://user@sindresorhus.com'), 'http://sindresorhus.com');
t.is(stripUrlAuth('http://sindresorhus.com/@foo'), 'http://sindresorhus.com/@foo');
t.is(stripUrlAuth('http://sindresorhus.com'), 'http://sindresorhus.com');
});
|
import { dispatchPost } from '../utils/actionsHelper';
import { FETCH_AUTH_FULFILLED, FETCH_AUTH_REJECTED } from '../constants/actionTypes';
import * as globalConstants from '../constants/config';
export default function getAuth(login) {
return dispatch => dispatchPost(
dispatch,
`${globalConstants.SERVER_BASE_URL}/employee/authenticate/`,
{
username: login.state.username,
password: login.state.password,
},
FETCH_AUTH_FULFILLED,
FETCH_AUTH_REJECTED,
(response) => {
if (response.data.token) {
localStorage.setItem('token', response.data.token);
localStorage.setItem('id', response.data.user_id);
login.props.router.go('/dashboard');
}
});
}
|
const describeKey = (key) => {
if (key.primaryChar != null && key.primaryChar !== '') {
return `${key.primaryChar}'s key`;
}
return `key with keyID ${key.keyID}`;
};
export default describeKey;
|
/**
* Unit test for the PropTypes.element validator
*/
import Ember from 'ember'
import {afterEach, beforeEach, describe} from 'mocha'
import sinon from 'sinon'
import {
itSupportsUpdatableOption,
itValidatesOnUpdate,
itValidatesTheProperty,
spyOnValidateMethods
} from 'dummy/tests/helpers/validator'
import PropTypesMixin, {PropTypes} from 'ember-prop-types/mixins/prop-types'
const requiredDef = {
required: true,
type: 'element'
}
const notRequiredDef = {
required: false,
type: 'element'
}
describe('Unit / validator / PropTypes.element', function () {
const ctx = {propertyName: 'bar'}
let sandbox, Foo
beforeEach(function () {
sandbox = sinon.sandbox.create()
spyOnValidateMethods(sandbox)
})
afterEach(function () {
sandbox.restore()
})
describe('when required option not present', function () {
beforeEach(function () {
ctx.def = notRequiredDef
Foo = Ember.Object.extend(PropTypesMixin, {
propTypes: {
bar: PropTypes.element()
}
})
})
describe('when initialized with element value', function () {
beforeEach(function () {
ctx.instance = Foo.create({bar: document.createElement('div')})
})
itValidatesTheProperty(ctx, false)
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
describe('when initialized with string value', function () {
beforeEach(function () {
ctx.instance = Foo.create({bar: 'baz'})
})
itValidatesTheProperty(ctx, false, 'Expected property bar to be an element')
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
describe('when initialized without value', function () {
beforeEach(function () {
ctx.instance = Foo.create()
})
itValidatesTheProperty(ctx, false)
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
})
describe('when required', function () {
beforeEach(function () {
ctx.def = requiredDef
Foo = Ember.Object.extend(PropTypesMixin, {
propTypes: {
bar: PropTypes.element({required: true})
}
})
})
describe('when initialized with element value', function () {
beforeEach(function () {
ctx.instance = Foo.create({bar: document.createElement('div')})
})
itValidatesTheProperty(ctx, false)
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
describe('when initialized with string value', function () {
beforeEach(function () {
ctx.instance = Foo.create({bar: 'baz'})
})
itValidatesTheProperty(ctx, false, 'Expected property bar to be an element')
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
describe('when initialized without value', function () {
beforeEach(function () {
ctx.instance = Foo.create()
})
itValidatesTheProperty(ctx, false, 'Missing required property bar')
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
})
describe('when not required', function () {
beforeEach(function () {
ctx.def = notRequiredDef
Foo = Ember.Object.extend(PropTypesMixin, {
propTypes: {
bar: PropTypes.element({required: false})
}
})
})
describe('when initialized with element value', function () {
beforeEach(function () {
ctx.instance = Foo.create({bar: document.createElement('div')})
})
itValidatesTheProperty(ctx, false)
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
describe('when initialized with string value', function () {
beforeEach(function () {
ctx.instance = Foo.create({bar: 'baz'})
})
itValidatesTheProperty(ctx, false, 'Expected property bar to be an element')
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
describe('when initialized without value', function () {
beforeEach(function () {
ctx.instance = Foo.create()
})
itValidatesTheProperty(ctx, false)
itValidatesOnUpdate(ctx, 'element', 'Expected property bar to be an element')
})
})
itSupportsUpdatableOption('element', document.createElement('div'), document.createElement('span'))
})
|
/*
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for
* license information.
*
* Code generated by Microsoft (R) AutoRest Code Generator 0.12.0.0
* Changes may cause incorrect behavior and will be lost if the code is
* regenerated.
*/
/* jshint latedef:false */
/* jshint forin:false */
/* jshint noempty:false */
'use strict';
exports.Implicit = require('./implicit');
exports.Explicit = require('./explicit');
|
export default class TestClass {
constructor () {
console.log('I am testing my class!');
}
} |
import React from 'react';
import PropTypes from 'prop-types';
import {createFragmentContainer, graphql} from 'react-relay';
import {TextBuffer} from 'atom';
import {CompositeDisposable} from 'event-kit';
import path from 'path';
import CreateDialogView from '../views/create-dialog-view';
export class BareCreateDialogController extends React.Component {
static propTypes = {
// Relay
user: PropTypes.shape({
id: PropTypes.string.isRequired,
}),
// Model
request: PropTypes.shape({
getParams: PropTypes.func.isRequired,
accept: PropTypes.func.isRequired,
}).isRequired,
error: PropTypes.instanceOf(Error),
isLoading: PropTypes.bool.isRequired,
inProgress: PropTypes.bool.isRequired,
// Atom environment
currentWindow: PropTypes.object.isRequired,
workspace: PropTypes.object.isRequired,
commands: PropTypes.object.isRequired,
config: PropTypes.object.isRequired,
}
constructor(props) {
super(props);
const {localDir} = this.props.request.getParams();
this.projectHome = this.props.config.get('core.projectHome');
this.modified = {
repoName: false,
localPath: false,
};
this.repoName = new TextBuffer({
text: localDir ? path.basename(localDir) : '',
});
this.localPath = new TextBuffer({
text: localDir || this.projectHome,
});
this.sourceRemoteName = new TextBuffer({
text: this.props.config.get('github.sourceRemoteName'),
});
this.subs = new CompositeDisposable(
this.repoName.onDidChange(this.didChangeRepoName),
this.localPath.onDidChange(this.didChangeLocalPath),
this.sourceRemoteName.onDidChange(this.didChangeSourceRemoteName),
this.props.config.onDidChange('github.sourceRemoteName', this.readSourceRemoteNameSetting),
this.props.config.onDidChange('github.remoteFetchProtocol', this.readRemoteFetchProtocolSetting),
);
this.state = {
acceptEnabled: this.acceptIsEnabled(),
selectedVisibility: 'PUBLIC',
selectedProtocol: this.props.config.get('github.remoteFetchProtocol'),
selectedOwnerID: this.props.user ? this.props.user.id : '',
};
}
render() {
return (
<CreateDialogView
selectedOwnerID={this.state.selectedOwnerID}
repoName={this.repoName}
selectedVisibility={this.state.selectedVisibility}
localPath={this.localPath}
sourceRemoteName={this.sourceRemoteName}
selectedProtocol={this.state.selectedProtocol}
didChangeOwnerID={this.didChangeOwnerID}
didChangeVisibility={this.didChangeVisibility}
didChangeProtocol={this.didChangeProtocol}
acceptEnabled={this.state.acceptEnabled}
accept={this.accept}
{...this.props}
/>
);
}
componentDidUpdate(prevProps) {
if (this.props.user !== prevProps.user) {
this.recheckAcceptEnablement();
}
}
componentWillUnmount() {
this.subs.dispose();
}
didChangeRepoName = () => {
this.modified.repoName = true;
if (!this.modified.localPath) {
if (this.localPath.getText() === this.projectHome) {
this.localPath.setText(path.join(this.projectHome, this.repoName.getText()));
} else {
const dirName = path.dirname(this.localPath.getText());
this.localPath.setText(path.join(dirName, this.repoName.getText()));
}
this.modified.localPath = false;
}
this.recheckAcceptEnablement();
}
didChangeOwnerID = ownerID => new Promise(resolve => this.setState({selectedOwnerID: ownerID}, resolve))
didChangeLocalPath = () => {
this.modified.localPath = true;
if (!this.modified.repoName) {
this.repoName.setText(path.basename(this.localPath.getText()));
this.modified.repoName = false;
}
this.recheckAcceptEnablement();
}
didChangeVisibility = visibility => {
return new Promise(resolve => this.setState({selectedVisibility: visibility}, resolve));
}
didChangeSourceRemoteName = () => {
this.writeSourceRemoteNameSetting();
this.recheckAcceptEnablement();
}
didChangeProtocol = async protocol => {
await new Promise(resolve => this.setState({selectedProtocol: protocol}, resolve));
this.writeRemoteFetchProtocolSetting(protocol);
}
readSourceRemoteNameSetting = ({newValue}) => {
if (newValue !== this.sourceRemoteName.getText()) {
this.sourceRemoteName.setText(newValue);
}
}
writeSourceRemoteNameSetting() {
if (this.props.config.get('github.sourceRemoteName') !== this.sourceRemoteName.getText()) {
this.props.config.set('github.sourceRemoteName', this.sourceRemoteName.getText());
}
}
readRemoteFetchProtocolSetting = ({newValue}) => {
if (newValue !== this.state.selectedProtocol) {
this.setState({selectedProtocol: newValue});
}
}
writeRemoteFetchProtocolSetting(protocol) {
if (this.props.config.get('github.remoteFetchProtocol') !== protocol) {
this.props.config.set('github.remoteFetchProtocol', protocol);
}
}
acceptIsEnabled() {
return !this.repoName.isEmpty() &&
!this.localPath.isEmpty() &&
!this.sourceRemoteName.isEmpty() &&
this.props.user !== null;
}
recheckAcceptEnablement() {
const nextEnablement = this.acceptIsEnabled();
if (nextEnablement !== this.state.acceptEnabled) {
this.setState({acceptEnabled: nextEnablement});
}
}
accept = () => {
if (!this.acceptIsEnabled()) {
return Promise.resolve();
}
const ownerID = this.state.selectedOwnerID !== '' ? this.state.selectedOwnerID : this.props.user.id;
return this.props.request.accept({
ownerID,
name: this.repoName.getText(),
visibility: this.state.selectedVisibility,
localPath: this.localPath.getText(),
protocol: this.state.selectedProtocol,
sourceRemoteName: this.sourceRemoteName.getText(),
});
}
}
export default createFragmentContainer(BareCreateDialogController, {
user: graphql`
fragment createDialogController_user on User
@argumentDefinitions(
organizationCount: {type: "Int!"}
organizationCursor: {type: "String"}
) {
id
...repositoryHomeSelectionView_user @arguments(
organizationCount: $organizationCount
organizationCursor: $organizationCursor
)
}
`,
});
|
module.exports = {
active: true,
default: false,
name: '100-IPIP-NEO-PI-R',
link: 'http://ipip.ori.org/newNEODomainsKey.htm',
info: `Costa and McCrae's NEO-PI-R (100 questions)`,
shuffle: true
}
|
function solve(input){
let reversed=findReversedWord(input);
if(input===reversed){
console.log('true')
} else{
console.log('false')
}
function findReversedWord(input){
let reversed='';
for (let i = input.length-1; i >= 0; i--) {
reversed+=input[i];
}
return reversed;
}
}
solve('racecar') |
import Employee from '../../components/EmployeePage';
import { graphql } from 'gatsby';
/** TODO: make this work dynamically */
export const query = graphql`
query {
EmployeeImages: allFile(
sort: { order: ASC, fields: [absolutePath] }
filter: { relativePath: { regex: "/mugshots/larsfredrik.jpg/" } }
) {
edges {
node {
relativePath
name
childImageSharp {
fluid(maxWidth: 1000) {
...GatsbyImageSharpFluid
}
}
}
}
}
}
`;
export default Employee;
|
var predefined_textures = {
water: {
bg: { r: 50, g: 100, b: 200 },
fg: { r: 7, g: 28, b: 10 }
},
fire: {
bg: { r: 255, g: 0, b: 0 },
fg: { r: 247, g: 228, b: 0 }
}
};
|
'use strict'
/* eslint-disable no-unused-vars */
const React = require('react')
const ReactBootstrap = require('react-bootstrap')
const Navbar = ReactBootstrap.Navbar
const Nav = ReactBootstrap.Nav
const NavItem = ReactBootstrap.NavItem
const ReactRouter = require('react-router')
const Link = ReactRouter.Link
const ReactRouterBootstrap = require('react-router-bootstrap')
const LinkContainer = ReactRouterBootstrap.LinkContainer
const Announcements = require('./announcements')
/* eslint-enable no-unused-vars */
const PropTypes = require('prop-types')
const createReactClass = require('create-react-class')
const Header = createReactClass({
displayName: 'Header',
propTypes: {
children: PropTypes.object
},
render: function render () {
return (
<div>
<Navbar fluid>
<Navbar.Header>
<Navbar.Brand>
<Link to='/' title='Home'>
Measure Mate
</Link>
</Navbar.Brand>
<Navbar.Toggle />
</Navbar.Header>
<Navbar.Collapse>
<Nav>
<LinkContainer to='/assessment/'>
<NavItem eventKey={1} title='Assessments'>Assessments</NavItem>
</LinkContainer>
<LinkContainer to='/team/'>
<NavItem eventKey={2} title='Teams'>Teams</NavItem>
</LinkContainer>
</Nav>
<Nav pullRight>
<NavItem eventKey={3} title='Admin' href='/admin/' target='_blank'>Admin</NavItem>
<NavItem eventKey={4} title='Export' href='/export/' target='_blank'>Export</NavItem>
<LinkContainer to='/about'>
<NavItem eventKey={5} title='About'>About</NavItem>
</LinkContainer>
</Nav>
</Navbar.Collapse>
</Navbar>
<div className='container-fluid'>
<Announcements />
{this.props.children}
</div>
</div>
)
}
})
module.exports = Header
|
class PollMeter {
constructor() {
this.contasinerId = 'poll-meter-container';
this.updateInterval = 3000;
this.gap = 10;
}
init(size) {
if(this.container) {
return;
}
let body = d3.select('body');
this.container = body.append('div')
.attr('id', this.contasinerId)
.style('width', `${(size*2) + this.gap}px`)
.style('font-family', 'Helvetica')
.style('font-weight', 'bold')
.style('position', 'absolute')
.style('right', '15px')
.style('bottom', '15px')
.style('z-index', '10000');
this.container
.append('svg:svg')
.attr('width', size)
.attr('height', size)
.style('margin-right', `${this.gap}px`)
.attr('id', 'angular');
this.container
.append('svg:svg')
.attr('width', size)
.attr('height', size)
.attr('id', 'react');
this.summary = this.container.append('div')
.attr('class', 'summary')
.style('color', '#7a8b9c')
.style('text-align', 'right');
let angularConfig = liquidFillGaugeDefaultSettings();
angularConfig.circleColor = '#c30e2e';
angularConfig.textColor = '#c30e2e';
angularConfig.waveTextColor = '#FFFFFF';
angularConfig.waveColor = '#dd0330';
angularConfig.waveAnimateTime = 1000;
let angularMeter = loadLiquidFillGauge('angular', 0, angularConfig);
let reactConfig = liquidFillGaugeDefaultSettings();
reactConfig.circleColor = '#4ab3ce';
reactConfig.textColor = '#3e839c';
reactConfig.waveTextColor = '#FFFFFF';
reactConfig.waveColor = '#53c1de';
reactConfig.waveAnimateTime = 1000;
let reactMeter = loadLiquidFillGauge('react', 0, reactConfig);
d3.selectAll('.liquidFillGaugeText')
.style('font-family', 'Helvetica')
.style('font-weight', 'bold');
this.updateMeters(angularMeter, reactMeter);
}
updateMeters(angularMeter, reactMeter) {
$.get('/stats', (data) => {
let result = {};
let totalCount = 0;
for (let i = 0; i < data.length; i++) {
let key = data[i]['_id'];
result[key] = data[i]['count'];
totalCount += result[key];
}
this.setPercent(angularMeter, result.angular, totalCount);
this.setPercent(reactMeter, result.react, totalCount);
this.summary.transition()
.duration(500).text(totalCount);
setTimeout(() => this.updateMeters(angularMeter, reactMeter),
this.updateInterval);
});
}
setPercent(meter, votes, total) {
let perc = votes ? Math.round((votes / total) * 100) : 0;
meter.update(perc);
}
remove() {
if(this.container) {
this.container.remove();
this.container = undefined;
}
}
}
|
'use strict';
/**
* @ngdoc function
* @name angularApp.controller:SearchCtrl
* @description
* # SearchCtrl
* Controller of the angularApp
*/
angular.module('angularApp')
.controller('SearchCtrl', function ($scope, $rootScope) {
var vm = $scope;
window.searchCtrl = vm;
vm.search = { fields: [], inputType: '', params: {}, queries: {} };
vm.$on('model:index-config-loaded', function (evt, modelName, configData) {
vm.initSearch(configData.schema.properties);
});
vm.initSearch = function (schemaProperties) {
vm.search.fields = _.map(schemaProperties, function(value, key) {
value.key = key;
value.inputType = 'text';
if (value.type === 'string' && value.format === 'date') {
value.inputType = 'date';
} else if (value.type === 'number' && value.items) {
value.inputType = 'select';
}
return value;
});
vm.search.dateRange = {startDate: moment().startOf('month'), endDate: moment().endOf('month')};
}
// Reinitialize searchValue if inputType is date
vm.$watch('search.searchField', function () {
if (!vm.search.searchField) return;
if (vm.search.searchField.inputType === 'date') {
vm.search.searchValue = {startDate: moment().endOf('day'), endDate: moment().endOf('day')};
}
});
vm.getQueryParams = function () {
var queryParams = _.reduce(vm.search.params, function (memo, value, key) {
var field = _.findWhere(vm.search.fields, {key: key});
if (!field) return memo;
if (field.inputType === 'date') {
memo[key + '.between'] = _.map(value, function (val) {
return val.startDate.toISOString() + '|' + val.endDate.toISOString();
}).join('||');
} else if (field.inputType === 'select') {
memo[key + '.in'] = value.join();
} else if (field.inputType === 'text') {
memo[key + '.like'] = value.join('|');
}
return memo;
}, {});
if (vm.search.dateRange && vm.search.dateRange.startDate) {
var startDate = vm.search.dateRange.startDate.toISOString();
var endDate = vm.search.dateRange.endDate.toISOString();
queryParams['created_at.between'] = startDate + '|' + endDate;
}
return queryParams;
}
vm.buildSearchQueries = function () {
vm.search.queries = _.reduce(vm.search.params, function (memo, value, key) {
var field = _.findWhere(vm.search.fields, {key: key});
if (!field) return memo;
var queryVal = field.title + ': ';
if (field.inputType === 'select') {
var vals = _.map(value, function (val) {
var item = _.findWhere(field.items, {value: val}) || {};
return item.label;
});
queryVal = queryVal + _.uniq(vals);
} else if (field.inputType === 'date') {
var vals = _.map(value, function (val) {
var startDate = new Date(val.startDate).toISOString().slice(0, 10);
var endDate = new Date(val.endDate).toISOString().slice(0, 10);
if (startDate === endDate) {
return startDate;
} else {
return '(' + startDate + ',' + endDate + ')';
}
});
queryVal = queryVal + _.uniq(vals);
} else {
queryVal = queryVal + _.uniq(value);
}
memo[key] = queryVal;
return memo;
}, {});
}
vm.addSearchParam = function () {
if (!vm.search.searchField || !vm.search.searchValue) {
return;
}
var fieldKey = vm.search.searchField.key;
// Check if field exists in params and initialize if not
if (!vm.search.params[fieldKey]) {
vm.search.params[fieldKey] = [];
}
vm.search.params[fieldKey].push(vm.search.searchValue);
vm.search.searchValue = null;
vm.buildSearchQueries();
}
vm.clearSearchParams = function () {
vm.search.params = {};
vm.search.queries = {};
}
vm.removeSearchParam = function (key) {
delete vm.search.params[key];
vm.buildSearchQueries();
}
vm.doSearch = function () {
$rootScope.$broadcast('model:do-search', vm.modelName, vm.getQueryParams());
}
if (vm.schema && vm.schema.properties) {
vm.initSearch(vm.schema.properties);
}
});
|
export * from './module';
export * from './components/component';
//# sourceMappingURL=index.js.map |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.