test("updates happen on two-way even when one binding is satisfied", function(assert) {
var done = assert.async();
var template = stache('<input value:bind="firstName"/>');
var viewModel = new SimpleMap({ firstName: "jeffrey" });
canReflect.assignSymbols(viewModel,{
"can.setKeyValue": function(key, val) {
if(val) {
this.set(key, val.toLowerCase());
}
}
});
var frag = template(viewModel);
domMutateNode.appendChild.call(this.fixture, frag);
var input = this.fixture.firstChild;
assert.equal(input.value, "jeffrey", 'initial value should be "jeffrey"');
input.value = "JEFFREY";
domEvents.dispatch(input, "change");
assert.equal(input.value, "jeffrey", 'updated value should be "jeffrey"');
testHelpers.afterMutation(function () {
done();
});
});
test("value:bind compute rejects new value (#887)", function() {
var template = stache("<input value:bind='age'/>");
// Compute only accepts numbers
var compute = new SimpleObservable(30);
canReflect.assignSymbols(compute,{
"can.setValue": function(newVal){
if(isNaN(+newVal)) {
// do nothing
} else {
this.set( +newVal );
}
}
});
var frag = template({
age: compute
});
var ta = this.fixture;
ta.appendChild(frag);
var input = ta.getElementsByTagName("input")[0];
// Set to non-number
input.value = "30f";
domEvents.dispatch(input, "change");
equal(compute.get(), 30, "Still the old value");
equal(input.value, "30", "Text input has also not changed");
});
viewModel: function(props){
var map = new SimpleMap(props);
canReflect.assignSymbols(map,{
"can.setKeyValue": function(key, value){
if(key === "page"){
equal(value, "view", "value should not be edit");
} else {
QUnit.equal(key, "title", "title was set, we are trapping right");
}
this.set(key, value);
}
});
return map;
}
attribute: function(bindingData, bindingContext ) {
if(bindingData.name === "this") {
return canReflect.assignSymbols({}, {
"can.getValue": function() {
return bindingContext.element;
},
"can.valueHasDependencies": function() {
return false;
},
"can.getName": function getName() {
//!steal-remove-start
return "<"+bindingContext.element.nodeName+">";
//!steal-remove-end
}
});
} else {
return new AttributeObservable(bindingContext.element, bindingData.name, {}, bindingData.event);
}
}
scope: function(bindingData, bindingContext) {
var scope = bindingContext.scope,
scopeProp = bindingData.name,
mustBeGettable = bindingData.exports;
if (!scopeProp) {
return new SimpleObservable();
} else {
// Check if we need to spend time building a scope-key-data
// If we have a '(', it likely means a call expression.
if (mustBeGettable || scopeProp.indexOf("(") >= 0 || scopeProp.indexOf("=") >= 0) {
var parentExpression = expression.parse(scopeProp,{baseMethodType: "Call"});
if (parentExpression instanceof expression.Hashes) {
return new SimpleObservable(function () {
var hashExprs = parentExpression.hashExprs;
var key = Object.keys(hashExprs)[0];
var value = parentExpression.hashExprs[key].value(scope);
var isObservableValue = canReflect.isObservableLike(value) && canReflect.isValueLike(value);
scope.set(key, isObservableValue ? canReflect.getValue(value) : value);
});
} else {
return parentExpression.value(scope);
}
} else {
var observation = {};
canReflect.assignSymbols(observation, {
"can.getValue": function getValue() {},
"can.valueHasDependencies": function hasValueDependencies() {
return false;
},
"can.setValue": function setValue(newVal) {
var expr = expression.parse(cleanVMName(scopeProp, scope),{baseMethodType: "Call"});
var value = expr.value(scope);
canReflect.setValue(value, newVal);
},
// Register what the custom observation changes
"can.getWhatIChange": function getWhatIChange() {
var data = scope.getDataForScopeSet(cleanVMName(scopeProp, scope));
var m = new Map();
var s = new Set();
s.add(data.key);
m.set(data.parent, s);
return {
mutate: {
keyDependencies: m
}
};
},
"can.getName": function getName() {
//!steal-remove-start
if (process.env.NODE_ENV !== 'production') {
var result = "ObservableFromScope<>";
var data = scope.getDataForScopeSet(cleanVMName(scopeProp, scope));
if (data.parent && data.key) {
result = "ObservableFromScope<" +
canReflect.getName(data.parent) +
"." +
data.key +
">";
}
return result;
}
//!steal-remove-end
},
});
var data = scope.getDataForScopeSet(cleanVMName(scopeProp, scope));
if (data.parent && data.key) {
// Register what changes the Scope's parent key
canReflectDeps.addMutatedBy(data.parent, data.key, observation);
}
return observation;
}
}
},
"use strict";
var SimpleObservable = require("can-simple-observable");
var canReflect = require("can-reflect");
function SetObservable(initialValue, setter) {
this.setter = setter;
SimpleObservable.call(this, initialValue);
}
SetObservable.prototype = Object.create(SimpleObservable.prototype);
SetObservable.prototype.constructor = SetObservable;
SetObservable.prototype.set = function(newVal) {
this.setter(newVal);
};
canReflect.assignSymbols(SetObservable.prototype, {
"can.setValue": SetObservable.prototype.set
});
module.exports = SetObservable;