var callAttrEnd = function(state, curIndex, handler, rest, lineNo){
if(state.valueStart !== undefined && state.valueStart < curIndex) {
var val = rest.substring(state.valueStart, curIndex);
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
var quotedVal, closedQuote;
quotedVal = rest.substring(state.valueStart - 1, curIndex + 1);
quotedVal = quotedVal.trim();
closedQuote = quotedVal.charAt(quotedVal.length - 1);
if (state.inQuote !== closedQuote) {
if (handler.filename) {
dev.warn(handler.filename + ":" + lineNo + ": End quote is missing for " + val);
} else {
dev.warn(lineNo + ": End quote is missing for " + val);
}
}
}
//!steal-remove-end
handler.attrValue(val, lineNo);
}
// if this never got to be inValue, like `DISABLED` then send a attrValue
// else if(!state.inValue){
// handler.attrValue(state.attrStart, lineNo);
// }
handler.attrEnd(state.attrStart, lineNo);
state.attrStart = undefined;
state.valueStart = undefined;
state.inValue = false;
state.inName = false;
state.lookingForEq = false;
state.inQuote = false;
state.lookingForName = true;
};
get: function(){
if(!hasWarned) {
hasWarned = true;
devLog.warn("The global " + property + " is not supported by can-vdom.");
}
return value;
},
var cleanVMName = function(name, scope) {
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if (name.indexOf("@") >= 0 && scope) {
var filename = scope.peek('scope.filename');
var lineNumber = scope.peek('scope.lineNumber');
dev.warn(
(filename ? filename + ':' : '') +
(lineNumber ? lineNumber + ': ' : '') +
'functions are no longer called by default so @ is unnecessary in \'' + name + '\'.');
}
}
//!steal-remove-end
return name.replace(/@/g, "");
};
renderer = function() {
if(typeof localPartialName === "function"){
return localPartialName(partialScope, {}, nodeList);
} else {
var domRenderer = core.getTemplateById(localPartialName);
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if (!domRenderer) {
dev.warn(
(state.filename ? state.filename + ':' : '') +
(state.lineNo ? state.lineNo + ': ' : '') +
'Unable to find partial "' + localPartialName + '".');
}
}
//!steal-remove-end
return domRenderer ? domRenderer(partialScope, {}, nodeList) : getDocument().createDocumentFragment();
}
};
dispatch: function(event, args, bubbles){
var ret;
var dispatchingOnDisabled = fixSyntheticEventsOnDisabled && isDispatchingOnDisabled(this, event);
var doc = this.ownerDocument || getDocument();
var ev = doc.createEvent('HTMLEvents');
var isString = typeof event === "string";
// removed / inserted events should not bubble
ev.initEvent(isString ? event : event.type, bubbles === undefined ? true : bubbles, false);
if(!isString) {
for (var prop in event) {
if (ev[prop] === undefined) {
ev[prop] = event[prop];
}
}
}
// ignore events from feature detection below
if(this.disabled === true && ev.type !== 'fix_synthetic_events_on_disabled_test') {
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
dev.warn(
"can-util/dom/events::dispatch: Dispatching a synthetic event on a disabled is " +
"problematic in FireFox and Internet Explorer. We recommend avoiding this if at " +
"all possible. see https://github.com/canjs/can-util/issues/294"
);
}
//!steal-remove-end
}
ev.args = args;
if(dispatchingOnDisabled) {
this.disabled = false;
}
ret = this.dispatchEvent(ev);
if(dispatchingOnDisabled) {
this.disabled = true;
}
return ret;
}
var branchRenderer = function branchRenderer(scope, parentSectionNodeList, truthyRenderer, falseyRenderer){
// If this is within a tag, make sure we only get string values.
var stringOnly = state.tag;
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
scope.set('scope.filename', state.filename);
scope.set('scope.lineNumber', state.lineNo);
}
//!steal-remove-end
var nodeList = [this];
nodeList.expression = expressionString;
// register this nodeList.
// Register it with its parent ONLY if this is directly nested. Otherwise, it's unnecessary.
nodeLists.register(nodeList, null, parentSectionNodeList || true, state.directlyNested);
// Get the evaluator. This does not need to be cached (probably) because if there
// an observable value, it will be handled by `can.view.live`.
var evaluator = makeEvaluator( scope, nodeList, mode, exprData, truthyRenderer, falseyRenderer, stringOnly );
// Create a compute that can not be observed by other
// computes. This is important because this renderer is likely called by
// parent expressions. If this value changes, the parent expressions should
// not re-evaluate. We prevent that by making sure this compute is ignored by
// everyone else.
//var compute = can.compute(evaluator, null, false);
var gotObservableValue = evaluator[canSymbol.for("can.onValue")];
var observable;
if(gotObservableValue) {
observable = evaluator;
} else {
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(evaluator,"name",{
value: "{{"+(mode || "")+expressionString+"}}"
});
}
//!steal-remove-end
observable = new Observation(evaluator,null,{isObservable: false});
}
if(canReflect.setPriority(observable, nodeList.nesting) === false) {
throw new Error("can-stache unable to set priority on observable");
}
// Bind on the computeValue to set the cached value. This helps performance
// so live binding can read a cached value instead of re-calculating.
canReflect.onValue(observable, k);
var value = canReflect.getValue(observable);
// If value is a function and not a Lookup ({{foo}}),
// it's a helper that returned a function and should be called.
if(typeof value === "function" && !(exprData instanceof expression.Lookup)) {
// A helper function should do it's own binding. Similar to how
// we prevented this function's compute from being noticed by parent expressions,
// we hide any observables read in the function by saving any observables that
// have been read and then setting them back which overwrites any `can.__observe` calls
// performed in value.
ObservationRecorder.ignore(value)(this);
}
// If the computeValue has observable dependencies, setup live binding.
else if( canReflect.valueHasDependencies(observable) ) {
// Depending on where the template is, setup live-binding differently.
if(state.attr) {
live.attr(this, state.attr, observable);
}
else if( state.tag ) {
live.attrs( this, observable );
}
else if(state.text && !valueShouldBeInsertedAsHTML(value)) {
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if(value !== null && typeof value === "object") {
dev.warn("Previously, the result of "+
expressionString+" in "+state.filename+":"+state.lineNo+
", was being inserted as HTML instead of TEXT. Please use stache.safeString(obj) "+
"if you would like the object to be treated as HTML.");
}
}
//!steal-remove-end
live.text(this, observable, this.parentNode, nodeList);
} else {
live.html(this, observable, this.parentNode, {
nodeList: nodeList
});
}
}
// If the computeValue has no observable dependencies, just set the value on the element.
else {
if(state.attr) {
domMutate.setAttribute(this, state.attr, value);
}
else if(state.tag) {
live.attrs(this, value);
}
else if(state.text && !valueShouldBeInsertedAsHTML(value)) {
this.nodeValue = live.makeString(value);
}
else if( value != null ){
if (typeof value[viewInsertSymbol] === "function") {
var insert = value[viewInsertSymbol]({
nodeList: nodeList
});
var oldNodes = nodeLists.update(nodeList, [insert]);
nodeLists.replace(oldNodes, insert);
} else {
nodeLists.replace([this], frag(value, this.ownerDocument));
}
}
}
// Unbind the compute.
canReflect.offValue(observable, k);
};
var partialFrag = new Observation(function(){
var localPartialName = partialName;
var partialScope = scope;
// If the second parameter of a partial is a custom context
if(exprData && exprData.argExprs.length === 1) {
var newContext = canReflect.getValue( exprData.argExprs[0].value(scope) );
if(typeof newContext === "undefined") {
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
dev.warn('The context ('+ exprData.argExprs[0].key +') you passed into the' +
'partial ('+ partialName +') is not defined in the scope!');
}
//!steal-remove-end
}else{
partialScope = scope.add(newContext);
}
}
// Look up partials in templateContext first
var partial = canReflect.getKeyValue(partialScope.templateContext.partials, localPartialName);
var renderer;
if (partial) {
renderer = function() {
return partial.render ? partial.render(partialScope, nodeList)
: partial(partialScope);
};
}
// Use can.view to get and render the partial.
else {
var scopePartialName = partialScope.read(localPartialName, {
isArgument: true
}).value;
if (scopePartialName === null || !scopePartialName && localPartialName[0] === '*') {
return frag("");
}
if (scopePartialName) {
localPartialName = scopePartialName;
}
renderer = function() {
if(typeof localPartialName === "function"){
return localPartialName(partialScope, {}, nodeList);
} else {
var domRenderer = core.getTemplateById(localPartialName);
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if (!domRenderer) {
dev.warn(
(state.filename ? state.filename + ':' : '') +
(state.lineNo ? state.lineNo + ': ' : '') +
'Unable to find partial "' + localPartialName + '".');
}
}
//!steal-remove-end
return domRenderer ? domRenderer(partialScope, {}, nodeList) : getDocument().createDocumentFragment();
}
};
}
var res = ObservationRecorder.ignore(renderer)();
return frag(res);
});
function parseEndTag(tag, tagName) {
// If no tag name is provided, clean shop
var pos;
if (!tagName) {
pos = 0;
}
// Find the closest opened tag of the same type
else {
tagName = caseMattersElements[tagName] ? tagName : tagName.toLowerCase();
for (pos = stack.length - 1; pos >= 0; pos--) {
if (stack[pos] === tagName) {
break;
}
}
}
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if (typeof tag === 'undefined') {
if (stack.length > 0) {
if (handler.filename) {
dev.warn(handler.filename + ": expected closing tag </" + stack[pos] + ">");
}
else {
dev.warn("expected closing tag </" + stack[pos] + ">");
}
}
} else if (pos < 0 || pos !== stack.length - 1) {
if (stack.length > 0) {
if (handler.filename) {
dev.warn(handler.filename + ":" + lineNo + ": unexpected closing tag " + tag + " expected </" + stack[stack.length - 1] + ">");
}
else {
dev.warn(lineNo + ": unexpected closing tag " + tag + " expected </" + stack[stack.length - 1] + ">");
}
} else {
if (handler.filename) {
dev.warn(handler.filename + ":" + lineNo + ": unexpected closing tag " + tag);
}
else {
dev.warn(lineNo + ": unexpected closing tag " + tag);
}
}
}
}
//!steal-remove-end
if (pos >= 0) {
// Close all the open elements, up the stack
for (var i = stack.length - 1; i >= pos; i--) {
if (handler.close) {
handler.close(stack[i], lineNo);
}
}
// Remove the open elements from the stack
stack.length = pos;
// Don't add TextNodes after the <body> tag
if(tagName === "body") {
skipChars = true;
}
}
}
* @module {events} can-util/dom/events/enter/enter enter
* @parent deprecated
*
* Watches for when enter keys are pressed on a given element
*
* ```js
* var events = require("can-util/dom/events/events");
* var input = document.createElement("input");
*
* function enterEventHandler() {
* console.log("enter key pressed");
* }
*
* events.addEventHandler.call(input, "enter", enterEventHandler);
* events.dispatch.call(input, {
* type: 'keyup',
* keyCode: keyCode
* });
*
*
*/
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
canDev.warn('dom/events/enter/enter is deprecated; please use can-event-dom-enter instead: https://github.com/canjs/can-event-dom-enter');
}
//!steal-remove-end
var addEnter = require('can-event-dom-enter/compat');
addEnter(events);
'use strict';
var canDev = require("can-log/dev/dev");
/**
* @module can-util/js/types/types types
* @parent deprecated
* @description Deprecated. Use [can-types] instead.
*/
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
canDev.warn('js/types/types is deprecated; please use can-types instead: https://github.com/canjs/can-types');
}
//!steal-remove-end
module.exports = require('can-types');
data: function(el, attrData) {
if (domData.get.call(el, "preventDataBindings")) {
return;
}
var viewModel,
getViewModel = ObservationRecorder.ignore(function() {
return viewModel || (viewModel = canViewModel(el));
}),
teardown,
attributeDisposal,
removedDisposal,
bindingContext = {
element: el,
templateType: attrData.templateType,
scope: attrData.scope,
parentNodeList: attrData.nodeList,
get viewModel(){
return getViewModel();
}
};
// Setup binding
var dataBinding = makeDataBinding({
name: attrData.attributeName,
value: el.getAttribute(attrData.attributeName),
}, bindingContext, {
syncChildWithParent: false
});
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if (dataBinding.siblingBindingData.child.source === "viewModel" && !domData.get(el, "viewModel")) {
dev.warn('This element does not have a viewModel. (Attempting to bind `' + dataBinding.siblingBindingData.bindingAttributeName + '="' + dataBinding.siblingBindingData.parent.name + '"`)');
}
}
//!steal-remove-end
dataBinding.binding.start();
var attributeListener = function(ev) {
var attrName = ev.attributeName,
value = el.getAttribute(attrName);
if (attrName === attrData.attributeName) {
if (teardown) {
teardown();
}
if(value !== null ) {
var dataBinding = makeDataBinding({name: attrName, value: value}, bindingContext, {
syncChildWithParent: false
});
if(dataBinding) {
// The viewModel is created, so call callback immediately.
dataBinding.binding.start();
teardown = dataBinding.binding.stop.bind(dataBinding.binding);
}
teardown = dataBinding.onTeardown;
}
}
};
var tearItAllDown = function() {
if (teardown) {
teardown();
teardown = undefined;
}
if (removedDisposal) {
removedDisposal();
removedDisposal = undefined;
}
if (attributeDisposal) {
attributeDisposal();
attributeDisposal = undefined;
}
};
if (attrData.nodeList) {
ViewNodeList.register([], tearItAllDown, attrData.nodeList, false);
}
// Listen for changes
teardown = dataBinding.binding.stop.bind(dataBinding.binding);
attributeDisposal = domMutate.onNodeAttributeChange(el, attributeListener);
removedDisposal = domMutate.onNodeRemoval(el, function() {
var doc = el.ownerDocument;
var ownerNode = doc.contains ? doc : doc.documentElement;
if (!ownerNode || ownerNode.contains(el) === false) {
tearItAllDown();
}
});
},
var makeDataBinding = function(node, bindingContext, bindingSettings) {
// Get information about the binding.
var siblingBindingData = getSiblingBindingData( node, bindingSettings );
if (!siblingBindingData) {
return;
}
// Get computes for the parent and child binding
var parentObservable = getObservableFrom[siblingBindingData.parent.source](
siblingBindingData.parent,
bindingContext, bindingSettings
),
childObservable = getObservableFrom[siblingBindingData.child.source](
siblingBindingData.child,
bindingContext, bindingSettings,
parentObservable
);
var childToParent = !!siblingBindingData.child.exports;
var parentToChild = !!siblingBindingData.parent.exports;
// Check for child:bind="~parent" (it’s not supported because it’s unclear
// what the “right” behavior should be)
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
if (siblingBindingData.child.setCompute && childToParent && parentToChild) {
dev.warn("Two-way binding computes is not supported.");
}
}
//!steal-remove-end
var bindingOptions = {
child: childObservable,
childToParent: childToParent,
// allow cycles if one directional
cycles: childToParent === true && parentToChild === true ? 0 : 100,
onInitDoNotUpdateChild: bindingSettings.alreadyUpdatedChild || siblingBindingData.initializeValues === false,
onInitDoNotUpdateParent: siblingBindingData.initializeValues === false,
onInitSetUndefinedParentIfChildIsDefined: true,
parent: parentObservable,
parentToChild: parentToChild,
priority: bindingContext.parentNodeList ? bindingContext.parentNodeList.nesting + 1 : undefined,
queue: "domUI",
sticky: siblingBindingData.parent.syncSibling ? "childSticksToParent" : undefined
};
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
var nodeHTML = encoder.decode(node.name)+"="+JSON.stringify(node.value);
var tagStart = "<"+bindingContext.element.nodeName.toLowerCase(),
tag = tagStart+">";
var makeUpdateName = function(child, childName) {
if(child === "viewModel") {
return tag+"."+childName;
}
else if(child === "scope") {
return "{{"+childName+"}}";
}
else {
return ""+child+"."+childName;
}
};
bindingOptions.updateChildName = tagStart+" "+nodeHTML+"> updates "+
makeUpdateName(siblingBindingData.child.source, siblingBindingData.child.name)+
" from "+makeUpdateName(siblingBindingData.parent.source, siblingBindingData.parent.name);
bindingOptions.updateParentName = tagStart+" "+nodeHTML+"> updates "+
makeUpdateName(siblingBindingData.parent.source, siblingBindingData.parent.name)+
" from "+makeUpdateName(siblingBindingData.child.source, siblingBindingData.child.name);
}
//!steal-remove-end
// Create the binding
var canBinding = new Bind(bindingOptions);
return {
siblingBindingData: siblingBindingData,
binding: canBinding
};
};