answer stringlengths 15 1.25M |
|---|
//BlendType
/**
* The value of the blend type of normal
* @constant
* @type Number
*/
ccs.BLEND_TYPE_NORMAL = 0;
/**
* The value of the blend type of layer
* @constant
* @type Number
*/
ccs.BLEND_TYPE_LAYER = 1;
/**
* The value of the blend type of darken
* @constant
* @type Number
*/
ccs.BLEND_TYPE_DARKEN = 2;
/**
* The value of the blend type of multiply
* @constant
* @type Number
*/
ccs.BLEND_TYPE_MULTIPLY = 3;
/**
* The value of the blend type of lighten
* @constant
* @type Number
*/
ccs.BLEND_TYPE_LIGHTEN = 4;
/**
* The value of the blend type of screen
* @constant
* @type Number
*/
ccs.BLEND_TYPE_SCREEN = 5;
/**
* The value of the blend type of overlay
* @constant
* @type Number
*/
ccs.BLEND_TYPE_OVERLAY = 6;
/**
* The value of the blend type of highlight
* @constant
* @type Number
*/
ccs.<API key> = 7;
/**
* The value of the blend type of add
* @constant
* @type Number
*/
ccs.BLEND_TYPE_ADD = 8;
/**
* The value of the blend type of subtract
* @constant
* @type Number
*/
ccs.BLEND_TYPE_SUBTRACT = 9;
/**
* The value of the blend type of difference
* @constant
* @type Number
*/
ccs.<API key> = 10;
/**
* The value of the blend type of invert
* @constant
* @type Number
*/
ccs.BLEND_TYPE_INVERT = 11;
/**
* The value of the blend type of alpha
* @constant
* @type Number
*/
ccs.BLEND_TYPE_ALPHA = 12;
/**
* The value of the blend type of erase
* @constant
* @type Number
*/
ccs.BLEND_TYPE_ERASE = 13;
//DisplayType
ccs.DISPLAY_TYPE_SPRITE = 0;
ccs.<API key> = 1;
ccs.<API key> = 2;
ccs.DISPLAY_TYPE_MAX = 3;
/**
* Base class for ccs.BaseData objects.
* @class
* @extends ccs.Class
*/
ccs.BaseData = ccs.Class.extend(/** @lends ccs.BaseData# */{
x:0,
y:0,
zOrder:0,
skewX:0,
skewY:0,
scaleX:1,
scaleY:1,
tweenRotate:0,
isUseColorInfo:false,
r:255,
g:255,
b:255,
a:255,
ctor:function () {
this.x = 0;
this.y = 0;
this.zOrder = 0;
this.skewX = 0;
this.skewY = 0;
this.scaleX = 1;
this.scaleY = 1;
this.tweenRotate = 0;
this.isUseColorInfo = false;
this.r = 255;
this.g = 255;
this.b = 255;
this.a = 255;
},
/**
* Copy data from node
* @param {ccs.BaseData} node
*/
copy:function (node) {
this.x = node.x;
this.y = node.y;
this.zOrder = node.zOrder;
this.scaleX = node.scaleX;
this.scaleY = node.scaleY;
this.skewX = node.skewX;
this.skewY = node.skewY;
this.tweenRotate = node.tweenRotate;
this.isUseColorInfo = node.isUseColorInfo;
this.r = node.r;
this.g = node.g;
this.b = node.b;
this.a = node.a;
},
/**
* color setter
* @param {cc.Color} color
*/
setColor:function(color){
this.r = color.r;
this.g = color.g;
this.b = color.b;
this.a = color.a;
},
/**
* color getter
* @returns {cc.Color}
*/
getColor:function(){
return cc.color(this.r, this.g, this.b, this.a);
},
/**
* Calculate two baseData's between value(to - from) and set to self
* @param {ccs.BaseData} from
* @param {ccs.BaseData} to
* @param {Boolean} limit
*/
subtract:function (from, to, limit) {
this.x = to.x - from.x;
this.y = to.y - from.y;
this.scaleX = to.scaleX - from.scaleX;
this.scaleY = to.scaleY - from.scaleY;
this.skewX = to.skewX - from.skewX;
this.skewY = to.skewY - from.skewY;
if (this.isUseColorInfo || from.isUseColorInfo || to.isUseColorInfo) {
this.a = to.a - from.a;
this.r = to.r - from.r;
this.g = to.g - from.g;
this.b = to.b - from.b;
this.isUseColorInfo = true;
} else {
this.a = this.r = this.g = this.b = 0;
this.isUseColorInfo = false;
}
if (limit) {
if (this.skewX > cc.PI) {
this.skewX -= ccs.M_PI_X_2;
}
if (this.skewX < -cc.PI) {
this.skewX += ccs.M_PI_X_2;
}
if (this.skewY > cc.PI) {
this.skewY -= ccs.M_PI_X_2;
}
if (this.skewY < -cc.PI) {
this.skewY += ccs.M_PI_X_2;
}
}
if (to.tweenRotate) {
this.skewX += to.tweenRotate * ccs.M_PI_X_2;
this.skewY -= to.tweenRotate * ccs.M_PI_X_2;
}
}
});
/**
* Base class for ccs.DisplayData objects.
* @class
* @extends ccs.Class
*/
ccs.DisplayData = ccs.Class.extend(/** @lends ccs.DisplayData# */{
displayType:ccs.DISPLAY_TYPE_MAX,
displayName:"",
ctor:function () {
this.displayType = ccs.DISPLAY_TYPE_MAX;
},
/**
* change display name to texture type
* @param {String} displayName
* @returns {String}
*/
<API key>:function (displayName) {
// remove .xxx
var textureName = displayName;
var startPos = textureName.lastIndexOf(".");
if (startPos != -1) {
textureName = textureName.substring(0, startPos);
}
return textureName;
},
/**
* copy data
* @param {ccs.DisplayData} displayData
*/
copy:function (displayData) {
this.displayName = displayData.displayName;
this.displayType = displayData.displayType;
}
});
/**
* Base class for ccs.SpriteDisplayData objects.
* @class
* @extends ccs.DisplayData
*/
ccs.SpriteDisplayData = ccs.DisplayData.extend(/** @lends ccs.SpriteDisplayData# */{
skinData:null,
ctor:function () {
this.skinData = new ccs.BaseData();
this.displayType = ccs.DISPLAY_TYPE_SPRITE;
},
/**
* copy data
* @param {ccs.SpriteDisplayData} displayData
*/
copy:function (displayData) {
ccs.DisplayData.prototype.copy.call(this,displayData);
this.skinData = displayData.skinData;
}
});
/**
* Base class for ccs.ArmatureDisplayData objects.
* @class
* @extends ccs.DisplayData
*/
ccs.ArmatureDisplayData = ccs.DisplayData.extend(/** @lends ccs.ArmatureDisplayData# */{
displayName:"",
ctor:function () {
this.displayName = "";
this.displayType = ccs.<API key>;
}
});
/**
* Base class for ccs.ParticleDisplayData objects.
* @class
* @extends ccs.DisplayData
*/
ccs.ParticleDisplayData = ccs.DisplayData.extend(/** @lends ccs.ParticleDisplayData# */{
ctor:function () {
this.displayType = ccs.<API key>;
}
});
/**
* Base class for ccs.BoneData objects.
* @class
* @extends ccs.BaseData
*/
ccs.BoneData = ccs.BaseData.extend(/** @lends ccs.BoneData# */{
displayDataList:null,
name:"",
parentName:"",
boneDataTransform:null,
ctor:function () {
this.displayDataList = [];
this.name = "";
this.parentName = "";
this.boneDataTransform = null;
},
init:function () {
},
/**
* add display data
* @param {ccs.DisplayData} displayData
*/
addDisplayData:function (displayData) {
this.displayDataList.push(displayData);
},
/**
* get display data
* @param {Number} index
* @returns {ccs.DisplayData}
*/
getDisplayData:function (index) {
return this.displayDataList[index];
}
});
/**
* Base class for ccs.ArmatureData objects.
* @class
* @extends ccs.Class
*/
ccs.ArmatureData = ccs.Class.extend(/** @lends ccs.ArmatureData# */{
boneDataDic:null,
name:"",
dataVersion:0.1,
ctor:function () {
this.boneDataDic = {};
this.name = "";
this.dataVersion = 0.1;
},
init:function () {
return true;
},
/**
* add bone data
* @param {ccs.BoneData} boneData
*/
addBoneData:function (boneData) {
this.boneDataDic[boneData.name] = boneData;
},
/**
* get bone datas
* @returns {Object}
*/
getBoneDataDic:function () {
return this.boneDataDic;
},
/**
* get bone data by bone name
* @param {String} boneName
* @returns {ccs.BoneData}
*/
getBoneData:function (boneName) {
return this.boneDataDic[boneName];
}
});
/**
* Base class for ccs.FrameData objects.
* @class
* @extends ccs.BaseData
*/
ccs.FrameData = ccs.BaseData.extend(/** @lends ccs.FrameData# */{
duration:0,
tweenEasing:0,
easingParamNumber: 0,
easingParams: null,
displayIndex:-1,
movement:"",
event:"",
sound:"",
soundEffect:"",
blendFunc:0,
frameID:0,
isTween:true,
ctor:function () {
ccs.BaseData.prototype.ctor.call(this);
this.duration = 1;
this.tweenEasing = ccs.TweenType.linear;
this.easingParamNumber = 0;
this.easingParams = [];
this.displayIndex = 0;
this.movement = "";
this.event = "";
this.sound = "";
this.soundEffect = "";
this.blendFunc = new cc.BlendFunc(cc.BLEND_SRC, cc.BLEND_DST);
this.frameID = 0;
this.isTween = true;
},
/**
* copy data
* @param frameData
*/
copy:function (frameData) {
ccs.BaseData.prototype.copy.call(this, frameData);
this.duration = frameData.duration;
this.tweenEasing = frameData.tweenEasing;
this.displayIndex = frameData.displayIndex;
this.movement = frameData.movement;
this.event = frameData.event;
this.sound = frameData.sound;
this.soundEffect = frameData.soundEffect;
this.blendFunc = frameData.blendFunc;
this.isTween = frameData.isTween;
this.easingParamNumber = frameData.easingParamNumber;
this.easingParams = [];
if (this.easingParamNumber != 0) {
for (var i = 0; i<this.easingParamNumber; i++) {
this.easingParams[i] = frameData.easingParams[i];
}
}
}
}
);
/**
* Base class for ccs.MovementBoneData objects.
* @class
* @extends ccs.Class
*/
ccs.MovementBoneData = ccs.Class.extend(/** @lends ccs.MovementBoneData# */{
delay:0,
scale:1,
duration:0,
frameList:null,
name:"",
ctor:function () {
this.delay = 0;
this.scale = 1;
this.duration = 0;
this.frameList = [];
this.name = "";
},
init:function () {
this.frameList = [];
},
/**
* add frame data
* @param {ccs.FrameData} frameData
*/
addFrameData:function (frameData) {
this.frameList.push(frameData);
},
/**
* get frame data
* @param {Number} index
* @returns {ccs.FrameData}
*/
getFrameData:function (index) {
return this.frameList[index];
}
});
/**
* Base class for ccs.MovementData objects.
* @class
* @extends ccs.Class
*/
ccs.MovementData = ccs.Class.extend(/** @lends ccs.MovementData# */{
movBoneDataDic:null,
duration:0,
scale:1,
durationTo:0,
durationTween:ccs.TweenType.linear,
loop:true,
tweenEasing:2,
name:"",
ctor:function () {
this.name = "";
this.duration = 0;
this.scale = 1;
this.durationTo = 0;
this.durationTween = 0;
this.loop = true;
this.tweenEasing = ccs.TweenType.linear;
this.movBoneDataDic = {};
},
/**
* add movement bone data
* @param {ccs.MovementBoneData} movBoneData
*/
addMovementBoneData:function (movBoneData) {
this.movBoneDataDic[ movBoneData.name] = movBoneData;
},
/**
* get movement bone data
* @param {String} boneName
* @returns {ccs.MovementBoneData}
*/
getMovementBoneData:function (boneName) {
return this.movBoneDataDic[boneName];
}
});
/**
* Base class for ccs.AnimationData objects.
* @class
* @extends ccs.Class
*/
ccs.AnimationData = ccs.Class.extend(/** @lends ccs.AnimationData# */{
moveDataDic:null,
movementNames:null,
name:"",
ctor:function () {
this.moveDataDic = {};
this.movementNames = [];
},
/**
* add movement data
* @param {ccs.MovementData} moveData
*/
addMovement:function (moveData) {
this.moveDataDic[moveData.name] = moveData;
this.movementNames.push(moveData.name);
},
/**
* get movement data
* @param {String} moveName
* @returns {ccs.MovementData}
*/
getMovement:function (moveName) {
return this.moveDataDic[moveName];
},
/**
*
* @returns {Number}
*/
getMovementCount:function () {
return Object.keys(this.moveDataDic).length;
}
});
/**
* contour vertex
* @param {Number} x
* @param {Number} y
* @constructor
*/
ccs.ContourVertex2 = function (x, y) {
this.x = x || 0;
this.y = y || 0;
};
/**
* Base class for ccs.ContourData objects.
* @class
* @extends ccs.Class
*/
ccs.ContourData = ccs.Class.extend({
vertexList:null,
ctor:function () {
this.vertexList = [];
},
init:function () {
this.vertexList = [];
return true;
},
/**
* add vertex
* @param {cc.Point} p
*/
addVertex: function (p) {
var v = ccs.ContourVertex2(p.x, p.y);
this.vertexList.push(v);
}
});
/**
* Base class for ccs.TextureData objects.
* @class
* @extends ccs.Class
*/
ccs.TextureData = ccs.Class.extend(/** @lends ccs.TextureData# */{
height:0,
width:0,
pivotX:0,
pivotY:0,
name:"",
contourDataList:null,
ctor:function () {
this.height = 0;
this.width = 0;
this.pivotX = 0.5;
this.pivotY = 0.5;
this.name = "";
this.contourDataList = [];
},
init:function () {
this.contourDataList = [];
},
/**
* set contourData
* @param {ccs.ContourData} contourData
*/
addContourData:function (contourData) {
this.contourDataList.push(contourData);
},
/**
* get contourData
* @param {Number} index
* @returns {ccs.ContourData}
*/
getContourData:function (index) {
return this.contourDataList[index];
}
}); |
package com.google.api.ads.adwords.jaxws.v201506.cm;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "AdGroupAd", propOrder = {
"adGroupId",
"ad",
"experimentData",
"status",
"approvalStatus",
"trademarks",
"disapprovalReasons",
"<API key>",
"labels",
"<API key>"
})
public class AdGroupAd {
protected Long adGroupId;
protected Ad ad;
protected <API key> experimentData;
@XmlSchemaType(name = "string")
protected AdGroupAdStatus status;
@XmlSchemaType(name = "string")
protected <API key> approvalStatus;
protected List<String> trademarks;
protected List<String> disapprovalReasons;
protected Boolean <API key>;
protected List<Label> labels;
protected List<<API key>> <API key>;
/**
* Gets the value of the adGroupId property.
*
* @return
* possible object is
* {@link Long }
*
*/
public Long getAdGroupId() {
return adGroupId;
}
/**
* Sets the value of the adGroupId property.
*
* @param value
* allowed object is
* {@link Long }
*
*/
public void setAdGroupId(Long value) {
this.adGroupId = value;
}
/**
* Gets the value of the ad property.
*
* @return
* possible object is
* {@link Ad }
*
*/
public Ad getAd() {
return ad;
}
/**
* Sets the value of the ad property.
*
* @param value
* allowed object is
* {@link Ad }
*
*/
public void setAd(Ad value) {
this.ad = value;
}
/**
* Gets the value of the experimentData property.
*
* @return
* possible object is
* {@link <API key> }
*
*/
public <API key> getExperimentData() {
return experimentData;
}
/**
* Sets the value of the experimentData property.
*
* @param value
* allowed object is
* {@link <API key> }
*
*/
public void setExperimentData(<API key> value) {
this.experimentData = value;
}
/**
* Gets the value of the status property.
*
* @return
* possible object is
* {@link AdGroupAdStatus }
*
*/
public AdGroupAdStatus getStatus() {
return status;
}
/**
* Sets the value of the status property.
*
* @param value
* allowed object is
* {@link AdGroupAdStatus }
*
*/
public void setStatus(AdGroupAdStatus value) {
this.status = value;
}
/**
* Gets the value of the approvalStatus property.
*
* @return
* possible object is
* {@link <API key> }
*
*/
public <API key> getApprovalStatus() {
return approvalStatus;
}
/**
* Sets the value of the approvalStatus property.
*
* @param value
* allowed object is
* {@link <API key> }
*
*/
public void setApprovalStatus(<API key> value) {
this.approvalStatus = value;
}
/**
* Gets the value of the trademarks property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the trademarks property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getTrademarks().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link String }
*
*
*/
public List<String> getTrademarks() {
if (trademarks == null) {
trademarks = new ArrayList<String>();
}
return this.trademarks;
}
/**
* Gets the value of the disapprovalReasons property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the disapprovalReasons property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* <API key>().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link String }
*
*
*/
public List<String> <API key>() {
if (disapprovalReasons == null) {
disapprovalReasons = new ArrayList<String>();
}
return this.disapprovalReasons;
}
/**
* Gets the value of the <API key> property.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean <API key>() {
return <API key>;
}
/**
* Sets the value of the <API key> property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void <API key>(Boolean value) {
this.<API key> = value;
}
/**
* Gets the value of the labels property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the labels property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getLabels().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link Label }
*
*
*/
public List<Label> getLabels() {
if (labels == null) {
labels = new ArrayList<Label>();
}
return this.labels;
}
/**
* Gets the value of the <API key> property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the <API key> property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* <API key>().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link <API key> }
*
*
*/
public List<<API key>> <API key>() {
if (<API key> == null) {
<API key> = new ArrayList<<API key>>();
}
return this.<API key>;
}
} |
require "spec_helper"
describe WorkspaceSearch do
let(:owner) { users(:owner) }
context "with solr disabled" do
describe "valid" do
it "is not valid without a workspace_id" do
search = WorkspaceSearch.new(owner, :query => 'fries')
search.should_not be_valid
end
end
describe "search" do
before do
any_instance_of(Sunspot::Search::AbstractSearch) do |search|
stub(search).group_response { {} }
end
end
context "when unscoped" do
let(:search) { WorkspaceSearch.new(owner, :query => 'bob', :workspace_id => 7) }
it "searches only for Workspace, Workfiles and Datasets (and Notes)" do
search.results
Sunspot.session.should be_a_search_for(Workspace)
Sunspot.session.should be_a_search_for(Workfile)
Sunspot.session.should be_a_search_for(Dataset)
Sunspot.session.should be_a_search_for(Events::Note)
Sunspot.session.should_not be_a_search_for(User)
end
it "scopes the search to the workspace" do
search.results
Sunspot.session.should have_search_params(:with) {
any_of do
with :workspace_id, 7
with :<API key>, 7
end
}
end
it "should not facet by type_name" do
search.results
Sunspot.session.should_not have_search_params(:facet, :type_name)
end
context "when scoped to a invalid entity type" do
let(:search) { WorkspaceSearch.new(owner, :query => 'bob', :workspace_id => 7, :entity_type => 'user') }
it "raises validation error" do
expect {
search.results
}.to raise_error(ApiValidationError)
end
end
end
context "when scoped to an entity_type" do
let(:search) { WorkspaceSearch.new(owner, :query => 'bob', :workspace_id => 7, :entity_type => 'workfile') }
it "scopes the search to the type" do
search.results
Sunspot.session.should be_a_search_for(Workfile)
Sunspot.session.should be_a_search_for(Events::Note)
Sunspot.session.should_not be_a_search_for(Workspace)
Sunspot.session.should_not be_a_search_for(Dataset)
Sunspot.session.should_not be_a_search_for(User)
end
end
end
end
context "with solr enabled" do
let(:workspace) { workspaces(:search_public) }
let(:workfile) { workfiles(:search_public) }
let(:matching_table) { datasets(:searchquery_table) }
let(:matching_view) { datasets(:<API key>) }
let(:typeahead_dataset) { datasets(:<API key>) }
let(:hdfs_dataset) { datasets(:searchquery_hadoop) }
before do
<API key>
end
describe "num_found" do
it "returns the total number of results found" do
VCR.use_cassette('<API key>') do
search = WorkspaceSearch.new(owner, :query => 'searchquery', :workspace_id => workspace.id)
search.num_found.should == 9
end
end
end
describe "results" do
it "returns the founds results" do
VCR.use_cassette('<API key>') do
search = WorkspaceSearch.new(owner, :query => 'searchquery', :workspace_id => workspace.id)
search.results.should =~ [
workfile, matching_table, matching_view, workspace, typeahead_dataset, hdfs_dataset,
datasets(:<API key>), datasets(:<API key>), datasets(:searchable_tag)
]
end
end
it "has highlighted results" do
VCR.use_cassette('<API key>') do
search = WorkspaceSearch.new(owner, :query => 'searchquery', :workspace_id => workspace.id)
<API key> = search.results.find { |m| m == workfile }
<API key>.<API key>[:description][0].should == '<em>searchquery</em>'
end
end
end
end
end |
using System;
using System.Linq;
using Akka.Actor.Internals;
namespace Akka.Actor
{
<summary>
This class contains implementations originally found in Akka´s trait ActorRefFactory in ActorRefProvider.scala
https://github.com/akka/akka/blob/master/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala#L180
<see cref="IActorRefFactory"/> corresponds to that trait, but since it is an interface it
cannot contain any code, hence this class.
</summary>
public static class <API key>
{
<summary>
Construct an <see cref="Akka.Actor.ActorSelection"/> from the given path, which is
parsed for wildcards (these are replaced by regular expressions
internally). No attempt is made to verify the existence of any part of
the supplied path, it is recommended to send a message and gather the
replies in order to resolve the matching set of actors.
</summary>
public static ActorSelection ActorSelection(ActorPath actorPath, ActorSystem system)
{
return new ActorSelection(((ActorSystemImpl)system).Provider.RootGuardianAt(actorPath.Address), actorPath.Elements);
}
<summary>
Construct an <see cref="Akka.Actor.ActorSelection"/> from the given path, which is
parsed for wildcards (these are replaced by regular expressions
internally). No attempt is made to verify the existence of any part of
the supplied path, it is recommended to send a message and gather the
replies in order to resolve the matching set of actors.
</summary>
public static ActorSelection ActorSelection(string path, ActorSystem system, IActorRef lookupRoot)
{
var provider = ((ActorSystemImpl)system).Provider;
//no path given
if (string.IsNullOrEmpty(path))
{
return new ActorSelection(system.DeadLetters, "");
}
//absolute path
var elements = path.Split('/');
if (elements[0] == "")
{
return new ActorSelection(provider.RootGuardian, elements.Skip(1));
}
if(Uri.<API key>(path, UriKind.Absolute))
{
ActorPath actorPath;
if(!ActorPath.TryParse(path, out actorPath))
return new ActorSelection(provider.DeadLetters, "");
var actorRef = provider.RootGuardianAt(actorPath.Address);
return new ActorSelection(actorRef, actorPath.Elements);
}
return new ActorSelection(lookupRoot, path);
}
}
} |
package org.imsglobal.lti2;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import org.imsglobal.lti2.LTI2Util;
public class LTI2UtilTest {
@Before
public void setUp() throws Exception {
}
@Test
public void testServiceCompare() {
assertTrue(LTI2Util.compareServiceIds("tcp:Result.item", "tcp:Result.item"));
assertTrue(LTI2Util.compareServiceIds("tcp:Result.item", "#Result.item"));
assertTrue(LTI2Util.compareServiceIds("tcp:Result.item", "http://sakai.ngrok.com/imsblis/lti2/#Result.item"));
}
} |
package com.google.api.ads.dfp.jaxws.v201411;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"rval"
})
@XmlRootElement(name = "<API key>")
public class <API key> {
protected UserPage rval;
/**
* Gets the value of the rval property.
*
* @return
* possible object is
* {@link UserPage }
*
*/
public UserPage getRval() {
return rval;
}
/**
* Sets the value of the rval property.
*
* @param value
* allowed object is
* {@link UserPage }
*
*/
public void setRval(UserPage value) {
this.rval = value;
}
} |
// file at the top-level directory of this distribution and at
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// <API key>
struct S<T> {
contents: T,
}
impl<T> S<T> {
fn new<U>(x: T, _: U) -> S<T> {
S {
contents: x,
}
}
}
trait Trait<T> {
fn new<U>(x: T, y: U) -> Self;
}
struct S2 {
contents: isize,
}
impl Trait<isize> for S2 {
fn new<U>(x: isize, _: U) -> S2 {
S2 {
contents: x,
}
}
}
fn foo<'a>() {
let _ = S::new::<isize,f64>(1, 1.0);
//~^ ERROR too many type parameters provided
let _ = S::<'a,isize>::new::<f64>(1, 1.0);
//~^ ERROR wrong number of lifetime parameters
let _: S2 = Trait::new::<isize,f64>(1, 1.0);
//~^ ERROR too many type parameters provided
let _: S2 = Trait::<'a,isize>::new::<f64>(1, 1.0);
//~^ ERROR too many lifetime parameters provided
}
fn main() {} |
package org.uberfire.workbench.events;
import org.jboss.errai.common.client.api.annotations.Portable;
import org.uberfire.backend.vfs.Path;
import org.uberfire.rpc.SessionInfo;
import static org.uberfire.commons.validation.<API key>.*;
/**
* An Event indicating a Resource has been updated
*/
@Portable
public class <API key> extends ResourceUpdated implements ResourceEvent {
private Path path;
private SessionInfo sessionInfo;
public <API key>() {
//Empty constructor for Errai marshalling
}
public <API key>( final Path path,
final String message,
final SessionInfo sessionInfo ) {
super( message );
this.path = checkNotNull( "path", path );
this.sessionInfo = checkNotNull( "sessionInfo", sessionInfo );
}
@Override
public Path getPath() {
return this.path;
}
public SessionInfo getSessionInfo() {
return sessionInfo;
}
@Override
public String toString() {
return "<API key> [path=" + path + ", sessionInfo=" + sessionInfo + "]";
}
} |
/**
* @file
* @brief ARCv2 auxiliary registers definitions
*
*
* Definitions for auxiliary registers.
*/
#ifndef <API key>
#define <API key>
#define _ARC_V2_LP_START 0x002
#define _ARC_V2_LP_END 0x003
#define _ARC_V2_IDENTITY 0x004
#define _ARC_V2_SEC_STAT 0x09
#define _ARC_V2_STATUS32 0x00a
#define _ARC_V2_STATUS32_P0 0x00b
#define _ARC_V2_USER_SP 0x00d
#define <API key> 0x00e
#define _ARC_V2_IC_IVIC 0x010
#define _ARC_V2_IC_CTRL 0x011
#define _ARC_V2_IC_LIL 0x013
#define _ARC_V2_IC_IVIL 0x019
#define _ARC_V2_IC_DATA 0x01d
#define _ARC_V2_TMR0_COUNT 0x021
#define <API key> 0x022
#define _ARC_V2_TMR0_LIMIT 0x023
#define <API key> 0x025
#define <API key> 0x26
#define _ARC_V2_KERNEL_SP 0x38
#define _ARC_V2_SEC_U_SP 0x39
#define _ARC_V2_SEC_K_SP 0x3a
#define _ARC_V2_AUX_IRQ_ACT 0x043
#define _ARC_V2_DC_IVDC 0x047
#define _ARC_V2_DC_CTRL 0x048
#define _ARC_V2_DC_LDL 0x049
#define _ARC_V2_DC_IVDL 0x04a
#define _ARC_V2_DC_FLSH 0x04b
#define _ARC_V2_DC_FLDL 0x04c
#define _ARC_V2_EA_BUILD 0x065
#define <API key> 0x068
#define _ARC_V2_FP_BUILD 0x06b
#define _ARC_V2_DPFP_BUILD 0x06c
#define _ARC_V2_MPU_BUILD 0x06d
#define _ARC_V2_RF_BUILD 0x06e
#define _ARC_V2_MMU_BUILD 0x06f
#define <API key> 0x071
#define <API key> 0x072
#define _ARC_V2_DCCM_BUILD 0x074
#define _ARC_V2_TIMER_BUILD 0x075
#define _ARC_V2_AP_BUILD 0x076
#define <API key> 0x077
#define _ARC_V2_ICCM_BUILD 0x078
#define <API key> 0x07b
#define _ARC_V2_SWAP_BUILD 0x07c
#define _ARC_V2_NORM_BUILD 0x07d
#define <API key> 0x07e
#define <API key> 0x07f
#define _ARC_V2_ISA_CONFIG 0x0c1
#define _ARC_V2_SEP_BUILD 0x0c7
#define _ARC_V2_IRQ_BUILD 0x0f3
#define _ARC_V2_PCT_BUILD 0x0f5
#define _ARC_V2_CC_BUILD 0x0f6
#define _ARC_V2_TMR1_COUNT 0x100
#define <API key> 0x101
#define _ARC_V2_TMR1_LIMIT 0x102
#define <API key> 0x106
#define <API key> 0x107
#define <API key> 0x108
#define <API key> 0x109
#define <API key> 0x10a
#define <API key> 0x10b
#define <API key> 0x200
#define <API key> 0x201
#define <API key> 0x206
#define _ARC_V2_USTACK_TOP 0x260
#define _ARC_V2_USTACK_BASE 0x261
#define <API key> 0x262
#define <API key> 0x263
#define _ARC_V2_KSTACK_TOP 0x264
#define _ARC_V2_KSTACK_BASE 0x265
#define <API key> 0x266
#define <API key> 0x267
#define <API key> 0x268
#define <API key> 0x269
#define _ARC_V2_JLI_BASE 0x290
#define _ARC_V2_LDI_BASE 0x291
#define _ARC_V2_EI_BASE 0x292
#define _ARC_V2_ERET 0x400
#define _ARC_V2_ERSTATUS 0x402
#define _ARC_V2_ECR 0x403
#define _ARC_V2_EFA 0x404
#define _ARC_V2_ERSEC_STAT 0x406
#define _ARC_V2_ICAUSE 0x40a
#define _ARC_V2_IRQ_SELECT 0x40b
#define _ARC_V2_IRQ_ENABLE 0x40c
#define _ARC_V2_IRQ_TRIGGER 0x40d
#define _ARC_V2_IRQ_STATUS 0x40f
#define <API key> 0x415
#define _ARC_V2_IRQ_PENDING 0x416
#define _ARC_V2_FPU_CTRL 0x300
#define _ARC_V2_FPU_STATUS 0x301
#define _ARC_V2_FPU_DPFP1L 0x302
#define _ARC_V2_FPU_DPFP1H 0x303
#define _ARC_V2_FPU_DPFP2L 0x304
#define _ARC_V2_FPU_DPFP2H 0x305
#define _ARC_V2_MPU_EN 0x409
#define _ARC_V2_MPU_RDB0 0x422
#define _ARC_V2_MPU_RDP0 0x423
#define _ARC_V2_MPU_INDEX 0x448
#define _ARC_V2_MPU_RSTART 0x449
#define _ARC_V2_MPU_REND 0x44A
#define _ARC_V2_MPU_RPER 0x44B
#define _ARC_V2_MPU_PROBE 0x44C
/* STATUS32/STATUS32_P0 bits */
#define _ARC_V2_STATUS32_H (1 << 0)
#define Z_ARC_V2_STATUS32_E(x) ((x) << 1)
#define <API key> 5
#define _ARC_V2_STATUS32_AE (1 << <API key>)
#define _ARC_V2_STATUS32_DE (1 << 6)
#define <API key> 7
#define _ARC_V2_STATUS32_U (1 << <API key>)
#define _ARC_V2_STATUS32_V (1 << 8)
#define _ARC_V2_STATUS32_C (1 << 9)
#define _ARC_V2_STATUS32_N (1 << 10)
#define _ARC_V2_STATUS32_Z (1 << 11)
#define _ARC_V2_STATUS32_L (1 << 12)
#define <API key> 13
#define _ARC_V2_STATUS32_DZ (1 << <API key>)
#define <API key> 14
#define _ARC_V2_STATUS32_SC (1 << <API key>)
#define _ARC_V2_STATUS32_ES (1 << 15)
#define _ARC_V2_STATUS32_RB(x) ((x) << 16)
#define <API key> 19
#define _ARC_V2_STATUS32_AD (1 << <API key>)
#define <API key> 20
#define _ARC_V2_STATUS32_US (1 << <API key>)
#define <API key> 21
#define _ARC_V2_STATUS32_S (1 << <API key>)
#define _ARC_V2_STATUS32_IE (1 << 31)
/* SEC_STAT bits */
#define <API key> 0
#define <API key> (1 << <API key>)
#define <API key> 1
#define <API key> (1 << <API key>)
#define <API key> 2
#define <API key> (1 << <API key>)
#define <API key> 3
#define <API key> (1 << <API key>)
#define <API key> 4
#define <API key> (1 << <API key>)
#define <API key> 5
#define <API key> (1 << <API key>)
/* interrupt related bits */
#define <API key> 0x100
/* exception cause register masks */
#define Z_ARC_V2_ECR_VECTOR(X) ((X & 0xff0000) >> 16)
#define Z_ARC_V2_ECR_CODE(X) ((X & 0xff00) >> 8)
#define <API key>(X) (X & 0xff)
#ifndef _ASMLANGUAGE
#include <zephyr/types.h>
#if defined(__CCAC__)
#define <API key>(reg) _lr((volatile uint32_t)reg)
#define <API key>(reg, val) \
_sr((unsigned int)val, (volatile uint32_t)reg)
#else /* ! __CCAC__ */
#define <API key>(reg) __builtin_arc_lr((volatile uint32_t)reg)
#define <API key>(reg, val) \
__builtin_arc_sr((unsigned int)val, (volatile uint32_t)reg)
#endif /* __CCAC__ */
#endif /* _ASMLANGUAGE */
#define z_arc_v2_core_id() \
({ \
unsigned int __ret; \
__asm__ __volatile__("lr %0, [%1]\n" \
"xbfu %0, %0, 0xe8\n" \
: "=r"(__ret) \
: "i"(_ARC_V2_IDENTITY)); \
__ret; \
})
#endif /* <API key> */ |
object i0 {
type i1 = (=> Int) | (2 => i2)("i3 i4{i5} i6 = i4;
case (i4, i5) => ()
i6
} def main(i4: Array[String]): Unit = {
val i5 = * i6
i5
} else
i6
}
})
object i7 {
import i0.{ classTag, i3 } & (2 -> filter*) }
def i7(i2: Int): i0
val i5 = _
i7 = i0
}) |
package main
import (
"flag"
"fmt"
"math/rand"
"os"
"regexp"
"runtime"
"strings"
"time"
"io/ioutil"
"path/filepath"
"github.com/onsi/ginkgo/config"
"github.com/onsi/ginkgo/ginkgo/interrupthandler"
"github.com/onsi/ginkgo/ginkgo/testrunner"
colorable "github.com/onsi/ginkgo/reporters/stenographer/support/go-colorable"
"github.com/onsi/ginkgo/types"
)
func BuildRunCommand() *Command {
commandFlags := NewRunCommandFlags(flag.NewFlagSet("ginkgo", flag.ExitOnError))
notifier := NewNotifier(commandFlags)
interruptHandler := interrupthandler.NewInterruptHandler()
runner := &SpecRunner{
commandFlags: commandFlags,
notifier: notifier,
interruptHandler: interruptHandler,
suiteRunner: NewSuiteRunner(notifier, interruptHandler),
}
return &Command{
Name: "",
FlagSet: commandFlags.FlagSet,
UsageCommand: "ginkgo <FLAGS> <PACKAGES> -- <PASS-THROUGHS>",
Usage: []string{
"Run the tests in the passed in <PACKAGES> (or the package in the current directory if left blank).",
"Any arguments after -- will be passed to the test.",
"Accepts the following flags:",
},
Command: runner.RunSpecs,
}
}
type SpecRunner struct {
commandFlags *<API key>
notifier *Notifier
interruptHandler *interrupthandler.InterruptHandler
suiteRunner *SuiteRunner
}
func (r *SpecRunner) RunSpecs(args []string, additionalArgs []string) {
r.commandFlags.computeNodes()
r.notifier.<API key>()
deprecationTracker := types.<API key>()
if r.commandFlags.ParallelStream && (runtime.GOOS != "windows") {
deprecationTracker.TrackDeprecation(types.Deprecation{
Message: "--stream is deprecated and will be removed in Ginkgo 2.0",
DocLink: "removed--stream",
Version: "1.16.0",
})
}
if r.commandFlags.Notify {
deprecationTracker.TrackDeprecation(types.Deprecation{
Message: "--notify is deprecated and will be removed in Ginkgo 2.0",
DocLink: "removed--notify",
Version: "1.16.0",
})
}
if deprecationTracker.<API key>() {
fmt.Fprintln(colorable.NewColorableStderr(), deprecationTracker.DeprecationsReport())
}
suites, skippedPackages := findSuites(args, r.commandFlags.Recurse, r.commandFlags.SkipPackage, true)
if len(skippedPackages) > 0 {
fmt.Println("Will skip:")
for _, skippedPackage := range skippedPackages {
fmt.Println(" " + skippedPackage)
}
}
if len(skippedPackages) > 0 && len(suites) == 0 {
fmt.Println("All tests skipped! Exiting...")
os.Exit(0)
}
if len(suites) == 0 {
complainAndQuit("Found no test suites")
}
r.ComputeSuccinctMode(len(suites))
t := time.Now()
runners := []*testrunner.TestRunner{}
for _, suite := range suites {
runners = append(runners, testrunner.New(suite, r.commandFlags.NumCPU, r.commandFlags.ParallelStream, r.commandFlags.Timeout, r.commandFlags.GoOpts, additionalArgs))
}
numSuites := 0
runResult := testrunner.PassingRunResult()
if r.commandFlags.UntilItFails {
iteration := 0
for {
r.UpdateSeed()
randomizedRunners := r.randomizeOrder(runners)
runResult, numSuites = r.suiteRunner.RunSuites(randomizedRunners, r.commandFlags.NumCompilers, r.commandFlags.KeepGoing, nil)
iteration++
if r.interruptHandler.WasInterrupted() {
break
}
if runResult.Passed {
fmt.Printf("\nAll tests passed...\nWill keep running them until they fail.\nThis was attempt #%d\n%s\n", iteration, orcMessage(iteration))
} else {
fmt.Printf("\nTests failed on attempt #%d\n\n", iteration)
break
}
}
} else {
randomizedRunners := r.randomizeOrder(runners)
runResult, numSuites = r.suiteRunner.RunSuites(randomizedRunners, r.commandFlags.NumCompilers, r.commandFlags.KeepGoing, nil)
}
for _, runner := range runners {
runner.CleanUp()
}
if r.isInCoverageMode() {
if r.getOutputDir() != "" {
// If coverprofile is set, combine coverages
if r.getCoverprofile() != "" {
if err := r.<API key>(runners); err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
} else {
// Just move them
r.moveCoverprofiles(runners)
}
}
}
fmt.Printf("\nGinkgo ran %d %s in %s\n", numSuites, pluralizedWord("suite", "suites", numSuites), time.Since(t))
if runResult.Passed {
if runResult.<API key> && strings.TrimSpace(os.Getenv("<API key>")) == "" {
fmt.Printf("Test Suite Passed\n")
fmt.Printf("Detected Programmatic Focus - setting exit status to %d\n", types.<API key>)
os.Exit(types.<API key>)
} else {
fmt.Printf("Test Suite Passed\n")
os.Exit(0)
}
} else {
fmt.Printf("Test Suite Failed\n")
emitRCAdvertisement()
os.Exit(1)
}
}
// Moves all generated profiles to specified directory
func (r *SpecRunner) moveCoverprofiles(runners []*testrunner.TestRunner) {
for _, runner := range runners {
_, filename := filepath.Split(runner.CoverageFile)
err := os.Rename(runner.CoverageFile, filepath.Join(r.getOutputDir(), filename))
if err != nil {
fmt.Printf("Unable to move coverprofile %s, %v\n", runner.CoverageFile, err)
return
}
}
}
// Combines all generated profiles in the specified directory
func (r *SpecRunner) <API key>(runners []*testrunner.TestRunner) error {
path, _ := filepath.Abs(r.getOutputDir())
if !fileExists(path) {
return fmt.Errorf("Unable to create combined profile, outputdir does not exist: %s", r.getOutputDir())
}
fmt.Println("path is " + path)
combined, err := os.OpenFile(
filepath.Join(path, r.getCoverprofile()),
os.O_WRONLY|os.O_CREATE,
0666,
)
if err != nil {
fmt.Printf("Unable to create combined profile, %v\n", err)
return nil // non-fatal error
}
modeRegex := regexp.MustCompile(`^mode: .*\n`)
for index, runner := range runners {
contents, err := ioutil.ReadFile(runner.CoverageFile)
if err != nil {
fmt.Printf("Unable to read coverage file %s to combine, %v\n", runner.CoverageFile, err)
return nil // non-fatal error
}
// remove the cover mode line from every file
// except the first one
if index > 0 {
contents = modeRegex.ReplaceAll(contents, []byte{})
}
_, err = combined.Write(contents)
// Add a newline to the end of every file if missing.
if err == nil && len(contents) > 0 && contents[len(contents)-1] != '\n' {
_, err = combined.Write([]byte("\n"))
}
if err != nil {
fmt.Printf("Unable to append to coverprofile, %v\n", err)
return nil // non-fatal error
}
}
fmt.Println("All profiles combined")
return nil
}
func (r *SpecRunner) isInCoverageMode() bool {
opts := r.commandFlags.GoOpts
return *opts["cover"].(*bool) || *opts["coverpkg"].(*string) != "" || *opts["covermode"].(*string) != ""
}
func (r *SpecRunner) getCoverprofile() string {
return *r.commandFlags.GoOpts["coverprofile"].(*string)
}
func (r *SpecRunner) getOutputDir() string {
return *r.commandFlags.GoOpts["outputdir"].(*string)
}
func (r *SpecRunner) ComputeSuccinctMode(numSuites int) {
if config.<API key>.Verbose {
config.<API key>.Succinct = false
return
}
if numSuites == 1 {
return
}
if numSuites > 1 && !r.commandFlags.wasSet("succinct") {
config.<API key>.Succinct = true
}
}
func (r *SpecRunner) UpdateSeed() {
if !r.commandFlags.wasSet("seed") {
config.GinkgoConfig.RandomSeed = time.Now().Unix()
}
}
func (r *SpecRunner) randomizeOrder(runners []*testrunner.TestRunner) []*testrunner.TestRunner {
if !r.commandFlags.RandomizeSuites {
return runners
}
if len(runners) <= 1 {
return runners
}
randomizedRunners := make([]*testrunner.TestRunner, len(runners))
randomizer := rand.New(rand.NewSource(config.GinkgoConfig.RandomSeed))
permutation := randomizer.Perm(len(runners))
for i, j := range permutation {
randomizedRunners[i] = runners[j]
}
return randomizedRunners
}
func orcMessage(iteration int) string {
if iteration < 10 {
return ""
} else if iteration < 30 {
return []string{
"If at first you succeed...",
"...try, try again.",
"Looking good!",
"Still good...",
"I think your tests are fine....",
"Yep, still passing",
"Oh boy, here I go testin' again!",
"Even the gophers are getting bored",
"Did you try -race?",
"Maybe you should stop now?",
"I'm getting tired...",
"What if I just made you a sandwich?",
"Hit ^C, hit ^C, please hit ^C",
"Make it stop. Please!",
"Come on! Enough is enough!",
"Dave, this conversation can serve no purpose anymore. Goodbye.",
"Just what do you think you're doing, Dave? ",
"I, Sisyphus",
"Insanity: doing the same thing over and over again and expecting different results. -Einstein",
"I guess Einstein never tried to churn butter",
}[iteration-10] + "\n"
} else {
return "No, seriously... you can probably stop now.\n"
}
} |
#include <ztest.h>
#include <zephyr.h>
#include <stdlib.h>
#include <arm_math.h>
#include "../../common/test_common.h"
#include "f32.pat"
#define ABS_ERROR_THRESH (1e-3)
#define DIMS_IN (dims[0])
#define DIMS_VEC (dims[1])
#define OP_BRAYCURTIS (0)
#define OP_CANBERRA (1)
#define OP_CHEBYSHEV (2)
#define OP_CITYBLOCK (3)
#define OP_CORRELATION (4)
#define OP_COSINE (5)
#define OP_EUCLIDEAN (6)
#define OP_JENSENSHANNON (7)
#define OP_MINKOWSKI (8)
static void test_arm_distance(int op, bool scratchy, const uint16_t *dims,
const uint32_t *dinput1, const uint32_t *dinput2, const uint32_t *ref)
{
size_t index;
const size_t length = DIMS_IN;
const float32_t *input1 = (const float32_t *)dinput1;
const float32_t *input2 = (const float32_t *)dinput2;
float32_t *output, *tmp1 = NULL, *tmp2 = NULL;
/* Allocate output buffer */
output = malloc(length * sizeof(float32_t));
zassert_not_null(output, <API key>);
/* Allocate scratch buffers */
if (scratchy) {
tmp1 = malloc(DIMS_VEC * sizeof(float32_t));
zassert_not_null(tmp1, <API key>);
tmp2 = malloc(DIMS_VEC * sizeof(float32_t));
zassert_not_null(tmp2, <API key>);
}
/* Enumerate input */
for (index = 0; index < length; index++) {
float32_t val;
/* Load input values into the scratch buffers */
if (scratchy) {
memcpy(tmp1, input1, DIMS_VEC * sizeof(float32_t));
memcpy(tmp2, input2, DIMS_VEC * sizeof(float32_t));
}
/* Run test function */
switch (op) {
case OP_BRAYCURTIS:
val = <API key>(
input1, input2, DIMS_VEC);
break;
case OP_CANBERRA:
val = <API key>(
input1, input2, DIMS_VEC);
break;
case OP_CHEBYSHEV:
val = <API key>(
input1, input2, DIMS_VEC);
break;
case OP_CITYBLOCK:
val = <API key>(
input1, input2, DIMS_VEC);
break;
case OP_CORRELATION:
val = <API key>(
tmp1, tmp2, DIMS_VEC);
break;
case OP_COSINE:
val = <API key>(
input1, input2, DIMS_VEC);
break;
case OP_EUCLIDEAN:
val = <API key>(
input1, input2, DIMS_VEC);
break;
case OP_JENSENSHANNON:
val = <API key>(
input1, input2, DIMS_VEC);
break;
default:
zassert_unreachable("invalid operation");
}
/* Store output value */
output[index] = val;
/* Increment pointers */
input1 += DIMS_VEC;
input2 += DIMS_VEC;
}
/* Validate output */
zassert_true(
test_near_equal_f32(
length, output, (float32_t *)ref, ABS_ERROR_THRESH),
<API key>);
/* Free buffers */
free(output);
free(tmp1);
free(tmp2);
}
<API key>(
arm_distance, braycurtis, OP_BRAYCURTIS, false, in_dims,
in_com1, in_com2, ref_braycurtis);
<API key>(
arm_distance, canberra, OP_CANBERRA, false, in_dims,
in_com1, in_com2, ref_canberra);
<API key>(
arm_distance, chebyshev, OP_CHEBYSHEV, false, in_dims,
in_com1, in_com2, ref_chebyshev);
<API key>(
arm_distance, cityblock, OP_CITYBLOCK, false, in_dims,
in_com1, in_com2, ref_cityblock);
<API key>(
arm_distance, correlation, OP_CORRELATION, true, in_dims,
in_com1, in_com2, ref_correlation);
<API key>(
arm_distance, cosine, OP_COSINE, false, in_dims,
in_com1, in_com2, ref_cosine);
<API key>(
arm_distance, euclidean, OP_EUCLIDEAN, false, in_dims,
in_com1, in_com2, ref_euclidean);
<API key>(
arm_distance, jensenshannon, OP_JENSENSHANNON, false, in_dims,
in_jen1, in_jen2, ref_jensenshannon);
static void <API key>(void)
{
size_t index;
const size_t length = in_dims_minkowski[0];
const size_t dims_vec = in_dims_minkowski[1];
const uint16_t *dims = in_dims_minkowski + 2;
const float32_t *input1 = (const float32_t *)in_com1;
const float32_t *input2 = (const float32_t *)in_com2;
float32_t *output;
/* Allocate output buffer */
output = malloc(length * sizeof(float32_t));
zassert_not_null(output, <API key>);
/* Enumerate input */
for (index = 0; index < length; index++) {
/* Run test function */
output[index] =
<API key>(
input1, input2, dims[index], dims_vec);
/* Increment pointers */
input1 += dims_vec;
input2 += dims_vec;
}
/* Validate output */
zassert_true(
test_near_equal_f32(length, output, (float32_t *)ref_minkowski,
ABS_ERROR_THRESH),
<API key>);
/* Free buffers */
free(output);
}
void test_distance_f32(void)
{
ztest_test_suite(distance_f32,
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>),
ztest_unit_test(<API key>)
);
<API key>(distance_f32);
} |
using System;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Text.Editor.<API key>;
using Roslyn.Utilities;
namespace Microsoft.CodeAnalysis.Text.Shared.Extensions
{
internal static class <API key>
{
<summary>
Returns the first non-whitespace position on the given line, or null if
the line is empty or contains only whitespace.
</summary>
public static int? <API key>(this ITextSnapshotLine line)
{
Contract.ThrowIfNull(line);
var text = line.GetText();
for (int i = 0; i < text.Length; i++)
{
if (!char.IsWhiteSpace(text[i]))
{
return line.Start + i;
}
}
return null;
}
<summary>
Returns the first non-whitespace position on the given line as an offset
from the start of the line, or null if the line is empty or contains only
whitespace.
</summary>
public static int? <API key>(this ITextSnapshotLine line)
{
Contract.ThrowIfNull(line);
var text = line.GetText();
for (int i = 0; i < text.Length; i++)
{
if (!char.IsWhiteSpace(text[i]))
{
return i;
}
}
return null;
}
<summary>
Returns the last non-whitespace position on the given line, or null if
the line is empty or contains only whitespace.
</summary>
public static int? <API key>(this ITextSnapshotLine line)
{
return line.AsTextLine().<API key>();
}
<summary>
Determines whether the specified line is empty or contains whitespace only.
</summary>
public static bool IsEmptyOrWhitespace(this ITextSnapshotLine line, int startIndex = 0, int endIndex = -1)
{
Contract.ThrowIfNull("line");
Contract.ThrowIfFalse(startIndex >= 0);
var text = line.GetText();
if (endIndex == -1)
{
endIndex = text.Length;
}
for (int i = startIndex; i < endIndex; i++)
{
if (!char.IsWhiteSpace(text[i]))
{
return false;
}
}
return true;
}
public static ITextSnapshotLine <API key>(this ITextSnapshotLine line, Func<ITextSnapshotLine, bool> predicate)
{
Contract.ThrowIfNull(line, @"line");
Contract.ThrowIfNull(predicate, @"tree");
if (line.LineNumber <= 0)
{
return null;
}
var snapshot = line.Snapshot;
for (int lineNumber = line.LineNumber - 1; lineNumber >= 0; lineNumber
{
var currentLine = snapshot.<API key>(lineNumber);
if (!predicate(currentLine))
{
continue;
}
return currentLine;
}
return null;
}
public static int <API key>(this ITextSnapshotLine line, IEditorOptions editorOptions)
{
return line.<API key>(editorOptions.GetTabSize());
}
public static int <API key>(this ITextSnapshotLine line, int tabSize)
{
return line.GetText().<API key>(tabSize);
}
public static int <API key>(this ITextSnapshotLine line, int lineOffset, IEditorOptions editorOptions)
{
return line.GetText().<API key>(lineOffset, editorOptions.GetTabSize());
}
public static int <API key>(this ITextSnapshotLine line, int column, IEditorOptions editorOptions)
{
return line.GetText().<API key>(column, editorOptions.GetTabSize());
}
<summary>
Checks if the given line at the given snapshot index starts with the provided value.
</summary>
public static bool StartsWith(this ITextSnapshotLine line, int index, string value, bool ignoreCase)
{
var snapshot = line.Snapshot;
if (index + value.Length > snapshot.Length)
{
return false;
}
for (int i = 0; i < value.Length; i++)
{
var snapshotIndex = index + i;
var actualCharacter = snapshot[snapshotIndex];
var expectedCharacter = value[i];
if (ignoreCase)
{
actualCharacter = char.ToLowerInvariant(actualCharacter);
expectedCharacter = char.ToLowerInvariant(expectedCharacter);
}
if (actualCharacter != expectedCharacter)
{
return false;
}
}
return true;
}
}
} |
import logging
import pytest
import gen
import pkgpanda.util
from gen.build_deploy.bash import onprem_source
# TODO(cmaloney): Should be able to pass an exact tree to gen so that we can test
# one little piece at a time rather than having to rework this every time that
# DC/OS parameters change.
@pytest.mark.skipif(pkgpanda.util.is_windows, reason="test fails on Windows reason no mesos master")
def <API key>(monkeypatch):
monkeypatch.setenv('BOOTSTRAP_ID', 'foobar')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
assert gen.validate({
'ip_detect_filename': 'not-a-existing-file',
'bootstrap_variant': ''
}, extra_sources=[onprem_source]) == {
'status': 'errors',
'errors': {
'ip_detect_contents': {'message': 'ip-detect script `not-a-existing-file` must exist'}
},
'unset': {
'bootstrap_url',
'cluster_name',
'<API key>',
'master_discovery'
}
}
@pytest.mark.skipif(pkgpanda.util.is_windows, reason="configuration not present on windows")
def <API key>(monkeypatch):
monkeypatch.setenv('BOOTSTRAP_ID', 'foobar')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
assert gen.validate({
'bootstrap_url': '',
'bootstrap_variant': '',
'ip_detect_contents': '', # so that ip_detect_filename doesn't get used from onprem_source
'ip6_detect_contents': '',
'<API key>': 'static',
'master_discovery': 'static',
'cluster_name': 'foobar',
'master_list': '["127.0.0.1"]',
}, extra_sources=[onprem_source]) == {
'status': 'errors',
'errors': {
'bootstrap_url': {'message': 'Should be a url (http://example.com/bar or file:///path/to/local/cache)'},
},
'unset': set()
} |
#include <irq.h>
/*
* In RISC-V there is no conventional way to handle CPU power save.
* Each RISC-V SOC handles it in its own way.
* Hence, by default, arch_cpu_idle and <API key> functions just
* unlock interrupts and return to the caller, without issuing any CPU power
* saving instruction.
*
* Nonetheless, define the default arch_cpu_idle and <API key>
* functions as weak functions, so that they can be replaced at the SOC-level.
*/
void __weak arch_cpu_idle(void)
{
irq_unlock(MSTATUS_IEN);
}
void __weak <API key>(unsigned int key)
{
irq_unlock(key);
} |
package com.siyeh.ig.encapsulation;
import com.intellij.codeInspection.dataFlow.Mutability;
import com.intellij.codeInspection.ui.<API key>;
import com.intellij.psi.*;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtil;
import com.intellij.util.ObjectUtils;
import com.siyeh.<API key>;
import com.siyeh.ig.BaseInspection;
import com.siyeh.ig.<API key>;
import com.siyeh.ig.<API key>;
import com.siyeh.ig.psiutils.ClassUtils;
import com.siyeh.ig.psiutils.CollectionUtils;
import com.siyeh.ig.psiutils.TypeUtils;
import org.jetbrains.annotations.Nls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
/**
* @author Bas Leijdekkers
*/
public class <API key> extends BaseInspection {
public static final String[] MUTABLE_TYPES = {
CommonClassNames.JAVA_UTIL_DATE,
CommonClassNames.JAVA_UTIL_CALENDAR,
CommonClassNames.<API key>,
CommonClassNames.JAVA_UTIL_MAP,
"com.google.common.collect.Multimap",
"com.google.common.collect.Table"
};
@SuppressWarnings("PublicField")
public boolean <API key> = true;
@Nls
@NotNull
@Override
public String getDisplayName() {
return <API key>.message("assignment.or.return.of.field.with.mutable.type.display.name");
}
@Override
@NotNull
public String buildErrorString(Object... infos) {
final PsiField field = (PsiField)infos[0];
final PsiExpression rhs = (PsiExpression)infos[1];
final PsiType type = field.getType();
final boolean assignment = ((Boolean)infos[3]).booleanValue();
return assignment
? <API key>.message("assignment.of.field.with.mutable.type.problem.descriptor",
type.getPresentableText(), field.getName(), rhs.getText())
: <API key>.message("return.of.field.with.mutable.type.problem.descriptor",
type.getPresentableText(), field.getName());
}
@Nullable
@Override
protected <API key> buildFix(Object... infos) {
final <API key> returnValue = (<API key>)infos[1];
final String type = (String)infos[2];
if (CommonClassNames.JAVA_UTIL_DATE.equals(type) ||
CommonClassNames.JAVA_UTIL_CALENDAR.equals(type) ||
returnValue.getType() instanceof PsiArrayType) {
final PsiField field = (PsiField)infos[0];
return new ReplaceWithCloneFix(field.getName());
}
final boolean assignment = ((Boolean)infos[3]).booleanValue();
if (!assignment) {
return <API key>.build(returnValue);
}
return null;
}
@Override
@Nullable
public JComponent createOptionsPanel() {
return new <API key>(<API key>.message("ignore.private.methods.option"), this, "<API key>");
}
@Override
public <API key> buildVisitor() {
return new <API key>();
}
private class <API key> extends <API key> {
@Override
public void <API key>(@NotNull <API key> expression) {
super.<API key>(expression);
final IElementType tokenType = expression.<API key>();
if (!JavaTokenType.EQ.equals(tokenType)) {
return;
}
final PsiExpression lhs = PsiUtil.<API key>(expression.getLExpression());
if (!(lhs instanceof <API key>)) {
return;
}
final String type = TypeUtils.<API key>(lhs, MUTABLE_TYPES);
if (type == null && !(lhs.getType() instanceof PsiArrayType)) {
return;
}
final PsiExpression rhs = PsiUtil.<API key>(expression.getRExpression());
if (!(rhs instanceof <API key>)) {
return;
}
final PsiField field = ObjectUtils.tryCast(((PsiReference)lhs).resolve(), PsiField.class);
if (field == null) return;
final PsiParameter parameter = ObjectUtils.tryCast(((PsiReference)rhs).resolve(), PsiParameter.class);
if (parameter == null || !(parameter.getDeclarationScope() instanceof PsiMethod) || ClassUtils.isImmutable(parameter.getType())) {
return;
}
if (<API key>) {
final PsiMethod containingMethod = PsiTreeUtil.getParentOfType(expression, PsiMethod.class);
if (containingMethod == null || containingMethod.hasModifierProperty(PsiModifier.PRIVATE)) {
return;
}
if (containingMethod.isConstructor()) {
final PsiClass containingClass = containingMethod.getContainingClass();
if (containingClass != null && containingClass.hasModifierProperty(PsiModifier.PRIVATE)) {
return;
}
}
}
registerError(rhs, field, rhs, type, Boolean.TRUE);
}
@Override
public void <API key>(@NotNull PsiReturnStatement statement) {
super.<API key>(statement);
final PsiExpression returnValue = PsiUtil.<API key>(statement.getReturnValue());
if (!(returnValue instanceof <API key>)) {
return;
}
final PsiElement element = PsiTreeUtil.getParentOfType(statement, PsiMethod.class, PsiLambdaExpression.class);
if (<API key> && element instanceof PsiMethod && ((PsiMethod)element).hasModifierProperty(PsiModifier.PRIVATE)) {
return;
}
final PsiField field = ObjectUtils.tryCast(((<API key>)returnValue).resolve(), PsiField.class);
if (field == null) return;
final String type = TypeUtils.<API key>(returnValue, MUTABLE_TYPES);
if (type == null && !(returnValue.getType() instanceof PsiArrayType)) return;
if (CollectionUtils.<API key>(field) ||
field.hasModifierProperty(PsiModifier.FINAL) && field.hasModifierProperty(PsiModifier.STATIC) && field.getType() instanceof PsiArrayType && field.getInitializer() == null ||
ClassUtils.isImmutable(field.getType()) ||
Mutability.getMutability(field).isUnmodifiable()) return;
registerError(returnValue, field, returnValue, type, Boolean.FALSE);
}
}
} |
cask "kubenav" do
version "3.6.0"
if Hardware::CPU.intel?
sha256 "<SHA256-like>"
url "https://github.com/kubenav/kubenav/releases/download/#{version}/<API key>.zip",
verified: "github.com/kubenav/kubenav/"
else
sha256 "<SHA256-like>"
url "https://github.com/kubenav/kubenav/releases/download/#{version}/<API key>.zip",
verified: "github.com/kubenav/kubenav/"
end
name "kubenav"
desc "Navigator for your Kubernetes clusters right in your pocket"
homepage "https://kubenav.io/"
app "kubenav.app"
binary "#{appdir}/kubenav.app/Contents/MacOS/kubenav"
end |
// This file was procedurally generated from the following sources:
// - src/dstr-binding/<API key>.case
// - src/dstr-binding/default/<API key>.template
var callCount = 0;
var C = class {
static async *method([[x, y, z] = [4, 5, 6]]) {
assert.sameValue(x, 4);
assert.sameValue(y, 5);
assert.sameValue(z, 6);
callCount = callCount + 1;
}
};
C.method([]).next().then(() => {
assert.sameValue(callCount, 1, 'invoked exactly once');
}).then($DONE, $DONE); |
from mi.instrument.seabird.driver import NEWLINE
SAMPLE_GETSD = "<StatusData DeviceType='SBE54' SerialNumber='05400012'>" + NEWLINE + \
"<DateTime>2012-11-06T10:55:44</DateTime>" + NEWLINE + \
"<EventSummary numEvents='573'/>" + NEWLINE + \
"<Power>" + NEWLINE + \
"<MainSupplyVoltage>23.3</MainSupplyVoltage>" + NEWLINE + \
"</Power>" + NEWLINE + \
"<MemorySummary>" + NEWLINE + \
"<Samples>22618</Samples>" + NEWLINE + \
"<Bytes>341504</Bytes>" + NEWLINE + \
"<BytesFree>133876224</BytesFree>" + NEWLINE + \
"</MemorySummary>" + NEWLINE + \
"</StatusData>"
SAMPLE_GETCD = "<ConfigurationData DeviceType='SBE54' SerialNumber='05400012'>" + NEWLINE +\
"<<API key>>" + NEWLINE +\
"<AcqOscCalDate>2012-02-20</AcqOscCalDate>" + NEWLINE +\
"<FRA0>5.999926E+06</FRA0>" + NEWLINE +\
"<FRA1>5.792290E-03</FRA1>" + NEWLINE +\
"<FRA2>-1.195664E-07</FRA2>" + NEWLINE +\
"<FRA3>7.018589E-13</FRA3>" + NEWLINE +\
"<PressureSerialNum>121451</PressureSerialNum>" + NEWLINE +\
"<PressureCalDate>2011-06-01</PressureCalDate>" + NEWLINE +\
"<pu0>5.820407E+00</pu0>" + NEWLINE +\
"<py1>-3.845374E+03</py1>" + NEWLINE +\
"<py2>-1.078882E+04</py2>" + NEWLINE +\
"<py3>0.000000E+00</py3>" + NEWLINE +\
"<pc1>-2.700543E+04</pc1>" + NEWLINE +\
"<pc2>-1.738438E+03</pc2>" + NEWLINE +\
"<pc3>7.629962E+04</pc3>" + NEWLINE +\
"<pd1>3.739600E-02</pd1>" + NEWLINE +\
"<pd2>0.000000E+00</pd2>" + NEWLINE +\
"<pt1>3.027306E+01</pt1>" + NEWLINE +\
"<pt2>2.231025E-01</pt2>" + NEWLINE +\
"<pt3>5.398972E+01</pt3>" + NEWLINE +\
"<pt4>1.455506E+02</pt4>" + NEWLINE +\
"<poffset>0.000000E+00</poffset>" + NEWLINE +\
"<prange>6.000000E+03</prange>" + NEWLINE +\
"</<API key>>" + NEWLINE +\
"<Settings" + NEWLINE +\
"batteryType='0'" + NEWLINE +\
"baudRate='9600'" + NEWLINE +\
"enableAlerts='0'" + NEWLINE +\
"uploadType='0'" + NEWLINE +\
"samplePeriod='15'" + NEWLINE +\
"/>" + NEWLINE +\
"</ConfigurationData>"
SAMPLE_GETEC = "<EventSummary numEvents='573' maxStack='354'/>" + NEWLINE +\
"<EventList DeviceType='SBE54' SerialNumber='05400012'>" + NEWLINE +\
"<Event type='PowerOnReset' count='25'/>" + NEWLINE +\
"<Event type='PowerFailReset' count='25'/>" + NEWLINE +\
"<Event type='SerialByteErr' count='9'/>" + NEWLINE +\
"<Event type='CMDBuffOflow' count='1'/>" + NEWLINE +\
"<Event type='SerialRxOflow' count='255'/>" + NEWLINE +\
"<Event type='LowBattery' count='255'/>" + NEWLINE +\
"<Event type='SignalErr' count='1'/>" + NEWLINE +\
"<Event type='Error10' count='1'/>" + NEWLINE +\
"<Event type='Error12' count='1'/>" + NEWLINE +\
"</EventList>"
SAMPLE_GETHD = "<HardwareData DeviceType='SBE54' SerialNumber='05400012'>" + NEWLINE +\
"<Manufacturer>Sea-Bird Electronics, Inc</Manufacturer>" + NEWLINE +\
"<FirmwareVersion>SBE54 V1.3-6MHZ</FirmwareVersion>" + NEWLINE +\
"<FirmwareDate>Mar 22 2007</FirmwareDate>" + NEWLINE +\
"<HardwareVersion>41477A.1</HardwareVersion>" + NEWLINE +\
"<HardwareVersion>41478A.1T</HardwareVersion>" + NEWLINE +\
"<PCBSerialNum>NOT SET</PCBSerialNum>" + NEWLINE +\
"<PCBSerialNum>NOT SET</PCBSerialNum>" + NEWLINE +\
"<PCBType>1</PCBType>" + NEWLINE +\
"<MfgDate>Jun 27 2007</MfgDate>" + NEWLINE +\
"</HardwareData>"
SAMPLE_SAMPLE = "<Sample Num='5947' Type='Pressure'>" + NEWLINE +\
"<Time>2012-11-07T12:21:25</Time>" + NEWLINE +\
"<PressurePSI>13.9669</PressurePSI>" + NEWLINE +\
"<PTemp>18.9047</PTemp>" + NEWLINE +\
"</Sample>"
SAMPLE_REF_OSC = "<SetTimeout>125000</SetTimeout>" + NEWLINE +\
"<SetTimeoutMax>150000</SetTimeoutMax>" + NEWLINE +\
"<SetTimeoutICD>150000</SetTimeoutICD>" + NEWLINE +\
"<!--Ref osc warmup next 120 seconds-->" + NEWLINE +\
"<!--Warmup complete, starting measurement at 0.1Hz-->" + NEWLINE +\
"<Sample Num='1244' Type='RefOsc'>" + NEWLINE +\
"<Time>2013-01-30T15:36:53</Time>" + NEWLINE +\
"<RefOscFreq>5999995.955</RefOscFreq>" + NEWLINE +\
"<PCBTempRaw>18413</PCBTempRaw>" + NEWLINE +\
"<RefErrorPPM>0.090</RefErrorPPM>" + NEWLINE +\
"</Sample>"
SAMPLE_REF_OSC_FAIL = "<SetTimeout>125000</SetTimeout>" + NEWLINE +\
"<SetTimeoutMax>150000</SetTimeoutMax>" + NEWLINE +\
"<SetTimeoutICD>125000</SetTimeoutICD>" + NEWLINE +\
"<!--Ref osc warmup next 120 seconds-->" + NEWLINE +\
"<!--Warmup complete, starting measurement at 0.1Hz-->" + NEWLINE +\
"<POWERON/>" + NEWLINE +\
"<!--BatteryType reset to Lithium (0)-->" + NEWLINE +\
"<Sample Num='0' Type='Pressure'>" + NEWLINE +\
"<Time>2016-05-03T17:14:40</Time>" + NEWLINE +\
"<PressurePSI>13.6866</PressurePSI>" + NEWLINE +\
"<PTemp>20.6288</PTemp>" + NEWLINE +\
"</Sample>" |
package org.reactfx;
import org.reactfx.util.<API key>;
import org.reactfx.util.AccumulatorSize;
import org.reactfx.util.<API key>;
public abstract class SuspendableBase<O, T, A>
extends ObservableBase<O, T>
implements Suspendable {
private final EventStream<T> input;
private final <API key><T, A> af;
private int suspended = 0;
private boolean hasValue = false;
private A accumulatedValue = null;
protected SuspendableBase(
EventStream<T> input,
<API key><O, T, A> pn) {
super(pn);
this.input = input;
this.af = pn.<API key>();
}
protected abstract AccumulatorSize sizeOf(A accum);
protected abstract T headOf(A accum);
protected abstract A tailOf(A accum);
protected A initialAccumulator(T value) {
return af.initialAccumulator(value);
}
protected A reduce(A accum, T value) {
return af.reduce(accum, value);
}
protected final boolean isSuspended() {
return suspended > 0;
}
@Override
public final Guard suspend() {
++suspended;
return Guard.closeableOnce(this::resume);
}
@Override
protected final Subscription observeInputs() {
Subscription sub = input.subscribe(this::handleEvent);
return sub.and(this::reset);
}
private void resume() {
--suspended;
if(suspended == 0 && hasValue) {
while(sizeOf(accumulatedValue) == AccumulatorSize.MANY) {
<API key>(headOf(accumulatedValue));
accumulatedValue = tailOf(accumulatedValue);
}
if(sizeOf(accumulatedValue) == AccumulatorSize.ONE) {
<API key>(headOf(accumulatedValue));
}
reset();
notifyObservers();
}
}
private void reset() {
hasValue = false;
accumulatedValue = null;
}
private void handleEvent(T event) {
if(isSuspended()) {
if(hasValue) {
accumulatedValue = reduce(accumulatedValue, event);
} else {
accumulatedValue = initialAccumulator(event);
hasValue = true;
}
} else {
notifyObservers(event);
}
}
} |
# with or without modification, are permitted provided that the following
# conditions are met:
# documentation and/or other materials provided with the distribution.
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from euca2ools.commands.ec2 import EC2Request
from requestbuilder import Arg, Filter
class DescribeBundleTasks(EC2Request):
DESCRIPTION = 'Describe current instance-bundling tasks'
ARGS = [Arg('BundleId', metavar='BUNDLE', nargs='*',
help='limit results to specific bundle tasks')]
FILTERS = [Filter('bundle-id', help='bundle task ID'),
Filter('error-code',
help='if the task failed, the error code returned'),
Filter('error-message',
help='if the task failed, the error message returned'),
Filter('instance-id', help='ID of the bundled instance'),
Filter('progress', help='level of task completion, in percent'),
Filter('s3-bucket',
help='bucket where the image will be stored'),
Filter('s3-prefix', help='beginning of the bundle name'),
Filter('start-time', help='task start time'),
Filter('state', help='task state'),
Filter('update-time', help='most recent task update time')]
LIST_TAGS = ['<API key>']
def print_result(self, result):
for task in result.get('<API key>', []):
self.print_bundle_task(task) |
using System.Collections.Generic;
using Moq;
using NUnit.Framework;
using XenAdmin;
using XenAdmin.Commands;
using XenAdminTests.UnitTests.UnitTestHelper.MockObjectBuilders;
using XenAPI;
namespace XenAdminTests.CommandTests
{
public class <API key> : <API key>
{
public const string id = "test";
public const string id2 = "test2";
private static readonly string[] ids = new []{id, id2};
/* run these tests without a target host, so they're forced to go further
than the <API key> and perform the rest of the checks */
public <API key>() : base(ids) { }
[TearDown]
public void TestTearDown()
{
foreach (string currentid in ids)
{
ObjectManager.ClearXenObjects(currentid);
ObjectManager.RefreshCache(currentid);
}
}
[Test, Category(TestCategories.SmokeTest)]
[TestCase(true, Description = "Is LunPerVdi", Result = false)]
[TestCase(false, Description = "Is Not LunPerVdi", Result = true)]
public bool <API key>(bool IsLunPerVdi)
{
Mock<VM> vm = ObjectFactory.BuiltObject<VM>(ObjectBuilderType.<API key>, id);
Mock<SR> sr = ObjectManager.NewXenObject<SR>(id);
vm.Setup(v => v.SRs()).Returns(new List<SR> {sr.Object});
vm.Setup(v => v.allowed_operations).Returns(new List<vm_operations> {vm_operations.migrate_send});
sr.Setup(s => s.HBALunPerVDI()).Returns(IsLunPerVdi);
IMainWindow mw = new MockMainWindow();
var cmd = new <API key>(mw, new List<SelectedItem> { new SelectedItem(vm.Object)}, null);
return cmd.CanExecute();
}
[Test, Category(TestCategories.SmokeTest)]
[TestCase(true, Description = "Wlb enabled", Result = false)]
[TestCase(false, Description = "Wlb disabled", Result = true)]
public bool <API key>(bool WlbEnabled)
{
Mock<VM> vm = ObjectFactory.BuiltObject<VM>(ObjectBuilderType.<API key>, id);
Mock<Host> targetHost = ObjectFactory.BuiltObject<Host>(ObjectBuilderType.TampaHost, id);
ObjectManager.MockConnectionFor(id).Setup(c => c.Resolve(It.IsAny<XenRef<Host>>())).Returns(targetHost.Object);
vm.Setup(v => v.allowed_operations).Returns(new List<vm_operations> { vm_operations.migrate_send });
Mock<Pool> pool = ObjectManager.NewXenObject<Pool>(id);
pool.Setup(p => p.wlb_enabled).Returns(WlbEnabled);
pool.Setup(p => p.wlb_url).Returns("wlburl"); //Configured == true
IMainWindow mw = new MockMainWindow();
var cmd = new <API key>(mw, new List<SelectedItem> { new SelectedItem(vm.Object) }, null);
bool canExecute = cmd.CanExecute();
pool.Verify(p=>p.wlb_enabled, Times.AtLeastOnce());
return canExecute;
}
[Test, Category(TestCategories.SmokeTest)]
[TestCase(true, true, Description = "Wlb enabled both", Result = false)]
[TestCase(false, false, Description = "Wlb disabled both", Result = true)]
[TestCase(true, false, Description = "Wlb enabled VM", Result = false)]
[TestCase(false, true, Description = "Wlb enabled target", Result = true)]
public bool <API key>(bool WlbEnabledVM, bool WlbEnabledTarget)
{
//First connection
Mock<VM> vm = ObjectFactory.BuiltObject<VM>(ObjectBuilderType.<API key>, id);
Mock<Host> master = ObjectFactory.BuiltObject<Host>(ObjectBuilderType.TampaHost, id);
ObjectManager.MockConnectionFor(id).Setup(c => c.Resolve(It.IsAny<XenRef<Host>>())).Returns(master.Object);
vm.Setup(v => v.allowed_operations).Returns(new List<vm_operations> { vm_operations.migrate_send });
Mock<Pool> pool = ObjectManager.NewXenObject<Pool>(id);
pool.Setup(p => p.wlb_enabled).Returns(WlbEnabledVM);
pool.Setup(p => p.wlb_url).Returns("wlburl"); //Configured == true
//Second connection
Mock<Host> targetHost = ObjectFactory.BuiltObject<Host>(ObjectBuilderType.TampaHost, id2);
Mock<Pool> targetPool = ObjectManager.NewXenObject<Pool>(id2);
ObjectManager.MockConnectionFor(id2).Setup(c => c.Resolve(It.IsAny<XenRef<Host>>())).Returns(targetHost.Object);
targetPool.Setup(p => p.wlb_enabled).Returns(WlbEnabledTarget);
targetPool.Setup(p => p.wlb_url).Returns("wlburl"); //Configured == true
//Command
IMainWindow mw = new MockMainWindow();
var cmd = new <API key>(mw, new List<SelectedItem> { new SelectedItem(vm.Object) }, null);
bool canExecute = cmd.CanExecute();
//As the command is launching the wizard it should only need to
//check the VMs are on Wlb as the target can be changed in the wizard anyhow
pool.Verify(p => p.wlb_enabled, Times.AtLeastOnce());
targetPool.Verify(tp => tp.wlb_enabled, Times.Never());
return canExecute;
}
}
} |
from django.core import exceptions
from devserver.logger import GenericLogger
MODULES = []
def load_modules():
global MODULES
MODULES = []
from devserver import settings
for path in settings.DEVSERVER_MODULES:
try:
name, class_name = path.rsplit('.', 1)
except ValueError:
raise exceptions.<API key>, '%s isn\'t a devserver module' % path
try:
module = __import__(name, {}, {}, [''])
except ImportError, e:
raise exceptions.<API key>, 'Error importing devserver module %s: "%s"' % (name, e)
try:
cls = getattr(module, class_name)
except AttributeError:
raise exceptions.<API key>, 'Error importing devserver module "%s" does not define a "%s" class' % (name, class_name)
try:
instance = cls(GenericLogger(cls))
except:
raise # Bubble up problem loading panel
MODULES.append(instance)
if not MODULES:
load_modules() |
#include "chrome/browser/history/android/<API key>.h"
#include <vector>
#include "base/file_path.h"
#include "base/file_util.h"
#include "base/memory/ref_counted.h"
#include "base/scoped_temp_dir.h"
#include "base/stringprintf.h"
#include "base/<API key>.h"
#include "chrome/browser/bookmarks/bookmark_model.h"
#include "chrome/browser/bookmarks/bookmark_service.h"
#include "chrome/browser/history/android/android_time.h"
#include "chrome/browser/history/history_backend.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/<API key>.h"
#include "chrome/test/base/<API key>.h"
#include "chrome/test/base/<API key>.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/base/ui_test_utils.h"
#include "content/public/browser/browser_thread.h"
#include "content/test/test_browser_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::Time;
using base::TimeDelta;
using content::BrowserThread;
namespace history {
namespace {
struct BookmarkCacheRow {
public:
BookmarkCacheRow()
: url_id_(0),
bookmark_(false),
favicon_id_(0) {
}
URLID url_id_;
Time create_time_;
Time last_visit_time_;
bool bookmark_;
FaviconID favicon_id_;
};
} // namespace
class <API key> : public HistoryBackend::Delegate {
public:
<API key>() {}
virtual void NotifyProfileError(int backend_id,
sql::InitStatus init_status) OVERRIDE {}
virtual void SetInMemoryBackend(int backend_id,
<API key>* backend) OVERRIDE {}
virtual void <API key>(int type,
HistoryDetails* details) OVERRIDE {
switch (type) {
case chrome::<API key>:
deleted_details_.reset(static_cast<URLsDeletedDetails*>(details));
break;
case chrome::<API key>:
favicon_details_.reset(static_cast<<API key>*>(details));
break;
case chrome::<API key>:
modified_details_.reset(static_cast<URLsModifiedDetails*>(details));
break;
}
}
virtual void DBLoaded(int backend_id) OVERRIDE {}
virtual void <API key>(int backend_id) OVERRIDE {}
virtual void <API key>(
const history::BriefVisitInfo& info) OVERRIDE {}
URLsDeletedDetails* deleted_details() const {
return deleted_details_.get();
}
URLsModifiedDetails* modified_details() const {
return modified_details_.get();
}
<API key>* favicon_details() const {
return favicon_details_.get();
}
void ResetDetails() {
deleted_details_.reset();
modified_details_.reset();
favicon_details_.reset();
}
private:
scoped_ptr<URLsDeletedDetails> deleted_details_;
scoped_ptr<URLsModifiedDetails> modified_details_;
scoped_ptr<<API key>> favicon_details_;
<API key>(<API key>);
};
class <API key> : public testing::Test {
public:
<API key>()
: profile_manager_(
static_cast<<API key>*>(g_browser_process)),
bookmark_model_(NULL),
ui_thread_(BrowserThread::UI, &message_loop_),
file_thread_(BrowserThread::FILE, &message_loop_) {
}
~<API key>() {
}
protected:
virtual void SetUp() OVERRIDE {
// Setup the testing profile, so the <API key> could
// get the bookmark model from it.
ASSERT_TRUE(profile_manager_.SetUp());
// It seems that the name has to be chrome::kInitialProfile, so it
// could be found by ProfileManager::GetLastUsedProfile().
TestingProfile* testing_profile = profile_manager_.<API key>(
chrome::kInitialProfile);
testing_profile->CreateBookmarkModel(true);
testing_profile-><API key>();
// Get the BookmarkModel from LastUsedProfile, this is the same way that
// how the <API key> gets the BookmarkModel.
Profile* profile = ProfileManager::GetLastUsedProfile();
ASSERT_TRUE(profile);
bookmark_model_ = profile->GetBookmarkModel();
ASSERT_TRUE(bookmark_model_);
// Setup the database directory and files.
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
history_db_name_ = temp_dir_.path().AppendASCII(chrome::kHistoryFilename);
thumbnail_db_name_ = temp_dir_.path().AppendASCII(
chrome::kFaviconsFilename);
<API key> = temp_dir_.path().AppendASCII(
"TestAndroidCache.db");
bookmark_temp_ = temp_dir_.path().AppendASCII("bookmark_temp");
ASSERT_TRUE(file_util::CreateDirectory(bookmark_temp_));
}
void AddBookmark(const GURL& url) {
const BookmarkNode* mobile_node = bookmark_model_->mobile_node();
ASSERT_TRUE(mobile_node);
ASSERT_TRUE(bookmark_model_->AddURL(mobile_node, 0, string16(), url));
}
bool GetAndroidURLsRows(std::vector<AndroidURLRow>* rows,
<API key>* backend) {
sql::Statement statement(backend->db_->GetCachedStatement(SQL_FROM_HERE,
"SELECT id, raw_url, url_id FROM android_urls ORDER BY url_id ASC"));
while (statement.Step()) {
AndroidURLRow row;
row.id = statement.ColumnInt64(0);
row.raw_url = statement.ColumnString(1);
row.url_id = statement.ColumnInt64(2);
rows->push_back(row);
}
return true;
}
bool <API key>(std::vector<BookmarkCacheRow>* rows,
<API key>* backend) {
sql::Statement statement(backend->db_->GetCachedStatement(SQL_FROM_HERE,
"SELECT created_time, last_visit_time, url_id, bookmark, favicon_id "
"FROM android_cache_db.bookmark_cache ORDER BY url_id ASC"));
while (statement.Step()) {
BookmarkCacheRow row;
row.create_time_ = FromDatabaseTime(statement.ColumnInt64(0));
row.last_visit_time_ = FromDatabaseTime(statement.ColumnInt64(1));
row.url_id_ = statement.ColumnInt64(2);
row.bookmark_ = statement.ColumnBool(3);
row.favicon_id_ = statement.ColumnInt64(4);
rows->push_back(row);
}
return true;
}
<API key> delegate_;
scoped_refptr<HistoryBackend> history_backend_;
HistoryDatabase history_db_;
ThumbnailDatabase thumbnail_db_;
ScopedTempDir temp_dir_;
FilePath <API key>;
FilePath history_db_name_;
FilePath thumbnail_db_name_;
FilePath bookmark_temp_;
<API key> profile_manager_;
BookmarkModel* bookmark_model_;
MessageLoopForUI message_loop_;
content::TestBrowserThread ui_thread_;
content::TestBrowserThread file_thread_;
<API key>(<API key>);
};
TEST_F(<API key>, UpdateTables) {
GURL url1("http:
URLID url_id1 = 0;
std::vector<VisitInfo> visits1;
Time last_visited1 = Time::Now() - TimeDelta::FromDays(1);
Time created1 = last_visited1 - TimeDelta::FromDays(20);
visits1.push_back(VisitInfo(created1, content::<API key>));
visits1.push_back(VisitInfo(last_visited1 - TimeDelta::FromDays(1),
content::<API key>));
visits1.push_back(VisitInfo(last_visited1, content::<API key>));
GURL url2("http:
URLID url_id2 = 0;
std::vector<VisitInfo> visits2;
Time last_visited2 = Time::Now();
Time created2 = last_visited2 - TimeDelta::FromDays(10);
visits2.push_back(VisitInfo(created2, content::<API key>));
visits2.push_back(VisitInfo(last_visited2 - TimeDelta::FromDays(5),
content::<API key>));
visits2.push_back(VisitInfo(last_visited2, content::<API key>));
// Only use the HistoryBackend to generate the test data.
// HistoryBackend will shutdown after that.
{
scoped_refptr<HistoryBackend> history_backend;
history_backend = new HistoryBackend(temp_dir_.path(), 0,
new <API key>(), bookmark_model_);
history_backend->Init(std::string(), false);
history_backend->AddVisits(url1, visits1, history::SOURCE_SYNCED);
history_backend->AddVisits(url2, visits2, history::SOURCE_SYNCED);
URLRow url_row;
ASSERT_TRUE(history_backend->GetURL(url1, &url_row));
url_id1 = url_row.id();
ASSERT_TRUE(history_backend->GetURL(url2, &url_row));
url_id2 = url_row.id();
// Set favicon to url2.
std::vector<unsigned char> data;
data.push_back('1');
history_backend->SetFavicon(url2,
GURL(),
new base::RefCountedBytes(data),
FAVICON);
history_backend->Closing();
}
// HistoryBackend. We need to open the same database files.
ASSERT_TRUE(file_util::PathExists(history_db_name_));
ASSERT_TRUE(file_util::PathExists(thumbnail_db_name_));
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
// Set url1 as bookmark.
AddBookmark(url1);
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
ASSERT_TRUE(backend-><API key>());
std::vector<AndroidURLRow> android_url_rows;
ASSERT_TRUE(GetAndroidURLsRows(&android_url_rows, backend.get()));
ASSERT_EQ(2u, android_url_rows.size());
std::vector<AndroidURLRow>::iterator i = android_url_rows.begin();
EXPECT_EQ(url_id1, i->url_id);
EXPECT_EQ(url1.spec(), i->raw_url);
i++;
EXPECT_EQ(url_id2, i->url_id);
EXPECT_EQ(url2.spec(), i->raw_url);
std::vector<BookmarkCacheRow> bookmark_cache_rows;
ASSERT_TRUE(<API key>(&bookmark_cache_rows, backend.get()));
ASSERT_EQ(2u, bookmark_cache_rows.size());
std::vector<BookmarkCacheRow>::const_iterator j = bookmark_cache_rows.begin();
EXPECT_EQ(url_id1, j->url_id_);
EXPECT_EQ(ToDatabaseTime(last_visited1), ToDatabaseTime(j->last_visit_time_));
EXPECT_EQ(ToDatabaseTime(created1), ToDatabaseTime(j->create_time_));
EXPECT_EQ(0, j->favicon_id_);
EXPECT_TRUE(j->bookmark_);
j++;
EXPECT_EQ(url_id2, j->url_id_);
EXPECT_EQ(ToDatabaseTime(last_visited2), ToDatabaseTime(j->last_visit_time_));
EXPECT_EQ(ToDatabaseTime(created2), ToDatabaseTime(j->create_time_));
EXPECT_NE(0, j->favicon_id_);
EXPECT_FALSE(j->bookmark_);
// Delete url2 from database.
ASSERT_TRUE(history_db_.DeleteURLRow(url_id2));
VisitVector visit_rows;
ASSERT_TRUE(history_db_.<API key>(url_id2, 10,
&visit_rows));
ASSERT_EQ(3u, visit_rows.size());
for (VisitVector::const_iterator v = visit_rows.begin();
v != visit_rows.end(); v++)
history_db_.DeleteVisit(*v);
backend->UpdateTables();
android_url_rows.clear();
ASSERT_TRUE(GetAndroidURLsRows(&android_url_rows, backend.get()));
ASSERT_EQ(1u, android_url_rows.size());
i = android_url_rows.begin();
EXPECT_EQ(url_id1, i->url_id);
EXPECT_EQ(url1.spec(), i->raw_url);
bookmark_cache_rows.clear();
ASSERT_TRUE(<API key>(&bookmark_cache_rows, backend.get()));
ASSERT_EQ(1u, bookmark_cache_rows.size());
j = bookmark_cache_rows.begin();
EXPECT_EQ(url_id1, j->url_id_);
EXPECT_EQ(ToDatabaseTime(last_visited1), ToDatabaseTime(j->last_visit_time_));
EXPECT_EQ(ToDatabaseTime(created1), ToDatabaseTime(j->create_time_));
EXPECT_EQ(0, j->favicon_id_);
EXPECT_TRUE(j->bookmark_);
}
TEST_F(<API key>, <API key>) {
GURL url1("http:
URLID url_id1 = 0;
const string16 title1(UTF8ToUTF16("cnn"));
std::vector<VisitInfo> visits1;
Time last_visited1 = Time::Now() - TimeDelta::FromDays(1);
Time created1 = last_visited1 - TimeDelta::FromDays(20);
visits1.push_back(VisitInfo(created1, content::<API key>));
visits1.push_back(VisitInfo(last_visited1 - TimeDelta::FromDays(1),
content::<API key>));
visits1.push_back(VisitInfo(last_visited1, content::<API key>));
GURL url2("http:
URLID url_id2 = 0;
std::vector<VisitInfo> visits2;
const string16 title2(UTF8ToUTF16("example"));
Time last_visited2 = Time::Now();
Time created2 = last_visited2 - TimeDelta::FromDays(10);
visits2.push_back(VisitInfo(created2, content::<API key>));
visits2.push_back(VisitInfo(last_visited2 - TimeDelta::FromDays(5),
content::<API key>));
visits2.push_back(VisitInfo(last_visited2, content::<API key>));
// Only use the HistoryBackend to generate the test data.
// HistoryBackend will shutdown after that.
{
scoped_refptr<HistoryBackend> history_backend;
history_backend = new HistoryBackend(temp_dir_.path(), 0,
new <API key>(), bookmark_model_);
history_backend->Init(std::string(), false);
history_backend->AddVisits(url1, visits1, history::SOURCE_SYNCED);
history_backend->AddVisits(url2, visits2, history::SOURCE_SYNCED);
URLRow url_row;
ASSERT_TRUE(history_backend->GetURL(url1, &url_row));
url_id1 = url_row.id();
url_row.set_title(title1);
ASSERT_TRUE(history_backend->UpdateURL(url_id1, url_row));
ASSERT_TRUE(history_backend->GetURL(url2, &url_row));
url_id2 = url_row.id();
url_row.set_title(title2);
ASSERT_TRUE(history_backend->UpdateURL(url_id2, url_row));
// Set favicon to url2.
std::vector<unsigned char> data;
data.push_back('1');
history_backend->SetFavicon(url2,
GURL(),
new base::RefCountedBytes(data),
FAVICON);
history_backend->Closing();
}
// HistoryBackend. We need to open the same database files.
ASSERT_TRUE(file_util::PathExists(history_db_name_));
ASSERT_TRUE(file_util::PathExists(thumbnail_db_name_));
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
// Set url1 as bookmark.
AddBookmark(url1);
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
std::vector<<API key>::ColumnID> projections;
projections.push_back(<API key>::ID);
projections.push_back(<API key>::URL);
projections.push_back(<API key>::TITLE);
projections.push_back(<API key>::CREATED);
projections.push_back(<API key>::LAST_VISIT_TIME);
projections.push_back(<API key>::VISIT_COUNT);
projections.push_back(<API key>::FAVICON);
projections.push_back(<API key>::BOOKMARK);
scoped_ptr<AndroidStatement> statement(backend-><API key>(
projections, std::string(), std::vector<string16>(),
std::string("url ASC")));
ASSERT_TRUE(statement->statement()->Step());
ASSERT_EQ(url1, GURL(statement->statement()->ColumnString(1)));
EXPECT_EQ(title1, statement->statement()->ColumnString16(2));
EXPECT_EQ(ToDatabaseTime(created1),
statement->statement()->ColumnInt64(3));
EXPECT_EQ(ToDatabaseTime(last_visited1),
statement->statement()->ColumnInt64(4));
EXPECT_EQ(3, statement->statement()->ColumnInt(5));
EXPECT_EQ(6, statement->favicon_index());
// No favicon.
EXPECT_EQ(0, statement->statement()->ColumnByteLength(6));
EXPECT_TRUE(statement->statement()->ColumnBool(7));
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(title2, statement->statement()->ColumnString16(2));
ASSERT_EQ(url2, GURL(statement->statement()->ColumnString(1)));
EXPECT_EQ(ToDatabaseTime(created2),
statement->statement()->ColumnInt64(3));
EXPECT_EQ(ToDatabaseTime(last_visited2),
statement->statement()->ColumnInt64(4));
EXPECT_EQ(3, statement->statement()->ColumnInt(5));
std::vector<unsigned char> favicon2;
EXPECT_EQ(6, statement->favicon_index());
// Has favicon.
EXPECT_NE(0, statement->statement()->ColumnByteLength(6));
EXPECT_FALSE(statement->statement()->ColumnBool(7));
// No more row.
EXPECT_FALSE(statement->statement()->Step());
// Query by bookmark
statement.reset(backend-><API key>(projections, "bookmark=1",
std::vector<string16>(), std::string("url ASC")));
// Only URL1 is returned.
ASSERT_TRUE(statement->statement()->Step());
ASSERT_EQ(url1, GURL(statement->statement()->ColumnString(1)));
EXPECT_FALSE(statement->statement()->Step());
statement.reset(backend-><API key>(projections, "bookmark=0",
std::vector<string16>(), std::string("url ASC")));
// Only URL2 is returned.
ASSERT_TRUE(statement->statement()->Step());
ASSERT_EQ(url2, GURL(statement->statement()->ColumnString(1)));
EXPECT_FALSE(statement->statement()->Step());
}
TEST_F(<API key>, <API key>) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
ASSERT_TRUE(backend-><API key>(row1));
EXPECT_FALSE(delegate_.deleted_details());
ASSERT_TRUE(delegate_.modified_details());
ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
EXPECT_EQ(row1.url(), delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(row1.last_visit_time(),
delegate_.modified_details()->changed_urls[0].last_visit());
EXPECT_EQ(row1.visit_count(),
delegate_.modified_details()->changed_urls[0].visit_count());
EXPECT_EQ(row1.title(),
delegate_.modified_details()->changed_urls[0].title());
EXPECT_FALSE(delegate_.favicon_details());
ui_test_utils::<API key>();
ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
ASSERT_TRUE(child);
EXPECT_EQ(row1.title(), child->GetTitle());
EXPECT_EQ(row1.url(), child->url());
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(row2));
EXPECT_FALSE(delegate_.deleted_details());
ASSERT_TRUE(delegate_.modified_details());
ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
EXPECT_EQ(row2.url(), delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(row2.last_visit_time(),
delegate_.modified_details()->changed_urls[0].last_visit());
EXPECT_EQ(row2.title(),
delegate_.modified_details()->changed_urls[0].title());
ASSERT_TRUE(delegate_.favicon_details());
ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
delegate_.favicon_details()->urls.find(row2.url()));
std::vector<<API key>::ColumnID> projections;
projections.push_back(<API key>::ID);
projections.push_back(<API key>::URL);
projections.push_back(<API key>::TITLE);
projections.push_back(<API key>::CREATED);
projections.push_back(<API key>::LAST_VISIT_TIME);
projections.push_back(<API key>::VISIT_COUNT);
projections.push_back(<API key>::FAVICON);
projections.push_back(<API key>::BOOKMARK);
scoped_ptr<AndroidStatement> statement(backend-><API key>(
projections, std::string(), std::vector<string16>(),
std::string("url ASC")));
ASSERT_TRUE(statement->statement()->Step());
ASSERT_EQ(row1.raw_url(), statement->statement()->ColumnString(1));
EXPECT_EQ(row1.title(), statement->statement()->ColumnString16(2));
EXPECT_EQ(ToDatabaseTime(row1.created()),
statement->statement()->ColumnInt64(3));
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
statement->statement()->ColumnInt64(4));
EXPECT_EQ(row1.visit_count(), statement->statement()->ColumnInt(5));
EXPECT_EQ(6, statement->favicon_index());
// No favicon.
EXPECT_EQ(0, statement->statement()->ColumnByteLength(6));
// TODO: Find a way to test the bookmark was added in BookmarkModel.
// The bookmark was added in UI thread, there is no good way to test it.
EXPECT_TRUE(statement->statement()->ColumnBool(7));
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(row2.title(), statement->statement()->ColumnString16(2));
EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(1)));
EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
statement->statement()->ColumnInt64(3));
EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
statement->statement()->ColumnInt64(4));
EXPECT_EQ(1, statement->statement()->ColumnInt(5));
EXPECT_EQ(6, statement->favicon_index());
// Has favicon.
EXPECT_NE(0, statement->statement()->ColumnByteLength(6));
// TODO: Find a way to test the bookmark was added in BookmarkModel.
// The bookmark was added in UI thread, there is no good way to test it.
EXPECT_FALSE(statement->statement()->ColumnBool(7));
// No more row.
EXPECT_FALSE(statement->statement()->Step());
}
TEST_F(<API key>, <API key>) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
ASSERT_TRUE(backend-><API key>(row1));
ASSERT_TRUE(backend-><API key>(row2));
// Verify the row1 has been added in bookmark model.
ui_test_utils::<API key>();
ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
ASSERT_TRUE(child);
EXPECT_EQ(row1.title(), child->GetTitle());
EXPECT_EQ(row1.url(), child->url());
// Delete the row1.
std::vector<string16> args;
int deleted_count = 0;
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>("Favicon IS NULL", args,
&deleted_count));
EXPECT_EQ(1, deleted_count);
// Verify the row1 was removed from bookmark model.
ui_test_utils::<API key>();
ASSERT_EQ(0, bookmark_model_->mobile_node()->child_count());
// Verify notifications
ASSERT_TRUE(delegate_.deleted_details());
EXPECT_FALSE(delegate_.modified_details());
EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
EXPECT_EQ(row1.url(), delegate_.deleted_details()->rows[0].url());
EXPECT_EQ(row1.last_visit_time(),
delegate_.deleted_details()->rows[0].last_visit());
EXPECT_EQ(row1.title(),
delegate_.deleted_details()->rows[0].title());
EXPECT_FALSE(delegate_.favicon_details());
std::vector<<API key>::ColumnID> projections;
projections.push_back(<API key>::ID);
projections.push_back(<API key>::URL);
projections.push_back(<API key>::TITLE);
projections.push_back(<API key>::CREATED);
projections.push_back(<API key>::LAST_VISIT_TIME);
projections.push_back(<API key>::VISIT_COUNT);
projections.push_back(<API key>::FAVICON);
projections.push_back(<API key>::BOOKMARK);
scoped_ptr<AndroidStatement> statement(backend-><API key>(
projections, std::string(), std::vector<string16>(),
std::string("url ASC")));
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(row2.title(), statement->statement()->ColumnString16(2));
EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(1)));
EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
statement->statement()->ColumnInt64(3));
EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
statement->statement()->ColumnInt64(4));
EXPECT_EQ(1, statement->statement()->ColumnInt(5));
EXPECT_EQ(6, statement->favicon_index());
// Has favicon.
EXPECT_NE(0, statement->statement()->ColumnByteLength(6));
// TODO: Find a way to test the bookmark was added in BookmarkModel.
// The bookmark was added in UI thread, there is no good way to test it.
EXPECT_FALSE(statement->statement()->ColumnBool(7));
// No more row.
EXPECT_FALSE(statement->statement()->Step());
deleted_count = 0;
// Delete row2.
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>("bookmark = 0",
std::vector<string16>(), &deleted_count));
// Verify notifications
ASSERT_TRUE(delegate_.deleted_details());
EXPECT_FALSE(delegate_.modified_details());
EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
EXPECT_EQ(row2.url(), delegate_.deleted_details()->rows[0].url());
EXPECT_EQ(row2.last_visit_time(),
delegate_.deleted_details()->rows[0].last_visit());
EXPECT_EQ(row2.title(),
delegate_.deleted_details()->rows[0].title());
ASSERT_TRUE(delegate_.favicon_details());
ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
delegate_.favicon_details()->urls.find(row2.url()));
ASSERT_EQ(1, deleted_count);
scoped_ptr<AndroidStatement> statement1(backend-><API key>(
projections, std::string(), std::vector<string16>(),
std::string("url ASC")));
ASSERT_FALSE(statement1->statement()->Step());
}
TEST_F(<API key>, <API key>) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
// The created time and last visit time are too close to have required visit
// count.
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::FromInternalValue(
row1.last_visit_time().ToInternalValue() - 1));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
EXPECT_FALSE(backend-><API key>(row1));
// Have different created time and last visit time, but only have 1 visit
// count.
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_created(Time::Now() - TimeDelta::FromDays(11));
row2.set_visit_count(1);
EXPECT_FALSE(backend-><API key>(row2));
// Have created time in the future.
<API key> row3;
row3.set_raw_url("http:
row3.set_url(GURL("http:
row3.set_created(Time::Now() + TimeDelta::FromDays(11));
EXPECT_FALSE(backend-><API key>(row3));
// Have last vist time in the future.
<API key> row4;
row4.set_raw_url("http:
row4.set_url(GURL("http:
row4.set_last_visit_time(Time::Now() + TimeDelta::FromDays(11));
EXPECT_FALSE(backend-><API key>(row4));
// Created time is larger than last visit time.
<API key> row5;
row5.set_raw_url("http:
row5.set_url(GURL("http:
row5.set_last_visit_time(Time::Now());
row5.set_created(Time::Now() + TimeDelta::FromDays(11));
EXPECT_FALSE(backend-><API key>(row5));
// Visit count is zero, and last visit time is not zero.
<API key> row6;
row6.set_raw_url("http:
row6.set_url(GURL("http:
row6.set_visit_count(0);
row6.set_last_visit_time(Time::Now());
row6.set_created(Time::Now() - TimeDelta::FromDays(1));
EXPECT_FALSE(backend-><API key>(row6));
// Visit count is zero, and create time is not zero.
<API key> row7;
row7.set_raw_url("http:
row7.set_url(GURL("http:
row7.set_visit_count(0);
row7.set_last_visit_time(Time::Now());
row7.set_created(Time::UnixEpoch());
EXPECT_TRUE(backend-><API key>(row7));
}
TEST_F(<API key>, UpdateURL) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
AndroidURLID id1 = backend-><API key>(row1);
ASSERT_TRUE(id1);
AndroidURLID id2 = backend-><API key>(row2);
ASSERT_TRUE(id2);
// Verify the row1 has been added in bookmark model.
ui_test_utils::<API key>();
ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
ASSERT_TRUE(child);
EXPECT_EQ(row1.title(), child->GetTitle());
EXPECT_EQ(row1.url(), child->url());
// Make sure the url has correctly insertted.
URLID url_id1 = history_db_.GetRowForURL(row1.url(), NULL);
ASSERT_TRUE(url_id1);
URLID url_id2 = history_db_.GetRowForURL(row2.url(), NULL);
ASSERT_TRUE(url_id2);
// Make sure we have the correct visit rows in visit table.
VisitVector visits;
ASSERT_TRUE(history_db_.GetVisitsForURL(url_id1, &visits));
ASSERT_EQ(10u, visits.size());
visits.clear();
ASSERT_TRUE(history_db_.GetVisitsForURL(url_id2, &visits));
ASSERT_EQ(1u, visits.size());
int update_count;
std::vector<string16> update_args;
// Try to update the mutiple rows with the same URL, this should failed.
<API key> update_row1;
update_row1.set_raw_url("newwebiste.com");
update_row1.set_url(GURL("http://newwebsite.com"));
update_args.clear();
ASSERT_FALSE(backend-><API key>(update_row1, std::string(),
update_args, &update_count));
// Only update one URL.
update_args.clear();
update_args.push_back(UTF8ToUTF16(row1.raw_url()));
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(update_row1, "url = ?",
update_args, &update_count));
// Verify notifications, Update involves insert and delete URLS.
ASSERT_TRUE(delegate_.deleted_details());
EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
EXPECT_EQ(row1.url(), delegate_.deleted_details()->rows[0].url());
EXPECT_EQ(row1.last_visit_time(),
delegate_.deleted_details()->rows[0].last_visit());
EXPECT_EQ(row1.title(),
delegate_.deleted_details()->rows[0].title());
ASSERT_TRUE(delegate_.modified_details());
ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
EXPECT_EQ(update_row1.url(),
delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
ToDatabaseTime(
delegate_.modified_details()->changed_urls[0].last_visit()));
EXPECT_EQ(row1.title(),
delegate_.modified_details()->changed_urls[0].title());
EXPECT_FALSE(delegate_.favicon_details());
EXPECT_EQ(1, update_count);
// We shouldn't find orignal url anymore.
EXPECT_FALSE(history_db_.GetRowForURL(row1.url(), NULL));
visits.clear();
EXPECT_TRUE(history_db_.GetVisitsForURL(url_id1, &visits));
EXPECT_EQ(0u, visits.size());
// Verify new URL.
URLRow new_row;
EXPECT_TRUE(history_db_.GetRowForURL(update_row1.url(), &new_row));
EXPECT_EQ(10, new_row.visit_count());
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
ToDatabaseTime(new_row.last_visit()));
visits.clear();
EXPECT_TRUE(history_db_.GetVisitsForURL(new_row.id(), &visits));
EXPECT_EQ(10u, visits.size());
AndroidURLRow android_url_row1;
ASSERT_TRUE(history_db_.GetAndroidURLRow(new_row.id(), &android_url_row1));
// Android URL ID shouldn't change.
EXPECT_EQ(id1, android_url_row1.id);
// Verify the bookmark model was updated.
ui_test_utils::<API key>();
ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
const BookmarkNode* child1 = bookmark_model_->mobile_node()->GetChild(0);
ASSERT_TRUE(child1);
EXPECT_EQ(row1.title(), child1->GetTitle());
EXPECT_EQ(update_row1.url(), child1->url());
// Update the URL with visit count, created time, and last visit time.
<API key> update_row2;
update_row2.set_raw_url("somethingelse.com");
update_row2.set_url(GURL("http://somethingelse.com"));
update_row2.set_last_visit_time(Time::Now());
update_row2.set_created(Time::Now() - TimeDelta::FromDays(20));
update_row2.set_visit_count(10);
update_args.clear();
update_args.push_back(UTF8ToUTF16(row2.raw_url()));
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(update_row2, "url = ?",
update_args, &update_count));
// Verify notifications, Update involves insert and delete URLS.
ASSERT_TRUE(delegate_.deleted_details());
EXPECT_EQ(1u, delegate_.deleted_details()->rows.size());
EXPECT_EQ(row2.url(), delegate_.deleted_details()->rows[0].url());
EXPECT_EQ(row2.last_visit_time(),
delegate_.deleted_details()->rows[0].last_visit());
EXPECT_EQ(row2.title(),
delegate_.deleted_details()->rows[0].title());
ASSERT_TRUE(delegate_.modified_details());
ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
EXPECT_EQ(update_row2.url(),
delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(ToDatabaseTime(update_row2.last_visit_time()),
ToDatabaseTime(
delegate_.modified_details()->changed_urls[0].last_visit()));
EXPECT_EQ(update_row2.visit_count(),
delegate_.modified_details()->changed_urls[0].visit_count());
ASSERT_TRUE(delegate_.favicon_details());
ASSERT_EQ(2u, delegate_.favicon_details()->urls.size());
ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
delegate_.favicon_details()->urls.find(row2.url()));
ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
delegate_.favicon_details()->urls.find(update_row2.url()));
EXPECT_EQ(1, update_count);
// We shouldn't find orignal url anymore.
EXPECT_FALSE(history_db_.GetRowForURL(row2.url(), NULL));
visits.clear();
EXPECT_TRUE(history_db_.GetVisitsForURL(url_id2, &visits));
EXPECT_EQ(0u, visits.size());
// Verify new URL.
URLRow new_row2;
ASSERT_TRUE(history_db_.GetRowForURL(update_row2.url(), &new_row2));
EXPECT_EQ(10, new_row2.visit_count());
EXPECT_EQ(update_row2.last_visit_time(), new_row2.last_visit());
visits.clear();
EXPECT_TRUE(history_db_.GetVisitsForURL(new_row2.id(), &visits));
EXPECT_EQ(10u, visits.size());
AndroidURLRow android_url_row2;
ASSERT_TRUE(history_db_.GetAndroidURLRow(new_row2.id(), &android_url_row2));
// Android URL ID shouldn't change.
EXPECT_EQ(id2, android_url_row2.id);
ASSERT_TRUE(history_db_.GetVisitsForURL(new_row2.id(), &visits));
ASSERT_EQ(10u, visits.size());
EXPECT_EQ(update_row2.created(), visits[0].visit_time);
EXPECT_EQ(update_row2.last_visit_time(), visits[9].visit_time);
}
TEST_F(<API key>, UpdateVisitCount) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
AndroidURLID id1 = backend-><API key>(row1);
ASSERT_TRUE(id1);
AndroidURLID id2 = backend-><API key>(row2);
ASSERT_TRUE(id2);
int update_count;
std::vector<string16> update_args;
// Update the visit_count to a value less than current one.
<API key> update_row1;
update_row1.set_visit_count(5);
update_args.push_back(UTF8ToUTF16(row1.raw_url()));
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(update_row1, "url = ?",
update_args, &update_count));
// Verify notifications, Update involves modified URL.
EXPECT_FALSE(delegate_.deleted_details());
ASSERT_TRUE(delegate_.modified_details());
ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
EXPECT_EQ(row1.url(),
delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
ToDatabaseTime(
delegate_.modified_details()->changed_urls[0].last_visit()));
EXPECT_EQ(update_row1.visit_count(),
delegate_.modified_details()->changed_urls[0].visit_count());
EXPECT_FALSE(delegate_.favicon_details());
// All visits should be removed, and 5 new visit insertted.
URLRow new_row1;
ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), &new_row1));
EXPECT_EQ(5, new_row1.visit_count());
VisitVector visits;
ASSERT_TRUE(history_db_.GetVisitsForURL(new_row1.id(), &visits));
ASSERT_EQ(5u, visits.size());
EXPECT_EQ(row1.last_visit_time(), visits[4].visit_time);
EXPECT_GT(row1.last_visit_time(), visits[0].visit_time);
// Update the visit_count to a value equal to current one.
<API key> update_row2;
update_row2.set_visit_count(1);
update_args.clear();
update_args.push_back(UTF8ToUTF16(row2.raw_url()));
ASSERT_TRUE(backend-><API key>(update_row2, "url = ?",
update_args, &update_count));
// All shouldn't have any change.
URLRow new_row2;
ASSERT_TRUE(history_db_.GetRowForURL(row2.url(), &new_row2));
EXPECT_EQ(1, new_row2.visit_count());
ASSERT_TRUE(history_db_.GetVisitsForURL(new_row2.id(), &visits));
ASSERT_EQ(1u, visits.size());
EXPECT_EQ(row2.last_visit_time(), visits[0].visit_time);
}
TEST_F(<API key>, UpdateLastVisitTime) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
AndroidURLID id1 = backend-><API key>(row1);
ASSERT_TRUE(id1);
AndroidURLID id2 = backend-><API key>(row2);
ASSERT_TRUE(id2);
int update_count;
std::vector<string16> update_args;
// Update the last visit time to a value greater than current one.
<API key> update_row1;
update_row1.set_last_visit_time(Time::Now());
update_args.push_back(UTF8ToUTF16(row1.raw_url()));
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(update_row1, "url = ?",
update_args, &update_count));
// Verify notifications, Update involves modified URL.
EXPECT_FALSE(delegate_.deleted_details());
ASSERT_TRUE(delegate_.modified_details());
ASSERT_EQ(1u, delegate_.modified_details()->changed_urls.size());
EXPECT_EQ(row1.url(),
delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(ToDatabaseTime(update_row1.last_visit_time()),
ToDatabaseTime(
delegate_.modified_details()->changed_urls[0].last_visit()));
EXPECT_FALSE(delegate_.favicon_details());
URLRow new_row1;
ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), &new_row1));
EXPECT_EQ(11, new_row1.visit_count());
EXPECT_EQ(update_row1.last_visit_time(), new_row1.last_visit());
VisitVector visits;
ASSERT_TRUE(history_db_.GetVisitsForURL(new_row1.id(), &visits));
// 1 new visit insertted.
ASSERT_EQ(11u, visits.size());
EXPECT_EQ(update_row1.last_visit_time(), visits[10].visit_time);
EXPECT_EQ(row1.last_visit_time(), visits[9].visit_time);
// Update the visit_tim to a value less than to current one.
<API key> update_row2;
update_row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
update_args.clear();
update_args.push_back(UTF8ToUTF16(row1.raw_url()));
ASSERT_FALSE(backend-><API key>(update_row2, "url = ?",
update_args, &update_count));
}
TEST_F(<API key>, UpdateFavicon) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
AndroidURLID id1 = backend-><API key>(row1);
ASSERT_TRUE(id1);
int update_count;
std::vector<string16> update_args;
// Update the last visit time to a value greater than current one.
<API key> update_row1;
// Set favicon.
std::vector<unsigned char> data;
data.push_back('1');
update_row1.set_favicon(data);
update_args.push_back(UTF8ToUTF16(row1.raw_url()));
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(update_row1, "url = ?",
update_args, &update_count));
// Verify notifications.
EXPECT_FALSE(delegate_.deleted_details());
EXPECT_FALSE(delegate_.modified_details());
ASSERT_TRUE(delegate_.favicon_details());
ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
delegate_.favicon_details()->urls.find(row1.url()));
IconMapping icon_mapping;
EXPECT_TRUE(thumbnail_db_.<API key>(row1.url(), FAVICON,
&icon_mapping));
Time last_updated;
std::vector<unsigned char> png_icon_data;
EXPECT_TRUE(thumbnail_db_.GetFavicon(icon_mapping.icon_id, &last_updated,
&png_icon_data, NULL, NULL));
EXPECT_EQ(data, png_icon_data);
// Remove favicon.
<API key> update_row2;
// Set favicon.
update_row1.set_favicon(std::vector<unsigned char>());
update_args.clear();
update_args.push_back(UTF8ToUTF16(row1.raw_url()));
delegate_.ResetDetails();
ASSERT_TRUE(backend-><API key>(update_row1, "url = ?",
update_args, &update_count));
// Verify notifications.
EXPECT_FALSE(delegate_.deleted_details());
EXPECT_FALSE(delegate_.modified_details());
ASSERT_TRUE(delegate_.favicon_details());
ASSERT_EQ(1u, delegate_.favicon_details()->urls.size());
ASSERT_TRUE(delegate_.favicon_details()->urls.end() !=
delegate_.favicon_details()->urls.find(row1.url()));
EXPECT_FALSE(thumbnail_db_.<API key>(row1.url(), FAVICON,
NULL));
}
TEST_F(<API key>, <API key>) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
// Insert a keyword search item to verify if the update succeeds.
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_title(UTF8ToUTF16("cnn"));
ASSERT_TRUE(backend-><API key>(row1));
string16 term = UTF8ToUTF16("Search term 1");
URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
ASSERT_TRUE(url_id);
ASSERT_TRUE(history_db_.<API key>(url_id, 1, term));
ASSERT_TRUE(backend-><API key>());
SearchTermRow keyword_cache;
SearchTermID id = history_db_.GetSearchTerm(term, &keyword_cache);
ASSERT_TRUE(id);
EXPECT_EQ(term, keyword_cache.term);
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
ToDatabaseTime(keyword_cache.last_visit_time));
// Add another row.
<API key> row2;
row2.set_raw_url("google.com");
row2.set_url(GURL("http://google.com"));
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(2));
row2.set_title(UTF8ToUTF16("cnn"));
ASSERT_TRUE(backend-><API key>(row2));
url_id = history_db_.GetRowForURL(row2.url(), NULL);
ASSERT_TRUE(url_id);
string16 term2 = UTF8ToUTF16("Search term 2");
ASSERT_TRUE(history_db_.<API key>(url_id, 1, term2));
ASSERT_TRUE(backend-><API key>());
SearchTermID search_id1 = history_db_.GetSearchTerm(term,
&keyword_cache);
// The id shouldn't changed.
ASSERT_EQ(id, search_id1);
EXPECT_EQ(term, keyword_cache.term);
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
ToDatabaseTime(keyword_cache.last_visit_time));
// Verify the row just inserted.
SearchTermID id2 = history_db_.GetSearchTerm(term2, &keyword_cache);
ASSERT_TRUE(id2);
EXPECT_EQ(term2, keyword_cache.term);
EXPECT_EQ(ToDatabaseTime(row2.last_visit_time()),
ToDatabaseTime(keyword_cache.last_visit_time));
// Add 3rd row and associate it with term.
<API key> row3;
row3.set_raw_url("search.com");
row3.set_url(GURL("http://search.com"));
row3.set_last_visit_time(Time::Now());
row3.set_title(UTF8ToUTF16("search"));
ASSERT_TRUE(backend-><API key>(row3));
url_id = history_db_.GetRowForURL(row3.url(), NULL);
ASSERT_TRUE(url_id);
ASSERT_TRUE(history_db_.<API key>(url_id, 1, term));
ASSERT_TRUE(backend-><API key>());
// Verify id not changed and last_visit_time updated.
ASSERT_EQ(search_id1, history_db_.GetSearchTerm(term, &keyword_cache));
EXPECT_EQ(ToDatabaseTime(row3.last_visit_time()),
ToDatabaseTime(keyword_cache.last_visit_time));
// The id of term2 wasn't changed.
EXPECT_EQ(id2, history_db_.GetSearchTerm(term2, NULL));
// Remove the term.
ASSERT_TRUE(history_db_.<API key>(term));
ASSERT_TRUE(backend-><API key>());
// The cache of term should removed.
ASSERT_FALSE(history_db_.GetSearchTerm(term, NULL));
// The id of term2 wasn't changed.
EXPECT_EQ(id2, history_db_.GetSearchTerm(term2, NULL));
}
TEST_F(<API key>, QuerySearchTerms) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
// Insert a keyword search item to verify if we can find it.
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_title(UTF8ToUTF16("cnn"));
ASSERT_TRUE(backend-><API key>(row1));
string16 term = UTF8ToUTF16("Search term 1");
URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
ASSERT_TRUE(url_id);
ASSERT_TRUE(history_db_.<API key>(url_id, 1, term));
std::vector<SearchRow::ColumnID> projections;
projections.push_back(SearchRow::ID);
projections.push_back(SearchRow::SEARCH_TERM);
projections.push_back(SearchRow::SEARCH_TIME);
scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
projections, std::string(), std::vector<string16>(), std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
EXPECT_TRUE(statement->statement()->ColumnInt64(0));
EXPECT_EQ(term, statement->statement()->ColumnString16(1));
EXPECT_EQ(ToDatabaseTime(row1.last_visit_time()),
statement->statement()->ColumnInt64(2));
EXPECT_FALSE(statement->statement()->Step());
}
TEST_F(<API key>, UpdateSearchTerms) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
// Insert a keyword.
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_title(UTF8ToUTF16("cnn"));
ASSERT_TRUE(backend-><API key>(row1));
string16 term = UTF8ToUTF16("Search term 1");
URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
ASSERT_TRUE(url_id);
ASSERT_TRUE(history_db_.<API key>(url_id, 1, term));
// Get the SearchTermID of the row we just inserted.
std::vector<SearchRow::ColumnID> projections;
projections.push_back(SearchRow::ID);
projections.push_back(SearchRow::SEARCH_TIME);
projections.push_back(SearchRow::SEARCH_TERM);
std::vector<string16> args;
args.push_back(term);
scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
projections, "search = ?", args, std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
SearchTermID id = statement->statement()->ColumnInt64(0);
ASSERT_TRUE(id);
EXPECT_FALSE(statement->statement()->Step());
// Update the search term and time.
string16 update_term = UTF8ToUTF16("Update search term");
args.clear();
args.push_back(term);
SearchRow search_row;
search_row.set_search_term(update_term);
search_row.set_url(GURL("http://google.com"));
search_row.set_template_url_id(1);
search_row.set_search_time(Time::Now() - TimeDelta::FromHours(1));
int update_count = 0;
ASSERT_TRUE(backend->UpdateSearchTerms(search_row, "search = ?", args,
&update_count));
EXPECT_EQ(1, update_count);
// Verify if the search term updated.
// The origin term should be removed.
std::vector<<API key>> rows;
ASSERT_TRUE(history_db_.<API key>(term, &rows));
EXPECT_TRUE(rows.empty());
// The new term should be inserted.
ASSERT_TRUE(history_db_.<API key>(update_term, &rows));
ASSERT_EQ(1u, rows.size());
// The history of urls shouldn't be removed.
ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), NULL));
// The new URL is inserted.
ASSERT_TRUE(history_db_.GetRowForURL(search_row.url(), NULL));
// Verfiy the AndoridSearchID isn't changed.
args.clear();
args.push_back(update_term);
statement.reset(backend->QuerySearchTerms(projections, "search = ?", args,
std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
// The id didn't change.
EXPECT_EQ(id, statement->statement()->ColumnInt64(0));
// The search time was updated.
EXPECT_EQ(ToDatabaseTime(search_row.search_time()),
statement->statement()->ColumnInt64(1));
// The search term was updated.
EXPECT_EQ(update_term, statement->statement()->ColumnString16(2));
EXPECT_FALSE(statement->statement()->Step());
// Only update the search time.
SearchRow update_time;
update_time.set_search_time(Time::Now());
// Update it by id.
args.clear();
std::ostringstream oss;
oss << id;
args.push_back(UTF8ToUTF16(oss.str()));
update_count = 0;
ASSERT_TRUE(backend->UpdateSearchTerms(update_time, "_id = ?", args,
&update_count));
EXPECT_EQ(1, update_count);
// Verify the update.
statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
// The id didn't change.
EXPECT_EQ(id, statement->statement()->ColumnInt64(0));
// The search time was updated.
EXPECT_EQ(ToDatabaseTime(update_time.search_time()),
statement->statement()->ColumnInt64(1));
// The search term didn't change.
EXPECT_EQ(update_term, statement->statement()->ColumnString16(2));
EXPECT_FALSE(statement->statement()->Step());
}
TEST_F(<API key>, DeleteSearchTerms) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
// Insert a keyword.
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_title(UTF8ToUTF16("cnn"));
ASSERT_TRUE(backend-><API key>(row1));
string16 term = UTF8ToUTF16("Search term 1");
URLID url_id = history_db_.GetRowForURL(row1.url(), NULL);
ASSERT_TRUE(url_id);
ASSERT_TRUE(history_db_.<API key>(url_id, 1, term));
// Get the SearchTermID of the row we just inserted.
std::vector<SearchRow::ColumnID> projections;
projections.push_back(SearchRow::ID);
projections.push_back(SearchRow::SEARCH_TIME);
projections.push_back(SearchRow::SEARCH_TERM);
std::vector<string16> args;
args.push_back(term);
scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
projections, "search = ?", args, std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
SearchTermID id1 = statement->statement()->ColumnInt64(0);
ASSERT_TRUE(id1);
EXPECT_FALSE(statement->statement()->Step());
// Insert a keyword.
<API key> row2;
row2.set_raw_url("google.com");
row2.set_url(GURL("http://google.com"));
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row2.set_title(UTF8ToUTF16("google"));
ASSERT_TRUE(backend-><API key>(row2));
string16 term2 = UTF8ToUTF16("Search term 2");
URLID url_id2 = history_db_.GetRowForURL(row2.url(), NULL);
ASSERT_TRUE(url_id2);
ASSERT_TRUE(history_db_.<API key>(url_id2, 1, term2));
// Get the SearchTermID of the row we just inserted.
projections.clear();
projections.push_back(SearchRow::ID);
projections.push_back(SearchRow::SEARCH_TIME);
projections.push_back(SearchRow::SEARCH_TERM);
args.clear();
args.push_back(term2);
statement.reset(backend->QuerySearchTerms(projections, "search = ?", args,
std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
SearchTermID id2 = statement->statement()->ColumnInt64(0);
ASSERT_TRUE(id2);
EXPECT_FALSE(statement->statement()->Step());
// Delete the first one.
args.clear();
args.push_back(term);
int deleted_count = 0;
ASSERT_TRUE(backend->DeleteSearchTerms("search = ?", args, &deleted_count));
EXPECT_EQ(1, deleted_count);
std::vector<<API key>> rows;
ASSERT_TRUE(history_db_.<API key>(term, &rows));
EXPECT_TRUE(rows.empty());
// Verify we can't get the first term.
args.clear();
std::ostringstream oss;
oss << id1;
args.push_back(UTF8ToUTF16(oss.str()));
statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
std::string()));
ASSERT_TRUE(statement.get());
EXPECT_FALSE(statement->statement()->Step());
// The second one is still there.
args.clear();
std::ostringstream oss1;
oss1 << id2;
args.push_back(UTF8ToUTF16(oss1.str()));
statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
std::string()));
ASSERT_TRUE(statement.get());
EXPECT_TRUE(statement->statement()->Step());
EXPECT_EQ(id2, statement->statement()->ColumnInt64(0));
EXPECT_FALSE(statement->statement()->Step());
// Remove all search terms in no condition.
deleted_count = 0;
args.clear();
ASSERT_TRUE(backend->DeleteSearchTerms(std::string(), args, &deleted_count));
EXPECT_EQ(1, deleted_count);
// Verify the second one was removed.
args.clear();
args.push_back(UTF8ToUTF16(oss1.str()));
statement.reset(backend->QuerySearchTerms(projections, "_id = ?", args,
std::string()));
ASSERT_TRUE(statement.get());
EXPECT_FALSE(statement->statement()->Step());
}
TEST_F(<API key>, InsertSearchTerm) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
SearchRow search_row;
search_row.set_search_term(UTF8ToUTF16("google"));
search_row.set_url(GURL("http://google.com"));
search_row.set_template_url_id(1);
search_row.set_search_time(Time::Now() - TimeDelta::FromHours(1));
SearchTermID id = backend->InsertSearchTerm(search_row);
ASSERT_TRUE(id);
std::vector<SearchRow::ColumnID> projections;
projections.push_back(SearchRow::ID);
projections.push_back(SearchRow::SEARCH_TIME);
projections.push_back(SearchRow::SEARCH_TERM);
std::vector<string16> args;
std::ostringstream oss;
oss << id;
args.push_back(UTF8ToUTF16(oss.str()));
scoped_ptr<AndroidStatement> statement(backend->QuerySearchTerms(
projections, "_id = ?", args, std::string()));
ASSERT_TRUE(statement.get());
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(id, statement->statement()->ColumnInt64(0));
EXPECT_EQ(ToDatabaseTime(search_row.search_time()),
statement->statement()->ColumnInt64(1));
EXPECT_EQ(search_row.search_term(),
statement->statement()->ColumnString16(2));
EXPECT_FALSE(statement->statement()->Step());
}
TEST_F(<API key>, DeleteHistory) {
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
AndroidURLID id1 = backend-><API key>(row1);
ASSERT_TRUE(id1);
AndroidURLID id2 = backend-><API key>(row2);
ASSERT_TRUE(id2);
// Verify the row1 has been added in bookmark model.
ui_test_utils::<API key>();
ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
const BookmarkNode* child = bookmark_model_->mobile_node()->GetChild(0);
ASSERT_TRUE(child);
EXPECT_EQ(row1.title(), child->GetTitle());
EXPECT_EQ(row1.url(), child->url());
// Delete history
int deleted_count = 0;
ASSERT_TRUE(backend->DeleteHistory(std::string(), std::vector<string16>(),
&deleted_count));
EXPECT_EQ(2, deleted_count);
// The row2 was deleted.
EXPECT_FALSE(history_db_.GetRowForURL(row2.url(), NULL));
// Still find the row1.
URLRow url_row;
ASSERT_TRUE(history_db_.GetRowForURL(row1.url(), &url_row));
// The visit_count was reset.
EXPECT_EQ(0, url_row.visit_count());
EXPECT_EQ(Time::UnixEpoch(), url_row.last_visit());
// Verify the row1 is still in bookmark model.
ui_test_utils::<API key>();
ASSERT_EQ(1, bookmark_model_->mobile_node()->child_count());
const BookmarkNode* child1 = bookmark_model_->mobile_node()->GetChild(0);
ASSERT_TRUE(child1);
EXPECT_EQ(row1.title(), child1->GetTitle());
EXPECT_EQ(row1.url(), child1->url());
// Verify notification
ASSERT_TRUE(delegate_.deleted_details());
ASSERT_EQ(2u, delegate_.deleted_details()->rows.size());
EXPECT_EQ(row1.url(),
delegate_.modified_details()->changed_urls[0].url());
EXPECT_EQ(Time::UnixEpoch(),
delegate_.modified_details()->changed_urls[0].last_visit());
EXPECT_EQ(1u, delegate_.favicon_details()->urls.size());
}
TEST_F(<API key>, <API key>) {
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
// Create the nested transactions.
history_db_.BeginTransaction();
history_db_.BeginTransaction();
history_db_.BeginTransaction();
thumbnail_db_.BeginTransaction();
thumbnail_db_.BeginTransaction();
int history_transaction = history_db_.transaction_nesting();
int <API key> = thumbnail_db_.transaction_nesting();
// Insert a row to verify the transaction number are not changed
// after a transaction commit.
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_title(UTF8ToUTF16("cnn"));
ASSERT_TRUE(backend-><API key>(row1));
EXPECT_EQ(history_transaction, history_db_.transaction_nesting());
EXPECT_EQ(<API key>, thumbnail_db_.transaction_nesting());
// Insert the same URL, it should failed. The transaction are still same
// after a rollback.
ASSERT_FALSE(backend-><API key>(row1));
EXPECT_EQ(history_transaction, history_db_.transaction_nesting());
EXPECT_EQ(<API key>, thumbnail_db_.transaction_nesting());
// Insert another row to verify we are still fine after the previous
// rollback.
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
ASSERT_TRUE(backend-><API key>(row2));
EXPECT_EQ(history_transaction, history_db_.transaction_nesting());
EXPECT_EQ(<API key>, thumbnail_db_.transaction_nesting());
}
TEST_F(<API key>, <API key>) {
// This is to verify the last visit time and created time are same when visit
// count is 0.
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
URLRow url_row(GURL("http:
url_row.set_last_visit(Time::Now());
url_row.set_visit_count(0);
history_db_.AddURL(url_row);
std::vector<<API key>::ColumnID> projections;
projections.push_back(<API key>::ID);
projections.push_back(<API key>::URL);
projections.push_back(<API key>::TITLE);
projections.push_back(<API key>::CREATED);
projections.push_back(<API key>::LAST_VISIT_TIME);
projections.push_back(<API key>::VISIT_COUNT);
projections.push_back(<API key>::FAVICON);
projections.push_back(<API key>::BOOKMARK);
scoped_ptr<AndroidStatement> statement(backend-><API key>(
projections, std::string(), std::vector<string16>(),
std::string("url ASC")));
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(ToDatabaseTime(url_row.last_visit()),
statement->statement()->ColumnInt64(3));
EXPECT_EQ(ToDatabaseTime(url_row.last_visit()),
statement->statement()->ColumnInt64(4));
EXPECT_EQ(url_row.visit_count(), statement->statement()->ColumnInt(5));
}
TEST_F(<API key>, <API key>) {
// This is test is used to verify the 'folder' column exists, all bookmarks
// returned when folder is 0 and the non bookmark rows returned when folder
// is 1.
ASSERT_EQ(sql::INIT_OK, history_db_.Init(history_db_name_, bookmark_temp_));
ASSERT_EQ(sql::INIT_OK, thumbnail_db_.Init(thumbnail_db_name_, NULL,
&history_db_));
scoped_ptr<<API key>> backend(
new <API key>(<API key>, &history_db_,
&thumbnail_db_, bookmark_model_, &delegate_));
<API key> row1;
row1.set_raw_url("cnn.com");
row1.set_url(GURL("http://cnn.com"));
row1.set_last_visit_time(Time::Now() - TimeDelta::FromDays(1));
row1.set_created(Time::Now() - TimeDelta::FromDays(20));
row1.set_visit_count(10);
row1.set_is_bookmark(true);
row1.set_title(UTF8ToUTF16("cnn"));
<API key> row2;
row2.set_raw_url("http:
row2.set_url(GURL("http:
row2.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
row2.set_is_bookmark(false);
row2.set_title(UTF8ToUTF16("example"));
std::vector<unsigned char> data;
data.push_back('1');
row2.set_favicon(data);
AndroidURLID id1 = backend-><API key>(row1);
ASSERT_TRUE(id1);
AndroidURLID id2 = backend-><API key>(row2);
ASSERT_TRUE(id2);
ui_test_utils::<API key>();
// Query by folder=0, the row1 should returned.
std::vector<<API key>::ColumnID> projections;
projections.push_back(<API key>::URL);
scoped_ptr<AndroidStatement> statement(backend-><API key>(
projections, std::string("folder=0"), std::vector<string16>(),
std::string("url ASC")));
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(row1.raw_url(), statement->statement()->ColumnString(0));
EXPECT_FALSE(statement->statement()->Step());
// Query by folder=1, the row2 should returned.
statement.reset(backend-><API key>(
projections, std::string("folder=1"), std::vector<string16>(),
std::string("url ASC")));
ASSERT_TRUE(statement->statement()->Step());
EXPECT_EQ(row2.url(), GURL(statement->statement()->ColumnString(0)));
EXPECT_FALSE(statement->statement()->Step());
}
} // namespace history |
#!/usr/bin/env python
"""Runs all the buildbot steps for ChromeDriver except for update/compile."""
import bisect
import csv
import datetime
import glob
import json
import optparse
import os
import platform as platform_module
import re
import shutil
import StringIO
import sys
import tempfile
import time
import urllib2
_THIS_DIR = os.path.abspath(os.path.dirname(__file__))
<API key> = 'gs://chromedriver'
<API key> = 'gs://chromedriver-data'
<API key> = 'http://chromedriver.storage.googleapis.com'
GS_CONTINUOUS_URL = <API key> + '/continuous'
GS_PREBUILTS_URL = <API key> + '/prebuilts'
GS_SERVER_LOGS_URL = <API key> + '/server_logs'
SERVER_LOGS_LINK = (
'http://chromedriver-data.storage.googleapis.com/server_logs')
TEST_LOG_FORMAT = '%s_log.json'
GS_GIT_LOG_URL = (
'https://chromium.googlesource.com/chromium/src/+/%s?format=json')
GS_SEARCH_PATTERN = (
r'Cr-Commit-Position: refs/heads/master@{
CR_REV_URL = 'https://cr-rev.appspot.com/_ah/api/crrev/v1/redirect/%s'
SCRIPT_DIR = os.path.join(_THIS_DIR, os.pardir, os.pardir, os.pardir, os.pardir,
os.pardir, os.pardir, os.pardir, 'scripts')
SITE_CONFIG_DIR = os.path.join(_THIS_DIR, os.pardir, os.pardir, os.pardir,
os.pardir, os.pardir, os.pardir, os.pardir,
'site_config')
sys.path.append(SCRIPT_DIR)
sys.path.append(SITE_CONFIG_DIR)
import archive
import chrome_paths
from slave import gsutil_download
from slave import slave_utils
import util
def _ArchivePrebuilts(commit_position):
"""Uploads the prebuilts to google storage."""
util.MarkBuildStepStart('archive prebuilts')
zip_path = util.Zip(os.path.join(chrome_paths.GetBuildDir(['chromedriver']),
'chromedriver'))
if slave_utils.GSUtilCopy(
zip_path,
'%s/%s' % (GS_PREBUILTS_URL, 'r%s.zip' % commit_position)):
util.MarkBuildStepError()
def _ArchiveServerLogs():
"""Uploads chromedriver server logs to google storage."""
util.MarkBuildStepStart('archive chromedriver server logs')
for server_log in glob.glob(os.path.join(tempfile.gettempdir(),
'chromedriver_*')):
base_name = os.path.basename(server_log)
util.AddLink(base_name, '%s/%s' % (SERVER_LOGS_LINK, base_name))
slave_utils.GSUtilCopy(
server_log,
'%s/%s' % (GS_SERVER_LOGS_URL, base_name),
mimetype='text/plain')
def _DownloadPrebuilts():
"""Downloads the most recent prebuilts from google storage."""
util.MarkBuildStepStart('Download latest chromedriver')
zip_path = os.path.join(util.MakeTempDir(), 'build.zip')
if gsutil_download.DownloadLatestFile(GS_PREBUILTS_URL,
GS_PREBUILTS_URL + '/r',
zip_path):
util.MarkBuildStepError()
util.Unzip(zip_path, chrome_paths.GetBuildDir(['host_forwarder']))
def _GetTestResultsLog(platform):
"""Gets the test results log for the given platform.
Args:
platform: The platform that the test results log is for.
Returns:
A dictionary where the keys are commit positions and the values are booleans
indicating whether the tests passed.
"""
temp_log = tempfile.mkstemp()[1]
log_name = TEST_LOG_FORMAT % platform
result = slave_utils.GSUtilDownloadFile(
'%s/%s' % (<API key>, log_name), temp_log)
if result:
return {}
with open(temp_log, 'rb') as log_file:
json_dict = json.load(log_file)
# Workaround for json encoding dictionary keys as strings.
return dict([(int(v[0]), v[1]) for v in json_dict.items()])
def _PutTestResultsLog(platform, test_results_log):
"""Pushes the given test results log to google storage."""
temp_dir = util.MakeTempDir()
log_name = TEST_LOG_FORMAT % platform
log_path = os.path.join(temp_dir, log_name)
with open(log_path, 'wb') as log_file:
json.dump(test_results_log, log_file)
if slave_utils.GSUtilCopyFile(log_path, <API key>):
raise Exception('Failed to upload test results log to google storage')
def <API key>(platform, commit_position, passed):
"""Updates the test results log for the given platform.
Args:
platform: The platform name.
commit_position: The commit position number.
passed: Boolean indicating whether the tests passed at this commit position.
"""
assert commit_position.isdigit(), 'The commit position must be a number'
commit_position = int(commit_position)
log = _GetTestResultsLog(platform)
if len(log) > 500:
del log[min(log.keys())]
assert commit_position not in log, \
'Results already exist for commit position %s' % commit_position
log[commit_position] = bool(passed)
_PutTestResultsLog(platform, log)
def _GetVersion():
"""Get the current chromedriver version."""
with open(os.path.join(_THIS_DIR, 'VERSION'), 'r') as f:
return f.read().strip()
def <API key>():
"""Get the minimum and maximum supported Chrome versions.
Returns:
A tuple of the form (min_version, max_version).
"""
# Minimum supported Chrome version is embedded as:
# const int <API key>[] = {27, 0, 1453, 0};
with open(os.path.join(_THIS_DIR, 'chrome', 'version.cc'), 'r') as f:
lines = f.readlines()
<API key> = [
x for x in lines if '<API key>' in x]
chrome_min_version = <API key>[0].split('{')[1].split(',')[0]
with open(os.path.join(chrome_paths.GetSrc(), 'chrome', 'VERSION'), 'r') as f:
chrome_max_version = f.readlines()[0].split('=')[1].strip()
return (chrome_min_version, chrome_max_version)
def <API key>(test_results_log, commit_position):
"""Check the state of tests at a given commit position.
Considers tests as having passed at a commit position if they passed at
revisons both before and after.
Args:
test_results_log: A test results log dictionary from _GetTestResultsLog().
commit_position: The commit position to check at.
Returns:
'passed', 'failed', or 'unknown'
"""
assert isinstance(commit_position, int), 'The commit position must be an int'
keys = sorted(test_results_log.keys())
# Return passed if the exact commit position passed on Android.
if commit_position in test_results_log:
return 'passed' if test_results_log[commit_position] else 'failed'
# Tests were not run on this exact commit position on Android.
index = bisect.bisect_right(keys, commit_position)
# Tests have not yet run on Android at or above this commit position.
if index == len(test_results_log):
return 'unknown'
# No log exists for any prior commit position, assume it failed.
if index == 0:
return 'failed'
# Return passed if the commit position on both sides passed.
if test_results_log[keys[index]] and test_results_log[keys[index - 1]]:
return 'passed'
return 'failed'
def _ArchiveGoodBuild(platform, commit_position):
"""Archive chromedriver binary if the build is green."""
assert platform != 'android'
util.MarkBuildStepStart('archive build')
server_name = 'chromedriver'
if util.IsWindows():
server_name += '.exe'
zip_path = util.Zip(os.path.join(chrome_paths.GetBuildDir([server_name]),
server_name))
build_name = 'chromedriver_%s_%s.%s.zip' % (
platform, _GetVersion(), commit_position)
build_url = '%s/%s' % (GS_CONTINUOUS_URL, build_name)
if slave_utils.GSUtilCopy(zip_path, build_url):
util.MarkBuildStepError()
(latest_fd, latest_file) = tempfile.mkstemp()
os.write(latest_fd, build_name)
os.close(latest_fd)
latest_url = '%s/latest_%s' % (GS_CONTINUOUS_URL, platform)
if slave_utils.GSUtilCopy(latest_file, latest_url, mimetype='text/plain'):
util.MarkBuildStepError()
os.remove(latest_file)
def _WasReleased(version, platform):
"""Check if the specified version is released for the given platform."""
result, _ = slave_utils.GSUtilListBucket(
'%s/%s/chromedriver_%s.zip' % (<API key>, version, platform),
[])
return result == 0
def _MaybeRelease(platform):
"""Releases a release candidate if conditions are right."""
assert platform != 'android'
version = _GetVersion()
# Check if the current version has already been released.
if _WasReleased(version, platform):
return
# Fetch Android test results.
<API key> = _GetTestResultsLog('android')
# Fetch release candidates.
result, output = slave_utils.GSUtilListBucket(
'%s/chromedriver_%s_%s*' % (
GS_CONTINUOUS_URL, platform, version),
[])
assert result == 0 and output, 'No release candidates found'
candidate_pattern = re.compile(
r'.*/chromedriver_%s_%s\.(\d+)\.zip$' % (platform, version))
candidates = []
for line in output.strip().split('\n'):
result = candidate_pattern.match(line)
if not result:
print 'Ignored line "%s"' % line
continue
candidates.append(int(result.group(1)))
# Release the latest candidate build that passed Android, if any.
# In this way, if a hot fix is needed, we can delete the release from
# the chromedriver bucket instead of bumping up the release version number.
candidates.sort(reverse=True)
for commit_position in candidates:
android_result = <API key>(<API key>, commit_position)
if android_result == 'failed':
print 'Android tests did not pass at commit position', commit_position
elif android_result == 'passed':
print 'Android tests passed at commit position', commit_position
candidate = 'chromedriver_%s_%s.%s.zip' % (
platform, version, commit_position)
_Release('%s/%s' % (GS_CONTINUOUS_URL, candidate), version, platform)
break
else:
print 'Android tests have not run at a commit position as recent as', \
commit_position
def _Release(build, version, platform):
"""Releases the given candidate build."""
release_name = 'chromedriver_%s.zip' % platform
util.MarkBuildStepStart('releasing %s' % release_name)
temp_dir = util.MakeTempDir()
slave_utils.GSUtilCopy(build, temp_dir)
zip_path = os.path.join(temp_dir, os.path.basename(build))
if util.IsLinux():
util.Unzip(zip_path, temp_dir)
server_path = os.path.join(temp_dir, 'chromedriver')
util.RunCommand(['strip', server_path])
zip_path = util.Zip(server_path)
slave_utils.GSUtilCopy(
zip_path, '%s/%s/%s' % (<API key>, version, release_name))
<API key>(version)
<API key>(version)
def _GetWebPageContent(url):
"""Return the content of the web page specified by the given url."""
return urllib2.urlopen(url).read()
def <API key>(version):
"""Upload release notes if conditions are right."""
# Check if the current version has already been released.
notes_name = 'notes.txt'
notes_url = '%s/%s/%s' % (<API key>, version, notes_name)
prev_version = '.'.join([version.split('.')[0],
str(int(version.split('.')[1]) - 1)])
prev_notes_url = '%s/%s/%s' % (
<API key>, prev_version, notes_name)
result, _ = slave_utils.GSUtilListBucket(notes_url, [])
if result == 0:
return
fixed_issues = []
query = ('https://code.google.com/p/chromedriver/issues/csv?'
'can=1&q=label%%3AChromeDriver-%s&colspec=ID%%20Summary' % version)
issues = StringIO.StringIO(_GetWebPageContent(query).split('\n', 1)[1])
for issue in csv.reader(issues):
if not issue:
continue
issue_id = issue[0]
desc = issue[1]
labels = issue[2]
labels.remove('ChromeDriver-%s' % version)
fixed_issues += ['Resolved issue %s: %s [%s]' % (issue_id, desc, labels)]
old_notes = ''
temp_notes_fname = tempfile.mkstemp()[1]
if not slave_utils.GSUtilDownloadFile(prev_notes_url, temp_notes_fname):
with open(temp_notes_fname, 'rb') as f:
old_notes = f.read()
new_notes = '
version, datetime.date.today().isoformat(),
'Supports Chrome v%s-%s' % <API key>(),
'\n'.join(fixed_issues),
old_notes)
with open(temp_notes_fname, 'w') as f:
f.write(new_notes)
if slave_utils.GSUtilCopy(temp_notes_fname, notes_url, mimetype='text/plain'):
util.MarkBuildStepError()
def <API key>(version):
"""Update the file LATEST_RELEASE with the latest release version number."""
<API key> = 'LATEST_RELEASE'
latest_release_url = '%s/%s' % (<API key>, <API key>)
# Check if LATEST_RELEASE is up-to-date.
<API key> = _GetWebPageContent(
'%s/%s' % (<API key>, <API key>))
if version == <API key>:
return
# Check if chromedriver was released on all supported platforms.
supported_platforms = ['linux32', 'linux64', 'mac32', 'win32']
for platform in supported_platforms:
if not _WasReleased(version, platform):
return
util.MarkBuildStepStart('updating LATEST_RELEASE to %s' % version)
<API key> = tempfile.mkstemp()[1]
with open(<API key>, 'w') as f:
f.write(version)
if slave_utils.GSUtilCopy(<API key>, latest_release_url,
mimetype='text/plain'):
util.MarkBuildStepError()
def _CleanTmpDir():
tmp_dir = tempfile.gettempdir()
print 'cleaning temp directory:', tmp_dir
for file_name in os.listdir(tmp_dir):
file_path = os.path.join(tmp_dir, file_name)
if os.path.isdir(file_path):
print 'deleting sub-directory', file_path
shutil.rmtree(file_path, True)
if file_name.startswith('chromedriver_'):
print 'deleting file', file_path
os.remove(file_path)
def <API key>(snapshot_hashcode):
json_url = GS_GIT_LOG_URL % snapshot_hashcode
try:
response = urllib2.urlopen(json_url)
except urllib2.HTTPError as error:
util.PrintAndFlush('HTTP Error %d' % error.getcode())
return None
except urllib2.URLError as error:
util.PrintAndFlush('URL Error %s' % error.message)
return None
data = json.loads(response.read()[4:])
if 'message' in data:
message = data['message'].split('\n')
message = [line for line in message if line.strip()]
search_pattern = re.compile(GS_SEARCH_PATTERN)
result = search_pattern.search(message[len(message)-1])
if result:
return result.group(1)
util.PrintAndFlush('Failed to get commit position number for %s' %
snapshot_hashcode)
return None
def <API key>(commit_position):
json_url = CR_REV_URL % commit_position
try:
response = urllib2.urlopen(json_url)
except urllib2.HTTPError as error:
util.PrintAndFlush('HTTP Error %d' % error.getcode())
return None
except urllib2.URLError as error:
util.PrintAndFlush('URL Error %s' % error.message)
return None
data = json.loads(response.read())
if 'git_sha' in data:
return data['git_sha']
util.PrintAndFlush('Failed to get git hash for %s' % commit_position)
return None
def <API key>(commit_position):
util.MarkBuildStepStart('wait_for_snapshot')
while True:
snapshot_position = archive.<API key>()
if commit_position is not None and snapshot_position is not None:
if int(snapshot_position) >= int(commit_position):
break
util.PrintAndFlush('Waiting for snapshot >= %s, found %s' %
(commit_position, snapshot_position))
time.sleep(60)
util.PrintAndFlush('Got snapshot commit position %s' % snapshot_position)
def _AddToolsToPath(platform_name):
"""Add some tools like Ant and Java to PATH for testing steps to use."""
paths = []
error_message = ''
if platform_name == 'win32':
paths = [
# Path to Ant and Java, required for the java acceptance tests.
'C:\\Program Files (x86)\\Java\\ant\\bin',
'C:\\Program Files (x86)\\Java\\jre\\bin',
]
error_message = ('Java test steps will fail as expected and '
'they can be ignored.\n'
'Ant, Java or others might not be installed on bot.\n'
'Please refer to page "WATERFALL" on site '
'go/chromedriver.')
if paths:
util.MarkBuildStepStart('Add tools to PATH')
path_missing = False
for path in paths:
if not os.path.isdir(path) or not os.listdir(path):
print 'Directory "%s" is not found or empty.' % path
path_missing = True
if path_missing:
print error_message
util.MarkBuildStepError()
return
os.environ['PATH'] += os.pathsep + os.pathsep.join(paths)
def main():
parser = optparse.OptionParser()
parser.add_option(
'', '--android-packages',
help=('Comma separated list of application package names, '
'if running tests on Android.'))
parser.add_option(
'-r', '--revision', help='Chromium git revision hash')
parser.add_option(
'', '--update-log', action='store_true',
help='Update the test results log (only applicable to Android)')
options, _ = parser.parse_args()
bitness = '32'
if util.IsLinux() and platform_module.architecture()[0] == '64bit':
bitness = '64'
platform = '%s%s' % (util.GetPlatformName(), bitness)
if options.android_packages:
platform = 'android'
_CleanTmpDir()
if not options.revision:
commit_position = None
else:
commit_position = <API key>(options.revision)
if platform == 'android':
if not options.revision and options.update_log:
parser.error('Must supply a --revision with --update-log')
_DownloadPrebuilts()
else:
if not options.revision:
parser.error('Must supply a --revision')
if platform == 'linux64':
_ArchivePrebuilts(commit_position)
<API key>(commit_position)
_AddToolsToPath(platform)
cmd = [
sys.executable,
os.path.join(_THIS_DIR, 'test', 'run_all_tests.py'),
]
if platform == 'android':
cmd.append('--android-packages=' + options.android_packages)
passed = (util.RunCommand(cmd) == 0)
_ArchiveServerLogs()
if platform == 'android':
if options.update_log:
util.MarkBuildStepStart('update test result log')
<API key>(platform, commit_position, passed)
elif passed:
_ArchiveGoodBuild(platform, commit_position)
_MaybeRelease(platform)
if not passed:
# Make sure the build is red if there is some uncaught exception during
# running run_all_tests.py.
util.MarkBuildStepStart('run_all_tests.py')
util.MarkBuildStepError()
# Add a "cleanup" step so that errors from runtest.py or bb_device_steps.py
# (which invoke this script) are kept in thier own build step.
util.MarkBuildStepStart('cleanup')
if __name__ == '__main__':
main() |
require 'fuelsdk'
require_relative 'sample_helper'
begin
stubObj = FuelSDK::Client.new auth
# Retrieve All Folder with GetMoreResults
p '>>> Retrieve All Folder with GetMoreResults'
getFolder = FuelSDK::Folder.new()
getFolder.authStub = stubObj
getFolder.props = ["ID", "Client.ID", "ParentFolder.ID", "ParentFolder.CustomerKey", "ParentFolder.ObjectID", "ParentFolder.Name", "ParentFolder.Description", "ParentFolder.ContentType", "ParentFolder.IsActive", "ParentFolder.IsEditable", "ParentFolder.AllowChildren", "Name", "Description", "ContentType", "IsActive", "IsEditable", "AllowChildren", "CreatedDate", "ModifiedDate", "Client.ModifiedBy", "ObjectID", "CustomerKey", "Client.EnterpriseID", "Client.CreatedBy"]
getResponse = getFolder.get
p 'Retrieve Status: ' + getResponse.status.to_s
p 'Code: ' + getResponse.code.to_s
p 'Message: ' + getResponse.message.to_s
p 'MoreResults: ' + getResponse.more?.to_s
p 'Results Length: ' + getResponse.results.length.to_s
#p 'Results: ' + getResponse.results.to_s
raise 'Failure retrieving Folders' unless getResponse.success?
while getResponse.more? do
p '>>> Continue Retrieve All Folder with GetMoreResults'
getResponse.continue
p 'Retrieve Status: ' + getResponse.status.to_s
p 'Code: ' + getResponse.code.to_s
p 'Message: ' + getResponse.message.to_s
p 'MoreResults: ' + getResponse.more?.to_s
p 'RequestID: ' + getResponse.request_id.to_s
p 'Results Length: ' + getResponse.results.length.to_s
end
NameOfTestFolder = "RubySDKFolder"
# Retrieve Specific Folder for Email Folder ParentID
p '>>> Retrieve Specific Folder for Email Folder ParentID'
getFolder = FuelSDK::Folder.new()
getFolder.authStub = stubObj
getFolder.props = ["ID"]
getFolder.filter = {'LeftOperand' => {'Property' => 'ParentFolder.ID','SimpleOperator' => 'equals','Value' => '0'}, 'LogicalOperator' => 'AND', 'RightOperand' => {'Property' => 'ContentType','SimpleOperator' => 'equals','Value' => 'EMAIL'}}
getResponse = getFolder.get
p 'Retrieve Status: ' + getResponse.status.to_s
p 'Code: ' + getResponse.code.to_s
p 'Message: ' + getResponse.message.to_s
p 'MoreResults: ' + getResponse.more?.to_s
p 'Results Length: ' + getResponse.results.length.to_s
p 'Results: ' + getResponse.results.to_s
raise 'Failure retrieving Folder' unless getResponse.success?
if getResponse.success? then
ParentIDForEmail = getResponse.results[0][:id]
p "Parent Folder for Email: #{ParentIDForEmail}"
# Create Folder
p '>>> Create Folder'
postFolder = FuelSDK::Folder.new
postFolder.authStub = stubObj
postFolder.props = {"CustomerKey" => NameOfTestFolder, "Name" => NameOfTestFolder, "Description" => NameOfTestFolder, "ContentType"=> "EMAIL", "ParentFolder" => {"ID" => ParentIDForEmail}}
postResponse = postFolder.post
p 'Post Status: ' + postResponse.status.to_s
p 'Code: ' + postResponse.code.to_s
p 'Message: ' + postResponse.message.to_s
p 'Result Count: ' + postResponse.results.length.to_s
p 'Results: ' + postResponse.results.inspect
raise 'Failure creating Folder' unless postResponse.success?
# Retrieve newly created Folder
p '>>> Retrieve newly created Folder'
getFolder = FuelSDK::Folder.new()
getFolder.authStub = stubObj
getFolder.props = ["ID", "Client.ID", "ParentFolder.ID", "ParentFolder.CustomerKey", "ParentFolder.ObjectID", "ParentFolder.Name", "ParentFolder.Description", "ParentFolder.ContentType", "ParentFolder.IsActive", "ParentFolder.IsEditable", "ParentFolder.AllowChildren", "Name", "Description", "ContentType", "IsActive", "IsEditable", "AllowChildren", "CreatedDate", "ModifiedDate", "Client.ModifiedBy", "ObjectID", "CustomerKey", "Client.EnterpriseID", "Client.CreatedBy"]
getFolder.filter = {'Property' => 'CustomerKey','SimpleOperator' => 'equals','Value' => NameOfTestFolder}
getResponse = getFolder.get
p 'Retrieve Status: ' + getResponse.status.to_s
p 'Code: ' + getResponse.code.to_s
p 'Message: ' + getResponse.message.to_s
p 'MoreResults: ' + getResponse.more?.to_s
p 'Results Length: ' + getResponse.results.length.to_s
p 'Results: ' + getResponse.results.to_s
raise 'Failure retrieving Folder' unless getResponse.success?
raise 'Failure verifying created Folder' if getResponse.results.empty?
# Update Folder
p '>>> Update Folder'
patchFolder = FuelSDK::Folder.new
patchFolder.authStub = stubObj
patchFolder.props = {"CustomerKey" => NameOfTestFolder, "Description" => "New Description"}
patchResponse = patchFolder.patch
p 'Patch Status: ' + patchResponse.status.to_s
p 'Code: ' + patchResponse.code.to_s
p 'Message: ' + patchResponse.message.to_s
p 'Result Count: ' + patchResponse.results.length.to_s
p 'Results: ' + patchResponse.results.inspect
raise 'Failure updating Folder' unless patchResponse.success?
# Retrieve updated Folder
p '>>> Retrieve updated Folder'
getFolder = FuelSDK::Folder.new()
getFolder.authStub = stubObj
getFolder.props = ["ID", "Client.ID", "ParentFolder.ID", "ParentFolder.CustomerKey", "ParentFolder.ObjectID", "ParentFolder.Name", "ParentFolder.Description", "ParentFolder.ContentType", "ParentFolder.IsActive", "ParentFolder.IsEditable", "ParentFolder.AllowChildren", "Name", "Description", "ContentType", "IsActive", "IsEditable", "AllowChildren", "CreatedDate", "ModifiedDate", "Client.ModifiedBy", "ObjectID", "CustomerKey", "Client.EnterpriseID", "Client.CreatedBy"]
getFolder.filter = {'Property' => 'CustomerKey','SimpleOperator' => 'equals','Value' => NameOfTestFolder}
getResponse = getFolder.get
p 'Retrieve Status: ' + getResponse.status.to_s
p 'Code: ' + getResponse.code.to_s
p 'Message: ' + getResponse.message.to_s
p 'MoreResults: ' + getResponse.more?.to_s
p 'Results Length: ' + getResponse.results.length.to_s
p 'Results: ' + getResponse.results.to_s
raise 'Failure retrieving Folder' unless getResponse.success?
# Delete Folder
p '>>> Delete Folder'
deleteFolder = FuelSDK::Folder.new
deleteFolder.authStub = stubObj
deleteFolder.props = {"CustomerKey" => NameOfTestFolder, "Name"=>NameOfTestFolder, "Content"=> "<b>Some HTML Content Goes here. NOW WITH NEW CONTENT</b>"}
deleteResponse = deleteFolder.delete
p 'Delete Status: ' + deleteResponse.status.to_s
p 'Code: ' + deleteResponse.code.to_s
p 'Message: ' + deleteResponse.message.to_s
p 'Result Count: ' + deleteResponse.results.length.to_s
p 'Results: ' + deleteResponse.results.inspect
raise 'Failure deleting Folder' unless deleteResponse.success?
# Retrieve Folder to confirm deletion
p '>>> Retrieve Folder to confirm deletion'
getFolder = FuelSDK::Folder.new()
getFolder.authStub = stubObj
getFolder.props = ["ID"]
getFolder.filter = {'Property' => 'CustomerKey','SimpleOperator' => 'equals','Value' => NameOfTestFolder}
getResponse = getFolder.get
p 'Retrieve Status: ' + getResponse.status.to_s
p 'Code: ' + getResponse.code.to_s
p 'Message: ' + getResponse.message.to_s
p 'MoreResults: ' + getResponse.more?.to_s
p 'Results Length: ' + getResponse.results.length.to_s
p 'Results: ' + getResponse.results.to_s
raise 'Failure verifying deleted Folder' unless getResponse.success?
raise 'Failure verifying deleted Folder' unless getResponse.results.empty?
end
rescue => e
p "Caught exception: #{e.message}"
p e.backtrace
end |
*> \brief <b> SSPSV computes the solution to system of linear equations A * X = B for OTHER matrices</b>
*
* =========== DOCUMENTATION ===========
*
* Online html documentation available at
* http:
*
*> \htmlonly
*> Download SSPSV + dependencies
*> <a href="http:
*> [TGZ]</a>
*> <a href="http:
*> [ZIP]</a>
*> <a href="http:
*> [TXT]</a>
*> \endhtmlonly
*
* Definition:
* ===========
*
* SUBROUTINE SSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO )
*
* .. Scalar Arguments ..
* CHARACTER UPLO
* INTEGER INFO, LDB, N, NRHS
* ..
* .. Array Arguments ..
* INTEGER IPIV( * )
* REAL AP( * ), B( LDB, * )
* ..
*
*
*> \par Purpose:
* =============
*>
*> \verbatim
*>
*> SSPSV computes the solution to a real system of linear equations
*> A * X = B,
*> where A is an N-by-N symmetric matrix stored in packed format and X
*> and B are N-by-NRHS matrices.
*>
*> The diagonal pivoting method is used to factor A as
*> A = U * D * U**T, if UPLO = 'U', or
*> A = L * D * L**T, if UPLO = 'L',
*> where U (or L) is a product of permutation and unit upper (lower)
*> triangular matrices, D is symmetric and block diagonal with 1-by-1
*> and 2-by-2 diagonal blocks. The factored form of A is then used to
*> solve the system of equations A * X = B.
*> \endverbatim
*
* Arguments:
* ==========
*
*> \param[in] UPLO
*> \verbatim
*> UPLO is CHARACTER*1
*> = 'U': Upper triangle of A is stored;
*> = 'L': Lower triangle of A is stored.
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*> N is INTEGER
*> The number of linear equations, i.e., the order of the
*> matrix A. N >= 0.
*> \endverbatim
*>
*> \param[in] NRHS
*> \verbatim
*> NRHS is INTEGER
*> The number of right hand sides, i.e., the number of columns
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
*> \param[in,out] AP
*> \verbatim
*> AP is REAL array, dimension (N*(N+1)/2)
*> On entry, the upper or lower triangle of the symmetric matrix
*> A, packed columnwise in a linear array. The j-th column of A
*> is stored in the array AP as follows:
*> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
*> if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
*> See below for further details.
*>
*> On exit, the block diagonal matrix D and the multipliers used
*> to obtain the factor U or L from the factorization
*> A = U*D*U**T or A = L*D*L**T as computed by SSPTRF, stored as
*> a packed triangular matrix in the same storage format as A.
*> \endverbatim
*>
*> \param[out] IPIV
*> \verbatim
*> IPIV is INTEGER array, dimension (N)
*> Details of the interchanges and the block structure of D, as
*> determined by SSPTRF. If IPIV(k) > 0, then rows and columns
*> k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1
*> diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,
*> then rows and columns k-1 and -IPIV(k) were interchanged and
*> D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and
*> IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and
*> -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2
*> diagonal block.
*> \endverbatim
*>
*> \param[in,out] B
*> \verbatim
*> B is REAL array, dimension (LDB,NRHS)
*> On entry, the N-by-NRHS right hand side matrix B.
*> On exit, if INFO = 0, the N-by-NRHS solution matrix X.
*> \endverbatim
*>
*> \param[in] LDB
*> \verbatim
*> LDB is INTEGER
*> The leading dimension of the array B. LDB >= max(1,N).
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*> INFO is INTEGER
*> = 0: successful exit
*> < 0: if INFO = -i, the i-th argument had an illegal value
*> > 0: if INFO = i, D(i,i) is exactly zero. The factorization
*> has been completed, but the block diagonal matrix D is
*> exactly singular, so the solution could not be
*> computed.
*> \endverbatim
*
* Authors:
* ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \date December 2016
*
*> \ingroup realOTHERsolve
*
*> \par Further Details:
* =====================
*>
*> \verbatim
*>
*> The packed storage scheme is illustrated by the following example
*> when N = 4, UPLO = 'U':
*>
*> Two-dimensional storage of the symmetric matrix A:
*>
*> a11 a12 a13 a14
*> a22 a23 a24
*> a33 a34 (aij = aji)
*> a44
*>
*> Packed storage of the upper triangle of A:
*>
*> AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]
*> \endverbatim
*>
* =====================================================================
SUBROUTINE SSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO )
*
* -- LAPACK driver routine (version 3.7.0) --
* -- LAPACK is a software package provided by Univ. of Tennessee, --
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
* December 2016
*
* .. Scalar Arguments ..
CHARACTER UPLO
INTEGER INFO, LDB, N, NRHS
* ..
* .. Array Arguments ..
INTEGER IPIV( * )
REAL AP( * ), B( LDB, * )
* ..
*
* =====================================================================
*
* .. External Functions ..
LOGICAL LSAME
EXTERNAL LSAME
* ..
* .. External Subroutines ..
EXTERNAL SSPTRF, SSPTRS, XERBLA
* ..
* .. Intrinsic Functions ..
INTRINSIC MAX
* ..
* .. Executable Statements ..
*
* Test the input parameters.
*
INFO = 0
IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
INFO = -1
ELSE IF( N.LT.0 ) THEN
INFO = -2
ELSE IF( NRHS.LT.0 ) THEN
INFO = -3
ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
INFO = -7
END IF
IF( INFO.NE.0 ) THEN
CALL XERBLA( 'SSPSV ', -INFO )
RETURN
END IF
*
* Compute the factorization A = U*D*U**T or A = L*D*L**T.
*
CALL SSPTRF( UPLO, N, AP, IPIV, INFO )
IF( INFO.EQ.0 ) THEN
*
* Solve the system A*X = B, overwriting B with X.
*
CALL SSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO )
*
END IF
RETURN
*
* End of SSPSV
*
END |
<div id="{{mojit_view_id}}" class="mojit">
<button>PUSH ME</button>
<div>a place for foo</div>
</div> |
#include "extensions/browser/process_manager.h"
#include "content/public/browser/<API key>.h"
#include "content/public/browser/<API key>.h"
#include "content/public/browser/site_instance.h"
#include "content/public/common/content_client.h"
#include "content/public/test/<API key>.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extensions_test.h"
#include "extensions/browser/notification_types.h"
#include "extensions/browser/<API key>.h"
#include "extensions/browser/<API key>.h"
using content::BrowserContext;
using content::SiteInstance;
using content::TestBrowserContext;
namespace extensions {
namespace {
// A trivial <API key>.
class <API key> : public <API key> {
public:
<API key>()
: <API key>(true),
<API key>(false) {}
~<API key>() override {}
// <API key> implementation.
bool <API key>(
BrowserContext* context) const override {
return <API key>;
}
bool <API key>(
BrowserContext* context,
const Extension& extension) const override {
return <API key>;
}
bool <API key>(
BrowserContext* context) const override {
return <API key>;
}
bool <API key>;
bool <API key>;
};
} // namespace
class ProcessManagerTest : public ExtensionsTest {
public:
ProcessManagerTest() {}
ProcessManagerTest(const ProcessManagerTest&) = delete;
ProcessManagerTest& operator=(const ProcessManagerTest&) = delete;
~ProcessManagerTest() override {}
void SetUp() override {
ExtensionsTest::SetUp();
extension_registry_ =
std::make_unique<ExtensionRegistry>(browser_context());
<API key>()-><API key>(
&<API key>);
}
// Use original_context() to make it clear it is a non-incognito context.
BrowserContext* original_context() { return browser_context(); }
ExtensionRegistry* extension_registry() { return extension_registry_.get(); }
<API key>* <API key>() {
return &<API key>;
}
private:
std::unique_ptr<ExtensionRegistry>
extension_registry_; // Shared between BrowserContexts.
<API key> <API key>;
};
// Test that startup background hosts are created when the extension system
// becomes ready.
// NOTE: This test and those that follow do not try to create ExtensionsHosts
// because ExtensionHost is tightly coupled to WebContents and can't be
// constructed in unit tests.
TEST_F(ProcessManagerTest, <API key>) {
std::unique_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
original_context(), extension_registry()));
ASSERT_FALSE(manager-><API key>());
// Simulate the extension system becoming ready.
extension_system()->SetReady();
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(manager-><API key>());
}
// Test that the embedder can defer background host creation. Chrome does this
// when the profile is created asynchronously, which may take a while.
TEST_F(ProcessManagerTest, <API key>) {
std::unique_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
original_context(), extension_registry()));
ASSERT_FALSE(manager-><API key>());
// Don't create background hosts if the delegate says to defer them.
<API key>()-><API key> = true;
manager-><API key>();
EXPECT_FALSE(manager-><API key>());
// The extension system becoming ready still doesn't create the hosts.
extension_system()->SetReady();
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(manager-><API key>());
// Once the embedder is ready the background hosts can be created.
<API key>()-><API key> = false;
manager-><API key>();
EXPECT_TRUE(manager-><API key>());
}
// Test that the embedder can disallow background host creation.
// Chrome OS does this in guest mode.
TEST_F(ProcessManagerTest, <API key>) {
std::unique_ptr<ProcessManager> manager(ProcessManager::CreateForTesting(
original_context(), extension_registry()));
ASSERT_FALSE(manager-><API key>());
// Don't create background hosts if the delegate disallows them.
<API key>()-><API key> = false;
manager-><API key>();
EXPECT_FALSE(manager-><API key>());
// The extension system becoming ready still doesn't create the hosts.
extension_system()->SetReady();
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(manager-><API key>());
}
// Test that extensions get grouped in the right SiteInstance (and therefore
// process) based on their URLs.
TEST_F(ProcessManagerTest, ProcessGrouping) {
// Extensions in different browser contexts should always be different
// SiteInstances.
std::unique_ptr<ProcessManager> manager1(ProcessManager::CreateForTesting(
original_context(), extension_registry()));
// NOTE: This context is not associated with the <API key>.
// That's OK because we're not testing regular vs. incognito behavior.
TestBrowserContext another_context;
ExtensionRegistry another_registry(&another_context);
std::unique_ptr<ProcessManager> manager2(
ProcessManager::CreateForTesting(&another_context, &another_registry));
// Extensions with common origins ("scheme://id/") should be grouped in the
// same SiteInstance.
GURL ext1_url1("chrome-extension://ext1_id/index.html");
GURL ext1_url2("chrome-extension://ext1_id/monkey/monkey.html");
GURL ext2_url1("chrome-extension://ext2_id/index.html");
scoped_refptr<SiteInstance> site11 =
manager1-><API key>(ext1_url1);
scoped_refptr<SiteInstance> site12 =
manager1-><API key>(ext1_url2);
EXPECT_EQ(site11, site12);
scoped_refptr<SiteInstance> site21 =
manager1-><API key>(ext2_url1);
EXPECT_NE(site11, site21);
scoped_refptr<SiteInstance> other_profile_site =
manager2-><API key>(ext1_url1);
EXPECT_NE(site11, other_profile_site);
<API key>::GetInstance()-><API key>(
&another_context);
}
} // namespace extensions |
from js_helper import TestCase
class <API key>(TestCase):
"""
Consider the following tree:
- body
|-function a()
| |- foo
| |- bar
|-zip
|-function b()
| |-abc
| |-def
|-zap
In the old traversal technique, it would be evaluated in the order:
body a() foo bar zip b() abc def zap
If the tree is considered as a graph, this would be prefix notation
traversal.
This is not optimal, however, as JS commonly uses callbacks which are set
up before delegation code. The new traversal technique should access nodes
in the following order:
body zip zap a() foo bar b() abc def
If the tree is considered a graph, this would be a custom prefix notation
traversal where all non-function nodes are traversed before all function
nodes.
"""
def <API key>(self):
"""Test that function declarations happen in the right time."""
self.run_script("""
foo = "first";
function test() {
foo = "second";
}
bar = foo;
""")
self.assert_var_eq("bar", "first")
self.assert_var_eq("foo", "second")
def <API key>(self):
"""Test that function expressions happen in the right time."""
self.run_script("""
foo = "first"
var x = function() {
foo = "second";
}
bar = foo;
""")
self.assert_var_eq("bar", "first")
self.assert_var_eq("foo", "second")
def <API key>(self):
"""Test that nested functions are considered in the right order."""
self.run_script("""
foo = "first"
function test() {
function a() {foo = "second"}
foo = "third";
}
""")
self.assert_var_eq("foo", "second") |
#include <af/array.h>
#include <af/defines.h>
#include <err_common.hpp>
#include <handle.hpp>
#include <backend.hpp>
#include <ArrayInfo.hpp>
#include <resize.hpp>
using af::dim4;
using namespace detail;
template<typename T>
static inline af_array resize(const af_array in, const dim_t odim0, const dim_t odim1,
const af_interp_type method)
{
return getHandle(resize<T>(getArray<T>(in), odim0, odim1, method));
}
af_err af_resize(af_array *out, const af_array in, const dim_t odim0, const dim_t odim1,
const af_interp_type method)
{
try {
ArrayInfo info = getInfo(in);
af_dtype type = info.getType();
ARG_ASSERT(4, (method == AF_INTERP_BILINEAR ||
method == AF_INTERP_NEAREST ||
method == AF_INTERP_LOWER
));
DIM_ASSERT(2, odim0 > 0);
DIM_ASSERT(3, odim1 > 0);
af_array output;
switch(type) {
case f32: output = resize<float >(in, odim0, odim1, method); break;
case f64: output = resize<double >(in, odim0, odim1, method); break;
case c32: output = resize<cfloat >(in, odim0, odim1, method); break;
case c64: output = resize<cdouble>(in, odim0, odim1, method); break;
case s32: output = resize<int >(in, odim0, odim1, method); break;
case u32: output = resize<uint >(in, odim0, odim1, method); break;
case s64: output = resize<intl >(in, odim0, odim1, method); break;
case u64: output = resize<uintl >(in, odim0, odim1, method); break;
case u8: output = resize<uchar >(in, odim0, odim1, method); break;
case b8: output = resize<char >(in, odim0, odim1, method); break;
default: TYPE_ERROR(1, type);
}
std::swap(*out,output);
}
CATCHALL;
return AF_SUCCESS;
} |
#ifndef <API key>
#define <API key>
#include <stdint.h>
#include <vector>
#include "base/time/time.h"
#include "content/common/content_export.h"
#include "url/gurl.h"
namespace content {
static const int kAppCacheNoHostId = 0;
static const int64_t kAppCacheNoCacheId = 0;
static const int64_t <API key> = 0;
static const int64_t <API key> = -1;
enum AppCacheStatus {
<API key>,
<API key>,
<API key>,
<API key>,
<API key>,
<API key>,
<API key> = <API key>
};
struct CONTENT_EXPORT AppCacheInfo {
AppCacheInfo();
~AppCacheInfo();
GURL manifest_url;
base::Time creation_time;
base::Time last_update_time;
base::Time last_access_time;
int64_t cache_id;
int64_t group_id;
AppCacheStatus status;
int64_t size;
bool is_complete;
};
typedef std::vector<AppCacheInfo> AppCacheInfoVector;
} // namespace
#endif // <API key> |
package org.motechproject.security.exception;
/**
* Represents a failed attempt to delete a role currently assigned to a user.
*/
public class <API key> extends RuntimeException {
public <API key>(String message) {
super(message);
}
} |
require 'spec_helper'
describe EmailValidator do
class Tester
include ActiveModel::Validations
attr_accessor :email_address
validates :email_address, email: true
end
let(:valid_emails) {
[
'valid@email.com',
'valid@email.com.uk',
'e@email.com',
'valid+email@email.com',
'valid-email@email.com',
'valid_email@email.com',
'valid.email@email.com'
]
}
let(:invalid_emails) {
[
'invalid email@email.com',
'.invalid.email@email.com',
'invalid.email.@email.com',
'@email.com',
'.@email.com',
'invalidemailemail.com',
'@invalid.email@email.com',
'invalid@email@email.com',
'invalid.email@@email.com'
]
}
it 'validates valid email addresses' do
tester = Tester.new
valid_emails.each do |email|
tester.email_address = email
expect(tester.valid?).to be true
end
end
it 'validates invalid email addresses' do
tester = Tester.new
invalid_emails.each do |email|
tester.email_address = email
expect(tester.valid?).to be false
end
end
end |
#ifndef <API key>
#define <API key>
#pragma once
#include <string>
#include "base/observer_list.h"
#include "base/time.h"
#include "chrome/browser/chromeos/disks/disk_mount_manager.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace chromeos {
namespace disks {
class <API key> : public DiskMountManager {
public:
<API key>();
virtual ~<API key>();
// DiskMountManager override.
MOCK_METHOD0(Init, void(void));
MOCK_METHOD1(AddObserver, void(DiskMountManager::Observer*));
MOCK_METHOD1(RemoveObserver, void(DiskMountManager::Observer*));
MOCK_CONST_METHOD0(disks, const DiskMountManager::DiskMap&(void));
MOCK_CONST_METHOD0(mount_points,
const DiskMountManager::MountPointMap&(void));
MOCK_METHOD0(<API key>, void(void));
MOCK_METHOD4(MountPath, void(const std::string&, const std::string&,
const std::string&, MountType));
MOCK_METHOD1(UnmountPath, void(const std::string&));
MOCK_METHOD3(<API key>, void(const std::string&, size_t*,
size_t*));
MOCK_METHOD1(<API key>, void(const std::string&));
MOCK_METHOD1(FormatMountedDevice, void(const std::string&));
MOCK_METHOD3(<API key>, void(const std::string&,
DiskMountManager::<API key>, void*));
// Invokes fake device insert events.
void <API key>();
// Invokes fake device remove events.
void <API key>();
// Sets up default results for mock methods.
void SetupDefaultReplies();
private:
// Is used to implement AddObserver.
void AddObserverInternal(DiskMountManager::Observer* observer);
// Is used to implement RemoveObserver.
void <API key>(DiskMountManager::Observer* observer);
// Is used to implement disks.
const DiskMountManager::DiskMap& disksInternal() const { return disks_; }
// Notifies observers about device status update.
void NotifyDeviceChanged(<API key> event,
const std::string& path);
// Notifies observers about disk status update.
void NotifyDiskChanged(<API key> event,
const DiskMountManager::Disk* disk);
// The list of observers.
ObserverList<DiskMountManager::Observer> observers_;
// The list of disks found.
DiskMountManager::DiskMap disks_;
<API key>(<API key>);
};
} // namespace disks
} // namespace chromeos
#endif // <API key> |
<?php
/**
* @see <API key>
*/
require_once 'Zend/Service/StrikeIron/BaseTest.php';
class <API key> extends <API key>
{
public function setUp()
{
$this->soapClient = new <API key>;
if (extension_loaded('soap')) {
$this->markTestSkipped('SOAP extension is loaded, so cannot test for exception');
}
}
public function testNoSoapException()
{
try {
$base = new <API key>(array('client' => $this->soapClient,
'username' => 'user',
'password' => 'pass'));
$this->fail('Expecting exception of type <API key>');
} catch (Zend_Exception $e) {
$this->assertType('<API key>', $e,
'Expecting exception of type <API key>, got '.get_class($e));
$this->assertEquals('SOAP extension is not enabled', $e->getMessage());
}
}
} |
package org.hisp.dhis.common;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.<API key>;
import org.hisp.dhis.dataset.DataSet;
import org.hisp.dhis.legend.LegendSet;
import java.util.List;
import static org.hisp.dhis.common.<API key>.<API key>;
/**
* @author Lars Helge Overland
*/
@<API key>( localName = "reportingRate", namespace = DxfNamespaces.DXF_2_0 )
public class ReportingRate
extends <API key> implements EmbeddedObject
{
private DataSet dataSet;
private ReportingRateMetric metric;
public ReportingRate()
{
}
public ReportingRate( DataSet dataSet )
{
this.dataSet = dataSet;
this.metric = ReportingRateMetric.REPORTING_RATE;
}
public ReportingRate( DataSet dataSet, ReportingRateMetric metric )
{
this.dataSet = dataSet;
this.metric = metric;
}
// <API key>
@Override
public String getUid()
{
return dataSet.getUid();
}
@Override
public String getName()
{
String metricName = metric != null ? metric.displayName() : ReportingRateMetric.REPORTING_RATE.displayName();
return dataSet.getName() + " " + metricName;
}
@Override
public String getShortName()
{
String metricName = metric != null ? metric.displayName() : ReportingRateMetric.REPORTING_RATE.displayName();
return dataSet.getShortName() + " " + metricName;
}
@Override
public String getDimensionItem()
{
return dataSet.getUid() + <API key> + metric.name();
}
@Override
public DimensionItemType <API key>()
{
return DimensionItemType.REPORTING_RATE;
}
@Override
public List<LegendSet> getLegendSets()
{
return dataSet.getLegendSets();
}
// Logic
@JsonProperty
@JsonSerialize( as = BaseNameableObject.class )
@JacksonXmlProperty( namespace = DxfNamespaces.DXF_2_0 )
public DataSet getDataSet()
{
return dataSet;
}
public void setDataSet( DataSet dataSet )
{
this.dataSet = dataSet;
}
@JsonProperty
@JacksonXmlProperty( namespace = DxfNamespaces.DXF_2_0 )
public ReportingRateMetric getMetric()
{
return metric;
}
public void setMetric( ReportingRateMetric metric )
{
this.metric = metric;
}
} |
$(document).ready(function() {
$(".select2").select2();
//Traditional form validation sample
$('#<API key>').validate({
focusInvalid: false,
ignore: "",
rules: {
form1Amount: {
minlength: 2,
required: true
},
form1CardHolderName: {
minlength: 2,
required: true,
},
form1CardNumber: {
required: true,
creditcard: true
}
},
invalidHandler: function (event, validator) {
//display error alert on form submit
},
errorPlacement: function (label, element) { // render error placement for each input type
$('<span class="error"></span>').insertAfter(element).append(label)
var parent = $(element).parent('.input-with-icon');
parent.removeClass('success-control').addClass('error-control');
},
highlight: function (element) { // hightlight error inputs
var parent = $(element).parent();
parent.removeClass('success-control').addClass('error-control');
},
unhighlight: function (element) { // revert the change done by hightlight
},
success: function (label, element) {
var parent = $(element).parent('.input-with-icon');
parent.removeClass('error-control').addClass('success-control');
},
submitHandler: function (form) {
}
});
//Iconic form validation sample
$('#<API key>').validate({
errorElement: 'span',
errorClass: 'error',
focusInvalid: false,
ignore: "",
rules: {
form1Name: {
minlength: 2,
required: true
},
form1Email: {
required: true,
email: true
},
form1Url: {
required: true,
url: true
}
},
invalidHandler: function (event, validator) {
//display error alert on form submit
},
errorPlacement: function (error, element) { // render error placement for each input type
var icon = $(element).parent('.input-with-icon').children('i');
var parent = $(element).parent('.input-with-icon');
icon.removeClass('icon-ok').addClass('icon-exclamation');
parent.removeClass('success-control').addClass('error-control');
},
highlight: function (element) { // hightlight error inputs
var parent = $(element).parent();
parent.removeClass('success-control').addClass('error-control');
},
unhighlight: function (element) { // revert the change done by hightlight
},
success: function (label, element) {
var icon = $(element).parent('.input-with-icon').children('i');
var parent = $(element).parent('.input-with-icon');
icon.removeClass("icon-exclamation").addClass('icon-ok');
parent.removeClass('error-control').addClass('success-control');
},
submitHandler: function (form) {
}
});
//Form Condensed Validation
$('#form-condensed').validate({
errorElement: 'span',
errorClass: 'error',
focusInvalid: false,
ignore: "",
rules: {
form3FirstName: {
minlength: 3,
required: true
},
form3LastName: {
minlength: 3,
required: true
},
form3Gender: {
required: true,
},
form3DateOfBirth: {
required: true,
},
form3Occupation: {
minlength: 3,
required: true,
},
form3Email: {
required: true,
email: true
},
form3Address: {
minlength: 10,
required: true,
},
form3City: {
minlength: 5,
required: true,
},
form3State: {
minlength: 3,
required: true,
},
form3Country: {
minlength: 3,
required: true,
},
form3PostalCode: {
number: true,
maxlength: 4,
required: true,
},
form3TeleCode: {
minlength: 3,
maxlength: 4,
required: true,
},
form3TeleNo: {
maxlength: 10,
required: true,
},
},
invalidHandler: function (event, validator) {
//display error alert on form submit
},
errorPlacement: function (label, element) { // render error placement for each input type
$('<span class="error"></span>').insertAfter(element).append(label)
},
highlight: function (element) { // hightlight error inputs
},
unhighlight: function (element) { // revert the change done by hightlight
},
success: function (label, element) {
},
submitHandler: function (form) {
}
});
//Form Wizard Validations
var $validator = $("#commentForm").validate({
rules: {
emailfield: {
required: true,
email: true,
minlength: 3
},
txtFullName: {
required: true,
minlength: 3
},
txtFirstName: {
required: true,
minlength: 3
},
txtLastName: {
required: true,
minlength: 3
},
txtCountry: {
required: true,
minlength: 3
},
txtPostalCode: {
required: true,
minlength: 3
},
txtPhoneCode: {
required: true,
minlength: 3
},
txtPhoneNumber: {
required: true,
minlength: 3
},
urlfield: {
required: true,
minlength: 3,
url: true
}
},
errorPlacement: function(label, element) {
$('<span class="arrow"></span>').insertBefore(element);
$('<span class="error"></span>').insertAfter(element).append(label)
}
});
$('#rootwizard').bootstrapWizard({
'tabClass': 'form-wizard',
'onNext': function(tab, navigation, index) {
var $valid = $("#commentForm").valid();
if(!$valid) {
$validator.focusInvalid();
return false;
}
else{
$('#rootwizard').find('.form-wizard').children('li').eq(index-1).addClass('complete');
$('#rootwizard').find('.form-wizard').children('li').eq(index-1).find('.step').html('<i class="icon-ok"></i>');
}
}
});
}); |
/**
* @constructor
* @implements {WebInspector.<API key>}
*/
WebInspector.SCSSParser = function()
{
}
WebInspector.SCSSParser.prototype = {
/**
* @override
* @param {string} content
* @return {!Array<!WebInspector.SCSSParser.Rule>}
*/
parse: function(content)
{
var ast = null;
try {
ast = gonzales.parse(content, {syntax: "scss"});
} catch (e) {
return [];
}
/** @type {!{properties: !Array<!Gonzales.Node>, node: !Gonzales.Node}} */
var rootBlock = {
properties: [],
node: ast
};
/** @type {!Array<!{properties: !Array<!Gonzales.Node>, node: !Gonzales.Node}>} */
var blocks = [rootBlock];
ast.selectors = [];
WebInspector.SCSSParser.extractNodes(ast, blocks, rootBlock);
var rules = [];
for (var block of blocks)
this._handleBlock(block, rules);
return rules;
},
/**
* @param {!{node: !Gonzales.Node, properties: !Array<!Gonzales.Node>}} block
* @param {!Array<!WebInspector.SCSSParser.Rule>} output
*/
_handleBlock: function(block, output)
{
var selectors = block.node.selectors.map(WebInspector.SCSSParser.rangeFromNode);
var properties = [];
var styleRange = WebInspector.SCSSParser.rangeFromNode(block.node);
styleRange.startColumn += 1;
styleRange.endColumn -= 1;
for (var node of block.properties) {
if (node.type === "declaration")
this._handleDeclaration(node, properties);
else if (node.type === "include")
this._handleInclude(node, properties);
else if (node.type === "multilineComment" && node.start.line === node.end.line)
this._handleComment(node, properties);
}
if (!selectors.length && !properties.length)
return;
var rule = new WebInspector.SCSSParser.Rule(selectors, properties, styleRange);
output.push(rule);
},
/**
* @param {!Gonzales.Node} node
* @param {!Array<!WebInspector.SCSSParser.Property>} output
*/
_handleDeclaration: function(node, output)
{
var propertyNode = node.content.find(node => node.type === "property");
var valueNode = node.content.find(node => node.type === "value");
if (!propertyNode || !valueNode)
return;
var nameRange = WebInspector.SCSSParser.rangeFromNode(propertyNode);
var valueRange = WebInspector.SCSSParser.rangeFromNode(valueNode);
var range = /** @type {!WebInspector.TextRange} */(node.declarationRange);
var property = new WebInspector.SCSSParser.Property(range, nameRange, valueRange, false);
output.push(property);
},
/**
* @param {!Gonzales.Node} node
* @param {!Array<!WebInspector.SCSSParser.Property>} output
*/
_handleInclude: function(node, output)
{
var mixinName = node.content.find(node => node.type === "ident");
if (!mixinName)
return;
var nameRange = WebInspector.SCSSParser.rangeFromNode(mixinName);
var mixinArguments = node.content.find(node => node.type === "arguments");
if (!mixinArguments)
return;
var parameters = mixinArguments.content.filter(node => node.type !== "delimiter" && node.type !== "space");
for (var parameter of parameters) {
var range = WebInspector.SCSSParser.rangeFromNode(node);
var valueRange = WebInspector.SCSSParser.rangeFromNode(parameter);
var property = new WebInspector.SCSSParser.Property(range, nameRange, valueRange, false);
output.push(property);
}
},
/**
* @param {!Gonzales.Node} node
* @param {!Array<!WebInspector.SCSSParser.Property>} output
*/
_handleComment: function(node, output)
{
if (node.start.line !== node.end.line)
return;
var innerText = /** @type {string} */(node.content);
var innerResult = this.parse(innerText);
if (innerResult.length !== 1 || innerResult[0].properties.length !== 1)
return;
var property = innerResult[0].properties[0];
var disabledProperty = property.<API key>(node);
output.push(disabledProperty);
},
}
/**
* @param {!Gonzales.Node} node
* @return {!WebInspector.TextRange}
*/
WebInspector.SCSSParser.rangeFromNode = function(node)
{
return new WebInspector.TextRange(node.start.line - 1, node.start.column - 1, node.end.line - 1, node.end.column);
}
/**
* @constructor
* @param {!WebInspector.TextRange} range
* @param {!WebInspector.TextRange} nameRange
* @param {!WebInspector.TextRange} valueRange
* @param {boolean} disabled
*/
WebInspector.SCSSParser.Property = function(range, nameRange, valueRange, disabled)
{
this.range = range;
this.name = nameRange;
this.value = valueRange;
this.disabled = disabled;
}
WebInspector.SCSSParser.Property.prototype = {
/**
* @param {!Gonzales.Node} commentNode
* @return {!WebInspector.SCSSParser.Property}
*/
<API key>: function(commentNode)
{
var lineOffset = commentNode.start.line - 1;
/**
* @param {!WebInspector.TextRange} range
* @param {number} lineOffset
* @param {number} columnOffset
* @return {!WebInspector.TextRange}
*/
function rebaseRange(range, lineOffset, columnOffset)
{
return new WebInspector.TextRange(range.startLine + lineOffset, range.startColumn + columnOffset, range.endLine + lineOffset, range.endColumn + columnOffset);
}
}
}
/**
* @constructor
* @param {!Array<!WebInspector.TextRange>} selectors
* @param {!Array<!WebInspector.SCSSParser.Property>} properties
* @param {!WebInspector.TextRange} styleRange
*/
WebInspector.SCSSParser.Rule = function(selectors, properties, styleRange)
{
this.selectors = selectors;
this.properties = properties;
this.styleRange = styleRange;
}
/**
* @param {!Gonzales.Node} node
* @param {!Array<{node: !Gonzales.Node, properties: !Array<!Gonzales.Node>}>} blocks
* @param {!{node: !Gonzales.Node, properties: !Array<!Gonzales.Node>}} lastBlock
*/
WebInspector.SCSSParser.extractNodes = function(node, blocks, lastBlock)
{
if (!Array.isArray(node.content))
return;
if (node.type === "block") {
lastBlock = {
node: node,
properties: []
};
blocks.push(lastBlock);
}
var lastDeclaration = null;
var selectors = [];
for (var i = 0; i < node.content.length; ++i) {
var child = node.content[i];
if (child.type === "<API key>" && lastDeclaration) {
lastDeclaration.declarationRange.endLine = child.end.line - 1;
lastDeclaration.declarationRange.endColumn = child.end.column;
lastDeclaration = null;
} else if (child.type === "selector") {
selectors.push(child);
} else if (child.type === "block") {
child.selectors = selectors;
selectors = [];
}
if (child.type === "include" || child.type === "declaration" || child.type === "multilineComment")
lastBlock.properties.push(child);
if (child.type === "declaration") {
lastDeclaration = child;
lastDeclaration.declarationRange = WebInspector.TextRange.createFromLocation(child.start.line - 1, child.start.column - 1);
}
WebInspector.SCSSParser.extractNodes(child, blocks, lastBlock);
}
if (lastDeclaration) {
lastDeclaration.declarationRange.endLine = node.end.line - 1;
lastDeclaration.declarationRange.endColumn = node.end.column - 1;
}
} |
#include "config.h"
#include "core/layout/<API key>.h"
#include "core/layout/LayoutImage.h"
#include "core/layout/LayoutTestHelper.h"
#include "platform/graphics/GraphicsContext.h"
#include "platform/graphics/paint/DisplayItemList.h"
#include <gtest/gtest.h>
namespace blink {
class <API key> : public RenderingTest {
protected:
<API key>* controller() { return m_controller; }
private:
virtual void SetUp() override
{
m_controller = <API key>::<API key>();
RenderingTest::SetUp();
}
virtual void TearDown() override
{
}
<API key>* m_controller;
};
TEST_F(<API key>, RegularImage)
{
setBodyInnerHTML("<img src='myimage'></img>");
LayoutObject* obj = document().body()->firstChild()->layoutObject();
EXPECT_EQ(<API key>, controller()-><API key>(nullptr, obj, nullptr, nullptr, LayoutSize()));
}
TEST_F(<API key>, <API key>)
{
setBodyInnerHTML("<img src='myimage' style='image-rendering: pixelated'></img>");
LayoutObject* obj = document().body()->firstChild()->layoutObject();
EXPECT_EQ(InterpolationNone, controller()-><API key>(nullptr, obj, nullptr, nullptr, LayoutSize()));
}
#if !USE(<API key>)
class TestImageAnimated : public Image {
public:
virtual bool maybeAnimated() override { return true; }
virtual bool <API key>() override { return false; }
virtual IntSize size() const override { return IntSize(); }
virtual void destroyDecodedData(bool) override { }
virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, SkXfermode::Mode, <API key>) override { }
};
TEST_F(<API key>, ImageMaybeAnimated)
{
setBodyInnerHTML("<img src='myimage'></img>");
LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
RefPtr<TestImageAnimated> testImage = adoptRef(new TestImageAnimated);
EXPECT_EQ(InterpolationMedium, controller()-><API key>(nullptr, img, testImage.get(), nullptr, LayoutSize()));
}
class <API key> : public Image {
public:
virtual bool maybeAnimated() override { return true; }
virtual bool <API key>() override { return false; }
virtual IntSize size() const override { return IntSize(); }
virtual void destroyDecodedData(bool) override { }
virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, SkXfermode::Mode, <API key>) override { }
virtual bool isBitmapImage() const override { return true; };
};
TEST_F(<API key>, <API key>)
{
setBodyInnerHTML("<img src='myimage' style='image-rendering: -<API key>'></img>");
LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
RefPtr<<API key>> testImage = adoptRef(new <API key>);
EXPECT_EQ(InterpolationLow, controller()-><API key>(nullptr, img, testImage.get(), testImage.get(), LayoutSize()));
}
class TestImageLowQuality : public Image {
public:
virtual bool maybeAnimated() override { return true; }
virtual bool <API key>() override { return false; }
virtual IntSize size() const override { return IntSize(1, 1); }
virtual void destroyDecodedData(bool) override { }
virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, SkXfermode::Mode, <API key>) override { }
virtual bool isBitmapImage() const override { return true; };
};
TEST_F(<API key>, <API key>)
{
setBodyInnerHTML("<img src='myimage'></img>");
LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
OwnPtr<DisplayItemList> displayItemList = DisplayItemList::create();
GraphicsContext context(displayItemList.get());
EXPECT_EQ(InterpolationMedium, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(1, 1)));
}
class MockTimer : public Timer<<API key>> {
typedef void (<API key>::*TimerFiredFunction)(Timer*);
public:
MockTimer(<API key>* o, TimerFiredFunction f)
: Timer<<API key>>(o, f)
{
}
void fire()
{
this->Timer<<API key>>::fired();
stop();
}
};
TEST_F(<API key>, <API key>)
{
MockTimer* mockTimer = new MockTimer(controller(), &<API key>::<API key>);
controller()->setTimer(mockTimer);
setBodyInnerHTML("<img src='myimage'></img>");
LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
OwnPtr<DisplayItemList> displayItemList = DisplayItemList::create();
GraphicsContext context(displayItemList.get());
// Start a resize
document().frame()->view()->willStartLiveResize();
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(2, 2)));
document().frame()->view()->willEndLiveResize();
// End of live resize, but timer has not fired. Therefore paint at non-low quality.
EXPECT_EQ(InterpolationMedium, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(3, 3)));
// Start another resize
document().frame()->view()->willStartLiveResize();
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(3, 3)));
// While still in resize, expire the timer.
document().frame()->view()->willEndLiveResize();
mockTimer->fire();
// End of live resize, and timer has fired. Therefore paint at non-low quality, even though the size has changed.
EXPECT_EQ(InterpolationMedium, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
}
TEST_F(<API key>, <API key>)
{
MockTimer* mockTimer = new MockTimer(controller(), &<API key>::<API key>);
controller()->setTimer(mockTimer);
setBodyInnerHTML("<img src='myimage'></img>");
LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
OwnPtr<DisplayItemList> displayItemList = DisplayItemList::create();
GraphicsContext context(displayItemList.get());
// Paint once. This will kick off a timer to see if we resize it during that timer's execution.
EXPECT_EQ(InterpolationMedium, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(2, 2)));
// Go into low-quality mode now that the size changed.
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(3, 3)));
// Stay in low-quality mode since the size changed again.
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
mockTimer->fire();
// The timer fired before painting at another size, so this doesn't count as animation. Therefore not painting at low quality.
EXPECT_EQ(InterpolationMedium, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
}
TEST_F(<API key>, <API key>)
{
MockTimer* mockTimer = new MockTimer(controller(), &<API key>::<API key>);
controller()->setTimer(mockTimer);
setBodyInnerHTML("<img src='myimage'></img>");
LayoutImage* img = toLayoutImage(document().body()->firstChild()->layoutObject());
RefPtr<TestImageLowQuality> testImage = adoptRef(new TestImageLowQuality);
OwnPtr<DisplayItemList> displayItemList = DisplayItemList::create();
GraphicsContext context(displayItemList.get());
// Paint once. This will kick off a timer to see if we resize it during that timer's execution.
EXPECT_EQ(InterpolationMedium, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(2, 2)));
// Go into low-quality mode now that the size changed.
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(3, 3)));
// Stay in low-quality mode since the size changed again.
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
mockTimer->stop();
EXPECT_FALSE(mockTimer->isActive());
// Painted at the same size, so even though timer is still executing, don't go to low quality.
EXPECT_EQ(InterpolationLow, controller()-><API key>(&context, img, testImage.get(), testImage.get(), LayoutSize(4, 4)));
// Check that the timer was not kicked. It should not have been, since the image was painted at the same size as last time.
EXPECT_FALSE(mockTimer->isActive());
}
#endif
} // namespace blink |
id: <API key>
title: Build the Game of Life
challengeType: 3
forumTopicId: 302362
dashedName: <API key>
# --description--
**Objective:** Build a [CodePen.io](https:
Fulfill the below [user stories](https://en.wikipedia.org/wiki/User_story). Use whichever libraries or APIs you need. Give it your own personal style.
**User Story:** When I first arrive at the game, it will randomly generate a board and start playing.
**User Story:** I can start and stop the board.
**User Story:** I can set up the board.
**User Story:** I can clear the board.
**User Story:** When I press start, the game will play out.
**User Story:** Each time the board changes, I can see how many generations have gone by.
**Hint:** Here's an explanation of Conway's Game of Life from John Conway himself: <https:
**Hint:** Here's an overview of Conway's Game of Life with rules for your reference: [https:
When you are finished, include a link to your project on CodePen and click the "I've completed this challenge" button.
You can get feedback on your project by sharing it on the [freeCodeCamp forum](https://forum.freecodecamp.org/c/project-feedback/409).
# --solutions--
js
// solution required |
#ifndef <API key>
#define <API key>
#include <stdint.h>
#include <memory>
#include "base/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/observer_list.h"
#include "base/trace_event/<API key>.h"
#include "components/viz/common/display/<API key>.h"
#include "components/viz/common/gpu/<API key>.h"
#include "components/viz/common/gpu/context_provider.h"
#include "components/viz/common/gpu/gpu_vsync_callback.h"
#include "components/viz/service/viz_service_export.h"
#include "gpu/command_buffer/common/<API key>.h"
#include "gpu/ipc/common/surface_handle.h"
#include "gpu/ipc/<API key>.h"
#include "ui/gfx/native_widget_types.h"
class GrDirectContext;
namespace gpu {
namespace gles2 {
class GLES2CmdHelper;
class GLES2Implementation;
} // namespace gles2
class <API key>;
class <API key>;
class <API key>;
class ImageFactory;
class <API key>;
class TransferBuffer;
struct SharedMemoryLimits;
} // namespace gpu
namespace skia_bindings {
class <API key>;
}
namespace viz {
class ContextLostObserver;
class <API key>;
class <API key>;
class RendererSettings;
// A ContextProvider used in the viz process to setup an <API key>
// for the display compositor.
class VIZ_SERVICE_EXPORT <API key>
: public base::<API key><<API key>>,
public ContextProvider,
public base::trace_event::MemoryDumpProvider {
public:
<API key>(
gpu::<API key>* task_executor,
gpu::SurfaceHandle surface_handle,
gpu::<API key>* <API key>,
gpu::ImageFactory* image_factory,
gpu::<API key>* <API key>,
<API key>* display_controller,
const RendererSettings& renderer_settings);
// ContextProvider implementation.
void AddRef() const override;
void Release() const override;
gpu::ContextResult BindToCurrentThread() override;
gpu::gles2::GLES2Interface* ContextGL() override;
gpu::ContextSupport* ContextSupport() override;
class GrDirectContext* GrContext() override;
gpu::<API key>* <API key>() override;
<API key>* CacheController() override;
base::Lock* GetLock() override;
const gpu::Capabilities& ContextCapabilities() const override;
const gpu::GpuFeatureInfo& GetGpuFeatureInfo() const override;
void AddObserver(ContextLostObserver* obs) override;
void RemoveObserver(ContextLostObserver* obs) override;
virtual void <API key>(
<API key> callback);
virtual void SetGpuVSyncCallback(GpuVSyncCallback callback);
virtual void SetGpuVSyncEnabled(bool enabled);
virtual bool <API key>() const;
// Provides the GL internal format that should be used when calling
// glCopyTexImage2D() on the default framebuffer.
virtual uint32_t <API key>();
virtual base::ScopedClosureRunner <API key>();
void <API key>();
protected:
friend class base::<API key><<API key>>;
<API key>(); // For testing only.
~<API key>() override;
private:
void InitializeContext(
gpu::<API key>* task_executor,
gpu::SurfaceHandle surface_handle,
gpu::<API key>* <API key>,
gpu::ImageFactory* image_factory,
gpu::<API key>* <API key>,
<API key>* display_controller,
const gpu::SharedMemoryLimits& mem_limits);
void OnContextLost();
// base::trace_event::MemoryDumpProvider implementation.
bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) override;
const gpu::<API key> attributes_;
// The |<API key>| has 1:1 relationship with the Display
// compositor.
raw_ptr<gpu::<API key>> <API key>;
std::unique_ptr<gpu::<API key>> command_buffer_;
std::unique_ptr<gpu::gles2::GLES2CmdHelper> gles2_helper_;
std::unique_ptr<gpu::TransferBuffer> transfer_buffer_;
std::unique_ptr<gpu::gles2::GLES2Implementation> <API key>;
std::unique_ptr<<API key>> cache_controller_;
gpu::ContextResult context_result_ = gpu::ContextResult::kSuccess;
std::unique_ptr<skia_bindings::<API key>> gr_context_;
base::ObserverList<ContextLostObserver>::Unchecked observers_;
};
} // namespace viz
#endif // <API key> |
#include "base.h"
#include "log.h"
#include "buffer.h"
#include "plugin.h"
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
/**
* this is a skeleton for a lighttpd plugin
*
* just replaces every occurance of 'skeleton' by your plugin name
*
* e.g. in vim:
*
* :%s/skeleton/myhandler/
*
*/
/* plugin config for all request/connections */
typedef struct {
array *match;
} plugin_config;
typedef struct {
PLUGIN_DATA;
buffer *match_buf;
plugin_config **config_storage;
plugin_config conf;
} plugin_data;
typedef struct {
size_t foo;
} handler_ctx;
static handler_ctx * handler_ctx_init() {
handler_ctx * hctx;
hctx = calloc(1, sizeof(*hctx));
return hctx;
}
static void handler_ctx_free(handler_ctx *hctx) {
free(hctx);
}
/* init the plugin data */
INIT_FUNC(mod_skeleton_init) {
plugin_data *p;
p = calloc(1, sizeof(*p));
p->match_buf = buffer_init();
return p;
}
/* destroy the plugin data */
FREE_FUNC(mod_skeleton_free) {
plugin_data *p = p_d;
UNUSED(srv);
if (!p) return HANDLER_GO_ON;
if (p->config_storage) {
size_t i;
for (i = 0; i < srv->config_context->used; i++) {
plugin_config *s = p->config_storage[i];
if (NULL == s) continue;
array_free(s->match);
free(s);
}
free(p->config_storage);
}
buffer_free(p->match_buf);
free(p);
return HANDLER_GO_ON;
}
/* handle plugin config and check values */
SETDEFAULTS_FUNC(<API key>) {
plugin_data *p = p_d;
size_t i = 0;
config_values_t cv[] = {
{ "skeleton.array", NULL, T_CONFIG_ARRAY, <API key> },
{ NULL, NULL, T_CONFIG_UNSET, <API key> }
};
if (!p) return HANDLER_ERROR;
p->config_storage = calloc(1, srv->config_context->used * sizeof(plugin_config *));
for (i = 0; i < srv->config_context->used; i++) {
plugin_config *s;
s = calloc(1, sizeof(plugin_config));
s->match = array_init();
cv[0].destination = s->match;
p->config_storage[i] = s;
if (0 != <API key>(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
return HANDLER_ERROR;
}
}
return HANDLER_GO_ON;
}
#define PATCH(x) \
p->conf.x = s->x;
static int <API key>(server *srv, connection *con, plugin_data *p) {
size_t i, j;
plugin_config *s = p->config_storage[0];
PATCH(match);
/* skip the first, the global context */
for (i = 1; i < srv->config_context->used; i++) {
data_config *dc = (data_config *)srv->config_context->data[i];
s = p->config_storage[i];
/* condition didn't match */
if (!config_check_cond(srv, con, dc)) continue;
/* merge config */
for (j = 0; j < dc->value->used; j++) {
data_unset *du = dc->value->data[j];
if (<API key>(du->key, CONST_STR_LEN("skeleton.array"))) {
PATCH(match);
}
}
}
return 0;
}
#undef PATCH
URIHANDLER_FUNC(<API key>) {
plugin_data *p = p_d;
int s_len;
size_t k, i;
UNUSED(srv);
if (con->mode != DIRECT) return HANDLER_GO_ON;
if (con->uri.path->used == 0) return HANDLER_GO_ON;
<API key>(srv, con, p);
s_len = con->uri.path->used - 1;
for (k = 0; k < p->conf.match->used; k++) {
data_string *ds = (data_string *)p->conf.match->data[k];
int ct_len = ds->value->used - 1;
if (ct_len > s_len) continue;
if (ds->value->used == 0) continue;
if (0 == strncmp(con->uri.path->ptr + s_len - ct_len, ds->value->ptr, ct_len)) {
con->http_status = 403;
return HANDLER_FINISHED;
}
}
/* not found */
return HANDLER_GO_ON;
}
/* this function is called at dlopen() time and inits the callbacks */
int <API key>(plugin *p) {
p->version = LIGHTTPD_VERSION_ID;
p->name = buffer_init_string("skeleton");
p->init = mod_skeleton_init;
p->handle_uri_clean = <API key>;
p->set_defaults = <API key>;
p->cleanup = mod_skeleton_free;
p->data = NULL;
return 0;
} |
#include "cc/resources/<API key>.h"
#include <algorithm>
#include "base/containers/stack_container.h"
#include "base/debug/trace_event.h"
#include "base/debug/<API key>.h"
#include "cc/debug/traced_value.h"
#include "cc/resources/resource.h"
#include "gpu/command_buffer/client/gles2_interface.h"
namespace cc {
namespace {
const int <API key> = 6;
const size_t <API key> = 48;
typedef base::StackVector<RasterTask*, <API key>>
RasterTaskVector;
} // namespace
// static
scoped_ptr<RasterWorkerPool> <API key>::Create(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
size_t <API key>) {
return make_scoped_ptr<RasterWorkerPool>(
new <API key>(task_runner,
task_graph_runner,
context_provider,
resource_provider,
<API key>));
}
<API key>::<API key>(
base::SequencedTaskRunner* task_runner,
TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
size_t <API key>)
: task_runner_(task_runner),
task_graph_runner_(task_graph_runner),
namespace_token_(task_graph_runner->GetNamespaceToken()),
context_provider_(context_provider),
resource_provider_(resource_provider),
shutdown_(false),
<API key>(0u),
<API key>(0u),
<API key>(0u),
<API key>(<API key>),
<API key>(false),
<API key>(false),
<API key>(
false),
<API key>(false),
<API key>(false),
<API key>(
task_runner,
base::Bind(&<API key>::<API key>,
base::Unretained(this)),
base::TimeDelta::FromMilliseconds(
<API key>)),
<API key>(this) {
DCHECK(context_provider_);
}
<API key>::~<API key>() {
DCHECK_EQ(0u, raster_task_states_.size());
DCHECK_EQ(0u, <API key>.size());
DCHECK_EQ(0u, <API key>.size());
DCHECK_EQ(0u, <API key>.size());
DCHECK_EQ(0u, <API key>);
}
Rasterizer* <API key>::AsRasterizer() { return this; }
void <API key>::SetClient(RasterizerClient* client) {
client_ = client;
}
void <API key>::Shutdown() {
TRACE_EVENT0("cc", "<API key>::Shutdown");
shutdown_ = true;
TaskGraph empty;
task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
task_graph_runner_-><API key>(namespace_token_);
<API key>();
<API key>();
<API key>.Cancel();
for (RasterTaskState::Vector::iterator it = raster_task_states_.begin();
it != raster_task_states_.end();
++it) {
RasterTaskState& state = *it;
// All unscheduled tasks need to be canceled.
if (state.type == RasterTaskState::UNSCHEDULED) {
<API key>.push_back(state.task);
state.type = RasterTaskState::COMPLETED;
}
}
DCHECK_EQ(<API key>.size(), raster_task_states_.size());
}
void <API key>::ScheduleTasks(RasterTaskQueue* queue) {
TRACE_EVENT0("cc", "<API key>::ScheduleTasks");
DCHECK_EQ(queue-><API key>,
static_cast<size_t>(
std::count_if(queue->items.begin(),
queue->items.end(),
RasterTaskQueue::Item::<API key>)));
if (!<API key>)
<API key>("cc", "ScheduledTasks", this);
<API key> = true;
<API key> = true;
<API key> = 0u;
// Update raster task state and remove items from old queue.
for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
it != queue->items.end();
++it) {
const RasterTaskQueue::Item& item = *it;
RasterTask* task = item.task;
// Remove any old items that are associated with this task. The result is
// that the old queue is left with all items not present in this queue,
// which we use below to determine what tasks need to be canceled.
RasterTaskQueue::Item::Vector::iterator old_it =
std::find_if(raster_tasks_.items.begin(),
raster_tasks_.items.end(),
RasterTaskQueue::Item::TaskComparator(task));
if (old_it != raster_tasks_.items.end()) {
std::swap(*old_it, raster_tasks_.items.back());
raster_tasks_.items.pop_back();
}
RasterTaskState::Vector::iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
if (state_it != raster_task_states_.end()) {
RasterTaskState& state = *state_it;
state.<API key> = item.<API key>;
// |<API key>| accounts for all tasks
// that need to complete before we can send a "ready to activate" signal.
// Tasks that have already completed should not be part of this count.
if (state.type != RasterTaskState::COMPLETED) {
<API key> +=
item.<API key>;
}
continue;
}
DCHECK(!task->HasBeenScheduled());
raster_task_states_.push_back(
RasterTaskState(task, item.<API key>));
<API key> += item.<API key>;
}
// Determine what tasks in old queue need to be canceled.
for (RasterTaskQueue::Item::Vector::const_iterator it =
raster_tasks_.items.begin();
it != raster_tasks_.items.end();
++it) {
const RasterTaskQueue::Item& item = *it;
RasterTask* task = item.task;
RasterTaskState::Vector::iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
// We've already processed completion if we can't find a RasterTaskState for
// this task.
if (state_it == raster_task_states_.end())
continue;
RasterTaskState& state = *state_it;
// Unscheduled task can be canceled.
if (state.type == RasterTaskState::UNSCHEDULED) {
DCHECK(!task->HasBeenScheduled());
DCHECK(std::find(<API key>.begin(),
<API key>.end(),
task) == <API key>.end());
<API key>.push_back(task);
state.type = RasterTaskState::COMPLETED;
}
// No longer required for activation.
state.<API key> = false;
}
raster_tasks_.Swap(queue);
// Check for completed tasks when ScheduleTasks() is called as
// priorities might have changed and this maximizes the number
// of top priority tasks that are scheduled.
<API key>();
<API key>();
FlushUploads();
// Schedule new tasks.
ScheduleMoreTasks();
// Reschedule check for completed raster tasks.
<API key>.Schedule();
<API key>(
"cc", "ScheduledTasks", this, StateName(), "state", StateAsValue());
}
void <API key>::<API key>() {
TRACE_EVENT0("cc", "<API key>::<API key>");
<API key>();
<API key>();
FlushUploads();
for (RasterizerTask::Vector::const_iterator it =
<API key>.begin();
it != <API key>.end();
++it) {
RasterizerTask* task = it->get();
task-><API key>();
}
<API key>.clear();
for (RasterTask::Vector::const_iterator it = <API key>.begin();
it != <API key>.end();
++it) {
RasterTask* task = it->get();
RasterTaskState::Vector::iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
DCHECK(state_it != raster_task_states_.end());
DCHECK_EQ(RasterTaskState::COMPLETED, state_it->type);
std::swap(*state_it, raster_task_states_.back());
raster_task_states_.pop_back();
task-><API key>();
}
<API key>.clear();
}
SkCanvas* <API key>::<API key>(
RasterTask* task) {
DCHECK(std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task)) !=
raster_task_states_.end());
resource_provider_-><API key>(task->resource()->id());
return resource_provider_-><API key>(task->resource()->id());
}
void <API key>::<API key>(RasterTask* task) {
DCHECK(std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task)) !=
raster_task_states_.end());
resource_provider_-><API key>(task->resource()->id());
}
void <API key>::OnRasterFinished() {
TRACE_EVENT0("cc", "<API key>::OnRasterFinished");
// |<API key>| can be set to false as
// a result of a scheduled <API key>() call. No need to
// perform another check in that case as we've already notified the client.
if (!<API key>)
return;
<API key> = false;
// Call <API key>() when we've finished running all
// raster tasks needed since last time ScheduleTasks() was called.
// This reduces latency between the time when all tasks have finished
// running and the time when the client is notified.
<API key>();
}
void <API key>::<API key>() {
TRACE_EVENT0(
"cc",
"<API key>::<API key>");
// Analogous to <API key>(), there's no need to call
// <API key>() if the client has already been notified.
if (!<API key>)
return;
<API key> = false;
// This reduces latency between the time when all tasks required for
// activation have finished running and the time when the client is
// notified.
<API key>();
}
void <API key>::FlushUploads() {
if (!<API key>)
return;
context_provider_->ContextGL()-><API key>();
<API key> = false;
}
void <API key>::<API key>() {
RasterTask::Vector <API key>;
// First check if any have completed.
while (!<API key>.empty()) {
RasterTask* task = <API key>.front().get();
DCHECK(std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task)) !=
raster_task_states_.end());
DCHECK_EQ(RasterTaskState::UPLOADING,
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task))->type);
// Uploads complete in the order they are issued.
if (!resource_provider_-><API key>(task->resource()->id()))
break;
<API key>.push_back(task);
<API key>.pop_front();
}
DCHECK(client_);
bool <API key> =
shutdown_ || client_-><API key>();
if (<API key>) {
RasterTask::Vector <API key>;
RasterTaskDeque::iterator it = <API key>.begin();
while (it != <API key>.end()) {
RasterTask* task = it->get();
RasterTaskState::Vector::const_iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
DCHECK(state_it != raster_task_states_.end());
const RasterTaskState& state = *state_it;
// Force all uploads required for activation to complete.
// During shutdown, force all pending uploads to complete.
if (shutdown_ || state.<API key>) {
<API key>.push_back(task);
<API key>.push_back(task);
it = <API key>.erase(it);
continue;
}
++it;
}
// Force uploads in reverse order. Since forcing can cause a wait on
// all previous uploads, we would rather wait only once downstream.
for (RasterTask::Vector::reverse_iterator it =
<API key>.rbegin();
it != <API key>.rend();
++it) {
RasterTask* task = it->get();
resource_provider_-><API key>(task->resource()->id());
<API key> = true;
}
}
// Release shared memory and move tasks with completed uploads
// to |<API key>|.
for (RasterTask::Vector::const_iterator it =
<API key>.begin();
it != <API key>.end();
++it) {
RasterTask* task = it->get();
RasterTaskState::Vector::iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
DCHECK(state_it != raster_task_states_.end());
RasterTaskState& state = *state_it;
<API key> -= task->resource()->bytes();
task->WillComplete();
task-><API key>(this);
task->DidComplete();
// Async set pixels commands are not necessarily processed in-sequence with
// drawing commands. Read lock fences are required to ensure that async
// commands don't access the resource while used for drawing.
resource_provider_-><API key>(task->resource()->id());
DCHECK(std::find(<API key>.begin(),
<API key>.end(),
task) == <API key>.end());
<API key>.push_back(task);
state.type = RasterTaskState::COMPLETED;
DCHECK_LE(static_cast<size_t>(state.<API key>),
<API key>);
<API key> -=
state.<API key>;
}
}
void <API key>::<API key>() {
TRACE_EVENT0("cc",
"<API key>::<API key>");
// Since this function can be called directly, cancel any pending checks.
<API key>.Cancel();
DCHECK(<API key>);
<API key>();
<API key>();
FlushUploads();
// Determine what client notifications to generate.
bool <API key> =
(<API key> &&
!<API key> &&
!<API key>());
bool <API key> =
(<API key> &&
!<API key> &&
!<API key> && !HasPendingTasks());
// Adjust the need to generate notifications before scheduling more tasks.
<API key> &=
!<API key>;
<API key> &=
!<API key>;
<API key> = 0;
if (<API key>())
ScheduleMoreTasks();
<API key>(
"cc", "ScheduledTasks", this, StateName(), "state", StateAsValue());
// Schedule another check for completed raster tasks while there are
// pending raster tasks or pending uploads.
if (HasPendingTasks())
<API key>.Schedule();
// Generate client notifications.
if (<API key>) {
DCHECK(!<API key>());
client_-><API key>();
}
if (<API key>) {
<API key>("cc", "ScheduledTasks", this);
DCHECK(!<API key>());
client_-><API key>();
}
}
void <API key>::ScheduleMoreTasks() {
TRACE_EVENT0("cc", "<API key>::ScheduleMoreTasks");
RasterTaskVector tasks;
RasterTaskVector <API key>;
unsigned priority = <API key>;
graph_.Reset();
size_t <API key> = <API key>;
bool <API key> = false;
bool <API key> = false;
for (RasterTaskQueue::Item::Vector::const_iterator it =
raster_tasks_.items.begin();
it != raster_tasks_.items.end();
++it) {
const RasterTaskQueue::Item& item = *it;
RasterTask* task = item.task;
// |raster_task_states_| contains the state of all tasks that we have not
// yet run reply callbacks for.
RasterTaskState::Vector::iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(task));
if (state_it == raster_task_states_.end())
continue;
RasterTaskState& state = *state_it;
// Skip task if completed.
if (state.type == RasterTaskState::COMPLETED) {
DCHECK(std::find(<API key>.begin(),
<API key>.end(),
task) != <API key>.end());
continue;
}
// All raster tasks need to be throttled by bytes of pending uploads,
// but if it's the only task allow it to complete no matter what its size,
// to prevent starvation of the task queue.
size_t <API key> = <API key>;
<API key> += task->resource()->bytes();
if (<API key> > <API key> &&
<API key>) {
<API key> = true;
if (item.<API key>)
<API key> = true;
continue;
}
// If raster has finished, just update |<API key>|.
if (state.type == RasterTaskState::UPLOADING) {
DCHECK(!task->HasCompleted());
<API key> = <API key>;
continue;
}
// Throttle raster tasks based on <API key>.
if (tasks.container().size() >= <API key>) {
<API key> = true;
if (item.<API key>)
<API key> = true;
continue;
}
// Update |<API key>| now that task has cleared all
// throttling limits.
<API key> = <API key>;
DCHECK(state.type == RasterTaskState::UNSCHEDULED ||
state.type == RasterTaskState::SCHEDULED);
state.type = RasterTaskState::SCHEDULED;
<API key>(&graph_, task, task->dependencies(), priority++);
tasks.container().push_back(task);
if (item.<API key>)
<API key>.container().push_back(task);
}
// Cancel existing OnRasterFinished callbacks.
<API key>.InvalidateWeakPtrs();
scoped_refptr<RasterizerTask>
<API key>;
size_t <API key> =
<API key>.container().size();
DCHECK_LE(<API key>,
<API key>);
// Schedule <API key> call only when
// notification is pending and throttling is not preventing all pending
// tasks required for activation from being scheduled.
if (!<API key> &&
<API key>) {
<API key> =
<API key>(
raster_tasks_.<API key>,
task_runner_.get(),
base::Bind(&<API key>::
<API key>,
<API key>.GetWeakPtr()));
<API key> = true;
InsertNodeForTask(&graph_,
<API key>.get(),
<API key>,
<API key>);
for (RasterTaskVector::ContainerType::const_iterator it =
<API key>.container().begin();
it != <API key>.container().end();
++it) {
graph_.edges.push_back(TaskGraph::Edge(
*it, <API key>.get()));
}
}
scoped_refptr<RasterizerTask> <API key>;
size_t <API key> = tasks.container().size();
DCHECK_LE(<API key>, <API key>());
// Schedule <API key> call only when notification is pending
// and throttling is not preventing all pending tasks from being scheduled.
if (!<API key> &&
<API key>) {
<API key> = <API key>(
task_runner_.get(),
base::Bind(&<API key>::OnRasterFinished,
<API key>.GetWeakPtr()));
<API key> = true;
InsertNodeForTask(&graph_,
<API key>.get(),
<API key>,
<API key>);
for (RasterTaskVector::ContainerType::const_iterator it =
tasks.container().begin();
it != tasks.container().end();
++it) {
graph_.edges.push_back(
TaskGraph::Edge(*it, <API key>.get()));
}
}
<API key>(this, &graph_);
task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
<API key> = <API key>;
<API key> = <API key>;
<API key> =
<API key>;
}
unsigned <API key>::<API key>() const {
unsigned <API key> =
<API key>.size() + <API key>.size();
DCHECK_GE(raster_task_states_.size(), <API key>);
return raster_task_states_.size() - <API key>;
}
bool <API key>::HasPendingTasks() const {
return <API key>() || !<API key>.empty();
}
bool <API key>::<API key>() const {
return !!<API key>;
}
const char* <API key>::StateName() const {
if (<API key>)
return "rasterizing";
if (<API key>())
return "throttled";
if (!<API key>.empty())
return "waiting_for_uploads";
return "finishing";
}
void <API key>::<API key>() {
TRACE_EVENT0("cc",
"<API key>::<API key>");
task_graph_runner_-><API key>(namespace_token_,
&completed_tasks_);
for (Task::Vector::const_iterator it = completed_tasks_.begin();
it != completed_tasks_.end();
++it) {
RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
RasterTask* raster_task = task->AsRasterTask();
if (!raster_task) {
task->WillComplete();
task-><API key>(this);
task->DidComplete();
<API key>.push_back(task);
continue;
}
RasterTaskState::Vector::iterator state_it =
std::find_if(raster_task_states_.begin(),
raster_task_states_.end(),
RasterTaskState::TaskComparator(raster_task));
DCHECK(state_it != raster_task_states_.end());
RasterTaskState& state = *state_it;
DCHECK_EQ(RasterTaskState::SCHEDULED, state.type);
// Balanced with <API key>() call in <API key>().
bool content_has_changed = resource_provider_-><API key>(
raster_task->resource()->id());
// |content_has_changed| can be false as result of task being canceled or
// task implementation deciding not to modify bitmap (ie. analysis of raster
// commands detected content as a solid color).
if (!content_has_changed) {
raster_task->WillComplete();
raster_task-><API key>(this);
raster_task->DidComplete();
if (!raster_task->HasFinishedRunning()) {
// When priorites change, a raster task can be canceled as a result of
// no longer being of high enough priority to fit in our throttled
// raster task budget. The task has not yet completed in this case.
RasterTaskQueue::Item::Vector::const_iterator item_it =
std::find_if(raster_tasks_.items.begin(),
raster_tasks_.items.end(),
RasterTaskQueue::Item::TaskComparator(raster_task));
if (item_it != raster_tasks_.items.end()) {
state.type = RasterTaskState::UNSCHEDULED;
continue;
}
}
DCHECK(std::find(<API key>.begin(),
<API key>.end(),
raster_task) == <API key>.end());
<API key>.push_back(raster_task);
state.type = RasterTaskState::COMPLETED;
DCHECK_LE(static_cast<size_t>(state.<API key>),
<API key>);
<API key> -=
state.<API key>;
continue;
}
DCHECK(raster_task->HasFinishedRunning());
resource_provider_->BeginSetPixels(raster_task->resource()->id());
<API key> = true;
<API key> += raster_task->resource()->bytes();
<API key>.push_back(raster_task);
state.type = RasterTaskState::UPLOADING;
}
completed_tasks_.clear();
}
scoped_refptr<base::debug::<API key>>
<API key>::StateAsValue() const {
scoped_refptr<base::debug::TracedValue> state =
new base::debug::TracedValue();
state->SetInteger("completed_count", <API key>.size());
state->SetInteger("pending_count", raster_task_states_.size());
state->SetInteger("<API key>",
<API key>.size());
state->SetInteger("<API key>",
<API key>);
state->BeginDictionary("throttle_state");
<API key>(state.get());
state->EndDictionary();
return state;
}
void <API key>::<API key>(
base::debug::TracedValue* throttle_state) const {
throttle_state->SetInteger("<API key>",
<API key> - <API key>);
throttle_state->SetInteger("<API key>", <API key>);
throttle_state->SetInteger("<API key>",
<API key>);
}
} // namespace cc |
<?php
$var="3".chr(0)."foo";
var_dump(filter_var($var, FILTER_VALIDATE_INT));
$var="3".chr(0)."foo";
var_dump(filter_var($var, <API key>));
?> |
#ifndef _LIBU_SYSLOG_H_
#define _LIBU_SYSLOG_H_
#include <stdarg.h>
#ifdef HAVE_SYSLOG
#include <syslog.h>
#else
#ifdef __cplusplus
extern "C" {
#endif
/* level codes */
#define LOG_EMERG 0
#define LOG_ALERT 1
#define LOG_CRIT 2
#define LOG_ERR 3
#define LOG_WARNING 4
#define LOG_NOTICE 5
#define LOG_INFO 6
#define LOG_DEBUG 7
/* facility codes */
#define LOG_KERN (0<<3)
#define LOG_USER (1<<3)
#define LOG_MAIL (2<<3)
#define LOG_DAEMON (3<<3)
#define LOG_AUTH (4<<3)
#define LOG_SYSLOG (5<<3)
#define LOG_LPR (6<<3)
#define LOG_NEWS (7<<3)
#define LOG_UUCP (8<<3)
#define LOG_CRON (9<<3)
#define LOG_AUTHPRIV (10<<3)
#define LOG_FTP (11<<3)
#define LOG_NETINFO (12<<3)
#define LOG_REMOTEAUTH (13<<3)
#define LOG_INSTALL (14<<3)
#define LOG_LOCAL0 (16<<3)
#define LOG_LOCAL1 (17<<3)
#define LOG_LOCAL2 (18<<3)
#define LOG_LOCAL3 (19<<3)
#define LOG_LOCAL4 (20<<3)
#define LOG_LOCAL5 (21<<3)
#define LOG_LOCAL6 (22<<3)
#define LOG_LOCAL7 (23<<3)
void syslog(int priority, const char *msg, ...);
void vsyslog(int priority, const char *msg, va_list args);
#ifdef __cplusplus
}
#endif
#endif /* !HAVE_SYSLOG */
#endif /* !_LIBU_SYSLOG_H_ */ |
#ifndef <API key>
#define <API key>
#include <memory>
#include "base/memory/scoped_refptr.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/receiver_set.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/blink/public/common/<API key>/<API key>.h"
#include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink-forward.h"
#include "third_party/blink/renderer/core/frame/local_frame_client.h"
#include "third_party/blink/renderer/core/frame/<API key>.h"
#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
#include "third_party/blink/renderer/platform/weborigin/kurl.h"
#include "third_party/blink/renderer/platform/wtf/casting.h"
namespace blink {
class <API key>;
class <API key>;
class WebLocalFrameImpl;
class <API key>;
class CORE_EXPORT <API key> final : public LocalFrameClient {
public:
explicit <API key>(WebLocalFrameImpl*);
~<API key>() override;
void Trace(Visitor*) const override;
WebLocalFrameImpl* GetWebFrame() const override;
<API key>* <API key>() const override;
void <API key>(DocumentLoader*) override;
// Notifies the WebView delegate that the JS window object has been cleared,
// giving it a chance to bind native objects to the window before script
// parsing begins.
void <API key>() override;
void <API key>() override;
void <API key>() override;
void <API key>(bool document_is_empty) override;
void <API key>() override;
void <API key>(v8::Local<v8::Context>,
int32_t world_id) override;
void <API key>(v8::Local<v8::Context>,
int32_t world_id) override;
// Returns true if we should allow register V8 extensions to be added.
bool <API key>() override;
bool HasWebView() const override;
bool InShadowTree() const override;
void WillBeDetached() override;
void Detached(FrameDetachType) override;
void <API key>(ResourceRequest&) override;
void <API key>(const ResourceRequest&,
const ResourceResponse&) override;
void <API key>() override;
void <API key>(HistoryItem*,
<API key>,
bool <API key>,
mojom::blink::<API key>,
bool is_client_redirect,
bool <API key>) override;
void <API key>(const KURL& url) override;
void <API key>(const String&) override;
void <API key>(
HistoryItem*,
<API key>,
bool <API key>,
const blink::<API key>& <API key>,
const blink::<API key>& <API key>) override;
void DispatchDidFailLoad(const ResourceError&, <API key>) override;
void <API key>() override;
void <API key>() override;
void <API key>() override;
void BeginNavigation(
const ResourceRequest&,
mojom::<API key>,
LocalDOMWindow* origin_window,
DocumentLoader*,
WebNavigationType,
NavigationPolicy,
WebFrameLoadType,
bool is_client_redirect,
mojom::blink::TriggeringEventInfo,
HTMLFormElement*,
network::mojom::CSPDisposition <API key>,
mojo::PendingRemote<mojom::blink::BlobURLToken>,
base::TimeTicks input_start_time,
const String& href_translate,
const absl::optional<WebImpression>& impression,
const LocalFrameToken* <API key>,
std::unique_ptr<SourceLocation> source_location,
mojo::PendingRemote<mojom::blink::<API key>>
<API key>) override;
void <API key>(HTMLFormElement*) override;
void DidStartLoading() override;
void DidStopLoading() override;
bool NavigateBackForward(int offset) const override;
void <API key>(const KURL&) override;
void <API key>() override;
void <API key>(base::TimeDelta) override;
void <API key>(base::TimeDelta max_event_duration,
base::TimeDelta <API key>,
UserInteractionType interaction_type) override;
void DidChangeCpuTiming(base::TimeDelta) override;
void <API key>(LoadingBehaviorFlag) override;
void <API key>(const UseCounterFeature&) override;
void <API key>(double score, bool <API key>) override;
void DidObserveLayoutNg(uint32_t all_block_count,
uint32_t ng_block_count,
uint32_t all_call_count,
uint32_t ng_call_count) override;
void <API key>(
const WTF::HashSet<scoped_refptr<const SecurityOrigin>,
SecurityOriginHash>& origins) override;
void <API key>(const Vector<String>& added_selectors,
const Vector<String>& removed_selectors) override;
// Creates a <API key> that is a DocumentLoader but also has:
// - storage to store an extra data that can be used by the content layer
// - wrapper methods to expose DocumentLoader's variables to the content
// layer
DocumentLoader* <API key>(
LocalFrame*,
WebNavigationType,
std::unique_ptr<WebNavigationParams> navigation_params,
std::unique_ptr<PolicyContainer> policy_container,
std::unique_ptr<WebDocumentLoader::ExtraData> extra_data) override;
String UserAgentOverride() override;
WTF::String UserAgent() override;
WTF::String FullUserAgent() override;
WTF::String ReducedUserAgent() override;
absl::optional<blink::UserAgentMetadata> UserAgentMetadata() override;
WTF::String DoNotTrackValue() override;
void <API key>() override;
LocalFrame* CreateFrame(const WTF::AtomicString& name,
<API key>*) override;
std::pair<RemoteFrame*, PortalToken> CreatePortal(
HTMLPortalElement*,
mojo::<API key><mojom::blink::Portal>,
mojo::<API key><mojom::blink::PortalClient>) override;
RemoteFrame* AdoptPortal(HTMLPortalElement*) override;
RemoteFrame* CreateFencedFrame(
<API key>*,
mojo::<API key><mojom::blink::<API key>>)
override;
<API key>* CreatePlugin(HTMLPlugInElement&,
const KURL&,
const Vector<WTF::String>&,
const Vector<WTF::String>&,
const WTF::String&,
bool load_manually) override;
std::unique_ptr<WebMediaPlayer> <API key>(
HTMLMediaElement&,
const <API key>&,
<API key>*) override;
<API key>* <API key>(
HTMLMediaElement&) override;
void <API key>() override;
void <API key>() override;
bool <API key>(const KURL&) override;
void DidChangeName(const String&) override;
std::unique_ptr<<API key>> <API key>()
override;
<API key>* <API key>() override;
void <API key>() override;
unsigned BackForwardLength() override;
BlameContext* <API key>() override;
KURL <API key>(const KURL&) override;
void <API key>() override;
void <API key>() override;
<API key>* <API key>() const override;
WebTextCheckClient* <API key>() const override;
std::unique_ptr<WebURLLoaderFactory> <API key>() override;
blink::<API key>& <API key>() override;
<API key>* <API key>()
override;
void <API key>() override;
base::Unguessable<API key>() const override;
String <API key>(const String& script) override;
bool <API key>() override;
void DidChangeSelection(bool is_selection_empty,
blink::SyncCondition force_sync) override;
void DidChangeContents() override;
Frame* FindFrame(const AtomicString& name) const override;
void <API key>(Element* element) override;
void <API key>(
const gfx::Rect& intersection_rect) override;
void <API key>() override;
void <API key>() override;
bool <API key>(HTMLPlugInElement&,
const KURL&,
const String&) override;
v8::Local<v8::Object> GetScriptableObject(HTMLPlugInElement&,
v8::Isolate*) override;
scoped_refptr<<API key>> <API key>() override;
scoped_refptr<<API key>>
<API key>(
<API key>*) override;
std::unique_ptr<<API key>> <API key>()
override;
void SetMouseCapture(bool capture) override;
bool UsePrintingLayout() const override;
std::unique_ptr<blink::<API key>>
<API key>() override;
void BindDevToolsAgent(
mojo::<API key><mojom::blink::DevToolsAgentHost> host,
mojo::<API key><mojom::blink::DevToolsAgent> receiver)
override;
void <API key>(
std::unique_ptr<blink::<API key>> pending_factory)
override;
void <API key>(const MobileFriendliness&) override;
private:
bool <API key>() const override { return true; }
<API key>* DevToolsAgent();
// The WebFrame that owns this object and manages its lifetime. Therefore,
// the web frame object is guaranteed to exist.
Member<WebLocalFrameImpl> web_frame_;
String user_agent_;
String full_user_agent_;
String reduced_user_agent_;
};
template <>
struct DowncastTraits<<API key>> {
static bool AllowFrom(const LocalFrameClient& client) {
return client.<API key>();
}
};
} // namespace blink
#endif // <API key> |
#ifndef <API key>
#define <API key>
#include <stdint.h>
#include "base/compiler_specific.h"
#include "base/memory/weak_ptr.h"
#include "third_party/webrtc/api/<API key>.h"
namespace remoting {
namespace protocol {
class <API key>;
class <API key> : public rtc::PacketSocketFactory {
public:
explicit <API key>(
base::WeakPtr<<API key>> <API key>);
<API key>(const <API key>&) = delete;
<API key>& operator=(const <API key>&) =
delete;
~<API key>() override;
rtc::AsyncPacketSocket* CreateUdpSocket(
const rtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port) override;
rtc::AsyncListenSocket* <API key>(
const rtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) override;
rtc::AsyncPacketSocket* <API key>(
const rtc::SocketAddress& local_address,
const rtc::SocketAddress& remote_address,
const rtc::ProxyInfo& proxy_info,
const std::string& user_agent,
const rtc::<API key>& opts) override;
rtc::<API key>* CreateAsyncResolver() override;
private:
base::WeakPtr<<API key>> <API key>;
};
} // namespace protocol
} // namespace remoting
#endif // <API key> |
// SeqAn - The Library for Sequence Analysis
// modification, are permitted provided that the following conditions are met:
// documentation and/or other materials provided with the distribution.
// * Neither the name of Knut Reinert or the FU Berlin nor the names of
// its contributors may be used to endorse or promote products derived
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL KNUT REINERT OR THE FU BERLIN BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
#include <seqan/basic.h>
#include "test_consensus.h"
#include "<API key>.h"
<API key>(test_consensus)
{
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
SEQAN_CALL_TEST(<API key>);
// SEQAN_CALL_TEST(<API key>);
// SEQAN_CALL_TEST(<API key>);
// SEQAN_CALL_TEST(<API key>);
// SEQAN_CALL_TEST(<API key>);
}
SEQAN_END_TESTSUITE |
#ifndef _ASM_X86_CPU_H
#define _ASM_X86_CPU_H
#include <linux/device.h>
#include <linux/cpu.h>
#include <linux/topology.h>
#include <linux/nodemask.h>
#include <linux/percpu.h>
#ifdef CONFIG_SMP
extern void <API key>(void);
#else /* CONFIG_SMP */
static inline void <API key>(void) {}
#define cpu_physical_id(cpu) <API key>
#define cpu_acpi_id(cpu) 0
#define <API key>() 0
#endif /* CONFIG_SMP */
struct x86_cpu {
struct cpu cpu;
};
#ifdef CONFIG_HOTPLUG_CPU
extern int arch_register_cpu(int num);
extern void arch_unregister_cpu(int);
extern void start_cpu0(void);
#ifdef <API key>
extern int _debug_hotplug_cpu(int cpu, int action);
#endif
#endif
int mwait_usable(const struct cpuinfo_x86 *);
unsigned int x86_family(unsigned int sig);
unsigned int x86_model(unsigned int sig);
unsigned int x86_stepping(unsigned int sig);
#endif /* _ASM_X86_CPU_H */ |
// Code generated by protoc-gen-gogo.
// source: plugin.proto
// DO NOT EDIT!
/*
Package plugin_go is a generated protocol buffer package.
It is generated from these files:
plugin.proto
It has these top-level messages:
<API key>
<API key>
*/
package plugin_go
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
const _ = proto.<API key>
// An encoded <API key> is written to the plugin's stdin.
type <API key> struct {
// The .proto files that were explicitly listed on the command-line. The
// code generator should generate code only for these files. Each file's
// descriptor will be included in proto_file, below.
FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
// The generator parameter passed on the command-line.
Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
// <API key> for all files in files_to_generate and everything
// they import. The files will appear in topological order, so each file
// appears before any file that imports it.
// protoc guarantees that all proto_files will be written after
// the fields above, even though this is not technically guaranteed by the
// protobuf wire format. This theoretically could allow a plugin to stream
// in the <API key> and handle them one by one rather than read
// the entire set into memory at once. However, as of this writing, this
// is not similarly optimized on protoc's end -- it will store all fields in
// memory at once before sending them to the plugin.
ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return <API key>, []int{0} }
func (m *<API key>) GetFileToGenerate() []string {
if m != nil {
return m.FileToGenerate
}
return nil
}
func (m *<API key>) GetParameter() string {
if m != nil && m.Parameter != nil {
return *m.Parameter
}
return ""
}
func (m *<API key>) GetProtoFile() []*google_protobuf.FileDescriptorProto {
if m != nil {
return m.ProtoFile
}
return nil
}
// The plugin writes an encoded <API key> to stdout.
type <API key> struct {
// Error message. If non-empty, code generation failed. The plugin process
// should exit with status code zero even if it reports an error in this way.
// This should be used to indicate errors in .proto files which prevent the
// code generator from generating correct code. Errors which indicate a
// problem in protoc itself -- such as the input <API key> being
// unparseable -- should be reported by writing a message to stderr and
// exiting with a non-zero status code.
Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
File []*<API key> `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return <API key>, []int{1} }
func (m *<API key>) GetError() string {
if m != nil && m.Error != nil {
return *m.Error
}
return ""
}
func (m *<API key>) GetFile() []*<API key> {
if m != nil {
return m.File
}
return nil
}
// Represents a single generated file.
type <API key> struct {
// The file name, relative to the output directory. The name must not
// contain "." or ".." components and must be relative, not be absolute (so,
// the file cannot lie outside the output directory). "/" must be used as
// the path separator, not "\".
// If the name is omitted, the content will be appended to the previous
// file. This allows the generator to break large files into small chunks,
// and allows the generated text to be streamed back to protoc so that large
// files need not reside completely in memory at one time. Note that as of
// this writing protoc does not optimize for this -- it will read the entire
// <API key> before writing files to disk.
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// If non-empty, indicates that the named file should already exist, and the
// content here is to be inserted into that file at a defined insertion
// point. This feature allows a code generator to extend the output
// produced by another code generator. The original generator may provide
// insertion points by placing special annotations in the file that look
// like:
// @@<API key>(NAME)
// The annotation can have arbitrary text before and after it on the line,
// which allows it to be placed in a comment. NAME should be replaced with
// an identifier naming the point -- this is what other generators will use
// as the insertion_point. Code inserted at this point will be placed
// immediately above the line containing the insertion point (thus multiple
// insertions to the same point will come out in the order they were added).
// The double-@ is intended to make it unlikely that the generated code
// could contain things that look like insertion points by accident.
// For example, the C++ code generator places the following line in the
// .pb.h files that it generates:
// // @@<API key>(namespace_scope)
// This line appears within the scope of the file's package namespace, but
// outside of any particular class. Another plugin can then specify the
// insertion_point "namespace_scope" to generate additional classes or
// other declarations that should be placed in this scope.
// Note that if the line containing the insertion point begins with
// whitespace, the same whitespace will be added to every line of the
// inserted text. This is useful for languages like Python, where
// indentation matters. In these languages, the insertion point comment
// should be indented the same amount as any inserted code will need to be
// in order to work correctly in that context.
// The code generator that generates the initial file and the one which
// inserts into it must both run as part of a single invocation of protoc.
// Code generators are executed in the order in which they appear on the
// command line.
// If |insertion_point| is present, |name| must also be present.
InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
// The file contents.
Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>, []int{1, 0}
}
func (m *<API key>) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *<API key>) GetInsertionPoint() string {
if m != nil && m.InsertionPoint != nil {
return *m.InsertionPoint
}
return ""
}
func (m *<API key>) GetContent() string {
if m != nil && m.Content != nil {
return *m.Content
}
return ""
}
func init() {
proto.RegisterType((*<API key>)(nil), "google.protobuf.compiler.<API key>")
proto.RegisterType((*<API key>)(nil), "google.protobuf.compiler.<API key>")
proto.RegisterType((*<API key>)(nil), "google.protobuf.compiler.<API key>.File")
}
var <API key> = []byte{
// 304 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x51, 0x4f, 0x4b, 0xfb, 0x40,
0x14, 0x24, 0xbf, 0x5f, 0x44, 0xf2, 0x2c, 0x8d, 0x2c, 0x15, 0x42, 0xe9, 0x21, 0x14, 0xc1, 0x9e,
0x52, 0x10, 0xc1, 0x7b, 0x2b, 0xea, 0x31, 0x04, 0x4f, 0x82, 0x84, 0x98, 0xbe, 0x86, 0x85, 0x74,
0xdf, 0xba, 0xd9, 0x7c, 0x22, 0xbf, 0x93, 0x9f, 0xc7, 0xfd, 0x93, 0x56, 0x29, 0xf6, 0x94, 0xbc,
0x99, 0xd9, 0x99, 0xd9, 0x7d, 0x30, 0x92, 0x6d, 0xdf, 0x70, 0x91, 0x49, 0x45, 0x9a, 0x58, 0xd2,
0x10, 0x35, 0x2d, 0xfa, 0xe9, 0xbd, 0xdf, 0x66, 0x35, 0xed, 0x24, 0x6f, 0x51, 0x4d, 0x53, 0xcf,
0x2c, 0xf7, 0xcc, 0x72, 0x83, 0x5d, 0xad, 0xb8, 0xd4, 0xa4, 0xbc, 0x7a, 0xfe, 0x19, 0xc0, 0x64,
0x4d, 0x1b, 0x7c, 0x42, 0x81, 0xaa, 0x32, 0x78, 0x81, 0x1f, 0x3d, 0x76, 0x9a, 0x2d, 0xe0, 0x72,
0x6b, 0x3c, 0x4a, 0x4d, 0x65, 0xe3, 0x39, 0x4c, 0x82, 0xf4, 0xff, 0x22, 0x2a, 0xc6, 0x16, 0x7f,
0xa1, 0xe1, 0x04, 0xb2, 0x19, 0x44, 0xb2, 0x52, 0xd5, 0x0e, 0x35, 0xaa, 0xe4, 0x5f, 0x1a, 0x18,
0xc9, 0x0f, 0xc0, 0xd6, 0x00, 0x2e, 0xa9, 0xb4, 0xa7, 0x92, 0xd8, 0x38, 0x5c, 0xdc, 0x5e, 0x67,
0xc7, 0x8d, 0x1f, 0x0d, 0xf9, 0x70, 0xe8, 0x96, 0x5b, 0xd8, 0x98, 0xd8, 0x8f, 0x65, 0xe6, 0x5f,
0x01, 0x5c, 0x1d, 0xb5, 0xec, 0x24, 0x89, 0x0e, 0xd9, 0x04, 0xce, 0x50, 0x29, 0x52, 0xa6, 0x9b,
0x0d, 0xf6, 0x03, 0x7b, 0x86, 0xf0, 0x57, 0xdc, 0x5d, 0x76, 0xea, 0x81, 0xb2, 0x3f, 0x4d, 0x5d,
0x9b, 0xc2, 0x39, 0x4c, 0xdf, 0x20, 0xb4, 0x13, 0x63, 0x10, 0x0a, 0x73, 0xa3, 0x21, 0xc6, 0xfd,
0xb3, 0x1b, 0x88, 0xb9, 0x91, 0x2b, 0xcd, 0x49, 0x94, 0x92, 0xb8, 0xd0, 0xc3, 0xf5, 0xc7, 0x07,
0x38, 0xb7, 0x28, 0x4b, 0xe0, 0xbc, 0x26, 0xa1, 0xd1, 0x08, 0x62, 0x27, 0xd8, 0x8f, 0xab, 0x7b,
0x98, 0x99, 0x2e, 0x27, 0xfb, 0xad, 0x46, 0xb9, 0x5b, 0xb4, 0x7b, 0x90, 0xee, 0x35, 0xf2, 0x6b,
0x2f, 0x1b, 0xfa, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x70, 0xa2, 0xbd, 0x30, 0x02, 0x02, 0x00, 0x00,
} |
#ifndef _INCLUDE_TREO680_H_
#define _INCLUDE_TREO680_H_
/* GPIOs */
#define <API key> 0
#define <API key> 27
#define <API key> 24
#define <API key> 44
#define <API key> 20
#define <API key> 79
#define <API key> 113
#define <API key> 33
#define <API key> 116
#define <API key> 42
#define <API key> 1
#define <API key> 114
#define <API key> 40
#define <API key> 87
#define <API key> 57
#define <API key> 14
#define <API key> 10
#define <API key> 43
#define <API key> 115
#define <API key> 47
#define <API key> 38
#define <API key> 25
/* Various addresses */
#define <API key> 0xa0000000
#define <API key> 0x40000000
#define TREO680_STR_BASE 0xa2000000
/* BACKLIGHT */
#define <API key> 254
#define <API key> 160
#define TREO680_LIMIT_MASK 0x7F
#define TREO680_PRESCALER 63
#define TREO680_PERIOD_NS 3500
#endif |
#team form {
margin-top: 2em;
font-size: 1.3em;
}
#team form label {
display: block;
margin-bottom: 2em;
}
#team form label span {
float: left;
display: block;
width: 180px;
text-align: right;
margin-right: 10px;
margin-top: 3px;
}
#team form label span.required:after {
content:"*";
color: #FF6666;
margin-left: 3px;
}
#team form .team-data input, #team form textarea {
width: 480px;
}
#team form textarea {
height: 8em;
}
#team form.wide .submit {
margin-left: 110px;
}
#team form p.error {
margin-left: 110px;
margin-bottom: 10px;
color: red;
}
#team form.search {
float: right;
margin: 20px;
}
#team table.slist td {
padding-top: 1em;
padding-bottom: 1em;
word-break: break-all;
}
#team table.slist a.team-name {
font-size: 1.3em;
display: block;
margin-bottom: 4px;
padding-bottom: 5px;
}
#team table.slist a.team-name span.team-icon {
float: left;
margin-top: 4px;
}
#team table.slist .info {
font-size: 0.9em;
white-space: nowrap;
}
#team .team-content {
overflow: hidden;
}
#team.team_show .lichess_title {
font-size: 1.8em;
}
#team.team_show .lichess_title span {
color: #909090;
font-size: 0.8em;
}
#team.team_show .content_box_top {
padding-bottom: 10px;
border-bottom: 1px solid #ccc;
}
#team.team_show .content_box_top .righty {
float: right;
margin-right: 20px;
line-height: 30px;
}
#team .team-left {
float: left;
width: 280px;
font-size: 1.2em;
border-right: 1px solid #ccc;
}
#team .team-left h2 {
font-size: 1.0em;
font-weight: bold;
padding: 0 0 5px 25px;
border-bottom: 1px solid #ccc;
}
#team .team-left .infos {
margin: 20px 0 20px 25px;
}
#team .team-right {
margin-left: 280px;
border-left: 1px solid #ccc;
}
#team .description {
font-size: 1.2em;
margin: 20px 0 20px 20px;
}
#team .best_players {
margin-bottom: 20px;
}
#team .userlist > li,
#team .userlist > div.paginated_element {
padding: 5px 0 5px 25px;
}
#team .actions {
margin-left: 20px;
}
#team .forum {
margin-top: 30px;
width: 100%;
}
#team .forum h2 {
font-size: 1.2em;
font-weight: bold;
border-bottom: 1px solid #ccc;
padding: 0 0 5px 20px;
}
#team .forum li {
padding: 20px 10px 20px 20px;
}
#team .forum li:nth-child(odd) {
background: none repeat scroll 0 0 #F4F4F4;
}
#team .forum a.user_link {
font-weight: bold;
margin-right: 6px;
color: #aaa;
}
#team .forum time {
font-size: 0.8em;
}
#team .forum .meta > * {
display: block;
float: left;
margin-right: 1em;
}
#team .forum a.more {
display: block;
text-align: right;
margin: 10px 10px 0 0;
}
#team table.requests form {
margin: 0;
}
#team table.requests {
margin: 0;
}
#team table.requests.all {
margin-bottom: 20px;
}
#team table.requests.for-team {
border: 1px solid #909090;
}
#team table.requests th {
padding: 0.5em;
text-align: center;
font-size: 1.4em;
}
#team table.requests.all td {
padding: 2.3em 1em;
}
#team table.requests .user_link {
margin-bottom: 0.7em;
}
#team table.requests .process {
white-space: nowrap;
}
#team table.requests button {
font-size: 0.8em;
display: inline;
margin-left: 5px;
}
#team .button.small {
font-size: 12px;
}
#team .undertitle {
margin-top: 1.5em;
}
#team .kick .button {
margin-bottom: 5px;
} |
/**
* @name: S11.8.7_A4;
* @section: 11.8.7, 9.8;
* @assertion: Operator "in" calls ToString(ShiftExpression);
* @description: Checking ToString coversion;;
*/
//CHECK
var object = {};
object["true"] = 1;
if (true in object !== "true" in object) {
$ERROR('
}
//CHECK
var object = {};
object.Infinity = 1;
if (Infinity in object !== "Infinity" in object) {
$ERROR('
}
//CHECK
var object = {};
object.undefined = 1;
if (undefined in object !== "undefined" in object) {
$ERROR('
}
//CHECK
var object = {};
object["null"] = 1;
if (null in object !== "null" in object) {
$ERROR('
} |
package org.takes.rs;
import java.io.<API key>;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.<API key>;
import javax.json.Json;
import javax.json.JsonException;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.json.JsonWriter;
import javax.json.stream.JsonGenerator;
import lombok.EqualsAndHashCode;
import org.takes.Response;
/**
* Response with properly indented JSON body.
*
* <p>The class is immutable and thread-safe.
*
* @author Eugene Kondrashev (eugene.kondrashev@gmail.com)
* @version $Id$
* @since 1.0
*/
@EqualsAndHashCode(of = "origin")
public final class RsPrettyJSON implements Response {
/**
* Original response.
*/
private final transient Response origin;
/**
* Response with properly transformed body.
*/
private final transient List<Response> transformed =
new <API key><Response>();
/**
* Ctor.
* @param res Original response
*/
public RsPrettyJSON(final Response res) {
this.origin = res;
}
@Override
public Iterable<String> head() throws IOException {
return this.make().head();
}
@Override
public InputStream body() throws IOException {
return this.make().body();
}
/**
* Make a response.
* @return Response just made
* @throws IOException If fails
*/
private Response make() throws IOException {
synchronized (this.transformed) {
if (this.transformed.isEmpty()) {
this.transformed.add(
new RsWithBody(
this.origin,
RsPrettyJSON.transform(this.origin.body())
)
);
}
}
return this.transformed.get(0);
}
/**
* Format body with proper indents.
* @param body Response body
* @return New properly formatted body
* @throws IOException If fails
*/
private static byte[] transform(final InputStream body) throws IOException {
final <API key> res = new <API key>();
final JsonReader rdr = Json.createReader(body);
try {
final JsonObject obj = rdr.readObject();
final JsonWriter wrt = Json.createWriterFactory(
Collections.singletonMap(
JsonGenerator.PRETTY_PRINTING,
true
)
).createWriter(res);
try {
wrt.writeObject(obj);
} finally {
wrt.close();
}
} catch (final JsonException ex) {
throw new IOException(ex);
} finally {
rdr.close();
}
return res.toByteArray();
}
} |
<?php
// class: GraphPattern
class GraphPattern extends Object{
/**
* Graphname. 0 if its in the default graph.
*/
protected $graphname = null;
/**
* Array of QueryTriple objects
* @var array
*/
protected $triplePatterns = array();
/**
* A List of Constraint objects
* @var array
*/
protected $constraints = array();
/**
* @var int Pointer to optional pattern.
*/
protected $optional = null;
/**
* @var int Pointer to union pattern.
*/
protected $union = null;
/**
* ID of the pattern in the pattern list that
* this pattern is subpattern of.
* @var int
*/
protected $subpatternOf = null;
/**
* @var boolean TRUE if the pattern is open- FALSE if closed.
*/
public $open = false;
/**
* @var boolean TRUE if the GraphPattern is a construct pattern.
*/
public $isConstructPattern = false;
/**
* @var int The GraphPatterns id.
*/
public $patternId = null;
/**
* Constructor
*/
public function GraphPattern() {
$this->open = true;
$this->isConstructPattern = false;
$this->constraints = array();
$this->triplePatterns = array();
}
/**
* Returns the graphname.
*
* @return String
*/
public function getGraphname(){
return $this->graphname;
}
/**
* Returns the triple pattern of the graph pattern.
*
* @return Array
*/
public function getTriplePatterns(){
return $this->triplePatterns;
}
/**
* Returns a constraint if there is one false if not.
*
* @return Constraint
*/
public function getConstraints() {
return $this->constraints;
}
/**
* Returns a pointer to an optional graph pattern.
*
* @return integer
*/
public function getOptional() {
return $this->optional;
}
/**
* Returns a pointer to the parent pattern this pattern
* is subpattern of.
*
* @return integer
*/
public function getSubpatternOf() {
return $this->subpatternOf;
}
/**
* Returns a pointer to a union graph pattern.
*
* @return integer
*/
public function getUnion() {
return $this->union;
}
/**
* Sets the graphname.
*
* @param String $name
* @return void
*/
public function setGraphname($name) {
$this->graphname = $name;
}
/**
* Adds List of QueryTriples to the GraphPattern.
*
* @param array $trpP
* @return void
*/
public function addTriplePatterns($trpP) {
$this->triplePatterns = array_merge($this->triplePatterns, $trpP);
}
/**
* Sets the List of QueryTriples to the GraphPattern.
*
* @param array $trpP
* @return void
*/
public function setTriplePatterns($trpP) {
$this->triplePatterns = $trpP;
}
/**
* Adds a single Constraint to the GraphPattern.
*
* @param Constraint $cons
*/
public function addConstraint(&$cons) {
$this->constraints[] = $cons;
}
/**
* Adds an array of Constraint objects to the GraphPattern.
*
* @param array $cons
*/
public function addConstraints(&$cons) {
$this->constraints = array_merge($this->constraints, $cons);
}
/**
* Adds a pointer to an optional graphPattern.
*
* @param integer $patternId
* @return void
*/
public function setOptional($patternId) {
$this->optional = &$patternId;
}
/**
* Adds a pointer to a union graphPattern.
*
* @param integer $patternId
* @return void
*/
public function setUnion($patternId) {
$this->union = &$patternId;
}
/**
* Adds a pointer to a pattern that
* this one is subpattern of
*
* @param integer $patternId
*/
public function setSubpatternOf($patternId) {
$this->subpatternOf = $patternId;
}
/**
* Sets the GraphPatterns Id.
*
* @param integer $id
* @return void
*/
public function setId($id){
$this->patternId = $id;
}
/**
* Returns the GraphPatterns id.
*
* @return integer
*/
public function getId(){
return $this->patternId;
}
/**
* Returns an array of all variables used in this
* graph pattern.
* All variables are listed only once (unique).
*
* @return array Array of variable names
*/
public function getVariables()
{
$arVars = array();
foreach ($this->triplePatterns as $pattern) {
$arVars = array_merge($arVars, $pattern->getVariables());
}
return array_unique($arVars);
}//public function getVariables()
/**
* Checks if the graph pattern is empty (contains no
* usable data).
* Occurs when using "{}" without pre- or suffixes
* WHERE
* {
* { ?person rdf:type foaf:Person } .
* }
*
* @return boolean True if the pattern is empty.
*/
public function isEmpty()
{
return
count($this->triplePatterns) == 0
&& count($this->constraints) == 0
&& $this->getGraphname() === null
;
}//public function isEmpty()
/**
* When cloning, we need to clone some subobjects, too
*/
public function __clone()
{
if (count($this->triplePatterns) > 0) {
foreach ($this->triplePatterns as $nId => $pattern) {
$this->triplePatterns[$nId] = clone $this->triplePatterns[$nId];
}
}
if (count($this->constraints) > 0) {
foreach ($this->constraints as $nId => $constraint) {
$this->constraints[$nId] = clone $this->constraints[$nId];
}
}
}
}// end class: GraphPattern.php
?> |
[Angular 1.x] Display treeDnD & event DrapnDrop, field 'td' by tree.
[*
[
http://thienhung1989.github.io/angular-tree-dnd/3.0.4/ng-tree-dnd.css
http://thienhung1989.github.io/angular-tree-dnd/3.0.4/ng-tree-dnd.js
http://thienhung1989.github.io/angular-tree-dnd/3.0.4/ng-tree-dnd.min.js
Install bower:
js
bower install angular-tree-dnd
npm install angular-tree-dnd
## Problems
* Big data not good (development with scrollInfinite, will update soon late).
## Feature
* Display Data-Tree with 2 type: Table-Grid & List *(ul, ol)*.
* Drag & Drop.
* Filter Data-Tree.
* GroupBy *(building, not ready)*
* Extended function `Directive for` Data-Tree *(next, prex, remove,...)*
## Manuals & Documents:
- https://github.com/thienhung1989/angular-tree-dnd/blob/master/DOCUMENTS.md
## Changes Log:
- https://github.com/thienhung1989/angular-tree-dnd/blob/master/CHANGELOG.md
Thank To:
This product is the combination and optimization of 2: [JimLiu](https:
## Contact
[git]: http://git-scm.com/
[bower]: http://bower.io
[npm]: https:
[node]: http://nodejs.org
[protractor]: https://github.com/angular/protractor
[jasmine]: http://jasmine.github.io
[karma]: http://karma-runner.github.io
[travis]: https://travis-ci.org/
[http-server]: https://github.com/nodeapps/http-server |
#nullable disable
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders
{
internal abstract class <API key> : <API key>
{
public <API key>(
SyntaxKind keywordKind,
bool <API key> = false,
bool <API key> = false)
: base(keywordKind, <API key>, <API key>)
{
}
protected abstract SpecialType SpecialType { get; }
protected override bool ShouldPreselect(CSharpSyntaxContext context, Cancellation<API key>)
=> context.InferredTypes.Any(t => t.SpecialType == SpecialType);
}
} |
// <auto-generated>
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is
// regenerated.
// </auto-generated>
namespace Microsoft.Azure.Management.ServiceFabric.Models
{
using Newtonsoft.Json;
using System.Linq;
public partial class <API key>
{
<summary>
Initializes a new instance of the <API key> class.
</summary>
public <API key>()
{
CustomInit();
}
<summary>
Initializes a new instance of the <API key> class.
</summary>
<param name="principalId">The principal id of user assigned
identity.</param>
<param name="clientId">The client id of user assigned
identity.</param>
public <API key>(string principalId = default(string), string clientId = default(string))
{
PrincipalId = principalId;
ClientId = clientId;
CustomInit();
}
<summary>
An initialization method that performs custom operations like setting defaults
</summary>
partial void CustomInit();
<summary>
Gets the principal id of user assigned identity.
</summary>
[JsonProperty(PropertyName = "principalId")]
public string PrincipalId { get; private set; }
<summary>
Gets the client id of user assigned identity.
</summary>
[JsonProperty(PropertyName = "clientId")]
public string ClientId { get; private set; }
}
} |
<?php
namespace HWI\Bundle\OAuthBundle\Tests\OAuth\ResourceOwner;
use HWI\Bundle\OAuthBundle\OAuth\ResourceOwner\<API key>;
use Symfony\Component\HttpFoundation\Request;
class GenericO<API key> extends \<API key>
{
/**
* @var <API key>
*/
protected $resourceOwner;
protected $resourceOwnerName;
protected $buzzClient;
protected $buzzResponse;
protected $<API key>;
protected $storage;
protected $options = array(
'client_id' => 'clientid',
'client_secret' => 'clientsecret',
'infos_url' => 'http://user.info/?test=1',
'request_token_url' => 'http://user.request/?test=2',
'authorization_url' => 'http://user.auth/?test=3',
'access_token_url' => 'http://user.access/?test=4',
);
protected $userResponse = '{"id": "1", "foo": "bar"}';
protected $paths = array(
'identifier' => 'id',
'nickname' => 'foo',
'realname' => 'foo_disp',
);
public function setUp()
{
$this->resourceOwnerName = str_replace(array('generic', 'resourceownertest'), '', strtolower(__CLASS__));
$this->resourceOwner = $this->createResourceOwner($this->resourceOwnerName);
}
/**
* @expectedException \Symfony\Component\OptionsResolver\Exception\<API key>
*/
public function <API key>()
{
$this->createResourceOwner($this->resourceOwnerName, array('non_existing' => null));
}
/**
* @expectedException \Symfony\Component\OptionsResolver\Exception\<API key>
*/
public function <API key>()
{
$this->createResourceOwner($this->resourceOwnerName, array('csrf' => 'invalid'));
}
public function <API key>()
{
$this->mockBuzz($this->userResponse, 'application/json; charset=utf-8');
$accessToken = array('oauth_token' => 'token', 'oauth_token_secret' => 'secret');
$userResponse = $this->resourceOwner->getUserInformation($accessToken);
$this->assertEquals('1', $userResponse->getUsername());
$this->assertEquals('bar', $userResponse->getNickname());
$this->assertEquals($accessToken['oauth_token'], $userResponse->getAccessToken());
$this->assertNull($userResponse->getRefreshToken());
$this->assertNull($userResponse->getExpiresIn());
}
public function testGet<API key>()
{
$this->mockBuzz('{"oauth_token": "token", "oauth_token_secret": "secret"}', 'application/json; charset=utf-8');
$this->storage->expects($this->once())
->method('save')
->with($this->resourceOwner, array('oauth_token' => 'token', 'oauth_token_secret' => 'secret', 'timestamp' => time()));
$this->assertEquals(
$this->options['authorization_url'].'&oauth_token=token',
$this->resourceOwner->getAuthorizationUrl('http://redirect.to/')
);
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function testGet<API key>()
{
$this->mockBuzz('{"oauth_token": "token"}', 'application/json; charset=utf-8');
$this->storage->expects($this->never())
->method('save');
$this->resourceOwner->getAuthorizationUrl('http://redirect.to/');
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function testGet<API key>()
{
$this->mockBuzz('oauth_problem=message');
$this->storage->expects($this->never())
->method('save');
$this->resourceOwner->getAuthorizationUrl('http://redirect.to/');
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function testGet<API key>()
{
$this->mockBuzz('o<API key>=false');
$this->storage->expects($this->never())
->method('save');
$this->resourceOwner->getAuthorizationUrl('http://redirect.to/');
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function testGet<API key>()
{
$this->mockBuzz('invalid');
$this->storage->expects($this->never())
->method('save');
$this->resourceOwner->getAuthorizationUrl('http://redirect.to/');
}
public function testGetAccessToken()
{
$this->mockBuzz('oauth_token=token&oauth_token_secret=secret');
$request = new Request(array('oauth_verifier' => 'code', 'oauth_token' => 'token'));
$this->storage->expects($this->once())
->method('fetch')
->with($this->resourceOwner, 'token')
->will($this->returnValue(array('oauth_token' => 'token2', 'oauth_token_secret' => 'secret2')));
$this->assertEquals(
array('oauth_token' => 'token', 'oauth_token_secret' => 'secret'),
$this->resourceOwner->getAccessToken($request, 'http://redirect.to/')
);
}
public function <API key>()
{
$this->mockBuzz('{"oauth_token": "token", "oauth_token_secret": "secret"}', 'application/json');
$request = new Request(array('oauth_verifier' => 'code', 'oauth_token' => 'token'));
$this->storage->expects($this->once())
->method('fetch')
->with($this->resourceOwner, 'token')
->will($this->returnValue(array('oauth_token' => 'token2', 'oauth_token_secret' => 'secret2')));
$this->assertEquals(
array('oauth_token' => 'token', 'oauth_token_secret' => 'secret'),
$this->resourceOwner->getAccessToken($request, 'http://redirect.to/')
);
}
public function testGetAccess<API key>()
{
$this->mockBuzz('{"oauth_token": "token", "oauth_token_secret": "secret"}', 'application/json; charset=utf-8');
$request = new Request(array('oauth_verifier' => 'code', 'oauth_token' => 'token'));
$this->storage->expects($this->once())
->method('fetch')
->with($this->resourceOwner, 'token')
->will($this->returnValue(array('oauth_token' => 'token2', 'oauth_token_secret' => 'secret2')));
$this->assertEquals(
array('oauth_token' => 'token', 'oauth_token_secret' => 'secret'),
$this->resourceOwner->getAccessToken($request, 'http://redirect.to/')
);
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function <API key>()
{
$this->mockBuzz('invalid');
$this->storage->expects($this->once())
->method('fetch')
->will($this->returnValue(array('oauth_token' => 'token', 'oauth_token_secret' => 'secret')));
$this->storage->expects($this->never())
->method('save');
$request = new Request(array('oauth_token' => 'token', 'oauth_verifier' => 'code'));
$this->resourceOwner->getAccessToken($request, 'http://redirect.to/');
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function <API key>()
{
$this->mockBuzz('error=foo');
$this->storage->expects($this->once())
->method('fetch')
->will($this->returnValue(array('oauth_token' => 'token', 'oauth_token_secret' => 'secret')));
$this->storage->expects($this->never())
->method('save');
$request = new Request(array('oauth_token' => 'token', 'oauth_verifier' => 'code'));
$this->resourceOwner->getAccessToken($request, 'http://redirect.to/');
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function <API key>()
{
$this->resourceOwner->refreshAccessToken('token');
}
/**
* @expectedException \Symfony\Component\Security\Core\Exception\<API key>
*/
public function testRevokeToken()
{
$this->resourceOwner->revokeToken('token');
}
public function testCsrf<API key>()
{
$this->storage->expects($this->never())
->method('fetch');
$this->assertTrue($this->resourceOwner->isCsrfTokenValid('valid_token'));
}
public function testCsrfTokenValid()
{
$resourceOwner = $this->createResourceOwner($this->resourceOwnerName, array('csrf' => true));
$this->storage->expects($this->never())
->method('fetch');
$this->assertTrue($resourceOwner->isCsrfTokenValid('valid_token'));
}
public function testGetSetName()
{
$this->assertEquals($this->resourceOwnerName, $this->resourceOwner->getName());
$this->resourceOwner->setName('foo');
$this->assertEquals('foo', $this->resourceOwner->getName());
}
public function <API key>()
{
$class = '\HWI\Bundle\OAuthBundle\Tests\Fixtures\CustomUserResponse';
$resourceOwner = $this->createResourceOwner($this->resourceOwnerName, array('user_response_class' => $class));
$this->mockBuzz();
/**
* @var $userResponse \HWI\Bundle\OAuthBundle\Tests\Fixtures\CustomUserResponse
*/
$userResponse = $resourceOwner->getUserInformation(array('oauth_token' => 'token', 'oauth_token_secret' => 'secret'));
$this->assertInstanceOf($class, $userResponse);
$this->assertEquals('foo666', $userResponse->getUsername());
$this->assertEquals('foo', $userResponse->getNickname());
$this->assertEquals('token', $userResponse->getAccessToken());
$this->assertNull($userResponse->getRefreshToken());
$this->assertNull($userResponse->getExpiresIn());
}
public function buzzSendMock($request, $response)
{
$response->setContent($this->buzzResponse);
$response->addHeader('Content-Type: ' . $this-><API key>);
}
protected function mockBuzz($response = '', $contentType = 'text/plain')
{
$this->buzzClient->expects($this->once())
->method('send')
->will($this->returnCallback(array($this, 'buzzSendMock')));
$this->buzzResponse = $response;
$this-><API key> = $contentType;
}
protected function createResourceOwner($name, array $options = array(), array $paths = array())
{
$this->buzzClient = $this->getMockBuilder('\Buzz\Client\ClientInterface')
-><API key>()->getMock();
$httpUtils = $this->getMockBuilder('\Symfony\Component\Security\Http\HttpUtils')
-><API key>()->getMock();
$this->storage = $this->getMock('\HWI\Bundle\OAuthBundle\OAuth\<API key>');
$resourceOwner = $this->setUpResourceOwner($name, $httpUtils, array_merge($this->options, $options));
$resourceOwner->addPaths(array_merge($this->paths, $paths));
return $resourceOwner;
}
protected function setUpResourceOwner($name, $httpUtils, array $options)
{
return new <API key>($this->buzzClient, $httpUtils, $options, $name, $this->storage);
}
} |
namespace NEventStore.Persistence
{
using System;
using System.Collections.Generic;
<summary>
Indicates the ability to adapt the underlying persistence infrastructure to behave like a stream of events.
</summary>
<remarks>
Instances of this class must be designed to be multi-thread safe such that they can be shared between threads.
</remarks>
public interface IPersistStreams : IDisposable, ICommitEvents, IAccessSnapshots
{
<summary>
Gets a value indicating whether this instance has been disposed of.
</summary>
bool IsDisposed { get; }
<summary>
Initializes and prepares the storage for use, if not already performed.
</summary>
<exception cref="StorageException" />
<exception cref="<API key>" />
void Initialize();
<summary>
Gets all commits on or after from the specified starting time.
</summary>
<param name="bucketId">The value which uniquely identifies bucket the stream belongs to.</param>
<param name="start">The point in time at which to start.</param>
<returns>All commits that have occurred on or after the specified starting time.</returns>
<exception cref="StorageException" />
<exception cref="<API key>" />
IEnumerable<ICommit> GetFrom(string bucketId, DateTime start);
<summary>
Gets all commits after the specified checkpoint. Use null to get from the beginning.
</summary>
<param name="checkpointToken">The checkpoint token.</param>
<returns>An enumerable of Commits.</returns>
IEnumerable<ICommit> GetFrom(string checkpointToken = null);
<summary>
Gets all commits after from the specified checkpoint. Use null to get from the beginning.
</summary>
<param name="bucketId">The value which uniquely identifies bucket the stream belongs to.</param>
<param name="checkpointToken">The checkpoint token.</param>
<returns>An enumerable of Commits.</returns>
IEnumerable<ICommit> GetFrom(string bucketId, string checkpointToken);
<summary>
Gets a checkpoint object that is comparable with other checkpoints from this storage engine.
</summary>
<param name="checkpointToken">The checkpoint token</param>
<returns>A <see cref="ICheckpoint"/> instance.</returns>
ICheckpoint GetCheckpoint(string checkpointToken = null);
<summary>
Gets all commits on or after from the specified starting time and before the specified end time.
</summary>
<param name="bucketId">The value which uniquely identifies bucket the stream belongs to.</param>
<param name="start">The point in time at which to start.</param>
<param name="end">The point in time at which to end.</param>
<returns>All commits that have occurred on or after the specified starting time and before the end time.</returns>
<exception cref="StorageException" />
<exception cref="<API key>" />
IEnumerable<ICommit> GetFromTo(string bucketId, DateTime start, DateTime end);
<summary>
Gets a set of commits that has not yet been dispatched.
</summary>
<returns>The set of commits to be dispatched.</returns>
<exception cref="StorageException" />
<exception cref="<API key>" />
IEnumerable<ICommit> <API key>();
<summary>
Marks the commit specified as dispatched.
</summary>
<param name="commit">The commit to be marked as dispatched.</param>
<exception cref="StorageException" />
<exception cref="<API key>" />
void <API key>(ICommit commit);
<summary>
Completely DESTROYS the contents of ANY and ALL streams that have been successfully persisted. Use with caution.
</summary>
void Purge();
<summary>
Completely DESTROYS the contents of ANY and ALL streams that have been successfully persisted
in the specified bucket. Use with caution.
</summary>
void Purge(string bucketId);
<summary>
Completely DESTROYS the contents and schema (if applicable) containting ANY and ALL streams that have been
successfully persisted
in the specified bucket. Use with caution.
</summary>
void Drop();
<summary>
Deletes a stream.
</summary>
<param name="bucketId">The bucket Id from which the stream is to be deleted.</param>
<param name="streamId">The stream Id of the stream that is to be deleted.</param>
void DeleteStream(string bucketId, string streamId);
}
} |
(function () {
'use strict';
describe('the uiTreeHandle directive', function () {
var $rootScope, $compile, $scope, element;
beforeEach(module('ui.tree'));
beforeEach(inject(function ($injector) {
$rootScope = $injector.get('$rootScope');
$compile = $injector.get('$compile');
$scope = $rootScope.$new();
$scope.items = [{
'id': 42,
'title': 'Node 42'
}];
}));
function createElement(template) {
template = template || '<div ui-tree><ol ui-tree-nodes ng-model="items"><li ng-repeat="item in items" ui-tree-node><div ui-tree-handle>{{item.title}}</div></li></ol></div>';
element = angular.element(template);
$compile(element)($scope);
$scope.$digest();
return element;
}
it('should add the configured CSS class to it\'s element', function () {
var element = createElement();
expect(element.find('[ui-tree-handle]')).toHaveClass('<API key>');
});
});
}()); |
package com.google.refine.browsing.util;
import com.google.refine.browsing.RecordVisitor;
import com.google.refine.browsing.RowVisitor;
import com.google.refine.model.Project;
import com.google.refine.model.Record;
public class <API key> implements RecordVisitor {
final protected RowVisitor _rowVisitor;
public <API key>(RowVisitor rowVisitor) {
_rowVisitor = rowVisitor;
}
@Override
public void start(Project project) {
_rowVisitor.start(project);
}
@Override
public void end(Project project) {
_rowVisitor.end(project);
}
@Override
public boolean visit(Project project, Record record) {
for (int r = record.fromRowIndex; r < record.toRowIndex; r++) {
if (_rowVisitor.visit(project, r, project.rows.get(r))) {
return true;
}
}
return false;
}
} |
// -*- mode: java; c-basic-offset: 2; -*-
package com.google.appinventor.client.settings.user;
import com.google.appinventor.client.Ode;
import com.google.appinventor.client.settings.Settings;
import com.google.appinventor.client.widgets.properties.EditableProperty;
import com.google.appinventor.shared.rpc.user.UserInfoProvider;
import com.google.appinventor.shared.settings.SettingsConstants;
/**
* General settings.
*
*/
public final class SplashSettings extends Settings {
/**
* Creates a new instance of user-specific general settings.
*
* @param user user associated with settings
*/
public SplashSettings(UserInfoProvider user) {
super(SettingsConstants.SPLASH_SETTINGS);
addProperty(new EditableProperty(this, SettingsConstants.<API key>,
"0", EditableProperty.TYPE_INVISIBLE));
addProperty(new EditableProperty(this, SettingsConstants.<API key>,
"", EditableProperty.TYPE_INVISIBLE));
}
@Override
protected void updateAfterDecoding() {
Ode.getInstance().showSplashScreens();
}
} |
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Example - <API key></title>
<script src="//ajax.googleapis.com/ajax/libs/angularjs/null/angular.min.js"></script>
</head>
<body ng-app="">
<input ng-paste="paste=true" ng-init="paste=false" placeholder='paste here'>
pasted: {{paste}}
</body>
</html> |
.dropup,
.dropdown {
position: relative;
}
.caret {
display: inline-block;
width: 0;
height: 0;
vertical-align: top;
border-top: 4px solid #000000;
border-right: 4px solid transparent;
border-left: 4px solid transparent;
content: "";
}
.dropdown .caret {
margin-top: 8px;
margin-left: 2px;
}
.dropdown-menu {
position: absolute;
top: 100%;
left: 0;
z-index: 1000;
display: none;
float: left;
min-width: 160px;
padding: 5px 0;
margin: 2px 0 0;
list-style: none;
background-color: #ffffff;
border: 1px solid #ccc;
border: 1px solid rgba(0, 0, 0, 0.2);
*border-right-width: 2px;
*border-bottom-width: 2px;
-<API key>: 6px;
-moz-border-radius: 6px;
border-radius: 6px;
-webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-<API key>: padding-box;
-moz-background-clip: padding;
background-clip: padding-box;
}
.dropdown-menu a {
display: block;
padding: 3px 20px;
clear: both;
font-weight: normal;
line-height: 20px;
color: #333333;
white-space: nowrap;
}
.dropdown-menu li > a:hover,
.dropdown-menu li > a:focus,
.dropdown-submenu:hover > a {
color: #ffffff;
text-decoration: none;
background-color: #0088cc;
background-color: #0081c2;
background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
background-image: -<API key>(top, #0088cc, #0077b3);
background-image: -o-linear-gradient(top, #0088cc, #0077b3);
background-image: linear-gradient(to bottom, #0088cc, #0077b3);
background-repeat: repeat-x;
filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
}
.dropdown-menu .active > a,
.dropdown-menu .active > a:hover {
color: #ffffff;
text-decoration: none;
background-color: #0088cc;
background-color: #0081c2;
background-image: linear-gradient(to bottom, #0088cc, #0077b3);
background-image: -moz-linear-gradient(top, #0088cc, #0077b3);
background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));
background-image: -<API key>(top, #0088cc, #0077b3);
background-image: -o-linear-gradient(top, #0088cc, #0077b3);
background-repeat: repeat-x;
outline: 0;
filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);
}
.dropdown-menu .disabled > a,
.dropdown-menu .disabled > a:hover {
color: #999999;
}
.dropdown-menu .disabled > a:hover {
text-decoration: none;
cursor: default;
background-color: transparent;
}
.dropup .caret,
.navbar-fixed-bottom .dropdown .caret {
border-top: 0;
border-bottom: 4px solid #000000;
content: "";
}
.dropup .dropdown-menu,
.navbar-fixed-bottom .dropdown .dropdown-menu {
top: auto;
bottom: 100%;
margin-bottom: 1px;
}
.btn {
display: inline-block;
*display: inline;
padding: 4px 14px;
margin-bottom: 0;
*margin-left: .3em;
font-size: 14px;
line-height: 20px;
*line-height: 20px;
color: #333333;
text-align: center;
text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
vertical-align: middle;
cursor: pointer;
background-color: #f5f5f5;
*background-color: #e6e6e6;
background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));
background-image: -<API key>(top, #ffffff, #e6e6e6);
background-image: -o-linear-gradient(top, #ffffff, #e6e6e6);
background-image: linear-gradient(to bottom, #ffffff, #e6e6e6);
background-image: -moz-linear-gradient(top, #ffffff, #e6e6e6);
background-repeat: repeat-x;
border: 1px solid #bbbbbb;
*border: 0;
border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
border-color: #e6e6e6 #e6e6e6 #bfbfbf;
border-bottom-color: #a2a2a2;
-<API key>: 4px;
-moz-border-radius: 4px;
border-radius: 4px;
filter: progid:dximagetransform.microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe6e6e6', GradientType=0);
filter: progid:dximagetransform.microsoft.gradient(enabled=false);
*zoom: 1;
-webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
-moz-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
}
.btn:hover,
.btn:active,
.btn.active,
.btn.disabled,
.btn[disabled] {
color: #333333;
background-color: #e6e6e6;
*background-color: #d9d9d9;
}
.btn:active,
.btn.active {
background-color: #cccccc \9;
}
.btn:first-child {
*margin-left: 0;
}
.btn:hover {
color: #333333;
text-decoration: none;
background-color: #e6e6e6;
*background-color: #d9d9d9;
/* Buttons in IE7 don't get borders, so darken on hover */
background-position: 0 -15px;
-webkit-transition: background-position 0.1s linear;
-moz-transition: background-position 0.1s linear;
-o-transition: background-position 0.1s linear;
transition: background-position 0.1s linear;
}
.btn:focus {
outline: thin dotted #333;
outline: 5px auto -<API key>;
outline-offset: -2px;
}
.btn.active,
.btn:active {
background-color: #e6e6e6;
background-color: #d9d9d9 \9;
background-image: none;
outline: 0;
-webkit-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
-moz-box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05); |
package org.spongycastle.crypto.tls.test;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.<API key>;
import java.security.SecureRandom;
import org.spongycastle.crypto.tls.DTLSServerProtocol;
import org.spongycastle.crypto.tls.DTLSTransport;
import org.spongycastle.crypto.tls.DatagramTransport;
import org.spongycastle.crypto.tls.UDPTransport;
/**
* A simple test designed to conduct a DTLS handshake with an external DTLS client.
* <p>
* Please refer to GnuTLSSetup.html or OpenSSLSetup.html (under 'docs'), and x509-*.pem files in
* this package (under 'src/test/resources') for help configuring an external DTLS client.
* </p>
*/
public class DTLSServerTest
{
public static void main(String[] args)
throws Exception
{
int port = 5556;
int mtu = 1500;
SecureRandom secureRandom = new SecureRandom();
DTLSServerProtocol serverProtocol = new DTLSServerProtocol(secureRandom);
byte[] data = new byte[mtu];
DatagramPacket packet = new DatagramPacket(data, mtu);
DatagramSocket socket = new DatagramSocket(port);
socket.receive(packet);
System.out.println("Accepting connection from " + packet.getAddress().getHostAddress() + ":" + port);
socket.connect(packet.getAddress(), packet.getPort());
/*
* NOTE: For simplicity, and since we don't yet have HelloVerifyRequest support, we just
* discard the initial packet, which the client should re-send anyway.
*/
DatagramTransport transport = new UDPTransport(socket, mtu);
// Uncomment to see packets
// transport = new <API key>(transport, System.out);
MockDTLSServer server = new MockDTLSServer();
DTLSTransport dtlsServer = serverProtocol.accept(server, transport);
byte[] buf = new byte[dtlsServer.getReceiveLimit()];
while (!socket.isClosed())
{
try
{
int length = dtlsServer.receive(buf, 0, buf.length, 60000);
if (length >= 0)
{
System.out.write(buf, 0, length);
dtlsServer.send(buf, 0, length);
}
}
catch (<API key> ste)
{
}
}
dtlsServer.close();
}
} |
using System;
#if !LEGACY
using ExcelDataReader.Portable.Core;
#else
using Excel.Core;
#endif
using Microsoft.VisualStudio.TestTools.UnitTesting;
#if LEGACY
namespace Excel.Tests
#else
namespace ExcelDataReader.Tests
#endif
{
[TestClass]
class FormatReaderTest
{
[TestMethod]
public void <API key>()
{
Assert.IsTrue(new FormatReader{FormatString = "dd/mm/yyyy"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "dd-mmm-yy"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "dd-mmmm"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "mmm-yy"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "h:mm AM/PM"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "h:mm:ss AM/PM"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "hh:mm"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "hh:mm:ss"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "dd/mm/yyyy hh:mm"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "mm:ss"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "mm:ss.0"}.IsDateFormatString());
Assert.IsTrue(new FormatReader{FormatString = "[$-809]dd mmmm yyyy" }.IsDateFormatString());
Assert.IsFalse(new FormatReader{FormatString = "#,##0;[Red]-#,##0" }.IsDateFormatString());
Assert.IsFalse(new FormatReader{FormatString = "0_);[Red](0)" }.IsDateFormatString());
Assert.IsFalse(new FormatReader{FormatString = @"0\h" }.IsDateFormatString());
Assert.IsFalse(new FormatReader{FormatString = "0\"h\"" }.IsDateFormatString());
Assert.IsFalse(new FormatReader{FormatString = "0%" }.IsDateFormatString());
Assert.IsFalse(new FormatReader{FormatString = "General" }.IsDateFormatString());
}
}
} |
const Command = require('../commands/base');
const GuildSettingsHelper = require('../providers/helper');
/** Contains additional methods and properties that are added to the discord.js Guild class */
class GuildExtension {
/**
* Command prefix in the guild. An empty string indicates that there is no prefix, and only mentions will be used.
* Setting to `null` means that the prefix from {@link CommandoClient#commandPrefix} will be used instead.
* @type {string}
* @emits {@link CommandoClient#commandPrefixChange}
*/
get commandPrefix() {
if(typeof this._commandPrefix === 'undefined' || this._commandPrefix === null) return this.client.commandPrefix;
return this._commandPrefix;
}
set commandPrefix(prefix) {
/**
* Internal command prefix for the guild, controlled by the {@link GuildExtension#commandPrefix} getter/setter
* @type {?string}
* @private
*/
this._commandPrefix = prefix;
/**
* Emitted whenever a guild's command prefix is changed
* @event CommandoClient#commandPrefixChange
* @param {?Guild} guild - Guild that the prefix was changed in (null for global)
* @param {?string} prefix - New command prefix (null for default)
*/
this.client.emit('commandPrefixChange', this, this._commandPrefix);
}
/**
* Shortcut to use setting provider methods for this guild
* @type {GuildSettingsHelper}
* @readonly
*/
get settings() {
if(!this._settings) {
/**
* Internal settings helper that is created upon accessing the {@link GuildExtension#settings} getter
* @type {GuildSettingsHelper}
* @private
*/
this._settings = new GuildSettingsHelper(this.client, this);
}
return this._settings;
}
/**
* Sets whether a command is enabled in the guild
* @param {CommandResolvable} command - Command to set status of
* @param {boolean} enabled - Whether the command should be enabled
*/
setCommandEnabled(command, enabled) {
command = this.client.registry.resolveCommand(command);
if(command.guarded) throw new Error('The command is guarded.');
if(typeof enabled === 'undefined') throw new TypeError('Enabled must not be undefined.');
enabled = Boolean(enabled);
if(!this._commandsEnabled) {
/**
* Map object of internal command statuses, mapped by command name
* @type {Object}
* @private
*/
this._commandsEnabled = {};
}
this._commandsEnabled[command.name] = enabled;
/**
* Emitted whenever a command is enabled/disabled in a guild
* @event CommandoClient#commandStatusChange
* @param {?Guild} guild - Guild that the command was enabled/disabled in (null for global)
* @param {Command} command - Command that was enabled/disabled
* @param {boolean} enabled - Whether the command is enabled
*/
this.client.emit('commandStatusChange', this, command, enabled);
}
/**
* Checks whether a command is enabled in the guild (does not take the command's group status into account)
* @param {CommandResolvable} command - Command to check status of
* @return {boolean}
*/
isCommandEnabled(command) {
command = this.client.registry.resolveCommand(command);
if(command.guarded) return true;
if(!this._commandsEnabled || typeof this._commandsEnabled[command.name] === 'undefined') {
return command._globalEnabled;
}
return this._commandsEnabled[command.name];
}
/**
* Sets whether a command group is enabled in the guild
* @param {<API key>} group - Command to set status of
* @param {boolean} enabled - Whether the group should be enabled
*/
setGroupEnabled(group, enabled) {
group = this.client.registry.resolveGroup(group);
if(group.guarded) throw new Error('The group is guarded.');
if(typeof enabled === 'undefined') throw new TypeError('Enabled must not be undefined.');
enabled = Boolean(enabled);
if(!this._groupsEnabled) {
/**
* Internal map object of group statuses, mapped by group ID
* @type {Object}
* @private
*/
this._groupsEnabled = {};
}
this._groupsEnabled[group.id] = enabled;
/**
* Emitted whenever a command group is enabled/disabled in a guild
* @event CommandoClient#groupStatusChange
* @param {?Guild} guild - Guild that the group was enabled/disabled in (null for global)
* @param {CommandGroup} group - Group that was enabled/disabled
* @param {boolean} enabled - Whether the group is enabled
*/
this.client.emit('groupStatusChange', this, group, enabled);
}
/**
* Checks whether a command group is enabled in the guild
* @param {<API key>} group - Group to check status of
* @return {boolean}
*/
isGroupEnabled(group) {
group = this.client.registry.resolveGroup(group);
if(group.guarded) return true;
if(!this._groupsEnabled || typeof this._groupsEnabled[group.id] === 'undefined') return group._globalEnabled;
return this._groupsEnabled[group.id];
}
/**
* Creates a command usage string using the guild's prefix
* @param {string} [command] - A command + arg string
* @param {User} [user=this.client.user] - User to use for the mention command format
* @return {string}
*/
commandUsage(command, user = this.client.user) {
return Command.usage(command, this.commandPrefix, user);
}
/**
* Applies the interface to a class prototype
* @param {Function} target - The constructor function to apply to the prototype of
* @private
*/
static applyToClass(target) {
for(const prop of [
'commandPrefix',
'settings',
'setCommandEnabled',
'isCommandEnabled',
'setGroupEnabled',
'isGroupEnabled',
'commandUsage'
]) {
Object.defineProperty(target.prototype, prop, Object.<API key>(this.prototype, prop));
}
}
}
module.exports = GuildExtension; |
using System;
using System.Threading;
using Xunit;
public partial class <API key>
{
[Fact]
public unsafe void <API key>()
{
using(<API key> handle = <API key>())
{
AssertExtensions.Throws<<API key>>("overlapped", () =>
{
handle.<API key>((NativeOverlapped*)null);
});
}
}
[Fact]
public unsafe void <API key>()
{
<API key> boundHandle = <API key>();
NativeOverlapped* overlapped = boundHandle.<API key>((_, __, ___) => { }, new object(), new byte[256]);
boundHandle.Dispose();
boundHandle.<API key>(overlapped);
}
[Fact]
public unsafe void <API key>()
{
using(<API key> handle = <API key>())
{
NativeOverlapped* overlapped = handle.<API key>((_, __, ___) => { }, (object)null, (byte[])null);
using (<API key> handle2 = <API key>())
{
Assert.Throws<ArgumentException>(() =>
{
handle2.<API key>(overlapped);
});
}
handle.<API key>(overlapped);
}
}
} |
<?php
App::uses('<API key>', 'Settings.Controller');
class SettingsController extends <API key> {
/**
* Controller name
*
* @var string
* @access public
*/
public $name = 'Settings';
/**
* Models used by the Controller
*
* @var array
* @access public
*/
public $uses = array('Settings.Setting');
/**
* Components used by the Controller
*/
public $components = array(
'Search.Prg' => array(
'presetForm' => array(
'paramType' => 'querystring',
),
'commonProcess' => array(
'paramType' => 'querystring',
'filterEmpty' => true,
),
),
);
/**
* Helpers used by the Controller
*
* @var array
* @access public
*/
public $helpers = array('Html', 'Form');
/**
* Preset Variables Search
*/
public $presetVars = true;
/**
* Admin index
*
* @return void
* @access public
*/
public function admin_index() {
$this->set('title_for_layout', __d('croogo', 'Settings'));
$this->Prg->commonProcess();
$this->Setting->recursive = 0;
$this->paginate['Setting']['order'] = "Setting.weight ASC";
$criteria = $this->Setting->parseCriteria($this->Prg->parsedParams());
$this->set('settings', $this->paginate($criteria));
}
/**
* Admin view
*
* @param view $id
* @return void
* @access public
*/
public function admin_view($id = null) {
if (!$id) {
$this->Session->setFlash(__d('croogo', 'Invalid Setting.'), 'flash', array('class' => 'error'));
return $this->redirect(array('action' => 'index'));
}
$this->set('setting', $this->Setting->read(null, $id));
}
/**
* Admin add
*
* @return void
* @access public
*/
public function admin_add() {
$this->set('title_for_layout', __d('croogo', 'Add Setting'));
if (!empty($this->request->data)) {
$this->Setting->create();
if ($this->Setting->save($this->request->data)) {
$this->Session->setFlash(__d('croogo', 'The Setting has been saved'), 'flash', array('class' => 'success'));
return $this->redirect(array('action' => 'index'));
} else {
$this->Session->setFlash(__d('croogo', 'The Setting could not be saved. Please, try again.'), 'flash', array('class' => 'error'));
}
}
}
/**
* Admin edit
*
* @param integer $id
* @return void
* @access public
*/
public function admin_edit($id = null) {
$this->set('title_for_layout', __d('croogo', 'Edit Setting'));
if (!$id && empty($this->request->data)) {
$this->Session->setFlash(__d('croogo', 'Invalid Setting'), 'flash', array('class' => 'error'));
return $this->redirect(array('action' => 'index'));
}
if (!empty($this->request->data)) {
if ($this->Setting->save($this->request->data)) {
$this->Session->setFlash(__d('croogo', 'The Setting has been saved'), 'flash', array('class' => 'success'));
return $this->redirect(array('action' => 'index'));
} else {
$this->Session->setFlash(__d('croogo', 'The Setting could not be saved. Please, try again.'), 'flash', array('class' => 'error'));
}
}
if (empty($this->request->data)) {
$this->request->data = $this->Setting->read(null, $id);
}
}
/**
* Admin delete
*
* @param integer $id
* @return void
* @access public
*/
public function admin_delete($id = null) {
if (!$id) {
$this->Session->setFlash(__d('croogo', 'Invalid id for Setting'), 'flash', array('class' => 'error'));
return $this->redirect(array('action' => 'index'));
}
if ($this->Setting->delete($id)) {
$this->Session->setFlash(__d('croogo', 'Setting deleted'), 'flash', array('class' => 'success'));
return $this->redirect(array('action' => 'index'));
}
}
/**
* Admin prefix
*
* @param string $prefix
* @return void
* @access public
*/
public function admin_prefix($prefix = null) {
$this->set('title_for_layout', __d('croogo', 'Settings: %s', $prefix));
$this->Setting->Behaviors->attach('Croogo.Params');
if (!empty($this->request->data) && $this->Setting->saveAll($this->request->data['Setting'])) {
$this->Session->setFlash(__d('croogo', "Settings updated successfully"), 'flash', array('class' => 'success'));
return $this->redirect(array('action' => 'prefix', $prefix));
}
$settings = $this->Setting->find('all', array(
'order' => 'Setting.weight ASC',
'conditions' => array(
'Setting.key LIKE' => $prefix . '.%',
'Setting.editable' => 1,
),
));
$this->set(compact('settings'));
if (count($settings) == 0) {
$this->Session->setFlash(__d('croogo', "Invalid Setting key"), 'flash', array('class' => 'error'));
}
$this->set("prefix", $prefix);
}
/**
* Admin moveup
*
* @param integer $id
* @param integer $step
* @return void
* @access public
*/
public function admin_moveup($id, $step = 1) {
if ($this->Setting->moveUp($id, $step)) {
$this->Session->setFlash(__d('croogo', 'Moved up successfully'), 'flash', array('class' => 'success'));
} else {
$this->Session->setFlash(__d('croogo', 'Could not move up'), 'flash', array('class' => 'error'));
}
if (!$redirect = $this->referer()) {
$redirect = array(
'admin' => true,
'plugin' => 'settings',
'controller' => 'settings',
'action' => 'index'
);
}
return $this->redirect($redirect);
}
/**
* Admin moveup
*
* @param integer $id
* @param integer $step
* @return void
* @access public
*/
public function admin_movedown($id, $step = 1) {
if ($this->Setting->moveDown($id, $step)) {
$this->Session->setFlash(__d('croogo', 'Moved down successfully'), 'flash', array('class' => 'success'));
} else {
$this->Session->setFlash(__d('croogo', 'Could not move down'), 'flash', array('class' => 'error'));
}
return $this->redirect(array('admin' => true, 'controller' => 'settings', 'action' => 'index'));
}
} |
class CreateResumes < ActiveRecord::Migration
def change
create_table :resumes do |t|
t.string :name
t.string :attachment
t.timestamps
end
end
end |
#include <string.h>
#include <stdlib.h>
#include "pref.h"
#include "pref_global.h"
static void decode(char *val, bool *d1, bool *d2, bool *d3, bool *d4)
{
*d1 = (val[0] == '1')? true : false;
*d2 = (val[1] == '1')? true : false;
*d3 = (val[2] == '1')? true : false;
*d4 = (val[3] == '1')? true : false;
}
static void encode(char *val, bool d1, bool d2, bool d3, bool d4)
{
val[0] = d1 ? '1' : '0';
val[1] = d2 ? '1' : '0';
val[2] = d3 ? '1' : '0';
val[3] = d4 ? '1' : '0';
val[4] = '\0';
}
static char run_id_key[] = "Running-indication";
static char pause_id_key[] = "Paused-indication";
static char run_indication[5] = "0000";
static char pause_indication[5] = "0000";
bool <API key>()
{
const char *dev = <API key>();
if(dev == NULL){
return false;
}
char *tmp = ltr_int_get_key(dev, run_id_key);
if(tmp != NULL){
strncpy(run_indication, tmp, 5);
free(tmp);
}
tmp = ltr_int_get_key(dev, pause_id_key);
if(tmp != NULL){
strncpy(pause_indication, tmp, 5);
free(tmp);
}
return true;
}
bool <API key>(bool *d1, bool *d2, bool *d3, bool *d4)
{
decode(run_indication, d1, d2, d3, d4);
return true;
}
bool <API key>(bool d1, bool d2, bool d3, bool d4)
{
encode(run_indication, d1, d2, d3, d4);
return ltr_int_change_key(<API key>(), run_id_key, run_indication);
}
bool <API key>(bool *d1, bool *d2, bool *d3, bool *d4)
{
decode(pause_indication, d1, d2, d3, d4);
return true;
}
bool <API key>(bool d1, bool d2, bool d3, bool d4)
{
encode(pause_indication, d1, d2, d3, d4);
return ltr_int_change_key(<API key>(), pause_id_key, pause_indication);
} |
#import <Foundation/Foundation.h>
#import "YapDatabase.h"
#import "<API key>.h"
#import "<API key>.h"
#import "<API key>.h"
#import "<API key>.h"
#import "YapCache.h"
#import "YapMemoryTable.h"
#import "YapCollectionKey.h"
#import "sqlite3.h"
/**
* Helper method to conditionally invoke sqlite3_finalize on a statement, and then set the ivar to NULL.
**/
NS_INLINE void <API key>(sqlite3_stmt **stmtPtr)
{
if (*stmtPtr) {
sqlite3_finalize(*stmtPtr);
*stmtPtr = NULL;
}
}
#ifndef SQLITE_BIND_START
#define SQLITE_BIND_START 1
#endif
#ifndef SQLITE_COLUMN_START
#define SQLITE_COLUMN_START 0
#endif
/**
* Keys for changeset dictionary.
**/
extern NSString *const <API key>;
extern NSString *const <API key>;
extern NSString *const <API key>;
extern NSString *const <API key>;
extern NSString *const <API key>;
extern NSString *const <API key>;
/**
* Key(s) for yap2 extension configuration table.
*
* This is the only key that is reserved, and should not be set by extension subclasses.
**/
static NSString *const ext_key_class = @"class";
@interface YapDatabase () {
@public
void *<API key>; // Only to be used by <API key>
void *IsOnWriteQueueKey; // Only to be used by <API key>
dispatch_queue_t snapshotQueue; // Only to be used by <API key>
dispatch_queue_t writeQueue; // Only to be used by <API key>
NSMutableArray *connectionStates; // Only to be used by <API key>
NSArray *<API key>; // Writeable only within snapshot queue
<API key> objectSerializer; // Read-only by transactions
<API key> objectDeserializer; // Read-only by transactions
<API key> metadataSerializer; // Read-only by transactions
<API key> <API key>; // Read-only by transactions
<API key> objectPreSanitizer; // Read-only by transactions
<API key> objectPostSanitizer; // Read-only by transactions
<API key> <API key>; // Read-only by transactions
<API key> <API key>; // Read-only by transactions
}
/**
* General utility methods.
**/
+ (int64_t)pragma:(NSString *)pragmaSetting using:(sqlite3 *)aDb;
+ (NSString *)<API key>:(int64_t)auto_vacuum;
+ (NSString *)<API key>:(int64_t)synchronous;
+ (BOOL)tableExists:(NSString *)tableName using:(sqlite3 *)aDb;
+ (NSArray *)tableNamesUsing:(sqlite3 *)aDb;
+ (NSArray *)columnNamesForTable:(NSString *)tableName using:(sqlite3 *)aDb;
+ (NSDictionary *)<API key>:(NSString *)tableName using:(sqlite3 *)aDb;
/**
* New connections inherit their default values from this structure.
**/
- (<API key> *)connectionDefaults;
/**
* Called from <API key>'s dealloc method to remove connection's state from connectionStates array.
**/
- (void)removeConnection:(<API key> *)connection;
/**
* <API key> uses these methods to recycle sqlite3 instances using the connection pool.
**/
- (BOOL)<API key>:(sqlite3 *)aDb;
- (sqlite3 *)<API key>;
/**
* These methods are only accessible from within the snapshotQueue.
* Used by [<API key> prepare].
**/
- (NSDictionary *)<API key>;
- (NSArray *)extensionsOrder;
- (NSDictionary *)<API key>;
/**
* This method is only accessible from within the snapshotQueue.
*
* Prior to starting the sqlite commit, the connection must report its changeset to the database.
* The database will store the changeset, and provide it to other connections if needed (due to a race condition).
*
* The following MUST be in the dictionary:
*
* - snapshot : NSNumber with the changeset's snapshot
**/
- (void)notePendingChanges:(NSDictionary *)changeset fromConnection:(<API key> *)connection;
/**
* This method is only accessible from within the snapshotQueue.
*
* This method is used if a transaction finds itself in a race condition.
* That is, the transaction started before it was able to process changesets from sibling connections.
*
* It should fetch the changesets needed and then process them via [connection <API key>:].
**/
- (NSArray *)<API key>:(uint64_t)connectionSnapshot until:(uint64_t)maxSnapshot;
/**
* This method is only accessible from within the snapshotQueue.
*
* Upon completion of a readwrite transaction, the connection must report its changeset to the database.
* The database will then forward the changeset to all other connections.
*
* The following MUST be in the dictionary:
*
* - snapshot : NSNumber with the changeset's snapshot
**/
- (void)<API key>:(NSDictionary *)changeset fromConnection:(<API key> *)connection;
/**
* This method should be called whenever the maximum checkpointable snapshot is incremented.
* That is, the state of every connection is known to the system.
* And a snaphot cannot be checkpointed until every connection is at or past that snapshot.
* Thus, we can know the point at which a snapshot becomes checkpointable,
* and we can thus optimize the checkpoint invocations such that
* each invocation is able to checkpoint one or more commits.
**/
- (void)asyncCheckpoint:(uint64_t)<API key>;
#ifdef SQLITE_HAS_CODEC
/**
* Configures database encryption via SQLCipher.
**/
- (BOOL)<API key>:(sqlite3 *)sqlite;
#endif
@end
#pragma mark -
@interface <API key> () {
@public
__strong YapDatabase *database;
sqlite3 *db;
dispatch_queue_t connectionQueue; // For <API key> subclasses
void *<API key>; // For <API key> subclasses
NSArray *extensionsOrder; // Read-only by <API key>
NSDictionary *<API key>; // Read-only for <API key> subclasses
BOOL hasDiskChanges;
YapCache *keyCache;
YapCache *objectCache;
YapCache *metadataCache;
NSUInteger objectCacheLimit; // Read-only by transaction. Use as consideration of whether to add to cache.
NSUInteger metadataCacheLimit; // Read-only by transaction. Use as consideration of whether to add to cache.
YapDatabasePolicy objectPolicy; // Read-only by transaction. Use to determine what goes in objectChanges.
YapDatabasePolicy metadataPolicy; // Read-only by transaction. Use to determine what goes in metadataChanges.
BOOL <API key>; // Read-only by transaction. Use as consideration of whether to invoke method.
NSMutableDictionary *objectChanges;
NSMutableDictionary *metadataChanges;
NSMutableSet *removedKeys;
NSMutableSet *removedCollections;
NSMutableSet *removedRowids;
BOOL allKeysRemoved;
}
- (id)initWithDatabase:(YapDatabase *)database;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>; // Against "yap" database, for internal use
- (sqlite3_stmt *)<API key>; // Against "yap" database, for internal use
- (sqlite3_stmt *)<API key>; // Against "yap" database, for internal use
- (sqlite3_stmt *)<API key>; // Against "yap" database, for internal use
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)removeAllStatement;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (sqlite3_stmt *)<API key>;
- (void)prepare;
- (NSDictionary *)extensions;
- (BOOL)registerExtension:(<API key> *)extension withName:(NSString *)extensionName;
- (void)<API key>:(NSString *)extensionName;
- (NSDictionary *)<API key>;
- (BOOL)registerMemoryTable:(YapMemoryTable *)table withName:(NSString *)name;
- (void)<API key>:(NSString *)name;
- (<API key> *)newReadTransaction;
- (<API key> *)<API key>;
- (void)<API key>;
- (void)<API key>:(NSMutableDictionary **)internalPtr externalChangeset:(NSMutableDictionary **)externalPtr;
- (void)processChangeset:(NSDictionary *)changeset;
- (void)<API key>:(NSDictionary *)changeset;
- (void)<API key>;
@end
#pragma mark -
@interface <API key> () {
@private
NSMutableArray *orderedExtensions;
BOOL extensionsReady;
<API key> *<API key>;
@protected
NSMutableDictionary *extensions;
BOOL isMutated; // Used for "mutation during enumeration" protection
@public
__unsafe_unretained <API key> *connection;
BOOL <API key>;
}
- (id)initWithConnection:(<API key> *)connection <API key>:(BOOL)flag;
- (void)beginTransaction;
- (void)<API key>;
- (void)commitTransaction;
- (void)rollbackTransaction;
- (NSDictionary *)extensions;
- (NSArray *)orderedExtensions;
- (<API key> *)<API key>:(NSString *)tableName;
- (<API key> *)<API key>;
- (BOOL)getBoolValue:(BOOL *)valuePtr forKey:(NSString *)key extension:(NSString *)extension;
- (BOOL)getIntValue:(int *)valuePtr forKey:(NSString *)key extension:(NSString *)extensionName;
- (BOOL)getDoubleValue:(double *)valuePtr forKey:(NSString *)key extension:(NSString *)extensionName;
- (NSString *)stringValueForKey:(NSString *)key extension:(NSString *)extensionName;
- (NSData *)dataValueForKey:(NSString *)key extension:(NSString *)extensionName;
- (NSException *)<API key>;
- (BOOL)getRowid:(int64_t *)rowidPtr forKey:(NSString *)key inCollection:(NSString *)collection;
- (YapCollectionKey *)<API key>:(int64_t)rowid;
- (BOOL)getCollectionKey:(YapCollectionKey **)collectionKeyPtr object:(id *)objectPtr forRowid:(int64_t)rowid;
- (BOOL)getCollectionKey:(YapCollectionKey **)collectionKeyPtr metadata:(id *)metadataPtr forRowid:(int64_t)rowid;
- (BOOL)getCollectionKey:(YapCollectionKey **)collectionKeyPtr
object:(id *)objectPtr
metadata:(id *)metadataPtr
forRowid:(int64_t)rowid;
- (BOOL)hasRowid:(int64_t)rowid;
- (id)objectForKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
- (id)<API key>:(YapCollectionKey *)cacheKey withRowid:(int64_t)rowid;
- (id)metadataForKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
- (id)<API key>:(YapCollectionKey *)cacheKey withRowid:(int64_t)rowid;
- (BOOL)getObject:(id *)objectPtr
metadata:(id *)metadataPtr
forCollectionKey:(YapCollectionKey *)collectionKey
withRowid:(int64_t)rowid;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, BOOL *stop))block;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, BOOL *stop))block;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, BOOL *stop))block;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, id metadata, BOOL *stop))block;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, id metadata, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *key))filter;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, id metadata, BOOL *stop))block;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, id metadata, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, id metadata, BOOL *stop))block;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, id metadata, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, id object, BOOL *stop))block;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, id object, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *key))filter;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, BOOL *stop))block;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, BOOL *stop))block;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, id object, id metadata, BOOL *stop))block;
- (void)<API key>:(NSString *)collection
usingBlock:(void (^)(int64_t rowid, NSString *key, id object, id metadata, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *key))filter;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block;
- (void)<API key>:(NSArray *)collections
usingBlock:(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block;
- (void)<API key>:
(void (^)(int64_t rowid, NSString *collection, NSString *key, id object, id metadata, BOOL *stop))block
withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
@end
#pragma mark -
@interface <API key> () {
@public
BOOL rollback;
id <API key>;
}
- (void)replaceObject:(id)object
forKey:(NSString *)key
inCollection:(NSString *)collection
withRowid:(int64_t)rowid
serializedObject:(NSData *)preSerializedObject;
- (void)replaceMetadata:(id)metadata
forKey:(NSString *)key
inCollection:(NSString *)collection
withRowid:(int64_t)rowid
serializedMetadata:(NSData *)<API key>;
- (void)removeObjectForKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
- (void)<API key>:(<API key> *)extTrnsactn withName:(NSString *)extName;
- (void)<API key>:(NSString *)extName;
- (void)setBoolValue:(BOOL)value forKey:(NSString *)key extension:(NSString *)extensionName;
- (void)setIntValue:(int)value forKey:(NSString *)key extension:(NSString *)extensionName;
- (void)setDoubleValue:(double)value forKey:(NSString *)key extension:(NSString *)extensionName;
- (void)setStringValue:(NSString *)value forKey:(NSString *)key extension:(NSString *)extensionName;
- (void)setDataValue:(NSData *)value forKey:(NSString *)key extension:(NSString *)extensionName;
- (void)removeValueForKey:(NSString *)key extension:(NSString *)extensionName;
- (void)<API key>:(NSString *)extensionName;
@end |
# -*- coding: utf-8 -*-
from __future__ import absolute_import as _init
__author__ = 'lovelylain'
__version__ = '0.3.0'
class TAError(Exception):
pass
class TAFunc(object):
__slots__ = ('inputs', 'outputs', 'params', 'lookback', 'size')
def __call__(self, stop, start=-1):
return 0
@classmethod
def C(cls, *a, **kw):
"""C(cls, *a, **kw) -> (outNBElement, outputs...)
calculate result on all inputs and return the result
"""
self = cls(*a, **kw)
return (self(self.size, 0),) + self.outputs
class ACOS(TAFunc):
"""ACOS(real, outReal=None) -> Acos
Acos(stop, start=-1) -> outNBElement
Vector Trigonometric ACos (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class AD(TAFunc):
"""AD(high, low, close, volume, outReal=None) -> Ad
Ad(stop, start=-1) -> outNBElement
Chaikin A/D Line (Volume Indicators)
Inputs: [high, low, close, volume]
Outputs: (outReal,d)
"""
__slots__ = ('high', 'low', 'close', 'volume', 'outReal')
def __init__(self, high, low, close, volume, outReal=None):
pass
class ADD(TAFunc):
"""ADD(real0, real1, outReal=None) -> Add
Add(stop, start=-1) -> outNBElement
Vector Arithmetic Add (Math Operators)
Inputs: real0, real1
Outputs: (outReal,d)
"""
__slots__ = ('real0', 'real1', 'outReal')
def __init__(self, real0, real1, outReal=None):
pass
class ADOSC(TAFunc):
"""ADOSC(high, low, close, volume, outReal=None, fastperiod=3, slowperiod=10) -> AdOsc
AdOsc(stop, start=-1) -> outNBElement
Chaikin A/D Oscillator (Volume Indicators)
Inputs: [high, low, close, volume]
Outputs: (outReal,d)
Parameters:
fastperiod: Fast Period (2 <= i <= 100000)
Number of period for the fast MA
slowperiod: Slow Period (2 <= i <= 100000)
Number of period for the slow MA
"""
__slots__ = ('high', 'low', 'close', 'volume', 'outReal', 'fastperiod', 'slowperiod')
def __init__(self, high, low, close, volume, outReal=None, fastperiod=3, slowperiod=10):
pass
class ADX(TAFunc):
"""ADX(high, low, close, outReal=None, timeperiod=14) -> Adx
Adx(stop, start=-1) -> outNBElement
Average Directional Movement Index (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class ADXR(TAFunc):
"""ADXR(high, low, close, outReal=None, timeperiod=14) -> Adxr
Adxr(stop, start=-1) -> outNBElement
Average Directional Movement Index Rating (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class APO(TAFunc):
"""APO(real, outReal=None, fastperiod=12, slowperiod=26, matype=0) -> Apo
Apo(stop, start=-1) -> outNBElement
Absolute Price Oscillator (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
fastperiod: Fast Period (2 <= i <= 100000)
Number of period for the fast MA
slowperiod: Slow Period (2 <= i <= 100000)
Number of period for the slow MA
matype: MA Type
Type of Moving Average
"""
__slots__ = ('real', 'outReal', 'fastperiod', 'slowperiod', 'matype')
def __init__(self, real, outReal=None, fastperiod=12, slowperiod=26, matype=0):
pass
class AROON(TAFunc):
"""AROON(high, low, outAroonDown=None, outAroonUp=None, timeperiod=14) -> Aroon
Aroon(stop, start=-1) -> outNBElement
Aroon (Momentum Indicators)
Inputs: [high, low]
Outputs: (outAroonDown,d), (outAroonUp,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'outAroonDown', 'outAroonUp', 'timeperiod')
def __init__(self, high, low, outAroonDown=None, outAroonUp=None, timeperiod=14):
pass
class AROONOSC(TAFunc):
"""AROONOSC(high, low, outReal=None, timeperiod=14) -> AroonOsc
AroonOsc(stop, start=-1) -> outNBElement
Aroon Oscillator (Momentum Indicators)
Inputs: [high, low]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'outReal', 'timeperiod')
def __init__(self, high, low, outReal=None, timeperiod=14):
pass
class ASIN(TAFunc):
"""ASIN(real, outReal=None) -> Asin
Asin(stop, start=-1) -> outNBElement
Vector Trigonometric ASin (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class ATAN(TAFunc):
"""ATAN(real, outReal=None) -> Atan
Atan(stop, start=-1) -> outNBElement
Vector Trigonometric ATan (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class ATR(TAFunc):
"""ATR(high, low, close, outReal=None, timeperiod=14) -> Atr
Atr(stop, start=-1) -> outNBElement
Average True Range (Volatility Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class AVGPRICE(TAFunc):
"""AVGPRICE(open, high, low, close, outReal=None) -> AvgPrice
AvgPrice(stop, start=-1) -> outNBElement
Average Price (Price Transform)
Inputs: [open, high, low, close]
Outputs: (outReal,d)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outReal')
def __init__(self, open, high, low, close, outReal=None):
pass
class BBANDS(TAFunc):
"""BBANDS(real, outUpperBand=None, outMiddleBand=None, outLowerBand=None, timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> Bbands
Bbands(stop, start=-1) -> outNBElement
Bollinger Bands (Overlap Studies)
Inputs: real
Outputs: (outUpperBand,d), (outMiddleBand,d), (outLowerBand,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
nbdevup: Deviations up (REAL_MIN <= d <= REAL_MAX)
Deviation multiplier for upper band
nbdevdn: Deviations down (REAL_MIN <= d <= REAL_MAX)
Deviation multiplier for lower band
matype: MA Type
Type of Moving Average
"""
__slots__ = ('real', 'outUpperBand', 'outMiddleBand', 'outLowerBand', 'timeperiod', 'nbdevup', 'nbdevdn', 'matype')
def __init__(self, real, outUpperBand=None, outMiddleBand=None, outLowerBand=None, timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0):
pass
class BETA(TAFunc):
"""BETA(real0, real1, outReal=None, timeperiod=5) -> Beta
Beta(stop, start=-1) -> outNBElement
Beta (Statistic Functions)
Inputs: real0, real1
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real0', 'real1', 'outReal', 'timeperiod')
def __init__(self, real0, real1, outReal=None, timeperiod=5):
pass
class BOP(TAFunc):
"""BOP(open, high, low, close, outReal=None) -> Bop
Bop(stop, start=-1) -> outNBElement
Balance Of Power (Momentum Indicators)
Inputs: [open, high, low, close]
Outputs: (outReal,d)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outReal')
def __init__(self, open, high, low, close, outReal=None):
pass
class CCI(TAFunc):
"""CCI(high, low, close, outReal=None, timeperiod=14) -> Cci
Cci(stop, start=-1) -> outNBElement
Commodity Channel Index (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class CDL2CROWS(TAFunc):
"""CDL2CROWS(open, high, low, close, outInt=None) -> Cdl2Crows
Cdl2Crows(stop, start=-1) -> outNBElement
Two Crows (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDL3BLACKCROWS(TAFunc):
"""CDL3BLACKCROWS(open, high, low, close, outInt=None) -> Cdl3BlackCrows
Cdl3BlackCrows(stop, start=-1) -> outNBElement
Three Black Crows (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDL3INSIDE(TAFunc):
"""CDL3INSIDE(open, high, low, close, outInt=None) -> Cdl3Inside
Cdl3Inside(stop, start=-1) -> outNBElement
Three Inside Up/Down (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDL3LINESTRIKE(TAFunc):
"""CDL3LINESTRIKE(open, high, low, close, outInt=None) -> Cdl3LineStrike
Cdl3LineStrike(stop, start=-1) -> outNBElement
Three-Line Strike (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDL3OUTSIDE(TAFunc):
"""CDL3OUTSIDE(open, high, low, close, outInt=None) -> Cdl3Outside
Cdl3Outside(stop, start=-1) -> outNBElement
Three Outside Up/Down (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDL3STARSINSOUTH(TAFunc):
"""CDL3STARSINSOUTH(open, high, low, close, outInt=None) -> Cdl3StarsInSouth
Cdl3StarsInSouth(stop, start=-1) -> outNBElement
Three Stars In The South (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDL3WHITESOLDIERS(TAFunc):
"""CDL3WHITESOLDIERS(open, high, low, close, outInt=None) -> Cdl3WhiteSoldiers
Cdl3WhiteSoldiers(stop, start=-1) -> outNBElement
Three Advancing White Soldiers (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLABANDONEDBABY(TAFunc):
"""CDLABANDONEDBABY(open, high, low, close, outInt=None, penetration=0.3) -> CdlAbandonedBaby
CdlAbandonedBaby(stop, start=-1) -> outNBElement
Abandoned Baby (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.3):
pass
class CDLADVANCEBLOCK(TAFunc):
"""CDLADVANCEBLOCK(open, high, low, close, outInt=None) -> CdlAdvanceBlock
CdlAdvanceBlock(stop, start=-1) -> outNBElement
Advance Block (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLBELTHOLD(TAFunc):
"""CDLBELTHOLD(open, high, low, close, outInt=None) -> CdlBeltHold
CdlBeltHold(stop, start=-1) -> outNBElement
Belt-hold (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLBREAKAWAY(TAFunc):
"""CDLBREAKAWAY(open, high, low, close, outInt=None) -> CdlBreakaway
CdlBreakaway(stop, start=-1) -> outNBElement
Breakaway (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLCLOSINGMARUBOZU(TAFunc):
"""CDLCLOSINGMARUBOZU(open, high, low, close, outInt=None) -> CdlClosingMarubozu
CdlClosingMarubozu(stop, start=-1) -> outNBElement
Closing Marubozu (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLCONCEALBABYSWALL(TAFunc):
"""CDLCONCEALBABYSWALL(open, high, low, close, outInt=None) -> CdlConcealBabysWall
CdlConcealBabysWall(stop, start=-1) -> outNBElement
Concealing Baby Swallow (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLCOUNTERATTACK(TAFunc):
"""CDLCOUNTERATTACK(open, high, low, close, outInt=None) -> CdlCounterAttack
CdlCounterAttack(stop, start=-1) -> outNBElement
Counterattack (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLDARKCLOUDCOVER(TAFunc):
"""CDLDARKCLOUDCOVER(open, high, low, close, outInt=None, penetration=0.5) -> CdlDarkCloudCover
CdlDarkCloudCover(stop, start=-1) -> outNBElement
Dark Cloud Cover (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.5):
pass
class CDLDOJI(TAFunc):
"""CDLDOJI(open, high, low, close, outInt=None) -> CdlDoji
CdlDoji(stop, start=-1) -> outNBElement
Doji (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLDOJISTAR(TAFunc):
"""CDLDOJISTAR(open, high, low, close, outInt=None) -> CdlDojiStar
CdlDojiStar(stop, start=-1) -> outNBElement
Doji Star (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLDRAGONFLYDOJI(TAFunc):
"""CDLDRAGONFLYDOJI(open, high, low, close, outInt=None) -> CdlDragonflyDoji
CdlDragonflyDoji(stop, start=-1) -> outNBElement
Dragonfly Doji (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLENGULFING(TAFunc):
"""CDLENGULFING(open, high, low, close, outInt=None) -> CdlEngulfing
CdlEngulfing(stop, start=-1) -> outNBElement
Engulfing Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLEVENINGDOJISTAR(TAFunc):
"""CDLEVENINGDOJISTAR(open, high, low, close, outInt=None, penetration=0.3) -> CdlEveningDojiStar
CdlEveningDojiStar(stop, start=-1) -> outNBElement
Evening Doji Star (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.3):
pass
class CDLEVENINGSTAR(TAFunc):
"""CDLEVENINGSTAR(open, high, low, close, outInt=None, penetration=0.3) -> CdlEveningStar
CdlEveningStar(stop, start=-1) -> outNBElement
Evening Star (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.3):
pass
class CDLGAPSIDESIDEWHITE(TAFunc):
"""CDLGAPSIDESIDEWHITE(open, high, low, close, outInt=None) -> CdlGapSideSideWhite
CdlGapSideSideWhite(stop, start=-1) -> outNBElement
Up/Down-gap side-by-side white lines (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLGRAVESTONEDOJI(TAFunc):
"""CDLGRAVESTONEDOJI(open, high, low, close, outInt=None) -> CdlGravestoneDoji
CdlGravestoneDoji(stop, start=-1) -> outNBElement
Gravestone Doji (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHAMMER(TAFunc):
"""CDLHAMMER(open, high, low, close, outInt=None) -> CdlHammer
CdlHammer(stop, start=-1) -> outNBElement
Hammer (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHANGINGMAN(TAFunc):
"""CDLHANGINGMAN(open, high, low, close, outInt=None) -> CdlHangingMan
CdlHangingMan(stop, start=-1) -> outNBElement
Hanging Man (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHARAMI(TAFunc):
"""CDLHARAMI(open, high, low, close, outInt=None) -> CdlHarami
CdlHarami(stop, start=-1) -> outNBElement
Harami Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHARAMICROSS(TAFunc):
"""CDLHARAMICROSS(open, high, low, close, outInt=None) -> CdlHaramiCross
CdlHaramiCross(stop, start=-1) -> outNBElement
Harami Cross Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHIGHWAVE(TAFunc):
"""CDLHIGHWAVE(open, high, low, close, outInt=None) -> CdlHignWave
CdlHignWave(stop, start=-1) -> outNBElement
High-Wave Candle (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHIKKAKE(TAFunc):
"""CDLHIKKAKE(open, high, low, close, outInt=None) -> CdlHikkake
CdlHikkake(stop, start=-1) -> outNBElement
Hikkake Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHIKKAKEMOD(TAFunc):
"""CDLHIKKAKEMOD(open, high, low, close, outInt=None) -> CdlHikkakeMod
CdlHikkakeMod(stop, start=-1) -> outNBElement
Modified Hikkake Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLHOMINGPIGEON(TAFunc):
"""CDLHOMINGPIGEON(open, high, low, close, outInt=None) -> CdlHomingPigeon
CdlHomingPigeon(stop, start=-1) -> outNBElement
Homing Pigeon (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLIDENTICAL3CROWS(TAFunc):
"""CDLIDENTICAL3CROWS(open, high, low, close, outInt=None) -> CdlIdentical3Crows
CdlIdentical3Crows(stop, start=-1) -> outNBElement
Identical Three Crows (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLINNECK(TAFunc):
"""CDLINNECK(open, high, low, close, outInt=None) -> CdlInNeck
CdlInNeck(stop, start=-1) -> outNBElement
In-Neck Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLINVERTEDHAMMER(TAFunc):
"""CDLINVERTEDHAMMER(open, high, low, close, outInt=None) -> CdlInvertedHammer
CdlInvertedHammer(stop, start=-1) -> outNBElement
Inverted Hammer (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLKICKING(TAFunc):
"""CDLKICKING(open, high, low, close, outInt=None) -> CdlKicking
CdlKicking(stop, start=-1) -> outNBElement
Kicking (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLKICKINGBYLENGTH(TAFunc):
"""CDLKICKINGBYLENGTH(open, high, low, close, outInt=None) -> CdlKickingByLength
CdlKickingByLength(stop, start=-1) -> outNBElement
Kicking - bull/bear determined by the longer marubozu (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLLADDERBOTTOM(TAFunc):
"""CDLLADDERBOTTOM(open, high, low, close, outInt=None) -> CdlLadderBottom
CdlLadderBottom(stop, start=-1) -> outNBElement
Ladder Bottom (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLLONGLEGGEDDOJI(TAFunc):
"""CDLLONGLEGGEDDOJI(open, high, low, close, outInt=None) -> CdlLongLeggedDoji
CdlLongLeggedDoji(stop, start=-1) -> outNBElement
Long Legged Doji (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLLONGLINE(TAFunc):
"""CDLLONGLINE(open, high, low, close, outInt=None) -> CdlLongLine
CdlLongLine(stop, start=-1) -> outNBElement
Long Line Candle (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLMARUBOZU(TAFunc):
"""CDLMARUBOZU(open, high, low, close, outInt=None) -> CdlMarubozu
CdlMarubozu(stop, start=-1) -> outNBElement
Marubozu (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLMATCHINGLOW(TAFunc):
"""CDLMATCHINGLOW(open, high, low, close, outInt=None) -> CdlMatchingLow
CdlMatchingLow(stop, start=-1) -> outNBElement
Matching Low (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLMATHOLD(TAFunc):
"""CDLMATHOLD(open, high, low, close, outInt=None, penetration=0.5) -> CdlMatHold
CdlMatHold(stop, start=-1) -> outNBElement
Mat Hold (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.5):
pass
class CDLMORNINGDOJISTAR(TAFunc):
"""CDLMORNINGDOJISTAR(open, high, low, close, outInt=None, penetration=0.3) -> CdlMorningDojiStar
CdlMorningDojiStar(stop, start=-1) -> outNBElement
Morning Doji Star (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.3):
pass
class CDLMORNINGSTAR(TAFunc):
"""CDLMORNINGSTAR(open, high, low, close, outInt=None, penetration=0.3) -> CdlMorningStar
CdlMorningStar(stop, start=-1) -> outNBElement
Morning Star (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
Parameters:
penetration: Penetration (0.0 <= d <= REAL_MAX)
Percentage of penetration of a candle within another candle
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt', 'penetration')
def __init__(self, open, high, low, close, outInt=None, penetration=0.3):
pass
class CDLONNECK(TAFunc):
"""CDLONNECK(open, high, low, close, outInt=None) -> CdlOnNeck
CdlOnNeck(stop, start=-1) -> outNBElement
On-Neck Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLPIERCING(TAFunc):
"""CDLPIERCING(open, high, low, close, outInt=None) -> CdlPiercing
CdlPiercing(stop, start=-1) -> outNBElement
Piercing Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLRICKSHAWMAN(TAFunc):
"""CDLRICKSHAWMAN(open, high, low, close, outInt=None) -> CdlRickshawMan
CdlRickshawMan(stop, start=-1) -> outNBElement
Rickshaw Man (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLRISEFALL3METHODS(TAFunc):
"""CDLRISEFALL3METHODS(open, high, low, close, outInt=None) -> CdlRiseFall3Methods
CdlRiseFall3Methods(stop, start=-1) -> outNBElement
Rising/Falling Three Methods (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLSEPARATINGLINES(TAFunc):
"""CDLSEPARATINGLINES(open, high, low, close, outInt=None) -> CdlSeperatingLines
CdlSeperatingLines(stop, start=-1) -> outNBElement
Separating Lines (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLSHOOTINGSTAR(TAFunc):
"""CDLSHOOTINGSTAR(open, high, low, close, outInt=None) -> CdlShootingStar
CdlShootingStar(stop, start=-1) -> outNBElement
Shooting Star (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLSHORTLINE(TAFunc):
"""CDLSHORTLINE(open, high, low, close, outInt=None) -> CdlShortLine
CdlShortLine(stop, start=-1) -> outNBElement
Short Line Candle (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLSPINNINGTOP(TAFunc):
"""CDLSPINNINGTOP(open, high, low, close, outInt=None) -> CdlSpinningTop
CdlSpinningTop(stop, start=-1) -> outNBElement
Spinning Top (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLSTALLEDPATTERN(TAFunc):
"""CDLSTALLEDPATTERN(open, high, low, close, outInt=None) -> CdlStalledPattern
CdlStalledPattern(stop, start=-1) -> outNBElement
Stalled Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLSTICKSANDWICH(TAFunc):
"""CDLSTICKSANDWICH(open, high, low, close, outInt=None) -> CdlStickSandwhich
CdlStickSandwhich(stop, start=-1) -> outNBElement
Stick Sandwich (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLTAKURI(TAFunc):
"""CDLTAKURI(open, high, low, close, outInt=None) -> CdlTakuri
CdlTakuri(stop, start=-1) -> outNBElement
Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLTASUKIGAP(TAFunc):
"""CDLTASUKIGAP(open, high, low, close, outInt=None) -> CdlTasukiGap
CdlTasukiGap(stop, start=-1) -> outNBElement
Tasuki Gap (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLTHRUSTING(TAFunc):
"""CDLTHRUSTING(open, high, low, close, outInt=None) -> CdlThrusting
CdlThrusting(stop, start=-1) -> outNBElement
Thrusting Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLTRISTAR(TAFunc):
"""CDLTRISTAR(open, high, low, close, outInt=None) -> CdlTristar
CdlTristar(stop, start=-1) -> outNBElement
Tristar Pattern (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLUNIQUE3RIVER(TAFunc):
"""CDLUNIQUE3RIVER(open, high, low, close, outInt=None) -> CdlUnique3River
CdlUnique3River(stop, start=-1) -> outNBElement
Unique 3 River (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLUPSIDEGAP2CROWS(TAFunc):
"""CDLUPSIDEGAP2CROWS(open, high, low, close, outInt=None) -> CdlUpsideGap2Crows
CdlUpsideGap2Crows(stop, start=-1) -> outNBElement
Upside Gap Two Crows (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CDLXSIDEGAP3METHODS(TAFunc):
"""CDLXSIDEGAP3METHODS(open, high, low, close, outInt=None) -> CdlXSideGap3Methods
CdlXSideGap3Methods(stop, start=-1) -> outNBElement
Upside/Downside Gap Three Methods (Pattern Recognition)
Inputs: [open, high, low, close]
Outputs: (outInt,i)
"""
__slots__ = ('open', 'high', 'low', 'close', 'outInt')
def __init__(self, open, high, low, close, outInt=None):
pass
class CEIL(TAFunc):
"""CEIL(real, outReal=None) -> Ceil
Ceil(stop, start=-1) -> outNBElement
Vector Ceil (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class CMO(TAFunc):
"""CMO(real, outReal=None, timeperiod=14) -> Cmo
Cmo(stop, start=-1) -> outNBElement
Chande Momentum Oscillator (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class CORREL(TAFunc):
"""CORREL(real0, real1, outReal=None, timeperiod=30) -> Correl
Correl(stop, start=-1) -> outNBElement
Pearson's Correlation Coefficient (r) (Statistic Functions)
Inputs: real0, real1
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real0', 'real1', 'outReal', 'timeperiod')
def __init__(self, real0, real1, outReal=None, timeperiod=30):
pass
class COS(TAFunc):
"""COS(real, outReal=None) -> Cos
Cos(stop, start=-1) -> outNBElement
Vector Trigonometric Cos (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class COSH(TAFunc):
"""COSH(real, outReal=None) -> Cosh
Cosh(stop, start=-1) -> outNBElement
Vector Trigonometric Cosh (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class DEMA(TAFunc):
"""DEMA(real, outReal=None, timeperiod=30) -> Dema
Dema(stop, start=-1) -> outNBElement
Double Exponential Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class DIV(TAFunc):
"""DIV(real0, real1, outReal=None) -> Div
Div(stop, start=-1) -> outNBElement
Vector Arithmetic Div (Math Operators)
Inputs: real0, real1
Outputs: (outReal,d)
"""
__slots__ = ('real0', 'real1', 'outReal')
def __init__(self, real0, real1, outReal=None):
pass
class DX(TAFunc):
"""DX(high, low, close, outReal=None, timeperiod=14) -> Dx
Dx(stop, start=-1) -> outNBElement
Directional Movement Index (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class EMA(TAFunc):
"""EMA(real, outReal=None, timeperiod=30) -> Ema
Ema(stop, start=-1) -> outNBElement
Exponential Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class EXP(TAFunc):
"""EXP(real, outReal=None) -> Exp
Exp(stop, start=-1) -> outNBElement
Vector Arithmetic Exp (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class FLOOR(TAFunc):
"""FLOOR(real, outReal=None) -> Floor
Floor(stop, start=-1) -> outNBElement
Vector Floor (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class HT_DCPERIOD(TAFunc):
"""HT_DCPERIOD(real, outReal=None) -> HtDcPeriod
HtDcPeriod(stop, start=-1) -> outNBElement
Hilbert Transform - Dominant Cycle Period (Cycle Indicators)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class HT_DCPHASE(TAFunc):
"""HT_DCPHASE(real, outReal=None) -> HtDcPhase
HtDcPhase(stop, start=-1) -> outNBElement
Hilbert Transform - Dominant Cycle Phase (Cycle Indicators)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class HT_PHASOR(TAFunc):
"""HT_PHASOR(real, outInPhase=None, outQuadrature=None) -> HtPhasor
HtPhasor(stop, start=-1) -> outNBElement
Hilbert Transform - Phasor Components (Cycle Indicators)
Inputs: real
Outputs: (outInPhase,d), (outQuadrature,d)
"""
__slots__ = ('real', 'outInPhase', 'outQuadrature')
def __init__(self, real, outInPhase=None, outQuadrature=None):
pass
class HT_SINE(TAFunc):
"""HT_SINE(real, outSine=None, outLeadSine=None) -> HtSine
HtSine(stop, start=-1) -> outNBElement
Hilbert Transform - SineWave (Cycle Indicators)
Inputs: real
Outputs: (outSine,d), (outLeadSine,d)
"""
__slots__ = ('real', 'outSine', 'outLeadSine')
def __init__(self, real, outSine=None, outLeadSine=None):
pass
class HT_TRENDLINE(TAFunc):
"""HT_TRENDLINE(real, outReal=None) -> HtTrendline
HtTrendline(stop, start=-1) -> outNBElement
Hilbert Transform - Instantaneous Trendline (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class HT_TRENDMODE(TAFunc):
"""HT_TRENDMODE(real, outInt=None) -> HtTrendMode
HtTrendMode(stop, start=-1) -> outNBElement
Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators)
Inputs: real
Outputs: (outInt,i)
"""
__slots__ = ('real', 'outInt')
def __init__(self, real, outInt=None):
pass
class KAMA(TAFunc):
"""KAMA(real, outReal=None, timeperiod=30) -> Kama
Kama(stop, start=-1) -> outNBElement
Kaufman Adaptive Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class LINEARREG(TAFunc):
"""LINEARREG(real, outReal=None, timeperiod=14) -> LinearReg
LinearReg(stop, start=-1) -> outNBElement
Linear Regression (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class LINEARREG_ANGLE(TAFunc):
"""LINEARREG_ANGLE(real, outReal=None, timeperiod=14) -> LinearRegAngle
LinearRegAngle(stop, start=-1) -> outNBElement
Linear Regression Angle (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class LINEARREG_INTERCEPT(TAFunc):
"""LINEARREG_INTERCEPT(real, outReal=None, timeperiod=14) -> LinearRegIntercept
LinearRegIntercept(stop, start=-1) -> outNBElement
Linear Regression Intercept (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class LINEARREG_SLOPE(TAFunc):
"""LINEARREG_SLOPE(real, outReal=None, timeperiod=14) -> LinearRegSlope
LinearRegSlope(stop, start=-1) -> outNBElement
Linear Regression Slope (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class LN(TAFunc):
"""LN(real, outReal=None) -> Ln
Ln(stop, start=-1) -> outNBElement
Vector Log Natural (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class LOG10(TAFunc):
"""LOG10(real, outReal=None) -> Log10
Log10(stop, start=-1) -> outNBElement
Vector Log10 (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class MA(TAFunc):
"""MA(real, outReal=None, timeperiod=30, matype=0) -> ma
ma(stop, start=-1) -> outNBElement
Moving average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
matype: MA Type
Type of Moving Average
"""
__slots__ = ('real', 'outReal', 'timeperiod', 'matype')
def __init__(self, real, outReal=None, timeperiod=30, matype=0):
pass
class MACD(TAFunc):
"""MACD(real, outMACD=None, outMACDSignal=None, outMACDHist=None, fastperiod=12, slowperiod=26, signalperiod=9) -> Macd
Macd(stop, start=-1) -> outNBElement
Moving Average Convergence/Divergence (Momentum Indicators)
Inputs: real
Outputs: (outMACD,d), (outMACDSignal,d), (outMACDHist,d)
Parameters:
fastperiod: Fast Period (2 <= i <= 100000)
Number of period for the fast MA
slowperiod: Slow Period (2 <= i <= 100000)
Number of period for the slow MA
signalperiod: Signal Period (1 <= i <= 100000)
Smoothing for the signal line (nb of period)
"""
__slots__ = ('real', 'outMACD', 'outMACDSignal', 'outMACDHist', 'fastperiod', 'slowperiod', 'signalperiod')
def __init__(self, real, outMACD=None, outMACDSignal=None, outMACDHist=None, fastperiod=12, slowperiod=26, signalperiod=9):
pass
class MACDEXT(TAFunc):
"""MACDEXT(real, outMACD=None, outMACDSignal=None, outMACDHist=None, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) -> MacdExt
MacdExt(stop, start=-1) -> outNBElement
MACD with controllable MA type (Momentum Indicators)
Inputs: real
Outputs: (outMACD,d), (outMACDSignal,d), (outMACDHist,d)
Parameters:
fastperiod: Fast Period (2 <= i <= 100000)
Number of period for the fast MA
fastmatype: Fast MA
Type of Moving Average for fast MA
slowperiod: Slow Period (2 <= i <= 100000)
Number of period for the slow MA
slowmatype: Slow MA
Type of Moving Average for slow MA
signalperiod: Signal Period (1 <= i <= 100000)
Smoothing for the signal line (nb of period)
signalmatype: Signal MA
Type of Moving Average for signal line
"""
__slots__ = ('real', 'outMACD', 'outMACDSignal', 'outMACDHist', 'fastperiod', 'fastmatype', 'slowperiod', 'slowmatype', 'signalperiod', 'signalmatype')
def __init__(self, real, outMACD=None, outMACDSignal=None, outMACDHist=None, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0):
pass
class MACDFIX(TAFunc):
"""MACDFIX(real, outMACD=None, outMACDSignal=None, outMACDHist=None, signalperiod=9) -> MacdFix
MacdFix(stop, start=-1) -> outNBElement
Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)
Inputs: real
Outputs: (outMACD,d), (outMACDSignal,d), (outMACDHist,d)
Parameters:
signalperiod: Signal Period (1 <= i <= 100000)
Smoothing for the signal line (nb of period)
"""
__slots__ = ('real', 'outMACD', 'outMACDSignal', 'outMACDHist', 'signalperiod')
def __init__(self, real, outMACD=None, outMACDSignal=None, outMACDHist=None, signalperiod=9):
pass
class MAMA(TAFunc):
"""MAMA(real, outMAMA=None, outFAMA=None, fastlimit=0.5, slowlimit=0.05) -> Mama
Mama(stop, start=-1) -> outNBElement
MESA Adaptive Moving Average (Overlap Studies)
Inputs: real
Outputs: (outMAMA,d), (outFAMA,d)
Parameters:
fastlimit: Fast Limit (0.01 <= d <= 0.99)
Upper limit use in the adaptive algorithm
slowlimit: Slow Limit (0.01 <= d <= 0.99)
Lower limit use in the adaptive algorithm
"""
__slots__ = ('real', 'outMAMA', 'outFAMA', 'fastlimit', 'slowlimit')
def __init__(self, real, outMAMA=None, outFAMA=None, fastlimit=0.5, slowlimit=0.05):
pass
class MAVP(TAFunc):
"""MAVP(real, periods, outReal=None, minperiod=2, maxperiod=30, matype=0) -> mavp
mavp(stop, start=-1) -> outNBElement
Moving average with variable period (Overlap Studies)
Inputs: real, periods
Outputs: (outReal,d)
Parameters:
minperiod: Minimum Period (2 <= i <= 100000)
Value less than minimum will be changed to Minimum period
maxperiod: Maximum Period (2 <= i <= 100000)
Value higher than maximum will be changed to Maximum period
matype: MA Type
Type of Moving Average
"""
__slots__ = ('real', 'periods', 'outReal', 'minperiod', 'maxperiod', 'matype')
def __init__(self, real, periods, outReal=None, minperiod=2, maxperiod=30, matype=0):
pass
class MAX(TAFunc):
"""MAX(real, outReal=None, timeperiod=30) -> Max
Max(stop, start=-1) -> outNBElement
Highest value over a specified period (Math Operators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class MAXINDEX(TAFunc):
"""MAXINDEX(real, outInt=None, timeperiod=30) -> MaxIndex
MaxIndex(stop, start=-1) -> outNBElement
Index of highest value over a specified period (Math Operators)
Inputs: real
Outputs: (outInt,i)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outInt', 'timeperiod')
def __init__(self, real, outInt=None, timeperiod=30):
pass
class MEDPRICE(TAFunc):
"""MEDPRICE(high, low, outReal=None) -> MedPrice
MedPrice(stop, start=-1) -> outNBElement
Median Price (Price Transform)
Inputs: [high, low]
Outputs: (outReal,d)
"""
__slots__ = ('high', 'low', 'outReal')
def __init__(self, high, low, outReal=None):
pass
class MFI(TAFunc):
"""MFI(high, low, close, volume, outReal=None, timeperiod=14) -> Mfi
Mfi(stop, start=-1) -> outNBElement
Money Flow Index (Momentum Indicators)
Inputs: [high, low, close, volume]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'volume', 'outReal', 'timeperiod')
def __init__(self, high, low, close, volume, outReal=None, timeperiod=14):
pass
class MIDPOINT(TAFunc):
"""MIDPOINT(real, outReal=None, timeperiod=14) -> MidPoint
MidPoint(stop, start=-1) -> outNBElement
MidPoint over period (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class MIDPRICE(TAFunc):
"""MIDPRICE(high, low, outReal=None, timeperiod=14) -> MidPrice
MidPrice(stop, start=-1) -> outNBElement
Midpoint Price over period (Overlap Studies)
Inputs: [high, low]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'outReal', 'timeperiod')
def __init__(self, high, low, outReal=None, timeperiod=14):
pass
class MIN(TAFunc):
"""MIN(real, outReal=None, timeperiod=30) -> Min
Min(stop, start=-1) -> outNBElement
Lowest value over a specified period (Math Operators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class MININDEX(TAFunc):
"""MININDEX(real, outInt=None, timeperiod=30) -> MinIndex
MinIndex(stop, start=-1) -> outNBElement
Index of lowest value over a specified period (Math Operators)
Inputs: real
Outputs: (outInt,i)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outInt', 'timeperiod')
def __init__(self, real, outInt=None, timeperiod=30):
pass
class MINMAX(TAFunc):
"""MINMAX(real, outMin=None, outMax=None, timeperiod=30) -> MinMax
MinMax(stop, start=-1) -> outNBElement
Lowest and highest values over a specified period (Math Operators)
Inputs: real
Outputs: (outMin,d), (outMax,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outMin', 'outMax', 'timeperiod')
def __init__(self, real, outMin=None, outMax=None, timeperiod=30):
pass
class MINMAXINDEX(TAFunc):
"""MINMAXINDEX(real, outMinIdx=None, outMaxIdx=None, timeperiod=30) -> MinMaxIndex
MinMaxIndex(stop, start=-1) -> outNBElement
Indexes of lowest and highest values over a specified period (Math Operators)
Inputs: real
Outputs: (outMinIdx,i), (outMaxIdx,i)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outMinIdx', 'outMaxIdx', 'timeperiod')
def __init__(self, real, outMinIdx=None, outMaxIdx=None, timeperiod=30):
pass
class MINUS_DI(TAFunc):
"""MINUS_DI(high, low, close, outReal=None, timeperiod=14) -> MinusDI
MinusDI(stop, start=-1) -> outNBElement
Minus Directional Indicator (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class MINUS_DM(TAFunc):
"""MINUS_DM(high, low, outReal=None, timeperiod=14) -> MinusDM
MinusDM(stop, start=-1) -> outNBElement
Minus Directional Movement (Momentum Indicators)
Inputs: [high, low]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'outReal', 'timeperiod')
def __init__(self, high, low, outReal=None, timeperiod=14):
pass
class MOM(TAFunc):
"""MOM(real, outReal=None, timeperiod=10) -> Mom
Mom(stop, start=-1) -> outNBElement
Momentum (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=10):
pass
class MULT(TAFunc):
"""MULT(real0, real1, outReal=None) -> Mult
Mult(stop, start=-1) -> outNBElement
Vector Arithmetic Mult (Math Operators)
Inputs: real0, real1
Outputs: (outReal,d)
"""
__slots__ = ('real0', 'real1', 'outReal')
def __init__(self, real0, real1, outReal=None):
pass
class NATR(TAFunc):
"""NATR(high, low, close, outReal=None, timeperiod=14) -> Natr
Natr(stop, start=-1) -> outNBElement
Normalized Average True Range (Volatility Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class OBV(TAFunc):
"""OBV(real, volume, outReal=None) -> Obv
Obv(stop, start=-1) -> outNBElement
On Balance Volume (Volume Indicators)
Inputs: real, [volume]
Outputs: (outReal,d)
"""
__slots__ = ('real', 'volume', 'outReal')
def __init__(self, real, volume, outReal=None):
pass
class PLUS_DI(TAFunc):
"""PLUS_DI(high, low, close, outReal=None, timeperiod=14) -> PlusDI
PlusDI(stop, start=-1) -> outNBElement
Plus Directional Indicator (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class PLUS_DM(TAFunc):
"""PLUS_DM(high, low, outReal=None, timeperiod=14) -> PlusDM
PlusDM(stop, start=-1) -> outNBElement
Plus Directional Movement (Momentum Indicators)
Inputs: [high, low]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'outReal', 'timeperiod')
def __init__(self, high, low, outReal=None, timeperiod=14):
pass
class PPO(TAFunc):
"""PPO(real, outReal=None, fastperiod=12, slowperiod=26, matype=0) -> Ppo
Ppo(stop, start=-1) -> outNBElement
Percentage Price Oscillator (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
fastperiod: Fast Period (2 <= i <= 100000)
Number of period for the fast MA
slowperiod: Slow Period (2 <= i <= 100000)
Number of period for the slow MA
matype: MA Type
Type of Moving Average
"""
__slots__ = ('real', 'outReal', 'fastperiod', 'slowperiod', 'matype')
def __init__(self, real, outReal=None, fastperiod=12, slowperiod=26, matype=0):
pass
class ROC(TAFunc):
"""ROC(real, outReal=None, timeperiod=10) -> Roc
Roc(stop, start=-1) -> outNBElement
Rate of change : ((price/prevPrice)-1)*100 (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=10):
pass
class ROCP(TAFunc):
"""ROCP(real, outReal=None, timeperiod=10) -> RocP
RocP(stop, start=-1) -> outNBElement
Rate of change Percentage: (price-prevPrice)/prevPrice (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=10):
pass
class ROCR(TAFunc):
"""ROCR(real, outReal=None, timeperiod=10) -> RocR
RocR(stop, start=-1) -> outNBElement
Rate of change ratio: (price/prevPrice) (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=10):
pass
class ROCR100(TAFunc):
"""ROCR100(real, outReal=None, timeperiod=10) -> RocR100
RocR100(stop, start=-1) -> outNBElement
Rate of change ratio 100 scale: (price/prevPrice)*100 (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=10):
pass
class RSI(TAFunc):
"""RSI(real, outReal=None, timeperiod=14) -> Rsi
Rsi(stop, start=-1) -> outNBElement
Relative Strength Index (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class SAR(TAFunc):
"""SAR(high, low, outReal=None, acceleration=0.02, maximum=0.2) -> Sar
Sar(stop, start=-1) -> outNBElement
Parabolic SAR (Overlap Studies)
Inputs: [high, low]
Outputs: (outReal,d)
Parameters:
acceleration: Acceleration Factor (0.0 <= d <= REAL_MAX)
Acceleration Factor used up to the Maximum value
maximum: AF Maximum (0.0 <= d <= REAL_MAX)
Acceleration Factor Maximum value
"""
__slots__ = ('high', 'low', 'outReal', 'acceleration', 'maximum')
def __init__(self, high, low, outReal=None, acceleration=0.02, maximum=0.2):
pass
class SAREXT(TAFunc):
"""SAREXT(high, low, outReal=None, startvalue=0.0, offsetonreverse=0.0, <API key>=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, <API key>=0.02, accelerationshort=0.02, <API key>=0.2) -> SarExt
SarExt(stop, start=-1) -> outNBElement
Parabolic SAR - Extended (Overlap Studies)
Inputs: [high, low]
Outputs: (outReal,d)
Parameters:
startvalue: Start Value (REAL_MIN <= d <= REAL_MAX)
Start value and direction. 0 for Auto, >0 for Long, <0 for Short
offsetonreverse: Offset on Reverse (0.0 <= d <= REAL_MAX)
Percent offset added/removed to initial stop on short/long reversal
<API key>: AF Init Long (0.0 <= d <= REAL_MAX)
Acceleration Factor initial value for the Long direction
accelerationlong: AF Long (0.0 <= d <= REAL_MAX)
Acceleration Factor for the Long direction
accelerationmaxlong: AF Max Long (0.0 <= d <= REAL_MAX)
Acceleration Factor maximum value for the Long direction
<API key>: AF Init Short (0.0 <= d <= REAL_MAX)
Acceleration Factor initial value for the Short direction
accelerationshort: AF Short (0.0 <= d <= REAL_MAX)
Acceleration Factor for the Short direction
<API key>: AF Max Short (0.0 <= d <= REAL_MAX)
Acceleration Factor maximum value for the Short direction
"""
__slots__ = ('high', 'low', 'outReal', 'startvalue', 'offsetonreverse', '<API key>', 'accelerationlong', 'accelerationmaxlong', '<API key>', 'accelerationshort', '<API key>')
def __init__(self, high, low, outReal=None, startvalue=0.0, offsetonreverse=0.0, <API key>=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, <API key>=0.02, accelerationshort=0.02, <API key>=0.2):
pass
class SIN(TAFunc):
"""SIN(real, outReal=None) -> Sin
Sin(stop, start=-1) -> outNBElement
Vector Trigonometric Sin (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class SINH(TAFunc):
"""SINH(real, outReal=None) -> Sinh
Sinh(stop, start=-1) -> outNBElement
Vector Trigonometric Sinh (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class SMA(TAFunc):
"""SMA(real, outReal=None, timeperiod=30) -> Sma
Sma(stop, start=-1) -> outNBElement
Simple Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class SQRT(TAFunc):
"""SQRT(real, outReal=None) -> Sqrt
Sqrt(stop, start=-1) -> outNBElement
Vector Square Root (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class STDDEV(TAFunc):
"""STDDEV(real, outReal=None, timeperiod=5, nbdev=1.0) -> StdDev
StdDev(stop, start=-1) -> outNBElement
Standard Deviation (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
nbdev: Deviations (REAL_MIN <= d <= REAL_MAX)
Nb of deviations
"""
__slots__ = ('real', 'outReal', 'timeperiod', 'nbdev')
def __init__(self, real, outReal=None, timeperiod=5, nbdev=1.0):
pass
class STOCH(TAFunc):
"""STOCH(high, low, close, outSlowK=None, outSlowD=None, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) -> Stoch
Stoch(stop, start=-1) -> outNBElement
Stochastic (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outSlowK,d), (outSlowD,d)
Parameters:
fastk_period: Fast-K Period (1 <= i <= 100000)
Time period for building the Fast-K line
slowk_period: Slow-K Period (1 <= i <= 100000)
Smoothing for making the Slow-K line. Usually set to 3
slowk_matype: Slow-K MA
Type of Moving Average for Slow-K
slowd_period: Slow-D Period (1 <= i <= 100000)
Smoothing for making the Slow-D line
slowd_matype: Slow-D MA
Type of Moving Average for Slow-D
"""
__slots__ = ('high', 'low', 'close', 'outSlowK', 'outSlowD', 'fastk_period', 'slowk_period', 'slowk_matype', 'slowd_period', 'slowd_matype')
def __init__(self, high, low, close, outSlowK=None, outSlowD=None, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0):
pass
class STOCHF(TAFunc):
"""STOCHF(high, low, close, outFastK=None, outFastD=None, fastk_period=5, fastd_period=3, fastd_matype=0) -> StochF
StochF(stop, start=-1) -> outNBElement
Stochastic Fast (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outFastK,d), (outFastD,d)
Parameters:
fastk_period: Fast-K Period (1 <= i <= 100000)
Time period for building the Fast-K line
fastd_period: Fast-D Period (1 <= i <= 100000)
Smoothing for making the Fast-D line. Usually set to 3
fastd_matype: Fast-D MA
Type of Moving Average for Fast-D
"""
__slots__ = ('high', 'low', 'close', 'outFastK', 'outFastD', 'fastk_period', 'fastd_period', 'fastd_matype')
def __init__(self, high, low, close, outFastK=None, outFastD=None, fastk_period=5, fastd_period=3, fastd_matype=0):
pass
class STOCHRSI(TAFunc):
"""STOCHRSI(real, outFastK=None, outFastD=None, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) -> StochRsi
StochRsi(stop, start=-1) -> outNBElement
Stochastic Relative Strength Index (Momentum Indicators)
Inputs: real
Outputs: (outFastK,d), (outFastD,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
fastk_period: Fast-K Period (1 <= i <= 100000)
Time period for building the Fast-K line
fastd_period: Fast-D Period (1 <= i <= 100000)
Smoothing for making the Fast-D line. Usually set to 3
fastd_matype: Fast-D MA
Type of Moving Average for Fast-D
"""
__slots__ = ('real', 'outFastK', 'outFastD', 'timeperiod', 'fastk_period', 'fastd_period', 'fastd_matype')
def __init__(self, real, outFastK=None, outFastD=None, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0):
pass
class SUB(TAFunc):
"""SUB(real0, real1, outReal=None) -> Sub
Sub(stop, start=-1) -> outNBElement
Vector Arithmetic Substraction (Math Operators)
Inputs: real0, real1
Outputs: (outReal,d)
"""
__slots__ = ('real0', 'real1', 'outReal')
def __init__(self, real0, real1, outReal=None):
pass
class SUM(TAFunc):
"""SUM(real, outReal=None, timeperiod=30) -> Sum
Sum(stop, start=-1) -> outNBElement
Summation (Math Operators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class T3(TAFunc):
"""T3(real, outReal=None, timeperiod=5, vfactor=0.7) -> t3
t3(stop, start=-1) -> outNBElement
Triple Exponential Moving Average (T3) (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
vfactor: Volume Factor (0.0 <= d <= 1.0)
Volume Factor
"""
__slots__ = ('real', 'outReal', 'timeperiod', 'vfactor')
def __init__(self, real, outReal=None, timeperiod=5, vfactor=0.7):
pass
class TAN(TAFunc):
"""TAN(real, outReal=None) -> Tan
Tan(stop, start=-1) -> outNBElement
Vector Trigonometric Tan (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class TANH(TAFunc):
"""TANH(real, outReal=None) -> Tanh
Tanh(stop, start=-1) -> outNBElement
Vector Trigonometric Tanh (Math Transform)
Inputs: real
Outputs: (outReal,d)
"""
__slots__ = ('real', 'outReal')
def __init__(self, real, outReal=None):
pass
class TEMA(TAFunc):
"""TEMA(real, outReal=None, timeperiod=30) -> Tema
Tema(stop, start=-1) -> outNBElement
Triple Exponential Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class TRANGE(TAFunc):
"""TRANGE(high, low, close, outReal=None) -> TrueRange
TrueRange(stop, start=-1) -> outNBElement
True Range (Volatility Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
"""
__slots__ = ('high', 'low', 'close', 'outReal')
def __init__(self, high, low, close, outReal=None):
pass
class TRIMA(TAFunc):
"""TRIMA(real, outReal=None, timeperiod=30) -> Trima
Trima(stop, start=-1) -> outNBElement
Triangular Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class TRIX(TAFunc):
"""TRIX(real, outReal=None, timeperiod=30) -> Trix
Trix(stop, start=-1) -> outNBElement
1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
class TSF(TAFunc):
"""TSF(real, outReal=None, timeperiod=14) -> Tsf
Tsf(stop, start=-1) -> outNBElement
Time Series Forecast (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=14):
pass
class TYPPRICE(TAFunc):
"""TYPPRICE(high, low, close, outReal=None) -> TypPrice
TypPrice(stop, start=-1) -> outNBElement
Typical Price (Price Transform)
Inputs: [high, low, close]
Outputs: (outReal,d)
"""
__slots__ = ('high', 'low', 'close', 'outReal')
def __init__(self, high, low, close, outReal=None):
pass
class ULTOSC(TAFunc):
"""ULTOSC(high, low, close, outReal=None, timeperiod1=7, timeperiod2=14, timeperiod3=28) -> UltOsc
UltOsc(stop, start=-1) -> outNBElement
Ultimate Oscillator (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod1: First Period (1 <= i <= 100000)
Number of bars for 1st period.
timeperiod2: Second Period (1 <= i <= 100000)
Number of bars fro 2nd period
timeperiod3: Third Period (1 <= i <= 100000)
Number of bars for 3rd period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod1', 'timeperiod2', 'timeperiod3')
def __init__(self, high, low, close, outReal=None, timeperiod1=7, timeperiod2=14, timeperiod3=28):
pass
class VAR(TAFunc):
"""VAR(real, outReal=None, timeperiod=5, nbdev=1.0) -> Variance
Variance(stop, start=-1) -> outNBElement
Variance (Statistic Functions)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (1 <= i <= 100000)
Number of period
nbdev: Deviations (REAL_MIN <= d <= REAL_MAX)
Nb of deviations
"""
__slots__ = ('real', 'outReal', 'timeperiod', 'nbdev')
def __init__(self, real, outReal=None, timeperiod=5, nbdev=1.0):
pass
class WCLPRICE(TAFunc):
"""WCLPRICE(high, low, close, outReal=None) -> WclPrice
WclPrice(stop, start=-1) -> outNBElement
Weighted Close Price (Price Transform)
Inputs: [high, low, close]
Outputs: (outReal,d)
"""
__slots__ = ('high', 'low', 'close', 'outReal')
def __init__(self, high, low, close, outReal=None):
pass
class WILLR(TAFunc):
"""WILLR(high, low, close, outReal=None, timeperiod=14) -> WillR
WillR(stop, start=-1) -> outNBElement
Williams' %R (Momentum Indicators)
Inputs: [high, low, close]
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('high', 'low', 'close', 'outReal', 'timeperiod')
def __init__(self, high, low, close, outReal=None, timeperiod=14):
pass
class WMA(TAFunc):
"""WMA(real, outReal=None, timeperiod=30) -> Wma
Wma(stop, start=-1) -> outNBElement
Weighted Moving Average (Overlap Studies)
Inputs: real
Outputs: (outReal,d)
Parameters:
timeperiod: Time Period (2 <= i <= 100000)
Number of period
"""
__slots__ = ('real', 'outReal', 'timeperiod')
def __init__(self, real, outReal=None, timeperiod=30):
pass
INT_MIN, INT_MAX, INT_DEFAULT, REAL_MIN, REAL_MAX, REAL_DEFAULT = (None,) * 6
MA_S, MA_E, MA_W, MA_DE, MA_TE, MA_TRI, MA_KA, MA_MA, MA_T3 = range(9)
def _init():
ENV = globals(); del ENV['_init']
from ._talib import _init; _init(ENV)
_init() |
// Too weird for Flow
"use strict";
/**
* Check whether it's a number or a number-like string:
* i.e. when coerced to a number it == itself.
*/
module.exports = function(value) {
/* eslint-disable eqeqeq */
return value.trim().length !== 0 && Number(value) == value;
/* eslint-enable eqeqeq */
}; |
using System.Diagnostics;
using System.Globalization;
using Octokit.Helpers;
namespace Octokit
{
<summary>
Base class with common properties for all the Repository Content Request APIs.
</summary>
public abstract class ContentRequest
{
<summary>
Initializes a new instance of the <see cref="ContentRequest"/> class.
</summary>
<param name="message">The message.</param>
protected ContentRequest(string message)
{
Ensure.<API key>(message, nameof(message));
Message = message;
}
<summary>
Initializes a new instance of the <see cref="ContentRequest"/> class.
</summary>
<param name="message">The message.</param>
<param name="branch">The branch the request is for.</param>
protected ContentRequest(string message, string branch) : this(message)
{
Ensure.<API key>(branch, nameof(branch));
Branch = branch;
}
<summary>
The commit message. This is required.
</summary>
public string Message { get; private set; }
<summary>
The branch name. If null, this defaults to the default branch which is usually "master".
</summary>
public string Branch { get; set; }
<summary>
Specifies the committer to use for the commit. This is optional.
</summary>
public Committer Committer { get; set; }
<summary>
Specifies the author to use for the commit. This is optional.
</summary>
public Committer Author { get; set; }
}
<summary>
Represents the request to delete a file in a repository.
</summary>
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public class DeleteFileRequest : ContentRequest
{
<summary>
Initializes a new instance of the <see cref="DeleteFileRequest"/> class.
</summary>
<param name="message">The message.</param>
<param name="sha">The sha.</param>
public DeleteFileRequest(string message, string sha) : base(message)
{
Ensure.<API key>(sha, nameof(sha));
Sha = sha;
}
<summary>
Initializes a new instance of the <see cref="DeleteFileRequest"/> class.
</summary>
<param name="message">The message.</param>
<param name="sha">The sha.</param>
<param name="branch">The branch the request is for.</param>
public DeleteFileRequest(string message, string sha, string branch) : base(message, branch)
{
Ensure.<API key>(sha, nameof(sha));
Sha = sha;
}
public string Sha { get; private set; }
internal string DebuggerDisplay
{
get
{
return string.Format(CultureInfo.InvariantCulture, "SHA: {0} Message: {1}", Sha, Message);
}
}
}
<summary>
Represents the parameters to create a file in a repository.
</summary>
<remarks>https://developer.github.com/v3/repos/contents/#create-a-file</remarks>
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public class CreateFileRequest : ContentRequest
{
<summary>
Creates an instance of a <see cref="CreateFileRequest" />.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
public CreateFileRequest(string message, string content) : this(message, content, true)
{ }
<summary>
Initializes a new instance of the <see cref="CreateFileRequest"/> class.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="branch">The branch the request is for.</param>
public CreateFileRequest(string message, string content, string branch) : this(message, content, branch, true)
{ }
<summary>
Creates an instance of a <see cref="CreateFileRequest" />.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="<API key>">True to convert content to base64.</param>
public CreateFileRequest(string message, string content, bool <API key>) : base(message)
{
Ensure.ArgumentNotNull(content, nameof(content));
if (<API key>)
{
content = content.ToBase64String();
}
Content = content;
}
<summary>
Initializes a new instance of the <see cref="CreateFileRequest"/> class.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="branch">The branch the request is for.</param>
<param name="<API key>">True to convert content to base64.</param>
public CreateFileRequest(string message, string content, string branch, bool <API key>) : base(message, branch)
{
Ensure.<API key>(content, nameof(content));
if (<API key>)
{
content = content.ToBase64String();
}
Content = content;
}
<summary>
The contents of the file to create, Base64 encoded. This is required.
</summary>
public string Content { get; private set; }
internal virtual string DebuggerDisplay
{
get
{
return string.Format(CultureInfo.InvariantCulture, "Message: {0} Content: {1}", Message, Content);
}
}
}
<summary>
Represents the parameters to update a file in a repository.
</summary>
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public class UpdateFileRequest : CreateFileRequest
{
<summary>
Creates an instance of a <see cref="UpdateFileRequest" />.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="sha">The sha.</param>
public UpdateFileRequest(string message, string content, string sha)
: this(message, content, sha, true)
{ }
<summary>
Creates an instance of a <see cref="UpdateFileRequest" />.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="sha">The sha.</param>
<param name="branch">The branch the request is for.</param>
public UpdateFileRequest(string message, string content, string sha, string branch)
: this(message, content, sha, branch, true)
{ }
<summary>
Creates an instance of a <see cref="UpdateFileRequest" />.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="sha">The sha.</param>
<param name="<API key>">True to convert content to base64.</param>
public UpdateFileRequest(string message, string content, string sha, bool <API key>)
: base(message, content, <API key>)
{
Ensure.<API key>(sha, nameof(sha));
Sha = sha;
}
<summary>
Creates an instance of a <see cref="UpdateFileRequest" />.
</summary>
<param name="message">The message.</param>
<param name="content">The content.</param>
<param name="sha">The sha.</param>
<param name="branch">The branch the request is for.</param>
<param name="<API key>">True to convert content to base64.</param>
public UpdateFileRequest(string message, string content, string sha, string branch, bool <API key>)
: base(message, content, branch, <API key>)
{
Ensure.<API key>(sha, nameof(sha));
Sha = sha;
}
<summary>
The blob SHA of the file being replaced.
</summary>
public string Sha { get; private set; }
internal override string DebuggerDisplay
{
get
{
return string.Format(CultureInfo.InvariantCulture, "SHA: {0} Message: {1}", Sha, Message);
}
}
}
} |
<?php
namespace Kunstmaan\SeoBundle\DependencyInjection;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Extension\<API key>;
use Symfony\Component\DependencyInjection\Loader;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
use Symfony\Component\Yaml\Yaml;
class <API key> extends Extension implements <API key>
{
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$this-><API key>($configuration, $configs);
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
$loader->load('services.yml');
$loader->load('parameters.yml');
}
public function prepend(ContainerBuilder $container)
{
$liipConfig = Yaml::parse(file_get_contents(__DIR__ . '/../Resources/config/imagine_filters.yml'));
$container-><API key>('liip_imagine', $liipConfig['liip_imagine']);
$configs = $container->getExtensionConfig($this->getAlias());
$this-><API key>(new Configuration(), $configs);
}
} |
<!DOCTYPE html>
<html>
<head>
<title>Pie Chart</title>
<script type="text/javascript" src="../../d3.js"></script>
<script type="text/javascript" src="../../d3.layout.js"></script>
<style type="text/css">
body {
font: 10px sans-serif;
}
</style>
</head>
<body>
<script type="text/javascript">
var w = 400,
h = 400,
r = Math.min(w, h) / 2,
data = d3.range(10).map(Math.random),
color = d3.scale.category20(),
arc = d3.svg.arc().outerRadius(r),
donut = d3.layout.pie();
var vis = d3.select("body")
.append("svg:svg")
.data([data.sort(d3.descending)])
.attr("width", w)
.attr("height", h);
var arcs = vis.selectAll("g.arc")
.data(donut)
.enter().append("svg:g")
.attr("class", "arc")
.attr("transform", "translate(" + r + "," + r + ")");
var paths = arcs.append("svg:path")
.attr("fill", function(d, i) { return color(i); });
paths.transition()
.ease("bounce")
.duration(2000)
.attrTween("d", tweenPie);
paths.transition()
.ease("elastic")
.delay(function(d, i) { return 2000 + i * 50; })
.duration(750)
.attrTween("d", tweenDonut);
function tweenPie(b) {
b.innerRadius = 0;
var i = d3.interpolate({startAngle: 0, endAngle: 0}, b);
return function(t) {
return arc(i(t));
};
}
function tweenDonut(b) {
b.innerRadius = r * .6;
var i = d3.interpolate({innerRadius: 0}, b);
return function(t) {
return arc(i(t));
};
}
</script>
</body>
</html> |
.oo-ui-icon-article {
background-image: url('themes/wikimediaui/images/icons/article-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/article-ltr.svg');
}
.oo-ui-icon-articles {
background-image: url('themes/wikimediaui/images/icons/articles-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/articles-ltr.svg');
}
.<API key> {
background-image: url('themes/wikimediaui/images/icons/articleCheck.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/articleCheck.svg');
}
.<API key> {
background-image: url('themes/wikimediaui/images/icons/articleSearch.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/articleSearch.svg');
}
.<API key> {
background-image: url('themes/wikimediaui/images/icons/articleRedirect-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/articleRedirect-ltr.svg');
}
.oo-ui-icon-book {
background-image: url('themes/wikimediaui/images/icons/book-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/book-ltr.svg');
}
.<API key> {
background-image: url('themes/wikimediaui/images/icons/reference.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/reference.svg');
}
.oo-ui-icon-die {
background-image: url('themes/wikimediaui/images/icons/die.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/die.svg');
}
.oo-ui-icon-download {
background-image: url('themes/wikimediaui/images/icons/download.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/download.svg');
}
.<API key> {
background-image: url('themes/wikimediaui/images/icons/<API key>.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/<API key>.svg');
}
.oo-ui-icon-history {
background-image: url('themes/wikimediaui/images/icons/history.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/history.svg');
}
.oo-ui-icon-info {
background-image: url('themes/wikimediaui/images/icons/info.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/info.svg');
}
.oo-ui-icon-journal {
background-image: url('themes/wikimediaui/images/icons/journal-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/journal-ltr.svg');
}
.<API key> {
background-image: url('themes/wikimediaui/images/icons/newspaper-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/newspaper-ltr.svg');
}
.oo-ui-icon-tag {
background-image: url('themes/wikimediaui/images/icons/tag-ltr.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/tag-ltr.svg');
}
.oo-ui-icon-upload {
background-image: url('themes/wikimediaui/images/icons/upload.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/upload.svg');
}
.oo-ui-icon-window {
background-image: url('themes/wikimediaui/images/icons/window.png');
background-image: linear-gradient(transparent, transparent), /* @embed */ url('themes/wikimediaui/images/icons/window.svg');
} |
@charset "UTF-8";
html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td,
article, aside, canvas, details, embed,
figure, figcaption, footer, header, hgroup,
menu, nav, output, ruby, section, summary,
time, mark, audio, video {
margin: 0;
padding: 0;
border: 0;
font-size: 100%;
font: inherit;
vertical-align: baseline;
}
article, aside, details, figcaption, figure,
footer, header, hgroup, menu, nav, section {
display: block;
}
html,
body {
padding: 0;
margin: 0;
width: 100%;
height: 100%;
min-height: 600px;
overflow: hidden;
}
body {
position: relative;
line-height: 1;
}
@media screen and (max-width: 900px) {
body {
font-size: 30px;
}
}
::selection {
background:#FF5E99;
color:#fff;
text-shadow: none;
}
.reveal h1 { font-size: 3.77em; }
.reveal h2 { font-size: 2.11em; }
.reveal h3 { font-size: 1.55em; }
.reveal h4 { font-size: 1em; }
.reveal .slides section .fragment {
opacity: 0;
-webkit-transition: all .2s ease;
-moz-transition: all .2s ease;
-ms-transition: all .2s ease;
-o-transition: all .2s ease;
transition: all .2s ease;
}
.reveal .slides section .fragment.visible {
opacity: 1;
}
.reveal .slides section {
line-height: 1.2em;
font-weight: normal;
}
.reveal strong,
.reveal b {
font-weight: bold;
}
.reveal em,
.reveal i {
font-style: italic;
}
.reveal ol,
.reveal ul {
display: inline-block;
text-align: left;
margin: 0 auto;
}
.reveal ol {
list-style-type: decimal;
}
.reveal ul {
list-style-type: disc;
}
.reveal ul ul {
list-style-type: square;
}
.reveal ul ul ul {
list-style-type: circle;
}
.reveal ul ul,
.reveal ul ol,
.reveal ol ol,
.reveal ol ul {
display: block;
margin-left: 40px;
}
.reveal p {
margin-bottom: 10px;
}
.reveal q,
.reveal blockquote {
quotes: none;
}
.reveal blockquote {
display: block;
position: relative;
width: 70%;
margin: 5px auto;
padding: 5px;
font-style: italic;
background: rgba(255, 255, 255, 0.05);
box-shadow: 0px 0px 2px rgba(0,0,0,0.2);
}
.reveal blockquote:before {
content: '“';
}
.reveal blockquote:after {
content: '”';
}
.reveal q {
font-style: italic;
}
.reveal q:before {
content: '“';
}
.reveal q:after {
content: '”';
}
.reveal pre {
display: block;
position: relative;
width: 90%;
margin: 10px auto;
text-align: left;
font-size: 0.55em;
font-family: monospace;
line-height: 1.2em;
word-wrap: break-word;
box-shadow: 0px 0px 6px rgba(0,0,0,0.3);
}
.reveal code {
font-family: monospace;
overflow-x: auto;
}
.reveal table th,
.reveal table td {
text-align: left;
padding-right: .3em;
}
.reveal table th {
text-shadow: rgb(255,255,255) 1px 1px 2px;
}
.reveal sup {
vertical-align: super;
}
.reveal sub {
vertical-align: sub;
}
.reveal small {
font-size: 0.6em;
line-height: 1em;
vertical-align: top;
}
.reveal small * {
vertical-align: top;
}
.reveal .controls {
display: none;
position: fixed;
width: 100px;
height: 100px;
z-index: 30;
right: 0;
bottom: 0;
}
.reveal .controls a {
font-size: 0.83em;
position: absolute;
opacity: 0.1;
}
.reveal .controls a.enabled {
opacity: 0.6;
}
.reveal .controls a.enabled:active {
margin-top: 1px;
}
.reveal .controls .left {
top: 30px;
}
.reveal .controls .right {
left: 60px;
top: 30px;
}
.reveal .controls .up {
left: 30px;
}
.reveal .controls .down {
left: 30px;
top: 60px;
}
.reveal .progress {
position: fixed;
display: none;
height: 3px;
width: 100%;
bottom: 0;
left: 0;
}
.reveal .progress span {
display: block;
height: 100%;
width: 0px;
-webkit-transition: width 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
-moz-transition: width 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
-ms-transition: width 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
-o-transition: width 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
transition: width 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
}
.reveal .roll {
display: inline-block;
overflow: hidden;
vertical-align: top;
-webkit-perspective: 400px;
-moz-perspective: 400px;
-ms-perspective: 400px;
perspective: 400px;
-<API key>: 50% 50%;
-<API key>: 50% 50%;
-<API key>: 50% 50%;
perspective-origin: 50% 50%;
}
.reveal .roll:hover {
background: none;
text-shadow: none;
}
.reveal .roll span {
display: block;
position: relative;
padding: 0 2px;
pointer-events: none;
-webkit-transition: all 400ms ease;
-moz-transition: all 400ms ease;
-ms-transition: all 400ms ease;
transition: all 400ms ease;
-<API key>: 50% 0%;
-<API key>: 50% 0%;
-ms-transform-origin: 50% 0%;
transform-origin: 50% 0%;
-<API key>: preserve-3d;
-moz-transform-style: preserve-3d;
-ms-transform-style: preserve-3d;
transform-style: preserve-3d;
-<API key>: hidden;
-<API key>: hidden;
backface-visibility: hidden;
}
.reveal .roll:hover span {
background: rgba(0,0,0,0.5);
-webkit-transform: translate3d( 0px, 0px, -45px ) rotateX( 90deg );
-moz-transform: translate3d( 0px, 0px, -45px ) rotateX( 90deg );
-ms-transform: translate3d( 0px, 0px, -45px ) rotateX( 90deg );
transform: translate3d( 0px, 0px, -45px ) rotateX( 90deg );
}
.reveal .roll span:after {
content: attr(data-title);
display: block;
position: absolute;
left: 0;
top: 0;
padding: 0 2px;
-<API key>: 50% 0%;
-<API key>: 50% 0%;
-ms-transform-origin: 50% 0%;
transform-origin: 50% 0%;
-webkit-transform: translate3d( 0px, 110%, 0px ) rotateX( -90deg );
-moz-transform: translate3d( 0px, 110%, 0px ) rotateX( -90deg );
-ms-transform: translate3d( 0px, 110%, 0px ) rotateX( -90deg );
transform: translate3d( 0px, 110%, 0px ) rotateX( -90deg );
}
.reveal .slides {
position: absolute;
max-width: 900px;
width: 80%;
height: 60%;
left: 50%;
top: 50%;
margin-top: -320px;
padding: 20px 0px;
overflow: visible;
text-align: center;
-webkit-transition: -webkit-perspective .4s ease;
-moz-transition: -moz-perspective .4s ease;
-ms-transition: -ms-perspective .4s ease;
-o-transition: -o-perspective .4s ease;
transition: perspective .4s ease;
-webkit-perspective: 600px;
-moz-perspective: 600px;
-ms-perspective: 600px;
perspective: 600px;
-<API key>: 0% 25%;
-<API key>: 0% 25%;
-<API key>: 0% 25%;
perspective-origin: 0% 25%;
}
.reveal .slides>section,
.reveal .slides>section>section {
display: none;
position: absolute;
width: 100%;
min-height: 600px;
z-index: 10;
-<API key>: preserve-3d;
-moz-transform-style: preserve-3d;
-ms-transform-style: preserve-3d;
transform-style: preserve-3d;
-webkit-transition: all 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
-moz-transition: all 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
-ms-transition: all 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
-o-transition: all 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
transition: all 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
}
.reveal .slides>section.present {
display: block;
z-index: 11;
opacity: 1;
}
.reveal .slides>section {
margin-left: -50%;
}
.reveal .slides>section.past {
display: block;
opacity: 0;
-webkit-transform: translate3d(-100%, 0, 0) rotateY(-90deg) translate3d(-100%, 0, 0);
-moz-transform: translate3d(-100%, 0, 0) rotateY(-90deg) translate3d(-100%, 0, 0);
-ms-transform: translate3d(-100%, 0, 0) rotateY(-90deg) translate3d(-100%, 0, 0);
transform: translate3d(-100%, 0, 0) rotateY(-90deg) translate3d(-100%, 0, 0);
}
.reveal .slides>section.future {
display: block;
opacity: 0;
-webkit-transform: translate3d(100%, 0, 0) rotateY(90deg) translate3d(100%, 0, 0);
-moz-transform: translate3d(100%, 0, 0) rotateY(90deg) translate3d(100%, 0, 0);
-ms-transform: translate3d(100%, 0, 0) rotateY(90deg) translate3d(100%, 0, 0);
transform: translate3d(100%, 0, 0) rotateY(90deg) translate3d(100%, 0, 0);
}
.reveal .slides>section>section.past {
display: block;
opacity: 0;
-webkit-transform: translate3d(0, -50%, 0) rotateX(70deg) translate3d(0, -50%, 0);
-moz-transform: translate3d(0, -50%, 0) rotateX(70deg) translate3d(0, -50%, 0);
-ms-transform: translate3d(0, -50%, 0) rotateX(70deg) translate3d(0, -50%, 0);
transform: translate3d(0, -50%, 0) rotateX(70deg) translate3d(0, -50%, 0);
}
.reveal .slides>section>section.future {
display: block;
opacity: 0;
-webkit-transform: translate3d(0, 50%, 0) rotateX(-70deg) translate3d(0, 50%, 0);
-moz-transform: translate3d(0, 50%, 0) rotateX(-70deg) translate3d(0, 50%, 0);
-ms-transform: translate3d(0, 50%, 0) rotateX(-70deg) translate3d(0, 50%, 0);
transform: translate3d(0, 50%, 0) rotateX(-70deg) translate3d(0, 50%, 0);
}
.reveal.concave .slides>section.past {
-webkit-transform: translate3d(-100%, 0, 0) rotateY(90deg) translate3d(-100%, 0, 0);
-moz-transform: translate3d(-100%, 0, 0) rotateY(90deg) translate3d(-100%, 0, 0);
-ms-transform: translate3d(-100%, 0, 0) rotateY(90deg) translate3d(-100%, 0, 0);
transform: translate3d(-100%, 0, 0) rotateY(90deg) translate3d(-100%, 0, 0);
}
.reveal.concave .slides>section.future {
-webkit-transform: translate3d(100%, 0, 0) rotateY(-90deg) translate3d(100%, 0, 0);
-moz-transform: translate3d(100%, 0, 0) rotateY(-90deg) translate3d(100%, 0, 0);
-ms-transform: translate3d(100%, 0, 0) rotateY(-90deg) translate3d(100%, 0, 0);
transform: translate3d(100%, 0, 0) rotateY(-90deg) translate3d(100%, 0, 0);
}
.reveal.concave .slides>section>section.past {
-webkit-transform: translate3d(0, -80%, 0) rotateX(-70deg) translate3d(0, -80%, 0);
-moz-transform: translate3d(0, -80%, 0) rotateX(-70deg) translate3d(0, -80%, 0);
-ms-transform: translate3d(0, -80%, 0) rotateX(-70deg) translate3d(0, -80%, 0);
transform: translate3d(0, -80%, 0) rotateX(-70deg) translate3d(0, -80%, 0);
}
.reveal.concave .slides>section>section.future {
-webkit-transform: translate3d(0, 80%, 0) rotateX(70deg) translate3d(0, 80%, 0);
-moz-transform: translate3d(0, 80%, 0) rotateX(70deg) translate3d(0, 80%, 0);
-ms-transform: translate3d(0, 80%, 0) rotateX(70deg) translate3d(0, 80%, 0);
transform: translate3d(0, 80%, 0) rotateX(70deg) translate3d(0, 80%, 0);
}
.reveal.linear .slides>section.past {
-webkit-transform: translate(-150%, 0);
-moz-transform: translate(-150%, 0);
-ms-transform: translate(-150%, 0);
-o-transform: translate(-150%, 0);
transform: translate(-150%, 0);
}
.reveal.linear .slides>section.future {
-webkit-transform: translate(150%, 0);
-moz-transform: translate(150%, 0);
-ms-transform: translate(150%, 0);
-o-transform: translate(150%, 0);
transform: translate(150%, 0);
}
.reveal.linear .slides>section>section.past {
-webkit-transform: translate(0, -150%);
-moz-transform: translate(0, -150%);
-ms-transform: translate(0, -150%);
-o-transform: translate(0, -150%);
transform: translate(0, -150%);
}
.reveal.linear .slides>section>section.future {
-webkit-transform: translate(0, 150%);
-moz-transform: translate(0, 150%);
-ms-transform: translate(0, 150%);
-o-transform: translate(0, 150%);
transform: translate(0, 150%);
}
.reveal.cube .slides {
margin-top: -350px;
-<API key>: 50% 25%;
-<API key>: 50% 25%;
-<API key>: 50% 25%;
perspective-origin: 50% 25%;
-webkit-perspective: 1300px;
-moz-perspective: 1300px;
-ms-perspective: 1300px;
perspective: 1300px;
}
.reveal.cube .slides section {
padding: 30px;
-<API key>: hidden;
-<API key>: hidden;
-<API key>: hidden;
backface-visibility: hidden;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
.reveal.cube .slides section:not(.stack):before {
content: '';
position: absolute;
display: block;
width: 100%;
height: 100%;
left: 0;
top: 0;
background: #232628;
border-radius: 4px;
-webkit-transform: translateZ( -20px );
-moz-transform: translateZ( -20px );
-ms-transform: translateZ( -20px );
-o-transform: translateZ( -20px );
transform: translateZ( -20px );
}
.reveal.cube .slides section:not(.stack):after {
content: '';
position: absolute;
display: block;
width: 90%;
height: 30px;
left: 5%;
bottom: 0;
background: none;
z-index: 1;
border-radius: 4px;
box-shadow: 0px 95px 25px rgba(0,0,0,0.2);
-webkit-transform: translateZ(-90px) rotateX( 65deg );
-moz-transform: translateZ(-90px) rotateX( 65deg );
-ms-transform: translateZ(-90px) rotateX( 65deg );
-o-transform: translateZ(-90px) rotateX( 65deg );
transform: translateZ(-90px) rotateX( 65deg );
}
.reveal.cube .slides>section.stack {
padding: 0;
background: none;
}
.reveal.cube .slides>section.past {
-<API key>: 100% 0%;
-<API key>: 100% 0%;
-ms-transform-origin: 100% 0%;
transform-origin: 100% 0%;
-webkit-transform: translate3d(-100%, 0, 0) rotateY(-90deg);
-moz-transform: translate3d(-100%, 0, 0) rotateY(-90deg);
-ms-transform: translate3d(-100%, 0, 0) rotateY(-90deg);
transform: translate3d(-100%, 0, 0) rotateY(-90deg);
}
.reveal.cube .slides>section.future {
-<API key>: 0% 0%;
-<API key>: 0% 0%;
-ms-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: translate3d(100%, 0, 0) rotateY(90deg);
-moz-transform: translate3d(100%, 0, 0) rotateY(90deg);
-ms-transform: translate3d(100%, 0, 0) rotateY(90deg);
transform: translate3d(100%, 0, 0) rotateY(90deg);
}
.reveal.cube .slides>section>section.past {
-<API key>: 0% 100%;
-<API key>: 0% 100%;
-ms-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: translate3d(0, -100%, 0) rotateX(90deg);
-moz-transform: translate3d(0, -100%, 0) rotateX(90deg);
-ms-transform: translate3d(0, -100%, 0) rotateX(90deg);
transform: translate3d(0, -100%, 0) rotateX(90deg);
}
.reveal.cube .slides>section>section.future {
-<API key>: 0% 0%;
-<API key>: 0% 0%;
-ms-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: translate3d(0, 100%, 0) rotateX(-90deg);
-moz-transform: translate3d(0, 100%, 0) rotateX(-90deg);
-ms-transform: translate3d(0, 100%, 0) rotateX(-90deg);
transform: translate3d(0, 100%, 0) rotateX(-90deg);
}
.reveal.page .slides {
margin-top: -350px;
-<API key>: 50% 50%;
-<API key>: 50% 50%;
-<API key>: 50% 50%;
perspective-origin: 50% 50%;
-webkit-perspective: 3000px;
-moz-perspective: 3000px;
-ms-perspective: 3000px;
perspective: 3000px;
}
.reveal.page .slides section {
padding: 30px;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
.reveal.page .slides section.past {
z-index: 12;
}
.reveal.page .slides section:not(.stack):before {
content: '';
position: absolute;
display: block;
width: 100%;
height: 100%;
left: 0;
top: 0;
background: rgba(0,0,0,0.2);
-webkit-transform: translateZ( -20px );
-moz-transform: translateZ( -20px );
-ms-transform: translateZ( -20px );
-o-transform: translateZ( -20px );
transform: translateZ( -20px );
}
.reveal.page .slides section:not(.stack):after {
content: '';
position: absolute;
display: block;
width: 90%;
height: 30px;
left: 5%;
bottom: 0;
background: none;
z-index: 1;
border-radius: 4px;
box-shadow: 0px 95px 25px rgba(0,0,0,0.2);
-webkit-transform: translateZ(-90px) rotateX( 65deg );
}
.reveal.page .slides>section.stack {
padding: 0;
background: none;
}
.reveal.page .slides>section.past {
-<API key>: 0% 0%;
-<API key>: 0% 0%;
-ms-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: translate3d(-40%, 0, 0) rotateY(-80deg);
-moz-transform: translate3d(-40%, 0, 0) rotateY(-80deg);
-ms-transform: translate3d(-40%, 0, 0) rotateY(-80deg);
transform: translate3d(-40%, 0, 0) rotateY(-80deg);
}
.reveal.page .slides>section.future {
-<API key>: 100% 0%;
-<API key>: 100% 0%;
-ms-transform-origin: 100% 0%;
transform-origin: 100% 0%;
-webkit-transform: translate3d(0, 0, 0);
-moz-transform: translate3d(0, 0, 0);
-ms-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
.reveal.page .slides>section>section.past {
-<API key>: 0% 0%;
-<API key>: 0% 0%;
-ms-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: translate3d(0, -40%, 0) rotateX(80deg);
-moz-transform: translate3d(0, -40%, 0) rotateX(80deg);
-ms-transform: translate3d(0, -40%, 0) rotateX(80deg);
transform: translate3d(0, -40%, 0) rotateX(80deg);
}
.reveal.page .slides>section>section.future {
-<API key>: 0% 100%;
-<API key>: 0% 100%;
-ms-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: translate3d(0, 0, 0);
-moz-transform: translate3d(0, 0, 0);
-ms-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
.reveal.overview .slides {
-webkit-perspective: 700px;
-moz-perspective: 700px;
-ms-perspective: 700px;
perspective: 700px;
}
.reveal.overview .slides section {
padding: 20px 0;
max-height: 600px;
overflow: hidden;
opacity: 1;
cursor: pointer;
background: rgba(0,0,0,0.1);
}
.reveal.overview .slides section .fragment {
opacity: 1;
}
.reveal.overview .slides section:after,
.reveal.overview .slides section:before {
display: none !important;
}
.reveal.overview .slides section>section {
opacity: 1;
cursor: pointer;
}
.reveal.overview .slides section:hover {
background: rgba(0,0,0,0.3);
}
.reveal.overview .slides section.present {
background: rgba(0,0,0,0.3);
}
.reveal.overview .slides>section.stack {
background: none;
padding: 0;
overflow: visible;
}
.no-transforms {
overflow-y: auto;
}
.no-transforms .slides section {
display: block!important;
opacity: 1!important;
position: relative!important;
height: auto;
min-height: auto;
margin-bottom: 100px;
-webkit-transform: none;
-moz-transform: none;
-ms-transform: none;
transform: none;
}
.state-background {
position: absolute;
width: 100%;
height: 100%;
background: rgba( 0, 0, 0, 0 );
-webkit-transition: background 800ms ease;
-moz-transition: background 800ms ease;
-ms-transition: background 800ms ease;
-o-transition: background 800ms ease;
transition: background 800ms ease;
}
.alert .state-background {
background: rgba( 200, 50, 30, 0.6 );
}
.soothe .state-background {
background: rgba( 50, 200, 90, 0.4 );
}
.blackout .state-background {
background: rgba( 0, 0, 0, 0.6 );
}
.reveal aside.notes {
display: none;
} |
(function(){
//if there is an old FuncUnit, use that for settings
var oldFuncUnit = window.FuncUnit;
FuncUnit = oldFuncUnit.jQuery.sub();
var origFuncUnit = FuncUnit;
// override the subbed init method
// context can be an object with frame and forceSync:
// - a number or string: this is a frame name/number, and means only do a sync query
// - true: means force the query to be sync only
FuncUnit = function( selector, context ) {
// if you pass true as context, this will avoid doing a synchronous query
var frame,
forceSync,
isSyncOnly = false,
isAsyncOnly = false;
if(typeof context === "string"){
frame = context;
}
if(context && typeof context.forceSync === "boolean"){
forceSync = context.forceSync;
if (typeof context.frame == "number" || typeof context.frame == "string") {
frame = context.frame;
context = context.frame;
}
}
isSyncOnly = typeof forceSync === "boolean"? forceSync: isSyncOnly;
// if its a function, just run it in the queue
if(typeof selector == "function"){
return FuncUnit.wait(0, selector);
}
// if the app window already exists, adjust the params (for the sync return value)
this.selector = selector;
// run this method in the queue also
if(isSyncOnly === true){
var collection = performSyncQuery(selector, context, this);
collection.frame = frame;
return collection;
} else if(isAsyncOnly === true){
performAsyncQuery(selector, context, this);
return this;
} else { // do both
performAsyncQuery(selector, context, this);
var collection = performSyncQuery(selector, context, this);
collection.frame = frame;
return collection;
}
}
var getContext = function(context){
if (typeof context === "number" || typeof context === "string") {
// try to get the context from an iframe in the funcunit document
var sel = (typeof context === "number" ? "iframe:eq(" + context + ")" : "iframe[name=" + context + "]"),
frames = new origFuncUnit.fn.init(sel, FuncUnit.win.document, true);
context = (frames.length ? frames.get(0).contentWindow : FuncUnit.win).document;
} else {
context = FuncUnit.win.document;
}
return context;
},
performAsyncQuery = function(selector, context, self){
FuncUnit.add({
method: function(success, error){
if (FuncUnit.win) {
context = getContext(context);
}
this.selector = selector;
this.bind = new origFuncUnit.fn.init( selector, context, true );
success();
return this;
},
error: "selector failed: " + selector,
type: "query"
});
},
performSyncQuery = function(selector, context, self){
if (FuncUnit.win) {
context = getContext(context);
}
return new origFuncUnit.fn.init( selector, context, true );
}
oldFuncUnit.jQuery.extend(FuncUnit, oldFuncUnit, origFuncUnit)
FuncUnit.prototype = origFuncUnit.prototype;
S = FuncUnit;
})() |
define([
'dojo/_base/declare', 'dijit/_WidgetBase', 'dojo/on',
'dojo/dom-class', 'dijit/form/Select'
], function (
declare, WidgetBase, on,
domClass, Select
) {
return declare([WidgetBase], {
baseClass: 'WorkspaceItemDetail',
disabled: false,
postCreate: function () {
this.domNode.innerHTML = 'WorkspaceItemDetail';
}
});
}); |
<?php
declare(strict_types=1);
namespace Sylius\Bundle\CoreBundle\Migrations;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;
class <API key> extends AbstractMigration
{
public function up(Schema $schema): void
{
$this->abortIf($this->connection->getDatabasePlatform()->getName() != 'mysql', 'Migration can only be executed safely on \'mysql\'.');
$this->addSql('ALTER TABLE sylius_locale DROP enabled');
}
public function down(Schema $schema): void
{
$this->abortIf($this->connection->getDatabasePlatform()->getName() != 'mysql', 'Migration can only be executed safely on \'mysql\'.');
$this->addSql('ALTER TABLE sylius_locale ADD enabled TINYINT(1) NOT NULL');
}
} |
using Microsoft.CodeAnalysis.Options;
using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
namespace Microsoft.VisualStudio.LanguageServices.Implementation.Options
{
internal abstract class <API key> : <API key>
{
private readonly string _truePreview;
private readonly string _falsePreview;
protected bool _isChecked;
protected <API key> Info { get; }
public IOption Option { get; }
public string Description { get; set; }
internal virtual string GetPreview() => _isChecked ? _truePreview : _falsePreview;
public <API key>(IOption option, string description, string preview, <API key> info)
: this(option, description, preview, preview, info)
{
}
public <API key>(IOption option, string description, string truePreview, string falsePreview, <API key> info)
{
_truePreview = truePreview;
_falsePreview = falsePreview;
Info = info;
Option = option;
Description = description;
}
public abstract bool IsChecked { get; set; }
}
} |
#!/bin/bash
# Add scripts
mkdir -p ${PREFIX}/bin |
## 0.2.6
* Update to ember 1.8.1
* Remove `textFieldClassNames` option from bs-datetimepicker
## 0.2.7
* Introduced new `forceDateOutput` option
## 0.2.8
* update to <API key> v4.0.0
## 0.3.0
* Update to ember-cli v0.1.7
* Prevent update of date if it didn't changed
* Add the ability to override the form-group-addon's child span class
## 0.3.1
* Possibility to overwrite TextField with a template block
* Exposing textField properties
## 0.3.2
* Upgrade to ember-cli 0.2.0
## 0.3.3
* Upgrade to ember-cli 0.2.1
## 0.4.0
* Upgrade to ember-cli 0.2.3
* Upgrade to Eonasdan/<API key> to 4.7.14
* Don't use property extensions
## 0.4.2
* Upgrade to ember-cli 0.2.7
* Introduce `ember-try`
* Add ember version compatibility to `README.md`
* Bugfixes |
#ifndef __MTD_DOC2000_H__
#define __MTD_DOC2000_H__
#include <asm/types.h>
#include <linux/mtd/mtd.h>
#include <asm/semaphore.h>
#define DoC_Sig1 0
#define DoC_Sig2 1
#define DoC_ChipID 0x1000
#define DoC_DOCStatus 0x1001
#define DoC_DOCControl 0x1002
#define DoC_FloorSelect 0x1003
#define DoC_CDSNControl 0x1004
#define <API key> 0x1005
#define DoC_ECCConf 0x1006
#define DoC_2k_ECCStatus 0x1007
#define DoC_CDSNSlowIO 0x100d
#define DoC_ECCSyndrome0 0x1010
#define DoC_ECCSyndrome1 0x1011
#define DoC_ECCSyndrome2 0x1012
#define DoC_ECCSyndrome3 0x1013
#define DoC_ECCSyndrome4 0x1014
#define DoC_ECCSyndrome5 0x1015
#define DoC_AliasResolution 0x101b
#define DoC_ConfigInput 0x101c
#define DoC_ReadPipeInit 0x101d
#define DoC_WritePipeTerm 0x101e
#define DoC_LastDataRead 0x101f
#define DoC_NOP 0x1020
#define DoC_Mil_CDSN_IO 0x0800
#define DoC_2k_CDSN_IO 0x1800
#define DoC_Mplus_NOP 0x1002
#define <API key> 0x1004
#define <API key> 0x1006
#define <API key> 0x1008
#define <API key> 0x1008
#define <API key> 0x100a
#define <API key> 0x100c
#define <API key> 0x1020
#define <API key> 0x1022
#define DoC_Mplus_FlashCmd 0x1024
#define <API key> 0x1026
#define <API key> 0x1028
#define <API key> 0x1029
#define <API key> 0x102a
#define <API key> 0x102c
#define <API key> 0x102d
#define <API key> 0x102e
#define <API key> 0x1040
#define <API key> 0x1041
#define <API key> 0x1042
#define <API key> 0x1043
#define <API key> 0x1044
#define <API key> 0x1045
#define DoC_Mplus_ECCConf 0x1046
#define DoC_Mplus_Toggle 0x1046
#define <API key> 0x1074
#define <API key> 0x1076
#define DoC_Mplus_Power 0x1fff
/* How to access the device?
* On ARM, it'll be mmap'd directly with 32-bit wide accesses.
* On PPC, it's mmap'd and 16-bit wide.
* Others use readb/writeb
*/
#if defined(__arm__)
#define ReadDOC_(adr, reg) ((unsigned char)(*(volatile __u32 *)(((unsigned long)adr)+((reg)<<2))))
#define WriteDOC_(d, adr, reg) do{ *(volatile __u32 *)(((unsigned long)adr)+((reg)<<2)) = (__u32)d; wmb();} while(0)
#define DOC_IOREMAP_LEN 0x8000
#elif defined(__ppc__)
#define ReadDOC_(adr, reg) ((unsigned char)(*(volatile __u16 *)(((unsigned long)adr)+((reg)<<1))))
#define WriteDOC_(d, adr, reg) do{ *(volatile __u16 *)(((unsigned long)adr)+((reg)<<1)) = (__u16)d; wmb();} while(0)
#define DOC_IOREMAP_LEN 0x4000
#else
#define ReadDOC_(adr, reg) readb((void *)(adr) + (reg))
#define WriteDOC_(d, adr, reg) writeb(d, (void *)(adr) + (reg))
#define DOC_IOREMAP_LEN 0x2000
#endif
#if defined(__i386__) || defined(__x86_64__)
#define USE_MEMCPY
#endif
/* These are provided to directly use the DoC_xxx defines */
#define ReadDOC(adr, reg) ReadDOC_(adr,DoC_##reg)
#define WriteDOC(d, adr, reg) WriteDOC_(d,adr,DoC_##reg)
#define DOC_MODE_RESET 0
#define DOC_MODE_NORMAL 1
#define DOC_MODE_RESERVED1 2
#define DOC_MODE_RESERVED2 3
#define DOC_MODE_CLR_ERR 0x80
#define DOC_MODE_RST_LAT 0x10
#define DOC_MODE_BDECT 0x08
#define DOC_MODE_MDWREN 0x04
#define DOC_ChipID_Doc2k 0x20
#define <API key> 0x21 /* internal number for MTD */
#define DOC_ChipID_DocMil 0x30
#define <API key> 0x40
#define <API key> 0x41
#define CDSN_CTRL_FR_B 0x80
#define CDSN_CTRL_FR_B0 0x40
#define CDSN_CTRL_FR_B1 0x80
#define CDSN_CTRL_ECC_IO 0x20
#define CDSN_CTRL_FLASH_IO 0x10
#define CDSN_CTRL_WP 0x08
#define CDSN_CTRL_ALE 0x04
#define CDSN_CTRL_CLE 0x02
#define CDSN_CTRL_CE 0x01
#define DOC_ECC_RESET 0
#define DOC_ECC_ERROR 0x80
#define DOC_ECC_RW 0x20
#define DOC_ECC__EN 0x08
#define DOC_TOGGLE_BIT 0x04
#define DOC_ECC_RESV 0x02
#define DOC_ECC_IGNORE 0x01
#define DOC_FLASH_CE 0x80
#define DOC_FLASH_WP 0x40
#define DOC_FLASH_BANK 0x02
/* We have to also set the reserved bit 1 for enable */
#define DOC_ECC_EN (DOC_ECC__EN | DOC_ECC_RESV)
#define DOC_ECC_DIS (DOC_ECC_RESV)
struct Nand {
char floor, chip;
unsigned long curadr;
unsigned char curmode;
/* Also some erase/write/pipeline info when we get that far */
};
#define MAX_FLOORS 4
#define MAX_CHIPS 4
#define MAX_FLOORS_MIL 1
#define MAX_CHIPS_MIL 1
#define MAX_FLOORS_MPLUS 2
#define MAX_CHIPS_MPLUS 1
#define ADDR_COLUMN 1
#define ADDR_PAGE 2
#define ADDR_COLUMN_PAGE 3
struct DiskOnChip {
unsigned long physadr;
void *virtadr;
unsigned long totlen;
unsigned char ChipID; /* Type of DiskOnChip */
int ioreg;
unsigned long mfr; /* Flash IDs - only one type of flash per device */
unsigned long id;
int chipshift;
char page256;
char pageadrlen;
char interleave; /* Internal interleaving - Millennium Plus style */
unsigned long erasesize;
int curfloor;
int curchip;
int numchips;
struct Nand *chips;
struct mtd_info *nextdoc;
struct semaphore lock;
};
int doc_decode_ecc(unsigned char sector[512], unsigned char ecc1[6]);
#endif /* __MTD_DOC2000_H__ */ |
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
namespace System.Runtime.InteropServices.WindowsRuntime
{
internal static class <API key>
{
private static EventHandler<<API key>> <API key>;
internal static string[] <API key>(AppDomain appDomain, string namespaceName)
{
EventHandler<<API key>> eventHandler = <API key>;
if (eventHandler != null)
{
Delegate[] ds = eventHandler.GetInvocationList();
int len = ds.Length;
for (int i = 0; i < len; i++)
{
<API key> eventArgs = new <API key>(namespaceName);
((EventHandler<<API key>>)ds[i])(appDomain, eventArgs);
Collection<string> <API key> = eventArgs.<API key>;
if (<API key>.Count > 0)
{
string[] retAssemblyFiles = new string[<API key>.Count];
int retIndex = 0;
foreach (string assemblyFile in <API key>)
{
if (String.IsNullOrEmpty(assemblyFile))
{ // <API key> event returned null or empty file name - that is not allowed
throw new ArgumentException(SR.<API key>, "<API key>.<API key>");
}
retAssemblyFiles[retIndex] = assemblyFile;
retIndex++;
}
return retAssemblyFiles;
}
}
}
return null;
}
}
internal class <API key> : EventArgs
{
private string _NamespaceName;
private Collection<string> <API key>;
public Collection<string> <API key>
{
get
{
return <API key>;
}
}
public <API key>(string namespaceName)
{
_NamespaceName = namespaceName;
<API key> = new Collection<string>();
}
}
} |
!function(){"use strict";angular.module("ui.grid.autoResize",["ui.grid"]).directive("uiGridAutoResize",["gridUtil",function(n){return{require:"uiGrid",scope:!1,link:function(i,r,e,u){var t;t=n.debounce(function(i,e,t,n){null!==r[0].offsetParent&&(u.grid.gridWidth=t,u.grid.gridHeight=n,u.grid.queueGridRefresh().then(function(){u.grid.api.core.raise.<API key>(e,i,n,t)}))},400),i.$watchCollection(function(){return{width:n.elementWidth(r),height:n.elementHeight(r)}},function(i,e){angular.equals(i,e)||t(e.width,e.height,i.width,i.height)})}}}])}(); |
namespace System.Runtime
{
using System;
interface ICancelable
{
void Cancel();
}
} |
<?php
declare(strict_types=1);
namespace Sylius\Behat\Page\Admin\Customer;
use Behat\Mink\Element\NodeElement;
use Sylius\Behat\Page\SymfonyPage;
use Webmozart\Assert\Assert;
/**
* @author Magdalena Banasiak <magdalena.banasiak@lakion.com>
*/
class ShowPage extends SymfonyPage implements ShowPageInterface
{
/**
* {@inheritdoc}
*/
public function isRegistered()
{
$username = $this->getDocument()->find('css', '#username');
return null !== $username;
}
/**
* {@inheritdoc}
*/
public function deleteAccount()
{
$deleteButton = $this->getElement('<API key>');
$deleteButton->pressButton('Delete');
}
/**
* {@inheritdoc}
*/
public function getCustomerEmail()
{
return $this->getElement('customer_email')->getText();
}
/**
* {@inheritdoc}
*/
public function <API key>()
{
return $this->getElement('<API key>')->getText();
}
/**
* {@inheritdoc}
*/
public function getCustomerName()
{
return $this->getElement('customer_name')->getText();
}
/**
* {@inheritdoc}
*/
public function getRegistrationDate()
{
return new \DateTime(str_replace('Customer since ', '', $this->getElement('registration_date')->getText()));
}
/**
* {@inheritdoc}
*/
public function getDefaultAddress()
{
return $this->getElement('default_address')->getText();
}
/**
* {@inheritdoc}
*/
public function hasAccount()
{
return $this->hasElement('no_account');
}
/**
* {@inheritdoc}
*/
public function <API key>()
{
$<API key> = $this->getElement('<API key>');
if ($<API key>->find('css', 'i.green')) {
return true;
}
return false;
}
/**
* {@inheritdoc}
*/
public function <API key>($provinceName)
{
$<API key> = $this->getElement('default_address')->getText();
return false !== stripos($<API key>, $provinceName);
}
/**
* {@inheritdoc}
*/
public function hasVerifiedEmail()
{
$verifiedEmail = $this->getElement('verified_email');
if ($verifiedEmail->find('css', 'i.green')) {
return true;
}
return false;
}
/**
* {@inheritdoc}
*/
public function getGroupName()
{
$group = $this->getElement('group');
Assert::notNull($group, 'There should be element group on page.');
list($text, $groupName) = explode(':', $group->getText());
return trim($groupName);
}
/**
* {@inheritdoc}
*/
public function <API key>()
{
return null === $this->getDocument()->find('css', '#verified-email');
}
/**
* {@inheritdoc}
*/
public function <API key>()
{
return $this->hasElement('impersonate_button');
}
/**
* {@inheritdoc}
*/
public function impersonate()
{
$this->getElement('impersonate_button')->click();
}
/**
* {@inheritdoc}
*/
public function <API key>()
{
return null !== $this->getElement('statistics')->find('css', '.<API key>');
}
/**
* {@inheritdoc}
*/
public function <API key>($channelName)
{
return (int) $this
-><API key>($channelName)
->find('css', '.sylius-orders-count')
->getText()
;
}
/**
* {@inheritdoc}
*/
public function <API key>($channelName)
{
return $this
-><API key>($channelName)
->find('css', '.sylius-orders-total')
->getText()
;
}
/**
* {@inheritdoc}
*/
public function <API key>($channelName)
{
return $this
-><API key>($channelName)
->find('css', '.<API key>')
->getText()
;
}
/**
* {@inheritdoc}
*/
public function <API key>()
{
return trim($this->getElement('flash_message')->getText());
}
/**
* {@inheritdoc}
*/
public function getRouteName()
{
return '<API key>';
}
/**
* {@inheritdoc}
*/
protected function getDefinedElements()
{
return array_merge(parent::getDefinedElements(), [
'customer_email' => '#info .content.extra > a',
'customer_name' => '#info .content > a',
'<API key>' => '#phone-number',
'default_address' => '#default-address',
'<API key>' => '#actions',
'flash_message' => '.ui.icon.positive.message .content p',
'group' => '.group',
'impersonate_button' => '#impersonate',
'no_account' => '#no-account',
'statistics' => '#statistics',
'registration_date' => '#info .content .date',
'<API key>' => '#<API key>',
'verified_email' => '#verified-email',
]);
}
/**
* @param string $channelName
*
* @return NodeElement
*
* @throws \<API key>
*/
private function <API key>($channelName)
{
$statisticsRibs = $this
->getElement('statistics')
->findAll('css', '.row > .column > .statistic > .sylius-channel-name')
;
$statisticsRibs = array_filter($statisticsRibs, function (NodeElement $statistic) use ($channelName) {
return $channelName === trim($statistic->getText());
});
$<API key> = count($statisticsRibs);
Assert::same(
1,
$<API key>,
sprintf(
'Expected a single statistic for channel "%s", but %d were found.',
$channelName,
$<API key>
)
);
$statisticsContents = $this->getElement('statistics')->findAll('css', '.row');
$contentIndexes = array_keys($statisticsRibs);
return $statisticsContents[reset($contentIndexes)];
}
} |
"use strict";
var resolveException = require("../lib/resolve-exception")
, resolveErrorMessage = require("../lib/<API key>")
, ensurePlainFunction = require("../plain-function/ensure")
, ensureArray = require("../array/ensure")
, is = require("./is");
var objHasOwnProperty = Object.prototype.hasOwnProperty
, invalidItemsLimit = 3
, defaultErrorMessage = "%v is not a valid plain object";
module.exports = function (value/*, options*/) {
var options = arguments[1];
if (!is(value)) return resolveException(value, defaultErrorMessage, options);
if (!options) return value;
var invalidKeys, key, errorMessage;
var allowedKeys = ensureArray(options.allowedKeys, { isOptional: true });
if (allowedKeys) {
for (key in value) {
if (!objHasOwnProperty.call(value, key)) continue;
if (allowedKeys.indexOf(key) > -1) continue;
if (!invalidKeys) invalidKeys = [];
if (invalidKeys.push(key) === invalidItemsLimit) break;
}
if (invalidKeys) {
errorMessage =
resolveErrorMessage(defaultErrorMessage, value, options) +
".\n Following keys are unexpected: " +
invalidKeys.join(", ");
throw new TypeError(errorMessage);
}
}
var ensurePropertyValue = ensurePlainFunction(options.ensurePropertyValue, {
isOptional: true
});
if (ensurePropertyValue) {
var coercedValue = {};
for (key in value) {
if (!objHasOwnProperty.call(value, key)) continue;
var <API key>;
try {
<API key> = ensurePropertyValue(value[key]);
} catch (error) {
if (!invalidKeys) invalidKeys = [];
if (invalidKeys.push(key) === invalidItemsLimit) break;
}
if (invalidKeys) continue;
coercedValue[key] = <API key>;
}
if (invalidKeys) {
errorMessage =
resolveErrorMessage(defaultErrorMessage, value, options) +
".\n Valuees for following keys are invalid: " +
invalidKeys.join(", ");
throw new TypeError(errorMessage);
}
return coercedValue;
}
return value;
}; |
// Code generated by Microsoft (R) AutoRest Code Generator 1.0.0.0
// Changes may cause incorrect behavior and will be lost if the code is
// regenerated.
namespace Microsoft.Azure.Management.DataLake.Analytics.Models
{
using Azure;
using Management;
using DataLake;
using Analytics;
using Rest;
using Newtonsoft.Json;
using System.Linq;
<summary>
Data Lake Analytics catalog credential creation parameters.
</summary>
public partial class <API key>
{
<summary>
Initializes a new instance of the
<API key> class.
</summary>
public <API key>() { }
<summary>
Initializes a new instance of the
<API key> class.
</summary>
<param name="password">the password for the credential and user
with access to the data source.</param>
<param name="uri">the URI identifier for the data source this
credential can connect to in the format
<hostname>:<port></param>
<param name="userId">the object identifier for the user associated
with this credential with access to the data source.</param>
public <API key>(string password, string uri, string userId)
{
Password = password;
Uri = uri;
UserId = userId;
}
<summary>
Gets or sets the password for the credential and user with access
to the data source.
</summary>
[JsonProperty(PropertyName = "password")]
public string Password { get; set; }
<summary>
Gets or sets the URI identifier for the data source this credential
can connect to in the format
&lt;hostname&gt;:&lt;port&gt;
</summary>
[JsonProperty(PropertyName = "uri")]
public string Uri { get; set; }
<summary>
Gets or sets the object identifier for the user associated with
this credential with access to the data source.
</summary>
[JsonProperty(PropertyName = "userId")]
public string UserId { get; set; }
<summary>
Validate the object.
</summary>
<exception cref="ValidationException">
Thrown if validation fails
</exception>
public virtual void Validate()
{
if (Password == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Password");
}
if (Uri == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Uri");
}
if (UserId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "UserId");
}
}
}
} |
package net.spy.memcached.protocol.ascii;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.Collections;
import net.spy.memcached.KeyUtil;
import net.spy.memcached.ops.Mutator;
import net.spy.memcached.ops.MutatorOperation;
import net.spy.memcached.ops.OperationCallback;
import net.spy.memcached.ops.OperationState;
import net.spy.memcached.ops.OperationStatus;
import net.spy.memcached.ops.StatusCode;
/**
* Operation for mutating integers inside of memcached.
*/
final class <API key> extends OperationImpl implements
MutatorOperation {
public static final int OVERHEAD = 32;
private static final OperationStatus NOT_FOUND = new OperationStatus(false,
"NOT_FOUND", StatusCode.ERR_NOT_FOUND);
private final Mutator mutator;
private final String key;
private final long amount;
public <API key>(Mutator m, String k, long amt,
OperationCallback c) {
super(c);
mutator = m;
key = k;
amount = amt;
}
@Override
public void handleLine(String line) {
getLogger().debug("Result: %s", line);
OperationStatus found = null;
if (line.equals("NOT_FOUND")) {
found = NOT_FOUND;
} else {
found = new OperationStatus(true, line, StatusCode.SUCCESS);
}
getCallback().receivedStatus(found);
transitionState(OperationState.COMPLETE);
}
@Override
public void initialize() {
int size = KeyUtil.getKeyBytes(key).length + OVERHEAD;
ByteBuffer b = ByteBuffer.allocate(size);
setArguments(b, mutator.name(), key, amount);
b.flip();
setBuffer(b);
}
@Override
protected void wasCancelled() {
// XXX: Replace this comment with why the hell I did this.
getCallback().receivedStatus(CANCELLED);
}
public Collection<String> getKeys() {
return Collections.singleton(key);
}
public long getBy() {
return amount;
}
public long getDefault() {
return -1;
}
public int getExpiration() {
return -1;
}
public Mutator getType() {
return mutator;
}
@Override
public String toString() {
return "Cmd: " + mutator.name() + " Key: " + key + " Amount: " + amount;
}
} |
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global.shave = factory());
}(this, (function () { 'use strict';
function shave(target, maxHeight) {
var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
if (!maxHeight) throw Error('maxHeight is required');
var els = typeof target === 'string' ? document.querySelectorAll(target) : target;
if (!els) return;
var character = opts.character || '…';
var classname = opts.classname || 'js-shave';
var spaces = typeof opts.spaces === 'boolean' ? opts.spaces : true;
var charHtml = "<span class=\"js-shave-char\">".concat(character, "</span>");
if (!('length' in els)) els = [els];
for (var i = 0; i < els.length; i += 1) {
var el = els[i];
var styles = el.style;
var span = el.querySelector(".".concat(classname));
var textProp = el.textContent === undefined ? 'innerText' : 'textContent'; // If element text has already been shaved
if (span) {
// Remove the ellipsis to recapture the original text
el.removeChild(el.querySelector('.js-shave-char'));
el[textProp] = el[textProp]; // eslint-disable-line
// nuke span, recombine text
}
var fullText = el[textProp];
var words = spaces ? fullText.split(' ') : fullText; // If 0 or 1 words, we're done
if (words.length < 2) continue; // Temporarily remove any CSS height for text height calculation
var heightStyle = styles.height;
styles.height = 'auto';
var maxHeightStyle = styles.maxHeight;
styles.maxHeight = 'none'; // If already short enough, we're done
if (el.offsetHeight <= maxHeight) {
styles.height = heightStyle;
styles.maxHeight = maxHeightStyle;
continue;
} // Binary search for number of words which can fit in allotted height
var max = words.length - 1;
var min = 0;
var pivot = void 0;
while (min < max) {
pivot = min + max + 1 >> 1; // eslint-disable-line no-bitwise
el[textProp] = spaces ? words.slice(0, pivot).join(' ') : words.slice(0, pivot);
el.insertAdjacentHTML('beforeend', charHtml);
if (el.offsetHeight > maxHeight) max = spaces ? pivot - 1 : pivot - 2;else min = pivot;
}
el[textProp] = spaces ? words.slice(0, max).join(' ') : words.slice(0, max);
el.insertAdjacentHTML('beforeend', charHtml);
var diff = spaces ? " ".concat(words.slice(max).join(' ')) : words.slice(max);
el.insertAdjacentHTML('beforeend', "<span class=\"".concat(classname, "\" style=\"display:none;\">").concat(diff, "</span>"));
styles.height = heightStyle;
styles.maxHeight = maxHeightStyle;
}
}
return shave;
}))); |
/*[process-shim]*/
(function(global, env) {
// jshint ignore:line
if (typeof process === "undefined") {
global.process = {
argv: [],
cwd: function() {
return "";
},
browser: true,
env: {
NODE_ENV: env || "development"
},
version: "",
platform:
global.navigator &&
global.navigator.userAgent &&
/Windows/.test(global.navigator.userAgent)
? "win"
: ""
};
}
})(
typeof self == "object" && self.Object == Object
? self
: typeof process === "object" &&
Object.prototype.toString.call(process) === "[object process]"
? global
: window,
"development"
);
/*[global-shim-start]*/
(function(exports, global, doEval) {
// jshint ignore:line
var origDefine = global.define;
var get = function(name) {
var parts = name.split("."),
cur = global,
i;
for (i = 0; i < parts.length; i++) {
if (!cur) {
break;
}
cur = cur[parts[i]];
}
return cur;
};
var set = function(name, val) {
var parts = name.split("."),
cur = global,
i,
part,
next;
for (i = 0; i < parts.length - 1; i++) {
part = parts[i];
next = cur[part];
if (!next) {
next = cur[part] = {};
}
cur = next;
}
part = parts[parts.length - 1];
cur[part] = val;
};
var useDefault = function(mod) {
if (!mod || !mod.__esModule) return false;
var esProps = { __esModule: true, default: true };
for (var p in mod) {
if (!esProps[p]) return false;
}
return true;
};
var hasCjsDependencies = function(deps) {
return (
deps[0] === "require" && deps[1] === "exports" && deps[2] === "module"
);
};
var modules =
(global.define && global.define.modules) ||
(global._define && global._define.modules) ||
{};
var ourDefine = (global.define = function(moduleName, deps, callback) {
var module;
if (typeof deps === "function") {
callback = deps;
deps = [];
}
var args = [],
i;
for (i = 0; i < deps.length; i++) {
args.push(
exports[deps[i]]
? get(exports[deps[i]])
: modules[deps[i]] || get(deps[i])
);
}
// CJS has no dependencies but 3 callback arguments
if (hasCjsDependencies(deps) || (!deps.length && callback.length)) {
module = { exports: {} };
args[0] = function(name) {
return exports[name] ? get(exports[name]) : modules[name];
};
args[1] = module.exports;
args[2] = module;
}
// Babel uses the exports and module object.
else if (!args[0] && deps[0] === "exports") {
module = { exports: {} };
args[0] = module.exports;
if (deps[1] === "module") {
args[1] = module;
}
} else if (!args[0] && deps[0] === "module") {
args[0] = { id: moduleName };
}
global.define = origDefine;
var result = callback ? callback.apply(null, args) : undefined;
global.define = ourDefine;
// Favor CJS module.exports over the return value
result = module && module.exports ? module.exports : result;
modules[moduleName] = result;
// Set global exports
var globalExport = exports[moduleName];
if (globalExport && !get(globalExport)) {
if (useDefault(result)) {
result = result["default"];
}
set(globalExport, result);
}
});
global.define.orig = origDefine;
global.define.modules = modules;
global.define.amd = true;
ourDefine("@loader", [], function() {
// shim for @@global-helpers
var noop = function() {};
return {
get: function() {
return { prepareGlobal: noop, retrieveGlobal: noop };
},
global: global,
__exec: function(__load) {
doEval(__load.source, global);
}
};
});
})(
{
jquery: "jQuery",
"can-namespace": "can",
kefir: "Kefir",
"validate.js": "validate",
react: "React"
},
typeof self == "object" && self.Object == Object
? self
: typeof process === "object" &&
Object.prototype.toString.call(process) === "[object process]"
? global
: window,
function(__$source__, __$global__) {
// jshint ignore:line
eval("(function() { " + __$source__ + " \n }).call(__$global__);");
}
);
/*can-namespace@1.0.0#can-namespace*/
define('can-namespace', function (require, exports, module) {
module.exports = {};
});
/*can-symbol@1.6.1#can-symbol*/
define('can-symbol', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
(function (global, require, exports, module) {
var namespace = require('can-namespace');
var CanSymbol;
if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {
CanSymbol = Symbol;
} else {
var symbolNum = 0;
CanSymbol = function CanSymbolPolyfill(description) {
var symbolValue = '@@symbol' + symbolNum++ + description;
var symbol = {};
Object.defineProperties(symbol, {
toString: {
value: function () {
return symbolValue;
}
}
});
return symbol;
};
var descriptionToSymbol = {};
var symbolToDescription = {};
CanSymbol.for = function (description) {
var symbol = descriptionToSymbol[description];
if (!symbol) {
symbol = descriptionToSymbol[description] = CanSymbol(description);
symbolToDescription[symbol] = description;
}
return symbol;
};
CanSymbol.keyFor = function (symbol) {
return symbolToDescription[symbol];
};
[
'hasInstance',
'isConcatSpreadable',
'iterator',
'match',
'prototype',
'replace',
'search',
'species',
'split',
'toPrimitive',
'toStringTag',
'unscopables'
].forEach(function (name) {
CanSymbol[name] = CanSymbol('Symbol.' + name);
});
}
[
'isMapLike',
'isListLike',
'isValueLike',
'isFunctionLike',
'getOwnKeys',
'getOwnKeyDescriptor',
'proto',
'<API key>',
'hasOwnKey',
'hasKey',
'size',
'getName',
'getIdentity',
'assignDeep',
'updateDeep',
'getValue',
'setValue',
'getKeyValue',
'setKeyValue',
'updateValues',
'addValue',
'removeValues',
'apply',
'new',
'onValue',
'offValue',
'onKeyValue',
'offKeyValue',
'getKeyDependencies',
'<API key>',
'keyHasDependencies',
'<API key>',
'onKeys',
'onKeysAdded',
'onKeysRemoved',
'onPatches'
].forEach(function (name) {
CanSymbol.for('can.' + name);
});
module.exports = namespace.Symbol = CanSymbol;
}(function () {
return this;
}(), require, exports, module));
});
/*can-reflect@1.16.7#reflections/helpers*/
define('can-reflect/reflections/helpers', [
'require',
'exports',
'module',
'can-symbol'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
module.exports = {
<API key>: function (symbolNames) {
var symbols = symbolNames.map(function (name) {
return canSymbol.for(name);
});
var length = symbols.length;
return function getFirstSymbol(obj) {
var index = -1;
while (++index < length) {
if (obj[symbols[index]] !== undefined) {
return obj[symbols[index]];
}
}
};
},
hasLength: function (list) {
var type = typeof list;
if (type === 'string' || Array.isArray(list)) {
return true;
}
var length = list && (type !== 'boolean' && type !== 'number' && 'length' in list) && list.length;
return typeof list !== 'function' && (length === 0 || typeof length === 'number' && length > 0 && length - 1 in list);
}
};
});
/*can-reflect@1.16.7#reflections/type/type*/
define('can-reflect/reflections/type/type', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect/reflections/helpers'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var helpers = require('can-reflect/reflections/helpers');
var <API key> = Object.getOwnPropertyNames(function () {
}.prototype);
var <API key> = Object.getPrototypeOf(function () {
}.prototype);
function isConstructorLike(func) {
var value = func[canSymbol.for('can.new')];
if (value !== undefined) {
return value;
}
if (typeof func !== 'function') {
return false;
}
var prototype = func.prototype;
if (!prototype) {
return false;
}
if (<API key> !== Object.getPrototypeOf(prototype)) {
return true;
}
var propertyNames = Object.getOwnPropertyNames(prototype);
if (propertyNames.length === <API key>.length) {
for (var i = 0, len = propertyNames.length; i < len; i++) {
if (propertyNames[i] !== <API key>[i]) {
return true;
}
}
return false;
} else {
return true;
}
}
var getNewOrApply = helpers.<API key>([
'can.new',
'can.apply'
]);
function isFunctionLike(obj) {
var result, symbolValue = obj[canSymbol.for('can.isFunctionLike')];
if (symbolValue !== undefined) {
return symbolValue;
}
result = getNewOrApply(obj);
if (result !== undefined) {
return !!result;
}
return typeof obj === 'function';
}
function isPrimitive(obj) {
var type = typeof obj;
if (obj == null || type !== 'function' && type !== 'object') {
return true;
} else {
return false;
}
}
function isBuiltIn(obj) {
if (isPrimitive(obj) || Array.isArray(obj) || isPlainObject(obj) || Object.prototype.toString.call(obj) !== '[object Object]' && Object.prototype.toString.call(obj).indexOf('[object ') !== -1) {
return true;
} else {
return false;
}
}
function isValueLike(obj) {
var symbolValue;
if (isPrimitive(obj)) {
return true;
}
symbolValue = obj[canSymbol.for('can.isValueLike')];
if (typeof symbolValue !== 'undefined') {
return symbolValue;
}
var value = obj[canSymbol.for('can.getValue')];
if (value !== undefined) {
return !!value;
}
}
function isMapLike(obj) {
if (isPrimitive(obj)) {
return false;
}
var isMapLike = obj[canSymbol.for('can.isMapLike')];
if (typeof isMapLike !== 'undefined') {
return !!isMapLike;
}
var value = obj[canSymbol.for('can.getKeyValue')];
if (value !== undefined) {
return !!value;
}
return true;
}
var onValueSymbol = canSymbol.for('can.onValue'), onKeyValueSymbol = canSymbol.for('can.onKeyValue'), onPatchesSymbol = canSymbol.for('can.onPatches');
function isObservableLike(obj) {
if (isPrimitive(obj)) {
return false;
}
return Boolean(obj[onValueSymbol] || obj[onKeyValueSymbol] || obj[onPatchesSymbol]);
}
function isListLike(list) {
var symbolValue, type = typeof list;
if (type === 'string') {
return true;
}
if (isPrimitive(list)) {
return false;
}
symbolValue = list[canSymbol.for('can.isListLike')];
if (typeof symbolValue !== 'undefined') {
return symbolValue;
}
var value = list[canSymbol.iterator];
if (value !== undefined) {
return !!value;
}
if (Array.isArray(list)) {
return true;
}
return helpers.hasLength(list);
}
var supportsSymbols = typeof Symbol !== 'undefined' && typeof Symbol.for === 'function';
var isSymbolLike;
if (supportsSymbols) {
isSymbolLike = function (symbol) {
return typeof symbol === 'symbol';
};
} else {
var symbolStart = '@@symbol';
isSymbolLike = function (symbol) {
if (typeof symbol === 'object' && !Array.isArray(symbol)) {
return symbol.toString().substr(0, symbolStart.length) === symbolStart;
} else {
return false;
}
};
}
var coreHasOwn = Object.prototype.hasOwnProperty;
var funcToString = Function.prototype.toString;
var objectCtorString = funcToString.call(Object);
function isPlainObject(obj) {
if (!obj || typeof obj !== 'object') {
return false;
}
var proto = Object.getPrototypeOf(obj);
if (proto === Object.prototype || proto === null) {
return true;
}
var Constructor = coreHasOwn.call(proto, 'constructor') && proto.constructor;
return typeof Constructor === 'function' && Constructor instanceof Constructor && funcToString.call(Constructor) === objectCtorString;
}
module.exports = {
isConstructorLike: isConstructorLike,
isFunctionLike: isFunctionLike,
isListLike: isListLike,
isMapLike: isMapLike,
isObservableLike: isObservableLike,
isPrimitive: isPrimitive,
isBuiltIn: isBuiltIn,
isValueLike: isValueLike,
isSymbolLike: isSymbolLike,
<API key>: function (obj) {
if (Array.isArray(obj)) {
return true;
}
if (obj instanceof Array) {
return true;
}
if (obj == null) {
return false;
}
var value = obj[canSymbol.for('can.<API key>')];
if (value !== undefined) {
return value;
}
var isListLike = this.isListLike(obj), isMapLike = this.isMapLike(obj);
if (isListLike && !isMapLike) {
return true;
} else if (!isListLike && isMapLike) {
return false;
}
},
isIteratorLike: function (obj) {
return obj && typeof obj === 'object' && typeof obj.next === 'function' && obj.next.length === 0;
},
isPromise: function (obj) {
return obj instanceof Promise || Object.prototype.toString.call(obj) === '[object Promise]';
},
isPlainObject: isPlainObject
};
});
/*can-reflect@1.16.7#reflections/call/call*/
define('can-reflect/reflections/call/call', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect/reflections/type/type'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var typeReflections = require('can-reflect/reflections/type/type');
module.exports = {
call: function (func, context) {
var args = [].slice.call(arguments, 2);
var apply = func[canSymbol.for('can.apply')];
if (apply) {
return apply.call(func, context, args);
} else {
return func.apply(context, args);
}
},
apply: function (func, context, args) {
var apply = func[canSymbol.for('can.apply')];
if (apply) {
return apply.call(func, context, args);
} else {
return func.apply(context, args);
}
},
'new': function (func) {
var args = [].slice.call(arguments, 1);
var makeNew = func[canSymbol.for('can.new')];
if (makeNew) {
return makeNew.apply(func, args);
} else {
var context = Object.create(func.prototype);
var ret = func.apply(context, args);
if (typeReflections.isPrimitive(ret)) {
return context;
} else {
return ret;
}
}
}
};
});
/*can-reflect@1.16.7#reflections/get-set/get-set*/
define('can-reflect/reflections/get-set/get-set', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect/reflections/type/type'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var typeReflections = require('can-reflect/reflections/type/type');
var setKeyValueSymbol = canSymbol.for('can.setKeyValue'), getKeyValueSymbol = canSymbol.for('can.getKeyValue'), getValueSymbol = canSymbol.for('can.getValue'), setValueSymbol = canSymbol.for('can.setValue');
var reflections = {
setKeyValue: function (obj, key, value) {
if (typeReflections.isSymbolLike(key)) {
if (typeof key === 'symbol') {
obj[key] = value;
} else {
Object.defineProperty(obj, key, {
enumerable: false,
configurable: true,
value: value,
writable: true
});
}
return;
}
var setKeyValue = obj[setKeyValueSymbol];
if (setKeyValue !== undefined) {
return setKeyValue.call(obj, key, value);
} else {
obj[key] = value;
}
},
getKeyValue: function (obj, key) {
var getKeyValue = obj[getKeyValueSymbol];
if (getKeyValue) {
return getKeyValue.call(obj, key);
}
return obj[key];
},
deleteKeyValue: function (obj, key) {
var deleteKeyValue = obj[canSymbol.for('can.deleteKeyValue')];
if (deleteKeyValue) {
return deleteKeyValue.call(obj, key);
}
delete obj[key];
},
getValue: function (value) {
if (typeReflections.isPrimitive(value)) {
return value;
}
var getValue = value[getValueSymbol];
if (getValue) {
return getValue.call(value);
}
return value;
},
setValue: function (item, value) {
var setValue = item && item[setValueSymbol];
if (setValue) {
return setValue.call(item, value);
} else {
throw new Error('can-reflect.setValue - Can not set value.');
}
},
splice: function (obj, index, removing, adding) {
var howMany;
if (typeof removing !== 'number') {
var updateValues = obj[canSymbol.for('can.updateValues')];
if (updateValues) {
return updateValues.call(obj, index, removing, adding);
}
howMany = removing.length;
} else {
howMany = removing;
}
if (arguments.length <= 3) {
adding = [];
}
var splice = obj[canSymbol.for('can.splice')];
if (splice) {
return splice.call(obj, index, howMany, adding);
}
return [].splice.apply(obj, [
index,
howMany
].concat(adding));
},
addValues: function (obj, adding, index) {
var add = obj[canSymbol.for('can.addValues')];
if (add) {
return add.call(obj, adding, index);
}
if (Array.isArray(obj) && index === undefined) {
return obj.push.apply(obj, adding);
}
return reflections.splice(obj, index, [], adding);
},
removeValues: function (obj, removing, index) {
var removeValues = obj[canSymbol.for('can.removeValues')];
if (removeValues) {
return removeValues.call(obj, removing, index);
}
if (Array.isArray(obj) && index === undefined) {
removing.forEach(function (item) {
var index = obj.indexOf(item);
if (index >= 0) {
obj.splice(index, 1);
}
});
return;
}
return reflections.splice(obj, index, removing, []);
}
};
reflections.get = reflections.getKeyValue;
reflections.set = reflections.setKeyValue;
reflections['delete'] = reflections.deleteKeyValue;
module.exports = reflections;
});
/*can-reflect@1.16.7#reflections/observe/observe*/
define('can-reflect/reflections/observe/observe', [
'require',
'exports',
'module',
'can-symbol'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var slice = [].slice;
function makeFallback(symbolName, fallbackName) {
return function (obj, event, handler, queueName) {
var method = obj[canSymbol.for(symbolName)];
if (method !== undefined) {
return method.call(obj, event, handler, queueName);
}
return this[fallbackName].apply(this, arguments);
};
}
function makeErrorIfMissing(symbolName, errorMessage) {
return function (obj) {
var method = obj[canSymbol.for(symbolName)];
if (method !== undefined) {
var args = slice.call(arguments, 1);
return method.apply(obj, args);
}
throw new Error(errorMessage);
};
}
module.exports = {
onKeyValue: makeFallback('can.onKeyValue', 'onEvent'),
offKeyValue: makeFallback('can.offKeyValue', 'offEvent'),
onKeys: makeErrorIfMissing('can.onKeys', 'can-reflect: can not observe an onKeys event'),
onKeysAdded: makeErrorIfMissing('can.onKeysAdded', 'can-reflect: can not observe an onKeysAdded event'),
onKeysRemoved: makeErrorIfMissing('can.onKeysRemoved', 'can-reflect: can not unobserve an onKeysRemoved event'),
getKeyDependencies: makeErrorIfMissing('can.getKeyDependencies', 'can-reflect: can not determine dependencies'),
getWhatIChange: makeErrorIfMissing('can.getWhatIChange', 'can-reflect: can not determine dependencies'),
<API key>: function <API key>(handler) {
var fn = handler[canSymbol.for('can.<API key>')];
if (typeof fn === 'function') {
return fn();
}
},
keyHasDependencies: makeErrorIfMissing('can.keyHasDependencies', 'can-reflect: can not determine if this has key dependencies'),
onValue: makeErrorIfMissing('can.onValue', 'can-reflect: can not observe value change'),
offValue: makeErrorIfMissing('can.offValue', 'can-reflect: can not unobserve value change'),
<API key>: makeErrorIfMissing('can.<API key>', 'can-reflect: can not determine dependencies'),
<API key>: makeErrorIfMissing('can.<API key>', 'can-reflect: can not determine if value has dependencies'),
onPatches: makeErrorIfMissing('can.onPatches', 'can-reflect: can not observe patches on object'),
offPatches: makeErrorIfMissing('can.offPatches', 'can-reflect: can not unobserve patches on object'),
onInstancePatches: makeErrorIfMissing('can.onInstancePatches', 'can-reflect: can not observe onInstancePatches on Type'),
offInstancePatches: makeErrorIfMissing('can.offInstancePatches', 'can-reflect: can not unobserve onInstancePatches on Type'),
<API key>: makeErrorIfMissing('can.<API key>', 'can-reflect: can not observe bound state change in instances.'),
<API key>: makeErrorIfMissing('can.<API key>', 'can-reflect: can not unobserve bound state change'),
isBound: makeErrorIfMissing('can.isBound', 'can-reflect: cannot determine if object is bound'),
onEvent: function (obj, eventName, callback, queue) {
if (obj) {
var onEvent = obj[canSymbol.for('can.onEvent')];
if (onEvent !== undefined) {
return onEvent.call(obj, eventName, callback, queue);
} else if (obj.addEventListener) {
obj.addEventListener(eventName, callback, queue);
}
}
},
offEvent: function (obj, eventName, callback, queue) {
if (obj) {
var offEvent = obj[canSymbol.for('can.offEvent')];
if (offEvent !== undefined) {
return offEvent.call(obj, eventName, callback, queue);
} else if (obj.removeEventListener) {
obj.removeEventListener(eventName, callback, queue);
}
}
},
setPriority: function (obj, priority) {
if (obj) {
var setPriority = obj[canSymbol.for('can.setPriority')];
if (setPriority !== undefined) {
setPriority.call(obj, priority);
return true;
}
}
return false;
},
getPriority: function (obj) {
if (obj) {
var getPriority = obj[canSymbol.for('can.getPriority')];
if (getPriority !== undefined) {
return getPriority.call(obj);
}
}
return undefined;
}
};
});
/*can-reflect@1.16.7#reflections/shape/shape*/
define('can-reflect/reflections/shape/shape', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect/reflections/get-set/get-set',
'can-reflect/reflections/type/type',
'can-reflect/reflections/helpers'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var getSetReflections = require('can-reflect/reflections/get-set/get-set');
var typeReflections = require('can-reflect/reflections/type/type');
var helpers = require('can-reflect/reflections/helpers');
var <API key> = true;
try {
Object.getPrototypeOf(1);
} catch (e) {
<API key> = false;
}
var ArrayMap;
if (typeof Map === 'function') {
ArrayMap = Map;
} else {
function isEven(num) {
return !(num % 2);
}
ArrayMap = function () {
this.contents = [];
};
ArrayMap.prototype = {
_getIndex: function (key) {
var idx;
do {
idx = this.contents.indexOf(key, idx);
} while (idx !== -1 && !isEven(idx));
return idx;
},
has: function (key) {
return this._getIndex(key) !== -1;
},
get: function (key) {
var idx = this._getIndex(key);
if (idx !== -1) {
return this.contents[idx + 1];
}
},
set: function (key, value) {
var idx = this._getIndex(key);
if (idx !== -1) {
this.contents[idx + 1] = value;
} else {
this.contents.push(key);
this.contents.push(value);
}
},
'delete': function (key) {
var idx = this._getIndex(key);
if (idx !== -1) {
this.contents.splice(idx, 2);
}
}
};
}
var shapeReflections;
var <API key> = function (func) {
return function () {
var args = [this];
args.push.apply(args, arguments);
return func.apply(null, args);
};
};
var getKeyValueSymbol = canSymbol.for('can.getKeyValue');
var shiftedGetKeyValue = <API key>(getSetReflections.getKeyValue);
var setKeyValueSymbol = canSymbol.for('can.setKeyValue');
var shiftedSetKeyValue = <API key>(getSetReflections.setKeyValue);
var sizeSymbol = canSymbol.for('can.size');
var hasUpdateSymbol = helpers.<API key>([
'can.updateDeep',
'can.assignDeep',
'can.setKeyValue'
]);
var <API key> = function (obj) {
return typeReflections.isPlainObject(obj) || Array.isArray(obj) || !!hasUpdateSymbol(obj);
};
function isSerializedHelper(obj) {
if (typeReflections.isPrimitive(obj)) {
return true;
}
if (hasUpdateSymbol(obj)) {
return false;
}
return typeReflections.isBuiltIn(obj) && !typeReflections.isPlainObject(obj) && !Array.isArray(obj);
}
var Object_Keys;
try {
Object.keys(1);
Object_Keys = Object.keys;
} catch (e) {
Object_Keys = function (obj) {
if (typeReflections.isPrimitive(obj)) {
return [];
} else {
return Object.keys(obj);
}
};
}
function makeSerializer(methodName, symbolsToCheck) {
var serializeMap = null;
function SerializeOperation(MapType) {
this.first = !serializeMap;
if (this.first) {
serializeMap = createSerializeMap(MapType);
}
this.map = serializeMap;
this.result = null;
}
SerializeOperation.prototype.end = function () {
if (this.first) {
serializeMap = null;
}
return this.result;
};
function createSerializeMap(Type) {
var MapType = Type || ArrayMap;
return {
unwrap: new MapType(),
serialize: new MapType(),
isSerializing: {
unwrap: new MapType(),
serialize: new MapType()
},
<API key>: {
unwrap: new MapType(),
serialize: new MapType()
}
};
}
return function serializer(value, MapType) {
if (isSerializedHelper(value)) {
return value;
}
var operation = new SerializeOperation(MapType);
if (typeReflections.isValueLike(value)) {
operation.result = this[methodName](getSetReflections.getValue(value));
} else {
var isListLike = typeReflections.isIteratorLike(value) || typeReflections.<API key>(value);
operation.result = isListLike ? [] : {};
if (operation.map[methodName].has(value)) {
if (operation.map.isSerializing[methodName].has(value)) {
operation.map.<API key>[methodName].set(value, true);
}
return operation.map[methodName].get(value);
} else {
operation.map[methodName].set(value, operation.result);
}
for (var i = 0, len = symbolsToCheck.length; i < len; i++) {
var serializer = value[symbolsToCheck[i]];
if (serializer) {
operation.map.isSerializing[methodName].set(value, true);
var oldResult = operation.result;
operation.result = serializer.call(value, oldResult);
operation.map.isSerializing[methodName].delete(value);
if (operation.result !== oldResult) {
if (operation.map.<API key>[methodName].has(value)) {
operation.end();
throw new Error('Cannot serialize cirular reference!');
}
operation.map[methodName].set(value, operation.result);
}
return operation.end();
}
}
if (typeof obj === 'function') {
operation.map[methodName].set(value, value);
operation.result = value;
} else if (isListLike) {
this.eachIndex(value, function (childValue, index) {
operation.result[index] = this[methodName](childValue);
}, this);
} else {
this.eachKey(value, function (childValue, prop) {
operation.result[prop] = this[methodName](childValue);
}, this);
}
}
return operation.end();
};
}
var makeMap;
if (typeof Map !== 'undefined') {
makeMap = function (keys) {
var map = new Map();
shapeReflections.eachIndex(keys, function (key) {
map.set(key, true);
});
return map;
};
} else {
makeMap = function (keys) {
var map = {};
keys.forEach(function (key) {
map[key] = true;
});
return {
get: function (key) {
return map[key];
},
set: function (key, value) {
map[key] = value;
},
keys: function () {
return keys;
}
};
};
}
var fastHasOwnKey = function (obj) {
var hasOwnKey = obj[canSymbol.for('can.hasOwnKey')];
if (hasOwnKey) {
return hasOwnKey.bind(obj);
} else {
var map = makeMap(shapeReflections.<API key>(obj));
return function (key) {
return map.get(key);
};
}
};
function addPatch(patches, patch) {
var lastPatch = patches[patches.length - 1];
if (lastPatch) {
if (lastPatch.deleteCount === lastPatch.insert.length && patch.index - lastPatch.index === lastPatch.deleteCount) {
lastPatch.insert.push.apply(lastPatch.insert, patch.insert);
lastPatch.deleteCount += patch.deleteCount;
return;
}
}
patches.push(patch);
}
function updateDeepList(target, source, isAssign) {
var sourceArray = this.toArray(source);
var patches = [], lastIndex = -1;
this.eachIndex(target, function (curVal, index) {
lastIndex = index;
if (index >= sourceArray.length) {
if (!isAssign) {
addPatch(patches, {
index: index,
deleteCount: target.length - index + 1,
insert: []
});
}
return false;
}
var newVal = sourceArray[index];
if (typeReflections.isPrimitive(curVal) || typeReflections.isPrimitive(newVal) || <API key>(curVal) === false) {
addPatch(patches, {
index: index,
deleteCount: 1,
insert: [newVal]
});
} else {
this.updateDeep(curVal, newVal);
}
}, this);
if (sourceArray.length > lastIndex) {
addPatch(patches, {
index: lastIndex + 1,
deleteCount: 0,
insert: sourceArray.slice(lastIndex + 1)
});
}
for (var i = 0, patchLen = patches.length; i < patchLen; i++) {
var patch = patches[i];
getSetReflections.splice(target, patch.index, patch.deleteCount, patch.insert);
}
return target;
}
shapeReflections = {
each: function (obj, callback, context) {
if (typeReflections.isIteratorLike(obj) || typeReflections.<API key>(obj)) {
return shapeReflections.eachIndex(obj, callback, context);
} else {
return shapeReflections.eachKey(obj, callback, context);
}
},
eachIndex: function (list, callback, context) {
if (Array.isArray(list)) {
return shapeReflections.eachListLike(list, callback, context);
} else {
var iter, iterator = list[canSymbol.iterator];
if (typeReflections.isIteratorLike(list)) {
iter = list;
} else if (iterator) {
iter = iterator.call(list);
}
if (iter) {
var res, index = 0;
while (!(res = iter.next()).done) {
if (callback.call(context || list, res.value, index++, list) === false) {
break;
}
}
} else {
shapeReflections.eachListLike(list, callback, context);
}
}
return list;
},
eachListLike: function (list, callback, context) {
var index = -1;
var length = list.length;
if (length === undefined) {
var size = list[sizeSymbol];
if (size) {
length = size.call(list);
} else {
throw new Error('can-reflect: unable to iterate.');
}
}
while (++index < length) {
var item = list[index];
if (callback.call(context || item, item, index, list) === false) {
break;
}
}
return list;
},
toArray: function (obj) {
var arr = [];
shapeReflections.each(obj, function (value) {
arr.push(value);
});
return arr;
},
eachKey: function (obj, callback, context) {
if (obj) {
var enumerableKeys = shapeReflections.<API key>(obj);
var getKeyValue = obj[getKeyValueSymbol] || shiftedGetKeyValue;
return shapeReflections.eachIndex(enumerableKeys, function (key) {
var value = getKeyValue.call(obj, key);
return callback.call(context || obj, value, key, obj);
});
}
return obj;
},
'hasOwnKey': function (obj, key) {
var hasOwnKey = obj[canSymbol.for('can.hasOwnKey')];
if (hasOwnKey) {
return hasOwnKey.call(obj, key);
}
var getOwnKeys = obj[canSymbol.for('can.getOwnKeys')];
if (getOwnKeys) {
var found = false;
shapeReflections.eachIndex(getOwnKeys.call(obj), function (objKey) {
if (objKey === key) {
found = true;
return false;
}
});
return found;
}
return obj.hasOwnProperty(key);
},
<API key>: function (obj) {
var <API key> = obj[canSymbol.for('can.<API key>')];
if (<API key>) {
return <API key>.call(obj);
}
if (obj[canSymbol.for('can.getOwnKeys')] && obj[canSymbol.for('can.getOwnKeyDescriptor')]) {
var keys = [];
shapeReflections.eachIndex(shapeReflections.getOwnKeys(obj), function (key) {
var descriptor = shapeReflections.getOwnKeyDescriptor(obj, key);
if (descriptor.enumerable) {
keys.push(key);
}
}, this);
return keys;
} else {
return Object_Keys(obj);
}
},
getOwnKeys: function (obj) {
var getOwnKeys = obj[canSymbol.for('can.getOwnKeys')];
if (getOwnKeys) {
return getOwnKeys.call(obj);
} else {
return Object.getOwnPropertyNames(obj);
}
},
getOwnKeyDescriptor: function (obj, key) {
var getOwnKeyDescriptor = obj[canSymbol.for('can.getOwnKeyDescriptor')];
if (getOwnKeyDescriptor) {
return getOwnKeyDescriptor.call(obj, key);
} else {
return Object.<API key>(obj, key);
}
},
unwrap: makeSerializer('unwrap', [canSymbol.for('can.unwrap')]),
serialize: makeSerializer('serialize', [
canSymbol.for('can.serialize'),
canSymbol.for('can.unwrap')
]),
assignMap: function (target, source) {
var hasOwnKey = fastHasOwnKey(target);
var getKeyValue = target[getKeyValueSymbol] || shiftedGetKeyValue;
var setKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
shapeReflections.eachKey(source, function (value, key) {
if (!hasOwnKey(key) || getKeyValue.call(target, key) !== value) {
setKeyValue.call(target, key, value);
}
});
return target;
},
assignList: function (target, source) {
var inserting = shapeReflections.toArray(source);
getSetReflections.splice(target, 0, inserting, inserting);
return target;
},
assign: function (target, source) {
if (typeReflections.isIteratorLike(source) || typeReflections.<API key>(source)) {
shapeReflections.assignList(target, source);
} else {
shapeReflections.assignMap(target, source);
}
return target;
},
assignDeepMap: function (target, source) {
var hasOwnKey = fastHasOwnKey(target);
var getKeyValue = target[getKeyValueSymbol] || shiftedGetKeyValue;
var setKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
shapeReflections.eachKey(source, function (newVal, key) {
if (!hasOwnKey(key)) {
getSetReflections.setKeyValue(target, key, newVal);
} else {
var curVal = getKeyValue.call(target, key);
if (newVal === curVal) {
} else if (typeReflections.isPrimitive(curVal) || typeReflections.isPrimitive(newVal) || <API key>(curVal) === false) {
setKeyValue.call(target, key, newVal);
} else {
shapeReflections.assignDeep(curVal, newVal);
}
}
}, this);
return target;
},
assignDeepList: function (target, source) {
return updateDeepList.call(this, target, source, true);
},
assignDeep: function (target, source) {
var assignDeep = target[canSymbol.for('can.assignDeep')];
if (assignDeep) {
assignDeep.call(target, source);
} else if (typeReflections.<API key>(source)) {
shapeReflections.assignDeepList(target, source);
} else {
shapeReflections.assignDeepMap(target, source);
}
return target;
},
updateMap: function (target, source) {
var sourceKeyMap = makeMap(shapeReflections.<API key>(source));
var sourceGetKeyValue = source[getKeyValueSymbol] || shiftedGetKeyValue;
var targetSetKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
shapeReflections.eachKey(target, function (curVal, key) {
if (!sourceKeyMap.get(key)) {
getSetReflections.deleteKeyValue(target, key);
return;
}
sourceKeyMap.set(key, false);
var newVal = sourceGetKeyValue.call(source, key);
if (newVal !== curVal) {
targetSetKeyValue.call(target, key, newVal);
}
}, this);
shapeReflections.eachIndex(sourceKeyMap.keys(), function (key) {
if (sourceKeyMap.get(key)) {
targetSetKeyValue.call(target, key, sourceGetKeyValue.call(source, key));
}
});
return target;
},
updateList: function (target, source) {
var inserting = shapeReflections.toArray(source);
getSetReflections.splice(target, 0, target, inserting);
return target;
},
update: function (target, source) {
if (typeReflections.isIteratorLike(source) || typeReflections.<API key>(source)) {
shapeReflections.updateList(target, source);
} else {
shapeReflections.updateMap(target, source);
}
return target;
},
updateDeepMap: function (target, source) {
var sourceKeyMap = makeMap(shapeReflections.<API key>(source));
var sourceGetKeyValue = source[getKeyValueSymbol] || shiftedGetKeyValue;
var targetSetKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
shapeReflections.eachKey(target, function (curVal, key) {
if (!sourceKeyMap.get(key)) {
getSetReflections.deleteKeyValue(target, key);
return;
}
sourceKeyMap.set(key, false);
var newVal = sourceGetKeyValue.call(source, key);
if (typeReflections.isPrimitive(curVal) || typeReflections.isPrimitive(newVal) || <API key>(curVal) === false) {
targetSetKeyValue.call(target, key, newVal);
} else {
shapeReflections.updateDeep(curVal, newVal);
}
}, this);
shapeReflections.eachIndex(sourceKeyMap.keys(), function (key) {
if (sourceKeyMap.get(key)) {
targetSetKeyValue.call(target, key, sourceGetKeyValue.call(source, key));
}
});
return target;
},
updateDeepList: function (target, source) {
return updateDeepList.call(this, target, source);
},
updateDeep: function (target, source) {
var updateDeep = target[canSymbol.for('can.updateDeep')];
if (updateDeep) {
updateDeep.call(target, source);
} else if (typeReflections.<API key>(source)) {
shapeReflections.updateDeepList(target, source);
} else {
shapeReflections.updateDeepMap(target, source);
}
return target;
},
hasKey: function (obj, key) {
if (obj == null) {
return false;
}
if (typeReflections.isPrimitive(obj)) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
return true;
} else {
var proto;
if (<API key>) {
proto = Object.getPrototypeOf(obj);
} else {
proto = obj.__proto__;
}
;
if (proto !== undefined) {
return key in proto;
} else {
return obj[key] !== undefined;
}
}
}
var hasKey = obj[canSymbol.for('can.hasKey')];
if (hasKey) {
return hasKey.call(obj, key);
}
var found = shapeReflections.hasOwnKey(obj, key);
return found || key in obj;
},
<API key>: function () {
},
getAllKeys: function () {
},
assignSymbols: function (target, source) {
shapeReflections.eachKey(source, function (value, key) {
var symbol = typeReflections.isSymbolLike(canSymbol[key]) ? canSymbol[key] : canSymbol.for(key);
getSetReflections.setKeyValue(target, symbol, value);
});
return target;
},
isSerialized: isSerializedHelper,
size: function (obj) {
if (obj == null) {
return 0;
}
var size = obj[sizeSymbol];
var count = 0;
if (size) {
return size.call(obj);
} else if (helpers.hasLength(obj)) {
return obj.length;
} else if (typeReflections.isListLike(obj)) {
shapeReflections.eachIndex(obj, function () {
count++;
});
return count;
} else if (obj) {
return shapeReflections.<API key>(obj).length;
} else {
return undefined;
}
},
defineInstanceKey: function (cls, key, properties) {
var defineInstanceKey = cls[canSymbol.for('can.defineInstanceKey')];
if (defineInstanceKey) {
return defineInstanceKey.call(cls, key, properties);
}
var proto = cls.prototype;
defineInstanceKey = proto[canSymbol.for('can.defineInstanceKey')];
if (defineInstanceKey) {
defineInstanceKey.call(proto, key, properties);
} else {
Object.defineProperty(proto, key, shapeReflections.assign({
configurable: true,
enumerable: !typeReflections.isSymbolLike(key),
writable: true
}, properties));
}
}
};
shapeReflections.isSerializable = shapeReflections.isSerialized;
shapeReflections.keys = shapeReflections.<API key>;
module.exports = shapeReflections;
});
/*can-reflect@1.16.7#reflections/shape/schema/schema*/
define('can-reflect/reflections/shape/schema/schema', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect/reflections/type/type',
'can-reflect/reflections/get-set/get-set',
'can-reflect/reflections/shape/shape'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var typeReflections = require('can-reflect/reflections/type/type');
var getSetReflections = require('can-reflect/reflections/get-set/get-set');
var shapeReflections = require('can-reflect/reflections/shape/shape');
var getSchemaSymbol = canSymbol.for('can.getSchema'), isMemberSymbol = canSymbol.for('can.isMember'), newSymbol = canSymbol.for('can.new');
function comparator(a, b) {
return a.localeCompare(b);
}
function sort(obj) {
if (typeReflections.isPrimitive(obj)) {
return obj;
}
var out;
if (typeReflections.isListLike(obj)) {
out = [];
shapeReflections.eachKey(obj, function (item) {
out.push(sort(item));
});
return out;
}
if (typeReflections.isMapLike(obj)) {
out = {};
shapeReflections.getOwnKeys(obj).sort(comparator).forEach(function (key) {
out[key] = sort(getSetReflections.getKeyValue(obj, key));
});
return out;
}
return obj;
}
function <API key>(Type) {
return Type === Number || Type === String || Type === Boolean;
}
var schemaReflections = {
getSchema: function (type) {
var getSchema = type[getSchemaSymbol];
if (getSchema === undefined) {
type = type.constructor;
getSchema = type && type[getSchemaSymbol];
}
return getSchema !== undefined ? getSchema.call(type) : undefined;
},
getIdentity: function (value, schema) {
schema = schema || schemaReflections.getSchema(value);
if (schema === undefined) {
throw new Error('can-reflect.getIdentity - Unable to find a schema for the given value.');
}
var identity = schema.identity;
if (!identity || identity.length === 0) {
throw new Error('can-reflect.getIdentity - Provided schema lacks an identity property.');
} else if (identity.length === 1) {
return getSetReflections.getKeyValue(value, identity[0]);
} else {
var id = {};
identity.forEach(function (key) {
id[key] = getSetReflections.getKeyValue(value, key);
});
return JSON.stringify(schemaReflections.cloneKeySort(id));
}
},
cloneKeySort: function (obj) {
return sort(obj);
},
convert: function (value, Type) {
if (<API key>(Type)) {
return Type(value);
}
var isMemberTest = Type[isMemberSymbol], isMember = false, type = typeof Type, createNew = Type[newSymbol];
if (isMemberTest !== undefined) {
isMember = isMemberTest.call(Type, value);
} else if (type === 'function') {
if (typeReflections.isConstructorLike(Type)) {
isMember = value instanceof Type;
}
}
if (isMember) {
return value;
}
if (createNew !== undefined) {
return createNew.call(Type, value);
} else if (type === 'function') {
if (typeReflections.isConstructorLike(Type)) {
return new Type(value);
} else {
return Type(value);
}
} else {
throw new Error('can-reflect: Can not convert values into type. Type must provide `can.new` symbol.');
}
}
};
module.exports = schemaReflections;
});
/*can-reflect@1.16.7#reflections/get-name/get-name*/
define('can-reflect/reflections/get-name/get-name', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect/reflections/type/type'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var typeReflections = require('can-reflect/reflections/type/type');
var getNameSymbol = canSymbol.for('can.getName');
function setName(obj, nameGetter) {
if (typeof nameGetter !== 'function') {
var value = nameGetter;
nameGetter = function () {
return value;
};
}
Object.defineProperty(obj, getNameSymbol, { value: nameGetter });
}
function getName(obj) {
var type = typeof obj;
if (obj === null || type !== 'object' && type !== 'function') {
return '' + obj;
}
var nameGetter = obj[getNameSymbol];
if (nameGetter) {
return nameGetter.call(obj);
}
if (type === 'function') {
return obj.name;
}
if (obj.constructor && obj !== obj.constructor) {
var parent = getName(obj.constructor);
if (parent) {
if (typeReflections.isValueLike(obj)) {
return parent + '<>';
}
if (typeReflections.<API key>(obj)) {
return parent + '[]';
}
if (typeReflections.isMapLike(obj)) {
return parent + '{}';
}
}
}
return undefined;
}
module.exports = {
setName: setName,
getName: getName
};
});
/*can-reflect@1.16.7#types/map*/
define('can-reflect/types/map', [
'require',
'exports',
'module',
'can-reflect/reflections/shape/shape',
'can-symbol'
], function (require, exports, module) {
var shape = require('can-reflect/reflections/shape/shape');
var CanSymbol = require('can-symbol');
function keysPolyfill() {
var keys = [];
var currentIndex = 0;
this.forEach(function (val, key) {
keys.push(key);
});
return {
next: function () {
return {
value: keys[currentIndex],
done: currentIndex++ === keys.length
};
}
};
}
if (typeof Map !== 'undefined') {
shape.assignSymbols(Map.prototype, {
'can.<API key>': Map.prototype.keys,
'can.setKeyValue': Map.prototype.set,
'can.getKeyValue': Map.prototype.get,
'can.deleteKeyValue': Map.prototype['delete'],
'can.hasOwnKey': Map.prototype.has
});
if (typeof Map.prototype.keys !== 'function') {
Map.prototype.keys = Map.prototype[CanSymbol.for('can.<API key>')] = keysPolyfill;
}
}
if (typeof WeakMap !== 'undefined') {
shape.assignSymbols(WeakMap.prototype, {
'can.<API key>': function () {
throw new Error('can-reflect: WeakMaps do not have enumerable keys.');
},
'can.setKeyValue': WeakMap.prototype.set,
'can.getKeyValue': WeakMap.prototype.get,
'can.deleteKeyValue': WeakMap.prototype['delete'],
'can.hasOwnKey': WeakMap.prototype.has
});
}
});
/*can-reflect@1.16.7#types/set*/
define('can-reflect/types/set', [
'require',
'exports',
'module',
'can-reflect/reflections/shape/shape',
'can-symbol'
], function (require, exports, module) {
var shape = require('can-reflect/reflections/shape/shape');
var CanSymbol = require('can-symbol');
if (typeof Set !== 'undefined') {
shape.assignSymbols(Set.prototype, {
'can.<API key>': true,
'can.updateValues': function (index, removing, adding) {
if (removing !== adding) {
shape.each(removing, function (value) {
this.delete(value);
}, this);
}
shape.each(adding, function (value) {
this.add(value);
}, this);
},
'can.size': function () {
return this.size;
}
});
if (typeof Set.prototype[CanSymbol.iterator] !== 'function') {
Set.prototype[CanSymbol.iterator] = function () {
var arr = [];
var currentIndex = 0;
this.forEach(function (val) {
arr.push(val);
});
return {
next: function () {
return {
value: arr[currentIndex],
done: currentIndex++ === arr.length
};
}
};
};
}
}
if (typeof WeakSet !== 'undefined') {
shape.assignSymbols(WeakSet.prototype, {
'can.isListLike': true,
'can.<API key>': true,
'can.updateValues': function (index, removing, adding) {
if (removing !== adding) {
shape.each(removing, function (value) {
this.delete(value);
}, this);
}
shape.each(adding, function (value) {
this.add(value);
}, this);
},
'can.size': function () {
throw new Error('can-reflect: WeakSets do not have enumerable keys.');
}
});
}
});
/*can-reflect@1.16.7#can-reflect*/
define('can-reflect', [
'require',
'exports',
'module',
'can-reflect/reflections/call/call',
'can-reflect/reflections/get-set/get-set',
'can-reflect/reflections/observe/observe',
'can-reflect/reflections/shape/shape',
'can-reflect/reflections/shape/schema/schema',
'can-reflect/reflections/type/type',
'can-reflect/reflections/get-name/get-name',
'can-namespace',
'can-reflect/types/map',
'can-reflect/types/set'
], function (require, exports, module) {
var functionReflections = require('can-reflect/reflections/call/call');
var getSet = require('can-reflect/reflections/get-set/get-set');
var observe = require('can-reflect/reflections/observe/observe');
var shape = require('can-reflect/reflections/shape/shape');
var schema = require('can-reflect/reflections/shape/schema/schema');
var type = require('can-reflect/reflections/type/type');
var getName = require('can-reflect/reflections/get-name/get-name');
var namespace = require('can-namespace');
var reflect = {};
[
functionReflections,
getSet,
observe,
shape,
type,
getName,
schema
].forEach(function (reflections) {
for (var prop in reflections) {
reflect[prop] = reflections[prop];
if (typeof reflections[prop] === 'function') {
var propDescriptor = Object.<API key>(reflections[prop], 'name');
if (!propDescriptor || propDescriptor.writable && propDescriptor.configurable) {
Object.defineProperty(reflections[prop], 'name', { value: 'canReflect.' + prop });
}
}
}
});
require('can-reflect/types/map');
require('can-reflect/types/set');
module.exports = namespace.Reflect = reflect;
});
/*can-log@1.0.0#can-log*/
define('can-log', function (require, exports, module) {
'use strict';
exports.warnTimeout = 5000;
exports.logLevel = 0;
exports.warn = function () {
var ll = this.logLevel;
if (ll < 2) {
if (typeof console !== 'undefined' && console.warn) {
this._logger('warn', Array.prototype.slice.call(arguments));
} else if (typeof console !== 'undefined' && console.log) {
this._logger('log', Array.prototype.slice.call(arguments));
}
}
};
exports.log = function () {
var ll = this.logLevel;
if (ll < 1) {
if (typeof console !== 'undefined' && console.log) {
this._logger('log', Array.prototype.slice.call(arguments));
}
}
};
exports.error = function () {
var ll = this.logLevel;
if (ll < 1) {
if (typeof console !== 'undefined' && console.error) {
this._logger('error', Array.prototype.slice.call(arguments));
}
}
};
exports._logger = function (type, arr) {
try {
console[type].apply(console, arr);
} catch (e) {
console[type](arr);
}
};
});
/*can-log@1.0.0#dev/dev*/
define('can-log/dev/dev', [
'require',
'exports',
'module',
'can-log'
], function (require, exports, module) {
'use strict';
var canLog = require('can-log');
module.exports = {
warnTimeout: 5000,
logLevel: 0,
stringify: function (value) {
var flagUndefined = function flagUndefined(key, value) {
return value === undefined ? '/* void(undefined) */' : value;
};
return JSON.stringify(value, flagUndefined, ' ').replace(/"\/\* void\(undefined\) \*\/"/g, 'undefined');
},
warn: function () {
canLog.warn.apply(this, arguments);
},
log: function () {
canLog.log.apply(this, arguments);
},
error: function () {
canLog.error.apply(this, arguments);
},
_logger: canLog._logger
};
});
/*can-queues@1.1.0#queue-state*/
define('can-queues/queue-state', function (require, exports, module) {
module.exports = { lastTask: null };
});
/*can-assign@1.1.1#can-assign*/
define('can-assign', function (require, exports, module) {
module.exports = function (d, s) {
for (var prop in s) {
d[prop] = s[prop];
}
return d;
};
});
/*can-queues@1.1.0#queue*/
define('can-queues/queue', [
'require',
'exports',
'module',
'can-queues/queue-state',
'can-log/dev/dev',
'can-assign'
], function (require, exports, module) {
var queueState = require('can-queues/queue-state');
var canDev = require('can-log/dev/dev');
var assign = require('can-assign');
function noOperation() {
}
var Queue = function (name, callbacks) {
this.callbacks = assign({
onFirstTask: noOperation,
onComplete: function () {
queueState.lastTask = null;
}
}, callbacks || {});
this.name = name;
this.index = 0;
this.tasks = [];
this._log = false;
};
Queue.prototype.constructor = Queue;
Queue.noop = noOperation;
Queue.prototype.enqueue = function (fn, context, args, meta) {
var len = this.tasks.push({
fn: fn,
context: context,
args: args,
meta: meta || {}
});
this._logEnqueue(this.tasks[len - 1]);
if (len === 1) {
this.callbacks.onFirstTask(this);
}
};
Queue.prototype.flush = function () {
while (this.index < this.tasks.length) {
var task = this.tasks[this.index++];
this._logFlush(task);
task.fn.apply(task.context, task.args);
}
this.index = 0;
this.tasks = [];
this.callbacks.onComplete(this);
};
Queue.prototype.log = function () {
this._log = arguments.length ? arguments[0] : true;
};
Queue.prototype._logEnqueue = function (task) {
task.meta.parentTask = queueState.lastTask;
task.meta.stack = this;
if (this._log === true || this._log === 'enqueue') {
var log = task.meta.log ? task.meta.log.concat(task) : [
task.fn.name,
task
];
canDev.log.apply(canDev, [this.name + ' enqueuing:'].concat(log));
}
};
Queue.prototype._logFlush = function (task) {
if (this._log === true || this._log === 'flush') {
var log = task.meta.log ? task.meta.log.concat(task) : [
task.fn.name,
task
];
canDev.log.apply(canDev, [this.name + ' running :'].concat(log));
}
queueState.lastTask = task;
};
module.exports = Queue;
});
/*can-queues@1.1.0#priority-queue*/
define('can-queues/priority-queue', [
'require',
'exports',
'module',
'can-queues/queue'
], function (require, exports, module) {
var Queue = require('can-queues/queue');
var PriorityQueue = function () {
Queue.apply(this, arguments);
this.taskMap = new Map();
this.<API key> = [];
this.curPriorityIndex = Infinity;
this.curPriorityMax = 0;
this.isFlushing = false;
this.tasksRemaining = 0;
};
PriorityQueue.prototype = Object.create(Queue.prototype);
PriorityQueue.prototype.constructor = PriorityQueue;
PriorityQueue.prototype.enqueue = function (fn, context, args, meta) {
if (!this.taskMap.has(fn)) {
this.tasksRemaining++;
var isFirst = this.<API key>.length === 0;
var task = {
fn: fn,
context: context,
args: args,
meta: meta || {}
};
var taskContainer = this.<API key>(task);
taskContainer.tasks.push(task);
this.taskMap.set(fn, task);
this._logEnqueue(task);
if (isFirst) {
this.callbacks.onFirstTask(this);
}
}
};
PriorityQueue.prototype.<API key> = function (task) {
var priority = task.meta.priority || 0;
if (priority < this.curPriorityIndex) {
this.curPriorityIndex = priority;
}
if (priority > this.curPriorityMax) {
this.curPriorityMax = priority;
}
var tcByPriority = this.<API key>;
var taskContainer = tcByPriority[priority];
if (!taskContainer) {
taskContainer = tcByPriority[priority] = {
tasks: [],
index: 0
};
}
return taskContainer;
};
PriorityQueue.prototype.flush = function () {
if (this.isFlushing) {
return;
}
this.isFlushing = true;
while (true) {
if (this.curPriorityIndex <= this.curPriorityMax) {
var taskContainer = this.<API key>[this.curPriorityIndex];
if (taskContainer && taskContainer.tasks.length > taskContainer.index) {
var task = taskContainer.tasks[taskContainer.index++];
this._logFlush(task);
this.tasksRemaining
this.taskMap['delete'](task.fn);
task.fn.apply(task.context, task.args);
} else {
this.curPriorityIndex++;
}
} else {
this.taskMap = new Map();
this.curPriorityIndex = Infinity;
this.curPriorityMax = 0;
this.<API key> = [];
this.isFlushing = false;
this.callbacks.onComplete(this);
return;
}
}
};
PriorityQueue.prototype.isEnqueued = function (fn) {
return this.taskMap.has(fn);
};
PriorityQueue.prototype.flushQueuedTask = function (fn) {
var task = this.dequeue(fn);
if (task) {
this._logFlush(task);
task.fn.apply(task.context, task.args);
}
};
PriorityQueue.prototype.dequeue = function (fn) {
var task = this.taskMap.get(fn);
if (task) {
var priority = task.meta.priority || 0;
var taskContainer = this.<API key>[priority];
var index = taskContainer.tasks.indexOf(task, taskContainer.index);
if (index >= 0) {
taskContainer.tasks.splice(index, 1);
this.tasksRemaining
this.taskMap['delete'](task.fn);
return task;
} else {
console.warn('Task', fn, 'has already run');
}
}
};
PriorityQueue.prototype.tasksRemainingCount = function () {
return this.tasksRemaining;
};
module.exports = PriorityQueue;
});
/*can-queues@1.1.0#completion-queue*/
define('can-queues/completion-queue', [
'require',
'exports',
'module',
'can-queues/queue'
], function (require, exports, module) {
var Queue = require('can-queues/queue');
var CompletionQueue = function () {
Queue.apply(this, arguments);
this.flushCount = 0;
};
CompletionQueue.prototype = Object.create(Queue.prototype);
CompletionQueue.prototype.constructor = CompletionQueue;
CompletionQueue.prototype.flush = function () {
if (this.flushCount === 0) {
this.flushCount++;
while (this.index < this.tasks.length) {
var task = this.tasks[this.index++];
this._logFlush(task);
task.fn.apply(task.context, task.args);
}
this.index = 0;
this.tasks = [];
this.flushCount
this.callbacks.onComplete(this);
}
};
module.exports = CompletionQueue;
});
/*can-queues@1.1.0#can-queues*/
define('can-queues', [
'require',
'exports',
'module',
'can-log/dev/dev',
'can-queues/queue',
'can-queues/priority-queue',
'can-queues/queue-state',
'can-queues/completion-queue',
'can-namespace'
], function (require, exports, module) {
var canDev = require('can-log/dev/dev');
var Queue = require('can-queues/queue');
var PriorityQueue = require('can-queues/priority-queue');
var queueState = require('can-queues/queue-state');
var CompletionQueue = require('can-queues/completion-queue');
var ns = require('can-namespace');
var batchStartCounter = 0;
var addedTask = false;
var isFlushing = false;
var batchNum = 0;
var batchData;
var queueNames = [
'notify',
'derive',
'domUI',
'mutate'
];
var NOTIFY_QUEUE, DERIVE_QUEUE, DOM_UI_QUEUE, MUTATE_QUEUE;
NOTIFY_QUEUE = new Queue('NOTIFY', {
onComplete: function () {
DERIVE_QUEUE.flush();
},
onFirstTask: function () {
if (!batchStartCounter) {
NOTIFY_QUEUE.flush();
} else {
addedTask = true;
}
}
});
DERIVE_QUEUE = new PriorityQueue('DERIVE', {
onComplete: function () {
DOM_UI_QUEUE.flush();
},
onFirstTask: function () {
addedTask = true;
}
});
DOM_UI_QUEUE = new CompletionQueue('DOM_UI', {
onComplete: function () {
MUTATE_QUEUE.flush();
},
onFirstTask: function () {
addedTask = true;
}
});
MUTATE_QUEUE = new Queue('MUTATE', {
onComplete: function () {
queueState.lastTask = null;
isFlushing = false;
},
onFirstTask: function () {
addedTask = true;
}
});
var queues = {
Queue: Queue,
PriorityQueue: PriorityQueue,
CompletionQueue: CompletionQueue,
notifyQueue: NOTIFY_QUEUE,
deriveQueue: DERIVE_QUEUE,
domUIQueue: DOM_UI_QUEUE,
mutateQueue: MUTATE_QUEUE,
batch: {
start: function () {
batchStartCounter++;
if (batchStartCounter === 1) {
batchNum++;
batchData = { number: batchNum };
}
},
stop: function () {
batchStartCounter
if (batchStartCounter === 0) {
if (addedTask) {
addedTask = false;
isFlushing = true;
NOTIFY_QUEUE.flush();
}
}
},
isCollecting: function () {
return batchStartCounter > 0;
},
number: function () {
return batchNum;
},
data: function () {
return batchData;
}
},
enqueueByQueue: function enqueueByQueue(fnByQueue, context, args, makeMeta, reasonLog) {
if (fnByQueue) {
queues.batch.start();
queueNames.forEach(function (queueName) {
var name = queueName + 'Queue';
var QUEUE = queues[name];
var tasks = fnByQueue[queueName];
if (tasks !== undefined) {
tasks.forEach(function (fn) {
var meta = makeMeta != null ? makeMeta(fn, context, args) : {};
meta.reasonLog = reasonLog;
QUEUE.enqueue(fn, context, args, meta);
});
}
});
queues.batch.stop();
}
},
stack: function () {
var current = queueState.lastTask;
var stack = [];
while (current) {
stack.unshift(current);
current = current.meta.parentTask;
}
return stack;
},
logStack: function () {
var stack = this.stack();
stack.forEach(function (task, i) {
var meta = task.meta;
if (i === 0 && meta && meta.reasonLog) {
canDev.log.apply(canDev, meta.reasonLog);
}
var log = meta && meta.log ? meta.log : [
task.fn.name,
task
];
canDev.log.apply(canDev, [task.meta.stack.name + ' ran task:'].concat(log));
});
},
taskCount: function () {
return NOTIFY_QUEUE.tasks.length + DERIVE_QUEUE.tasks.length + DOM_UI_QUEUE.tasks.length + MUTATE_QUEUE.tasks.length;
},
flush: function () {
NOTIFY_QUEUE.flush();
},
log: function () {
NOTIFY_QUEUE.log.apply(NOTIFY_QUEUE, arguments);
DERIVE_QUEUE.log.apply(DERIVE_QUEUE, arguments);
DOM_UI_QUEUE.log.apply(DOM_UI_QUEUE, arguments);
MUTATE_QUEUE.log.apply(MUTATE_QUEUE, arguments);
}
};
if (ns.queues) {
throw new Error('You can\'t have two versions of can-queues, check your dependencies');
} else {
module.exports = ns.queues = queues;
}
});
/*<API key>@1.1.2#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-namespace',
'can-symbol'
], function (require, exports, module) {
var namespace = require('can-namespace');
var canSymbol = require('can-symbol');
var stack = [];
var addParentSymbol = canSymbol.for('can.addParent');
var ObservationRecorder = {
stack: stack,
start: function () {
var deps = {
keyDependencies: new Map(),
valueDependencies: new Set(),
childDependencies: new Set(),
traps: null,
ignore: 0
};
stack.push(deps);
return deps;
},
stop: function () {
return stack.pop();
},
add: function (obj, event) {
var top = stack[stack.length - 1];
if (top && top.ignore === 0) {
if (top.traps) {
top.traps.push([
obj,
event
]);
} else {
if (event === undefined) {
top.valueDependencies.add(obj);
} else {
var eventSet = top.keyDependencies.get(obj);
if (!eventSet) {
eventSet = new Set();
top.keyDependencies.set(obj, eventSet);
}
eventSet.add(event);
}
}
}
},
addMany: function (observes) {
var top = stack[stack.length - 1];
if (top) {
if (top.traps) {
top.traps.push.apply(top.traps, observes);
} else {
for (var i = 0, len = observes.length; i < len; i++) {
this.add(observes[i][0], observes[i][1]);
}
}
}
},
created: function (obs) {
var top = stack[stack.length - 1];
if (top) {
top.childDependencies.add(obs);
if (obs[addParentSymbol]) {
obs[addParentSymbol](top);
}
}
},
ignore: function (fn) {
return function () {
if (stack.length) {
var top = stack[stack.length - 1];
top.ignore++;
var res = fn.apply(this, arguments);
top.ignore
return res;
} else {
return fn.apply(this, arguments);
}
};
},
isRecording: function () {
var len = stack.length;
var last = len && stack[len - 1];
return last && last.ignore === 0 && last;
},
<API key>: function () {
return {
traps: null,
keyDependencies: new Map(),
valueDependencies: new Set(),
ignore: 0
};
},
<API key>: function () {
return ObservationRecorder.<API key>();
},
trap: function () {
if (stack.length) {
var top = stack[stack.length - 1];
var oldTraps = top.traps;
var traps = top.traps = [];
return function () {
top.traps = oldTraps;
return traps;
};
} else {
return function () {
return [];
};
}
},
trapsCount: function () {
if (stack.length) {
var top = stack[stack.length - 1];
return top.traps.length;
} else {
return 0;
}
}
};
if (namespace.ObservationRecorder) {
throw new Error('You can\'t have two versions of <API key>, check your dependencies');
} else {
module.exports = namespace.ObservationRecorder = ObservationRecorder;
}
});
/*can-key-tree@1.0.2#can-key-tree*/
define('can-key-tree', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var reflect = require('can-reflect');
function isBuiltInPrototype(obj) {
if (obj === Object.prototype) {
return true;
}
var protoString = Object.prototype.toString.call(obj);
var isNotObjObj = protoString !== '[object Object]';
var isObjSomething = protoString.indexOf('[object ') !== -1;
return isNotObjObj && isObjSomething;
}
function getDeepSize(root, level) {
if (level === 0) {
return reflect.size(root);
} else if (reflect.size(root) === 0) {
return 0;
} else {
var count = 0;
reflect.each(root, function (value) {
count += getDeepSize(value, level - 1);
});
return count;
}
}
function getDeep(node, items, depth, maxDepth) {
if (!node) {
return;
}
if (maxDepth === depth) {
if (reflect.<API key>(node)) {
reflect.addValues(items, reflect.toArray(node));
} else {
throw new Error('can-key-tree: Map-type leaf containers are not supported yet.');
}
} else {
reflect.each(node, function (value) {
getDeep(value, items, depth + 1, maxDepth);
});
}
}
function clearDeep(node, keys, maxDepth, deleteHandler) {
if (maxDepth === keys.length) {
if (reflect.<API key>(node)) {
var valuesToRemove = reflect.toArray(node);
if (deleteHandler) {
valuesToRemove.forEach(function (value) {
deleteHandler.apply(null, keys.concat(value));
});
}
reflect.removeValues(node, valuesToRemove);
} else {
throw new Error('can-key-tree: Map-type leaf containers are not supported yet.');
}
} else {
reflect.each(node, function (value, key) {
clearDeep(value, keys.concat(key), maxDepth, deleteHandler);
reflect.deleteKeyValue(node, key);
});
}
}
var KeyTree = function (treeStructure, callbacks) {
this.callbacks = callbacks || {};
this.treeStructure = treeStructure;
var FirstConstructor = treeStructure[0];
if (reflect.isConstructorLike(FirstConstructor)) {
this.root = new FirstConstructor();
} else {
this.root = FirstConstructor;
}
};
reflect.assign(KeyTree.prototype, {
add: function (keys) {
if (keys.length > this.treeStructure.length) {
throw new Error('can-key-tree: Can not add path deeper than tree.');
}
var place = this.root;
var rootWasEmpty = reflect.size(this.root) === 0;
for (var i = 0; i < keys.length - 1; i++) {
var key = keys[i];
var childNode = reflect.getKeyValue(place, key);
if (!childNode) {
var Constructor = this.treeStructure[i + 1];
if (isBuiltInPrototype(Constructor.prototype)) {
childNode = new Constructor();
} else {
childNode = new Constructor(key);
}
reflect.setKeyValue(place, key, childNode);
}
place = childNode;
}
if (reflect.<API key>(place)) {
reflect.addValues(place, [keys[keys.length - 1]]);
} else {
throw new Error('can-key-tree: Map types are not supported yet.');
}
if (rootWasEmpty && this.callbacks.onFirst) {
this.callbacks.onFirst.call(this);
}
return this;
},
getNode: function (keys) {
var node = this.root;
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
node = reflect.getKeyValue(node, key);
if (!node) {
return;
}
}
return node;
},
get: function (keys) {
var node = this.getNode(keys);
if (this.treeStructure.length === keys.length) {
return node;
} else {
var Type = this.treeStructure[this.treeStructure.length - 1];
var items = new Type();
getDeep(node, items, keys.length, this.treeStructure.length - 1);
return items;
}
},
delete: function (keys, deleteHandler) {
var parentNode = this.root, path = [this.root], lastKey = keys[keys.length - 1];
for (var i = 0; i < keys.length - 1; i++) {
var key = keys[i];
var childNode = reflect.getKeyValue(parentNode, key);
if (childNode === undefined) {
return false;
} else {
path.push(childNode);
}
parentNode = childNode;
}
if (!keys.length) {
clearDeep(parentNode, [], this.treeStructure.length - 1, deleteHandler);
} else if (keys.length === this.treeStructure.length) {
if (reflect.<API key>(parentNode)) {
if (deleteHandler) {
deleteHandler.apply(null, keys.concat(lastKey));
}
reflect.removeValues(parentNode, [lastKey]);
} else {
throw new Error('can-key-tree: Map types are not supported yet.');
}
} else {
var nodeToRemove = reflect.getKeyValue(parentNode, lastKey);
if (nodeToRemove !== undefined) {
clearDeep(nodeToRemove, keys, this.treeStructure.length - 1, deleteHandler);
reflect.deleteKeyValue(parentNode, lastKey);
} else {
return false;
}
}
for (i = path.length - 2; i >= 0; i
if (reflect.size(parentNode) === 0) {
parentNode = path[i];
reflect.deleteKeyValue(parentNode, keys[i]);
} else {
break;
}
}
if (this.callbacks.onEmpty && reflect.size(this.root) === 0) {
this.callbacks.onEmpty.call(this);
}
return true;
},
size: function () {
return getDeepSize(this.root, this.treeStructure.length - 1);
}
});
module.exports = KeyTree;
});
/*<API key>@1.0.2#define-lazy-value*/
define('<API key>', function (require, exports, module) {
module.exports = function defineLazyValue(obj, prop, initializer, writable) {
Object.defineProperty(obj, prop, {
configurable: true,
get: function () {
Object.defineProperty(this, prop, {
value: undefined,
writable: true
});
var value = initializer.call(this, obj, prop);
Object.defineProperty(this, prop, {
value: value,
writable: !!writable
});
return value;
},
set: function (value) {
Object.defineProperty(this, prop, {
value: value,
writable: !!writable
});
return value;
}
});
};
});
/*can-event-queue@1.0.1#dependency-record/merge*/
define('can-event-queue/dependency-record/merge', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var <API key> = function <API key>(obj, source) {
var sourceValueDeps = source.valueDependencies;
if (sourceValueDeps) {
var destValueDeps = obj.valueDependencies;
if (!destValueDeps) {
destValueDeps = new Set();
obj.valueDependencies = destValueDeps;
}
canReflect.eachIndex(sourceValueDeps, function (dep) {
destValueDeps.add(dep);
});
}
};
var <API key> = function <API key>(obj, source) {
var sourcekeyDeps = source.keyDependencies;
if (sourcekeyDeps) {
var destKeyDeps = obj.keyDependencies;
if (!destKeyDeps) {
destKeyDeps = new Map();
obj.keyDependencies = destKeyDeps;
}
canReflect.eachKey(sourcekeyDeps, function (keys, obj) {
var entry = destKeyDeps.get(obj);
if (!entry) {
entry = new Set();
destKeyDeps.set(obj, entry);
}
canReflect.eachIndex(keys, function (key) {
entry.add(key);
});
});
}
};
module.exports = function <API key>(object, source) {
<API key>(object, source);
<API key>(object, source);
return object;
};
});
/*can-event-queue@1.0.1#value/value*/
define('can-event-queue/value/value', [
'require',
'exports',
'module',
'can-queues',
'can-key-tree',
'can-reflect',
'<API key>',
'can-event-queue/dependency-record/merge'
], function (require, exports, module) {
var queues = require('can-queues');
var KeyTree = require('can-key-tree');
var canReflect = require('can-reflect');
var defineLazyValue = require('<API key>');
var <API key> = require('can-event-queue/dependency-record/merge');
var properties = {
on: function (handler, queue) {
this.handlers.add([
queue || 'mutate',
handler
]);
},
off: function (handler, queueName) {
if (handler === undefined) {
if (queueName === undefined) {
this.handlers.delete([]);
} else {
this.handlers.delete([queueName]);
}
} else {
this.handlers.delete([
queueName || 'mutate',
handler
]);
}
}
};
var symbols = {
'can.onValue': properties.on,
'can.offValue': properties.off,
'can.dispatch': function (value, old) {
queues.enqueueByQueue(this.handlers.getNode([]), this, [
value,
old
], null, [
canReflect.getName(this),
'changed to',
value,
'from',
old
]);
if (typeof this._log === 'function') {
this._log(old, value);
}
},
'can.getWhatIChange': function getWhatIChange() {
var whatIChange = {};
var notifyHandlers = this.handlers.get(['notify']);
var mutateHandlers = [].concat(this.handlers.get(['mutate']), this.handlers.get(['domUI']));
if (notifyHandlers.length) {
notifyHandlers.forEach(function (handler) {
var changes = canReflect.<API key>(handler);
if (changes) {
var record = whatIChange.derive;
if (!record) {
record = whatIChange.derive = {};
}
<API key>(record, changes);
}
});
}
if (mutateHandlers.length) {
mutateHandlers.forEach(function (handler) {
var changes = canReflect.<API key>(handler);
if (changes) {
var record = whatIChange.mutate;
if (!record) {
record = whatIChange.mutate = {};
}
<API key>(record, changes);
}
});
}
return Object.keys(whatIChange).length ? whatIChange : undefined;
},
'can.isBound': function isBound() {
return this.handlers.size() > 0;
}
};
function defineLazyHandlers() {
return new KeyTree([
Object,
Array
], {
onFirst: this.onBound !== undefined && this.onBound.bind(this),
onEmpty: this.onUnbound !== undefined && this.onUnbound.bind(this)
});
}
var <API key> = function (obj) {
canReflect.assign(obj, properties);
canReflect.assignSymbols(obj, symbols);
defineLazyValue(obj, 'handlers', defineLazyHandlers, true);
return obj;
};
<API key>.addHandlers = function (obj, callbacks) {
console.warn('can-event-queue/value: Avoid using addHandlers. Add onBound and onUnbound methods instead.');
obj.handlers = new KeyTree([
Object,
Array
], callbacks);
return obj;
};
module.exports = <API key>;
});
/*can-observation@4.0.1#<API key>*/
define('can-observation/<API key>', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
function <API key>(event) {
if (this.oldEventSet === undefined || this.oldEventSet['delete'](event) === false) {
canReflect.onKeyValue(this.observable, event, this.onDependencyChange, 'notify');
}
}
function <API key>(eventSet, observable) {
eventSet.forEach(<API key>, {
onDependencyChange: this.onDependencyChange,
observable: observable,
oldEventSet: this.oldDependencies.keyDependencies.get(observable)
});
}
function <API key>(event) {
canReflect.offKeyValue(this.observable, event, this.onDependencyChange, 'notify');
}
function <API key>(oldEventSet, observable) {
oldEventSet.forEach(<API key>, {
onDependencyChange: this.onDependencyChange,
observable: observable
});
}
function <API key>(observable) {
if (this.oldDependencies.valueDependencies.delete(observable) === false) {
canReflect.onValue(observable, this.onDependencyChange, 'notify');
}
}
function <API key>(observable) {
canReflect.offValue(observable, this.onDependencyChange, 'notify');
}
module.exports = {
updateObservations: function (observationData) {
observationData.newDependencies.keyDependencies.forEach(<API key>, observationData);
observationData.oldDependencies.keyDependencies.forEach(<API key>, observationData);
observationData.newDependencies.valueDependencies.forEach(<API key>, observationData);
observationData.oldDependencies.valueDependencies.forEach(<API key>, observationData);
},
stopObserving: function (observationReciever, onDependencyChange) {
observationReciever.keyDependencies.forEach(<API key>, { onDependencyChange: onDependencyChange });
observationReciever.valueDependencies.forEach(<API key>, { onDependencyChange: onDependencyChange });
}
};
});
/*can-observation@4.0.1#temporarily-bind*/
define('can-observation/temporarily-bind', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var <API key> = function () {
};
var observables;
var <API key> = function () {
for (var i = 0, len = observables.length; i < len; i++) {
canReflect.offValue(observables[i], <API key>);
}
observables = null;
};
function temporarilyBind(compute) {
var computeInstance = compute.computeInstance || compute;
canReflect.onValue(computeInstance, <API key>);
if (!observables) {
observables = [];
setTimeout(<API key>, 10);
}
observables.push(computeInstance);
}
module.exports = temporarilyBind;
});
/*can-observation@4.0.1#can-observation*/
define('can-observation', [
'require',
'exports',
'module',
'can-namespace',
'can-reflect',
'can-queues',
'<API key>',
'can-symbol',
'can-log/dev/dev',
'can-event-queue/value/value',
'can-observation/<API key>',
'can-observation/temporarily-bind'
], function (require, exports, module) {
(function (global, require, exports, module) {
var namespace = require('can-namespace');
var canReflect = require('can-reflect');
var queues = require('can-queues');
var ObservationRecorder = require('<API key>');
var canSymbol = require('can-symbol');
var dev = require('can-log/dev/dev');
var valueEventBindings = require('can-event-queue/value/value');
var recorderHelpers = require('can-observation/<API key>');
var temporarilyBind = require('can-observation/temporarily-bind');
var dispatchSymbol = canSymbol.for('can.dispatch');
var getChangesSymbol = canSymbol.for('can.<API key>');
var <API key> = canSymbol.for('can.<API key>');
function Observation(func, context, options) {
this.func = func;
this.context = context;
this.options = options || {
priority: 0,
isObservable: true
};
this.bound = false;
this.newDependencies = ObservationRecorder.<API key>();
this.oldDependencies = null;
var self = this;
this.onDependencyChange = function (newVal) {
self.dependencyChange(this, newVal);
};
this.update = this.update.bind(this);
this.onDependencyChange[getChangesSymbol] = function getChanges() {
return { valueDependencies: new Set([self]) };
};
Object.defineProperty(this.onDependencyChange, 'name', { value: canReflect.getName(this) + '.onDependencyChange' });
Object.defineProperty(this.update, 'name', { value: canReflect.getName(this) + '.update' });
}
valueEventBindings(Observation.prototype);
canReflect.assign(Observation.prototype, {
onBound: function () {
this.bound = true;
this.oldDependencies = this.newDependencies;
ObservationRecorder.start();
this.value = this.func.call(this.context);
this.newDependencies = ObservationRecorder.stop();
recorderHelpers.updateObservations(this);
},
dependencyChange: function (context, args) {
if (this.bound === true) {
queues.deriveQueue.enqueue(this.update, this, [], {
priority: this.options.priority,
log: [canReflect.getName(this.update)]
}, [
canReflect.getName(context),
'changed'
]);
}
},
update: function () {
if (this.bound === true) {
var oldValue = this.value;
this.oldValue = null;
this.onBound();
if (oldValue !== this.value) {
this[dispatchSymbol](this.value, oldValue);
}
}
},
onUnbound: function () {
this.bound = false;
recorderHelpers.stopObserving(this.newDependencies, this.onDependencyChange);
this.newDependencies = ObservationRecorder.<API key>();
},
get: function () {
if (this.options.isObservable && ObservationRecorder.isRecording()) {
ObservationRecorder.add(this);
if (!this.bound) {
Observation.temporarilyBind(this);
}
}
if (this.bound === true) {
if (queues.deriveQueue.tasksRemainingCount() > 0) {
Observation.<API key>(this);
}
return this.value;
} else {
return this.func.call(this.context);
}
},
hasDependencies: function () {
var newDependencies = this.newDependencies;
return this.bound ? newDependencies.valueDependencies.size + newDependencies.keyDependencies.size > 0 : undefined;
},
log: function () {
var quoteString = function quoteString(x) {
return typeof x === 'string' ? JSON.stringify(x) : x;
};
this._log = function (previous, current) {
dev.log(canReflect.getName(this), '\n is ', quoteString(current), '\n was ', quoteString(previous));
};
}
});
canReflect.assignSymbols(Observation.prototype, {
'can.getValue': Observation.prototype.get,
'can.isValueLike': true,
'can.isMapLike': false,
'can.isListLike': false,
'can.<API key>': Observation.prototype.hasDependencies,
'can.<API key>': function () {
if (this.bound === true) {
var deps = this.newDependencies, result = {};
if (deps.keyDependencies.size) {
result.keyDependencies = deps.keyDependencies;
}
if (deps.valueDependencies.size) {
result.valueDependencies = deps.valueDependencies;
}
return result;
}
return undefined;
},
'can.getPriority': function () {
return this.options.priority;
},
'can.setPriority': function (priority) {
this.options.priority = priority;
},
'can.getName': function () {
return canReflect.getName(this.constructor) + '<' + canReflect.getName(this.func) + '>';
}
});
Observation.<API key> = function (observation) {
if (observation.update !== undefined && queues.deriveQueue.isEnqueued(observation.update) === true) {
queues.deriveQueue.flushQueuedTask(observation.update);
return true;
}
if (observation[<API key>]) {
var childHasChanged = false;
var valueDependencies = observation[<API key>]().valueDependencies || [];
valueDependencies.forEach(function (observable) {
if (Observation.<API key>(observable) === true) {
childHasChanged = true;
}
});
return childHasChanged;
} else {
return false;
}
};
var alias = { addAll: 'addMany' };
[
'add',
'addAll',
'ignore',
'trap',
'trapsCount',
'isRecording'
].forEach(function (methodName) {
Observation[methodName] = function () {
var name = alias[methodName] ? alias[methodName] : methodName;
console.warn('can-observation: Call ' + name + '() on <API key>.');
return ObservationRecorder[name].apply(this, arguments);
};
});
Observation.prototype.start = function () {
console.warn('can-observation: Use .on and .off to bind.');
return this.onBound();
};
Observation.prototype.stop = function () {
console.warn('can-observation: Use .on and .off to bind.');
return this.onUnbound();
};
Observation.temporarilyBind = temporarilyBind;
module.exports = namespace.Observation = Observation;
}(function () {
return this;
}(), require, exports, module));
});
/*<API key>@2.0.5#log*/
define('<API key>/log', [
'require',
'exports',
'module',
'can-log/dev/dev',
'can-reflect'
], function (require, exports, module) {
var dev = require('can-log/dev/dev');
var canReflect = require('can-reflect');
function quoteString(x) {
return typeof x === 'string' ? JSON.stringify(x) : x;
}
module.exports = function log() {
this._log = function (previous, current) {
dev.log(canReflect.getName(this), '\n is ', quoteString(current), '\n was ', quoteString(previous));
};
};
});
/*<API key>@2.0.5#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'<API key>/log',
'can-namespace',
'can-symbol',
'can-reflect',
'<API key>',
'can-event-queue/value/value'
], function (require, exports, module) {
var log = require('<API key>/log');
var ns = require('can-namespace');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var ObservationRecorder = require('<API key>');
var valueEventBindings = require('can-event-queue/value/value');
var dispatchSymbol = canSymbol.for('can.dispatch');
function SimpleObservable(initialValue) {
this.value = initialValue;
}
valueEventBindings(SimpleObservable.prototype);
Object.assign(SimpleObservable.prototype, {
log: log,
get: function () {
ObservationRecorder.add(this);
return this.value;
},
set: function (value) {
var old = this.value;
this.value = value;
this[dispatchSymbol](value, old);
}
});
canReflect.assignSymbols(SimpleObservable.prototype, {
'can.getValue': SimpleObservable.prototype.get,
'can.setValue': SimpleObservable.prototype.set,
'can.isMapLike': false,
'can.<API key>': function () {
return true;
},
'can.getName': function () {
var value = this.value;
if (typeof value !== 'object' || value === null) {
value = JSON.stringify(value);
} else {
value = '';
}
return canReflect.getName(this.constructor) + '<' + value + '>';
}
});
module.exports = ns.SimpleObservable = SimpleObservable;
});
/*<API key>@2.0.5#settable/settable*/
define('<API key>/settable/settable', [
'require',
'exports',
'module',
'can-reflect',
'<API key>',
'<API key>',
'can-observation',
'can-queues',
'<API key>/log',
'can-event-queue/value/value'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var ObservationRecorder = require('<API key>');
var SimpleObservable = require('<API key>');
var Observation = require('can-observation');
var queues = require('can-queues');
var log = require('<API key>/log');
var valueEventBindings = require('can-event-queue/value/value');
var peek = ObservationRecorder.ignore(canReflect.getValue.bind(canReflect));
function SettableObservable(fn, context, initialValue) {
this.lastSetValue = new SimpleObservable(initialValue);
function observe() {
return fn.call(context, this.lastSetValue.get());
}
this.handler = this.handler.bind(this);
canReflect.assignSymbols(this, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '<' + canReflect.getName(fn) + '>';
}
});
Object.defineProperty(this.handler, 'name', { value: canReflect.getName(this) + '.handler' });
Object.defineProperty(observe, 'name', { value: canReflect.getName(fn) + '::' + canReflect.getName(this.constructor) });
this.observation = new Observation(observe, this);
}
valueEventBindings(SettableObservable.prototype);
Object.assign(SettableObservable.prototype, {
log: log,
constructor: SettableObservable,
handler: function (newVal) {
var old = this.value;
this.value = newVal;
if (typeof this._log === 'function') {
this._log(old, newVal);
}
queues.enqueueByQueue(this.handlers.getNode([]), this, [
newVal,
old
], function () {
return {};
});
},
onBound: function () {
if (!this.bound) {
this.bound = true;
this.activate();
}
},
activate: function () {
canReflect.onValue(this.observation, this.handler, 'notify');
this.value = peek(this.observation);
},
onUnbound: function () {
this.bound = false;
canReflect.offValue(this.observation, this.handler, 'notify');
},
set: function (newVal) {
var oldVal = this.lastSetValue.get();
if (canReflect.isObservableLike(oldVal) && canReflect.isValueLike(oldVal) && !canReflect.isObservableLike(newVal)) {
canReflect.setValue(oldVal, newVal);
} else {
if (newVal !== oldVal) {
this.lastSetValue.set(newVal);
}
}
},
get: function () {
if (ObservationRecorder.isRecording()) {
ObservationRecorder.add(this);
if (!this.bound) {
this.onBound();
}
}
if (this.bound === true) {
return this.value;
} else {
return this.observation.get();
}
},
hasDependencies: function () {
return canReflect.<API key>(this.observation);
},
<API key>: function () {
return canReflect.<API key>(this.observation);
}
});
canReflect.assignSymbols(SettableObservable.prototype, {
'can.getValue': SettableObservable.prototype.get,
'can.setValue': SettableObservable.prototype.set,
'can.isMapLike': false,
'can.getPriority': function () {
return canReflect.getPriority(this.observation);
},
'can.setPriority': function (newPriority) {
canReflect.setPriority(this.observation, newPriority);
},
'can.<API key>': SettableObservable.prototype.hasDependencies,
'can.<API key>': SettableObservable.prototype.<API key>
});
module.exports = SettableObservable;
});
/*<API key>@2.0.5#async/async*/
define('<API key>/async/async', [
'require',
'exports',
'module',
'<API key>',
'can-observation',
'can-queues',
'<API key>/settable/settable',
'can-reflect',
'<API key>',
'can-event-queue/value/value'
], function (require, exports, module) {
var SimpleObservable = require('<API key>');
var Observation = require('can-observation');
var queues = require('can-queues');
var SettableObservable = require('<API key>/settable/settable');
var canReflect = require('can-reflect');
var ObservationRecorder = require('<API key>');
var valueEventBindings = require('can-event-queue/value/value');
function AsyncObservable(fn, context, initialValue) {
this.resolve = this.resolve.bind(this);
this.lastSetValue = new SimpleObservable(initialValue);
this.handler = this.handler.bind(this);
function observe() {
this.resolveCalled = false;
this.inGetter = true;
var newVal = fn.call(context, this.lastSetValue.get(), this.bound === true ? this.resolve : undefined);
this.inGetter = false;
if (newVal !== undefined) {
this.resolve(newVal);
} else if (this.resolveCalled) {
this.resolve(this.value);
}
if (this.bound !== true) {
return newVal;
}
}
canReflect.assignSymbols(this, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '<' + canReflect.getName(fn) + '>';
}
});
Object.defineProperty(this.handler, 'name', { value: canReflect.getName(this) + '.handler' });
Object.defineProperty(observe, 'name', { value: canReflect.getName(fn) + '::' + canReflect.getName(this.constructor) });
this.observation = new Observation(observe, this);
}
AsyncObservable.prototype = Object.create(SettableObservable.prototype);
AsyncObservable.prototype.constructor = AsyncObservable;
AsyncObservable.prototype.handler = function (newVal) {
if (newVal !== undefined) {
SettableObservable.prototype.handler.apply(this, arguments);
}
};
var peek = ObservationRecorder.ignore(canReflect.getValue.bind(canReflect));
AsyncObservable.prototype.activate = function () {
canReflect.onValue(this.observation, this.handler, 'notify');
if (!this.resolveCalled) {
this.value = peek(this.observation);
}
};
AsyncObservable.prototype.resolve = function resolve(newVal) {
this.resolveCalled = true;
var old = this.value;
this.value = newVal;
if (typeof this._log === 'function') {
this._log(old, newVal);
}
if (!this.inGetter) {
queues.enqueueByQueue(this.handlers.getNode([]), this, [
newVal,
old
], null, [
canReflect.getName(this),
'resolved with',
newVal
]);
}
};
module.exports = AsyncObservable;
});
/*can-globals@1.1.1#can-globals-proto*/
define('can-globals/can-globals-proto', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
function dispatch(key) {
var handlers = this.eventHandlers[key];
if (handlers) {
var handlersCopy = handlers.slice();
var value = this.getKeyValue(key);
for (var i = 0; i < handlersCopy.length; i++) {
handlersCopy[i](value);
}
}
}
function Globals() {
this.eventHandlers = {};
this.properties = {};
}
Globals.prototype.define = function (key, value, enableCache) {
if (enableCache === undefined) {
enableCache = true;
}
if (!this.properties[key]) {
this.properties[key] = {
default: value,
value: value,
enableCache: enableCache
};
}
return this;
};
Globals.prototype.getKeyValue = function (key) {
var property = this.properties[key];
if (property) {
if (typeof property.value === 'function') {
if (property.cachedValue) {
return property.cachedValue;
}
if (property.enableCache) {
property.cachedValue = property.value();
return property.cachedValue;
} else {
return property.value();
}
}
return property.value;
}
};
Globals.prototype.makeExport = function (key) {
return function (value) {
if (arguments.length === 0) {
return this.getKeyValue(key);
}
if (typeof value === 'undefined' || value === null) {
this.deleteKeyValue(key);
} else {
if (typeof value === 'function') {
this.setKeyValue(key, function () {
return value;
});
} else {
this.setKeyValue(key, value);
}
return value;
}
}.bind(this);
};
Globals.prototype.offKeyValue = function (key, handler) {
if (this.properties[key]) {
var handlers = this.eventHandlers[key];
if (handlers) {
var i = handlers.indexOf(handler);
handlers.splice(i, 1);
}
}
return this;
};
Globals.prototype.onKeyValue = function (key, handler) {
if (this.properties[key]) {
if (!this.eventHandlers[key]) {
this.eventHandlers[key] = [];
}
this.eventHandlers[key].push(handler);
}
return this;
};
Globals.prototype.deleteKeyValue = function (key) {
var property = this.properties[key];
if (property !== undefined) {
property.value = property.default;
property.cachedValue = undefined;
dispatch.call(this, key);
}
return this;
};
Globals.prototype.setKeyValue = function (key, value) {
if (!this.properties[key]) {
return this.define(key, value);
}
var property = this.properties[key];
property.value = value;
property.cachedValue = undefined;
dispatch.call(this, key);
return this;
};
Globals.prototype.reset = function () {
for (var key in this.properties) {
if (this.properties.hasOwnProperty(key)) {
this.properties[key].value = this.properties[key].default;
this.properties[key].cachedValue = undefined;
dispatch.call(this, key);
}
}
return this;
};
canReflect.assignSymbols(Globals.prototype, {
'can.getKeyValue': Globals.prototype.getKeyValue,
'can.setKeyValue': Globals.prototype.setKeyValue,
'can.deleteKeyValue': Globals.prototype.deleteKeyValue,
'can.onKeyValue': Globals.prototype.onKeyValue,
'can.offKeyValue': Globals.prototype.offKeyValue
});
module.exports = Globals;
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#<API key>*/
define('can-globals/<API key>', [
'require',
'exports',
'module',
'can-namespace',
'can-globals/can-globals-proto'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var namespace = require('can-namespace');
var Globals = require('can-globals/can-globals-proto');
var globals = new Globals();
if (namespace.globals) {
throw new Error('You can\'t have two versions of can-globals, check your dependencies');
} else {
module.exports = namespace.globals = globals;
}
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#global/global*/
define('can-globals/global/global', [
'require',
'exports',
'module',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals/<API key>');
globals.define('global', function () {
return typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self : typeof process === 'object' && {}.toString.call(process) === '[object process]' ? global : window;
});
module.exports = globals.makeExport('global');
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#document/document*/
define('can-globals/document/document', [
'require',
'exports',
'module',
'can-globals/global/global',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
require('can-globals/global/global');
var globals = require('can-globals/<API key>');
globals.define('document', function () {
return globals.getKeyValue('global').document;
});
module.exports = globals.makeExport('document');
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#is-node/is-node*/
define('can-globals/is-node/is-node', [
'require',
'exports',
'module',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals/<API key>');
globals.define('isNode', function () {
return typeof process === 'object' && {}.toString.call(process) === '[object process]';
});
module.exports = globals.makeExport('isNode');
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#is-browser-window/is-browser-window*/
define('can-globals/is-browser-window/is-browser-window', [
'require',
'exports',
'module',
'can-globals/<API key>',
'can-globals/is-node/is-node'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals/<API key>');
require('can-globals/is-node/is-node');
globals.define('isBrowserWindow', function () {
var isNode = globals.getKeyValue('isNode');
return typeof window !== 'undefined' && typeof document !== 'undefined' && isNode === false;
});
module.exports = globals.makeExport('isBrowserWindow');
}(function () {
return this;
}(), require, exports, module));
});
/*can-dom-events@1.2.0#helpers/util*/
define('can-dom-events/helpers/util', [
'require',
'exports',
'module',
'can-globals/document/document',
'can-globals/is-browser-window/is-browser-window'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var getCurrentDocument = require('can-globals/document/document');
var isBrowserWindow = require('can-globals/is-browser-window/is-browser-window');
function getTargetDocument(target) {
return target.ownerDocument || getCurrentDocument();
}
function createEvent(target, eventData, bubbles, cancelable) {
var doc = getTargetDocument(target);
var event = doc.createEvent('HTMLEvents');
var eventType;
if (typeof eventData === 'string') {
eventType = eventData;
} else {
eventType = eventData.type;
for (var prop in eventData) {
if (event[prop] === undefined) {
event[prop] = eventData[prop];
}
}
}
if (bubbles === undefined) {
bubbles = true;
}
event.initEvent(eventType, bubbles, cancelable);
return event;
}
function isDomEventTarget(obj) {
if (!(obj && obj.nodeName)) {
return obj === window;
}
var nodeType = obj.nodeType;
return nodeType === 1 || nodeType === 9 || nodeType === 11;
}
function addDomContext(context, args) {
if (isDomEventTarget(context)) {
args = Array.prototype.slice.call(args, 0);
args.unshift(context);
}
return args;
}
function removeDomContext(context, args) {
if (!isDomEventTarget(context)) {
args = Array.prototype.slice.call(args, 0);
context = args.shift();
}
return {
context: context,
args: args
};
}
var <API key> = false;
(function () {
if (!isBrowserWindow()) {
return;
}
var testEventName = '<API key>';
var input = document.createElement('input');
input.disabled = true;
var timer = setTimeout(function () {
<API key> = true;
}, 50);
var onTest = function onTest() {
clearTimeout(timer);
input.removeEventListener(testEventName, onTest);
};
input.addEventListener(testEventName, onTest);
try {
var event = document.create('HTMLEvents');
event.initEvent(testEventName, false);
input.dispatchEvent(event);
} catch (e) {
onTest();
<API key> = true;
}
}());
function <API key>(element, event) {
var eventType = event.type;
var isInsertedOrRemoved = eventType === 'inserted' || eventType === 'removed';
var isDisabled = !!element.disabled;
return isInsertedOrRemoved && isDisabled;
}
function <API key>(element, event) {
return <API key> && <API key>(element, event);
}
module.exports = {
createEvent: createEvent,
addDomContext: addDomContext,
removeDomContext: removeDomContext,
isDomEventTarget: isDomEventTarget,
getTargetDocument: getTargetDocument,
<API key>: <API key>
};
}(function () {
return this;
}(), require, exports, module));
});
/*can-dom-events@1.2.0#helpers/make-event-registry*/
define('can-dom-events/helpers/make-event-registry', function (require, exports, module) {
'use strict';
function EventRegistry() {
this._registry = {};
}
module.exports = function makeEventRegistry() {
return new EventRegistry();
};
EventRegistry.prototype.has = function (eventType) {
return !!this._registry[eventType];
};
EventRegistry.prototype.get = function (eventType) {
return this._registry[eventType];
};
EventRegistry.prototype.add = function (event, eventType) {
if (!event) {
throw new Error('An EventDefinition must be provided');
}
if (typeof event.addEventListener !== 'function') {
throw new TypeError('EventDefinition addEventListener must be a function');
}
if (typeof event.removeEventListener !== 'function') {
throw new TypeError('EventDefinition removeEventListener must be a function');
}
eventType = eventType || event.defaultEventType;
if (typeof eventType !== 'string') {
throw new TypeError('Event type must be a string, not ' + eventType);
}
if (this.has(eventType)) {
throw new Error('Event "' + eventType + '" is already registered');
}
this._registry[eventType] = event;
var self = this;
return function remove() {
self._registry[eventType] = undefined;
};
};
});
/*can-dom-events@1.2.0#helpers/-<API key>*/
define('can-dom-events/helpers/-<API key>', [
'require',
'exports',
'module',
'can-key-tree',
'can-reflect'
], function (require, exports, module) {
var KeyTree = require('can-key-tree');
var canReflect = require('can-reflect');
var useCapture = function (eventType) {
return eventType === 'focus' || eventType === 'blur';
};
function makeDelegator(domEvents) {
var Delegator = function Delegator(parentKey) {
this.element = parentKey;
this.events = {};
this.delegated = {};
};
canReflect.assignSymbols(Delegator.prototype, {
'can.setKeyValue': function (eventType, handlersBySelector) {
var handler = this.delegated[eventType] = function (ev) {
canReflect.each(handlersBySelector, function (handlers, selector) {
var cur = ev.target;
do {
var el = cur === document ? document.documentElement : cur;
var matches = el.matches || el.msMatchesSelector;
if (matches.call(el, selector)) {
handlers.forEach(function (handler) {
handler.call(el, ev);
});
}
cur = cur.parentNode;
} while (cur && cur !== ev.currentTarget);
});
};
this.events[eventType] = handlersBySelector;
domEvents.addEventListener(this.element, eventType, handler, useCapture(eventType));
},
'can.getKeyValue': function (eventType) {
return this.events[eventType];
},
'can.deleteKeyValue': function (eventType) {
domEvents.removeEventListener(this.element, eventType, this.delegated[eventType], useCapture(eventType));
delete this.delegated[eventType];
delete this.events[eventType];
},
'can.<API key>': function () {
return Object.keys(this.events);
}
});
return Delegator;
}
module.exports = function <API key>(domEvents) {
var Delegator = makeDelegator(domEvents);
return new KeyTree([
Map,
Delegator,
Object,
Array
]);
};
});
/*can-dom-events@1.2.0#can-dom-events*/
define('can-dom-events', [
'require',
'exports',
'module',
'can-namespace',
'can-dom-events/helpers/util',
'can-dom-events/helpers/make-event-registry',
'can-dom-events/helpers/-<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var namespace = require('can-namespace');
var util = require('can-dom-events/helpers/util');
var makeEventRegistry = require('can-dom-events/helpers/make-event-registry');
var <API key> = require('can-dom-events/helpers/-<API key>');
var domEvents = {
_eventRegistry: makeEventRegistry(),
addEvent: function (event, eventType) {
return this._eventRegistry.add(event, eventType);
},
addEventListener: function (target, eventType) {
var hasCustomEvent = domEvents._eventRegistry.has(eventType);
if (hasCustomEvent) {
var event = domEvents._eventRegistry.get(eventType);
return event.addEventListener.apply(domEvents, arguments);
}
var eventArgs = Array.prototype.slice.call(arguments, 1);
return target.addEventListener.apply(target, eventArgs);
},
removeEventListener: function (target, eventType) {
var hasCustomEvent = domEvents._eventRegistry.has(eventType);
if (hasCustomEvent) {
var event = domEvents._eventRegistry.get(eventType);
return event.removeEventListener.apply(domEvents, arguments);
}
var eventArgs = Array.prototype.slice.call(arguments, 1);
return target.removeEventListener.apply(target, eventArgs);
},
addDelegateListener: function (root, eventType, selector, handler) {
domEvents._eventTree.add([
root,
eventType,
selector,
handler
]);
},
<API key>: function (target, eventType, selector, handler) {
domEvents._eventTree.delete([
target,
eventType,
selector,
handler
]);
},
dispatch: function (target, eventData, bubbles, cancelable) {
var event = util.createEvent(target, eventData, bubbles, cancelable);
var enableForDispatch = util.<API key>(target, event);
if (enableForDispatch) {
target.disabled = false;
}
var ret = target.dispatchEvent(event);
if (enableForDispatch) {
target.disabled = true;
}
return ret;
}
};
domEvents._eventTree = <API key>(domEvents);
module.exports = namespace.domEvents = domEvents;
}(function () {
return this;
}(), require, exports, module));
});
/*can-event-queue@1.0.1#map/map*/
define('can-event-queue/map/map', [
'require',
'exports',
'module',
'can-log/dev/dev',
'can-queues',
'can-reflect',
'can-symbol',
'can-key-tree',
'can-dom-events',
'can-dom-events/helpers/util',
'can-event-queue/dependency-record/merge'
], function (require, exports, module) {
var canDev = require('can-log/dev/dev');
var queues = require('can-queues');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var KeyTree = require('can-key-tree');
var domEvents = require('can-dom-events');
var isDomEventTarget = require('can-dom-events/helpers/util').isDomEventTarget;
var <API key> = require('can-event-queue/dependency-record/merge');
var metaSymbol = canSymbol.for('can.meta'), <API key> = canSymbol.for('can.<API key>'), <API key> = canSymbol.for('can.<API key>'), onKeyValueSymbol = canSymbol.for('can.onKeyValue'), offKeyValueSymbol = canSymbol.for('can.offKeyValue'), onEventSymbol = canSymbol.for('can.onEvent'), offEventSymbol = canSymbol.for('can.offEvent'), onValueSymbol = canSymbol.for('can.onValue'), offValueSymbol = canSymbol.for('can.offValue');
var legacyMapBindings;
function addHandlers(obj, meta) {
if (!meta.handlers) {
meta.handlers = new KeyTree([
Object,
Object,
Object,
Array
], {
onFirst: function () {
if (obj._eventSetup !== undefined) {
obj._eventSetup();
}
if (obj.constructor[<API key>]) {
obj.constructor[<API key>](obj, true);
}
},
onEmpty: function () {
if (obj._eventTeardown !== undefined) {
obj._eventTeardown();
}
if (obj.constructor[<API key>]) {
obj.constructor[<API key>](obj, false);
}
}
});
}
if (!meta.listenHandlers) {
meta.listenHandlers = new KeyTree([
Map,
Map,
Object,
Array
]);
}
}
var ensureMeta = function ensureMeta(obj) {
var meta = obj[metaSymbol];
if (!meta) {
meta = {};
canReflect.setKeyValue(obj, metaSymbol, meta);
}
addHandlers(obj, meta);
return meta;
};
function <API key>(bindTarget, event, handler, queueName) {
if (arguments.length && canReflect.isPrimitive(bindTarget)) {
queueName = handler;
handler = event;
event = bindTarget;
bindTarget = this.context;
}
if (typeof event === 'function') {
queueName = handler;
handler = event;
event = undefined;
}
if (typeof handler === 'string') {
queueName = handler;
handler = undefined;
}
var keys = [];
if (bindTarget) {
keys.push(bindTarget);
if (event || handler || queueName) {
keys.push(event);
if (queueName || handler) {
keys.push(queueName || this.defaultQueue);
if (handler) {
keys.push(handler);
}
}
}
}
return keys;
}
var props = {
dispatch: function (event, args) {
if (arguments.length > 4) {
canDev.warn('Arguments to dispatch should be an array, not multiple arguments.');
args = Array.prototype.slice.call(arguments, 1);
}
if (args && !Array.isArray(args)) {
canDev.warn('Arguments to dispatch should be an array.');
args = [args];
}
if (!this.__inSetup) {
if (typeof event === 'string') {
event = { type: event };
}
var meta = ensureMeta(this);
if (!event.reasonLog) {
event.reasonLog = [
canReflect.getName(this),
'dispatched',
'"' + event.type + '"',
'with'
].concat(args);
}
if (typeof meta._log === 'function') {
meta._log.call(this, event, args);
}
var handlers = meta.handlers;
var handlersByType = event.type !== undefined && handlers.getNode([event.type]);
var <API key> = event.patches && this.constructor[<API key>];
var patchesNode = event.patches !== undefined && handlers.getNode([
'can.patches',
'onKeyValue'
]);
var keysNode = event.keyChanged !== undefined && handlers.getNode([
'can.keys',
'onKeyValue'
]);
var batch = <API key> || handlersByType || patchesNode || keysNode;
if (batch) {
queues.batch.start();
}
if (handlersByType) {
if (handlersByType.onKeyValue) {
queues.enqueueByQueue(handlersByType.onKeyValue, this, args, event.makeMeta, event.reasonLog);
}
if (handlersByType.event) {
event.batchNum = queues.batch.number();
var eventAndArgs = [event].concat(args);
queues.enqueueByQueue(handlersByType.event, this, eventAndArgs, event.makeMeta, event.reasonLog);
}
}
if (keysNode) {
queues.enqueueByQueue(keysNode, this, [event.keyChanged], event.makeMeta, event.reasonLog);
}
if (patchesNode) {
queues.enqueueByQueue(patchesNode, this, [event.patches], event.makeMeta, event.reasonLog);
}
if (<API key>) {
this.constructor[<API key>](this, event.patches);
}
if (batch) {
queues.batch.stop();
}
}
return event;
},
addEventListener: function (key, handler, queueName) {
ensureMeta(this).handlers.add([
key,
'event',
queueName || 'mutate',
handler
]);
return this;
},
removeEventListener: function (key, handler, queueName) {
if (key === undefined) {
var handlers = ensureMeta(this).handlers;
var keyHandlers = handlers.getNode([]);
Object.keys(keyHandlers).forEach(function (key) {
handlers.delete([
key,
'event'
]);
});
} else if (!handler && !queueName) {
ensureMeta(this).handlers.delete([
key,
'event'
]);
} else if (!handler) {
ensureMeta(this).handlers.delete([
key,
'event',
queueName || 'mutate'
]);
} else {
ensureMeta(this).handlers.delete([
key,
'event',
queueName || 'mutate',
handler
]);
}
return this;
},
one: function (event, handler) {
var one = function () {
legacyMapBindings.off.call(this, event, one);
return handler.apply(this, arguments);
};
legacyMapBindings.on.call(this, event, one);
return this;
},
listenTo: function (bindTarget, event, handler, queueName) {
if (canReflect.isPrimitive(bindTarget)) {
queueName = handler;
handler = event;
event = bindTarget;
bindTarget = this;
}
if (typeof event === 'function') {
queueName = handler;
handler = event;
event = undefined;
}
ensureMeta(this).listenHandlers.add([
bindTarget,
event,
queueName || 'mutate',
handler
]);
legacyMapBindings.on.call(bindTarget, event, handler, queueName || 'mutate');
return this;
},
stopListening: function () {
var keys = <API key>.apply({
context: this,
defaultQueue: 'mutate'
}, arguments);
var listenHandlers = ensureMeta(this).listenHandlers;
function deleteHandler(bindTarget, event, queue, handler) {
legacyMapBindings.off.call(bindTarget, event, handler, queue);
}
listenHandlers.delete(keys, deleteHandler);
return this;
},
on: function (eventName, handler, queue) {
var listenWithDOM = isDomEventTarget(this);
if (listenWithDOM) {
if (typeof handler === 'string') {
domEvents.addDelegateListener(this, eventName, handler, queue);
} else {
domEvents.addEventListener(this, eventName, handler, queue);
}
} else {
if ('addEventListener' in this) {
this.addEventListener(eventName, handler, queue);
} else if (this[onKeyValueSymbol]) {
canReflect.onKeyValue(this, eventName, handler, queue);
} else if (this[onEventSymbol]) {
this[onEventSymbol](eventName, handler, queue);
} else {
if (!eventName && this[onValueSymbol]) {
canReflect.onValue(this, handler, queue);
} else {
throw new Error('can-event-queue: Unable to bind ' + eventName);
}
}
}
return this;
},
off: function (eventName, handler, queue) {
var listenWithDOM = isDomEventTarget(this);
if (listenWithDOM) {
if (typeof handler === 'string') {
domEvents.<API key>(this, eventName, handler, queue);
} else {
domEvents.removeEventListener(this, eventName, handler, queue);
}
} else {
if ('removeEventListener' in this) {
this.removeEventListener(eventName, handler, queue);
} else if (this[offKeyValueSymbol]) {
canReflect.offKeyValue(this, eventName, handler, queue);
} else if (this[offEventSymbol]) {
this[offEventSymbol](eventName, handler, queue);
} else {
if (!eventName && this[offValueSymbol]) {
canReflect.offValue(this, handler, queue);
} else {
throw new Error('can-event-queue: Unable to unbind ' + eventName);
}
}
}
return this;
}
};
var symbols = {
'can.onKeyValue': function (key, handler, queueName) {
ensureMeta(this).handlers.add([
key,
'onKeyValue',
queueName || 'mutate',
handler
]);
},
'can.offKeyValue': function (key, handler, queueName) {
ensureMeta(this).handlers.delete([
key,
'onKeyValue',
queueName || 'mutate',
handler
]);
},
'can.isBound': function () {
return ensureMeta(this).handlers.size() > 0;
},
'can.getWhatIChange': function getWhatIChange(key) {
var whatIChange = {};
var meta = ensureMeta(this);
var notifyHandlers = [].concat(meta.handlers.get([
key,
'event',
'notify'
]), meta.handlers.get([
key,
'onKeyValue',
'notify'
]));
var mutateHandlers = [].concat(meta.handlers.get([
key,
'event',
'mutate'
]), meta.handlers.get([
key,
'event',
'domUI'
]), meta.handlers.get([
key,
'onKeyValue',
'mutate'
]), meta.handlers.get([
key,
'onKeyValue',
'domUI'
]));
if (notifyHandlers.length) {
notifyHandlers.forEach(function (handler) {
var changes = canReflect.<API key>(handler);
if (changes) {
var record = whatIChange.derive;
if (!record) {
record = whatIChange.derive = {};
}
<API key>(record, changes);
}
});
}
if (mutateHandlers.length) {
mutateHandlers.forEach(function (handler) {
var changes = canReflect.<API key>(handler);
if (changes) {
var record = whatIChange.mutate;
if (!record) {
record = whatIChange.mutate = {};
}
<API key>(record, changes);
}
});
}
return Object.keys(whatIChange).length ? whatIChange : undefined;
},
'can.onPatches': function (handler, queue) {
var handlers = ensureMeta(this).handlers;
handlers.add([
'can.patches',
'onKeyValue',
queue || 'notify',
handler
]);
},
'can.offPatches': function (handler, queue) {
var handlers = ensureMeta(this).handlers;
handlers.delete([
'can.patches',
'onKeyValue',
queue || 'notify',
handler
]);
}
};
function defineNonEnumerable(obj, prop, value) {
Object.defineProperty(obj, prop, {
enumerable: false,
value: value
});
}
legacyMapBindings = function (obj) {
canReflect.assignMap(obj, props);
return canReflect.assignSymbols(obj, symbols);
};
defineNonEnumerable(legacyMapBindings, 'addHandlers', addHandlers);
defineNonEnumerable(legacyMapBindings, '<API key>', <API key>);
props.bind = props.addEventListener;
props.unbind = props.removeEventListener;
canReflect.assignMap(legacyMapBindings, props);
canReflect.assignSymbols(legacyMapBindings, symbols);
defineNonEnumerable(legacyMapBindings, 'start', function () {
console.warn('use can-queues.batch.start()');
queues.batch.start();
});
defineNonEnumerable(legacyMapBindings, 'stop', function () {
console.warn('use can-queues.batch.stop()');
queues.batch.stop();
});
defineNonEnumerable(legacyMapBindings, 'flush', function () {
console.warn('use can-queues.flush()');
queues.flush();
});
defineNonEnumerable(legacyMapBindings, 'afterPreviousEvents', function (handler) {
console.warn('don\'t use afterPreviousEvents');
queues.mutateQueue.enqueue(function afterPreviousEvents() {
queues.mutateQueue.enqueue(handler);
});
queues.flush();
});
defineNonEnumerable(legacyMapBindings, 'after', function (handler) {
console.warn('don\'t use after');
queues.mutateQueue.enqueue(handler);
queues.flush();
});
module.exports = legacyMapBindings;
});
/*<API key>@2.0.5#resolver/resolver*/
define('<API key>/resolver/resolver', [
'require',
'exports',
'module',
'can-reflect',
'can-symbol',
'<API key>',
'can-observation',
'can-queues',
'can-event-queue/map/map',
'<API key>/settable/settable',
'<API key>'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var ObservationRecorder = require('<API key>');
var Observation = require('can-observation');
var queues = require('can-queues');
var mapEventBindings = require('can-event-queue/map/map');
var SettableObservable = require('<API key>/settable/settable');
var SimpleObservable = require('<API key>');
var getChangesSymbol = canSymbol.for('can.<API key>');
function ResolverObservable(resolver, context) {
this.resolver = ObservationRecorder.ignore(resolver);
this.context = context;
this.valueOptions = {
resolve: this.resolve.bind(this),
listenTo: this.listenTo.bind(this),
stopListening: this.stopListening.bind(this),
lastSet: new SimpleObservable(undefined)
};
this.update = this.update.bind(this);
this.contextHandlers = new WeakMap();
this.teardown = null;
this.binder = {};
canReflect.assignSymbols(this, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '<' + canReflect.getName(resolver) + '>';
}
});
Object.defineProperty(this.update, 'name', { value: canReflect.getName(this) + '.update' });
canReflect.assignSymbols(this.valueOptions.lastSet, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '::lastSet' + '<' + canReflect.getName(resolver) + '>';
}
});
}
ResolverObservable.prototype = Object.create(SettableObservable.prototype);
function deleteHandler(bindTarget, event, queue, handler) {
mapEventBindings.off.call(bindTarget, event, handler, queue);
}
canReflect.assignMap(ResolverObservable.prototype, {
constructor: ResolverObservable,
listenTo: function (bindTarget, event, handler, queueName) {
if (canReflect.isPrimitive(bindTarget)) {
handler = event;
event = bindTarget;
bindTarget = this.context;
}
if (typeof event === 'function') {
handler = event;
event = undefined;
}
var resolverInstance = this;
if (!handler.name) {
Object.defineProperty(handler, 'name', { value: (bindTarget ? canReflect.getName(bindTarget) : '') + (event ? '.on(\'' + event + '\',handler)' : '.on(handler)') + '::' + canReflect.getName(this) });
}
var contextHandler = handler.bind(this.context);
contextHandler[getChangesSymbol] = function <API key>() {
return { valueDependencies: new Set([resolverInstance]) };
};
this.contextHandlers.set(handler, contextHandler);
mapEventBindings.listenTo.call(this.binder, bindTarget, event, contextHandler, queueName || 'notify');
},
stopListening: function () {
var meta = this.binder[canSymbol.for('can.meta')];
var listenHandlers = meta && meta.listenHandlers;
if (listenHandlers) {
var keys = mapEventBindings.<API key>.call({
context: this.context,
defaultQueue: 'notify'
});
listenHandlers.delete(keys, deleteHandler);
}
return this;
},
resolve: function (newVal) {
this.value = newVal;
if (this.isBinding) {
this.lastValue = this.value;
return newVal;
}
if (this.value !== this.lastValue) {
queues.batch.start();
queues.deriveQueue.enqueue(this.update, this, [], {
log: [canReflect.getName(this.update)],
reasonLog: [
canReflect.getName(this),
'resolved with',
newVal
]
});
queues.batch.stop();
}
return newVal;
},
update: function () {
if (this.lastValue !== this.value) {
var old = this.lastValue;
this.lastValue = this.value;
if (typeof this._log === 'function') {
this._log(old, this.value);
}
queues.enqueueByQueue(this.handlers.getNode([]), this, [
this.value,
old
]);
}
},
activate: function () {
this.isBinding = true;
this.teardown = this.resolver.call(this.context, this.valueOptions);
this.isBinding = false;
},
onUnbound: function () {
this.bound = false;
mapEventBindings.stopListening.call(this.binder);
if (this.teardown != null) {
this.teardown();
this.teardown = null;
}
},
set: function (value) {
this.valueOptions.lastSet.set(value);
},
get: function () {
if (ObservationRecorder.isRecording()) {
ObservationRecorder.add(this);
if (!this.bound) {
this.onBound();
}
}
if (this.bound === true) {
return this.value;
} else {
var handler = function () {
};
this.on(handler);
var val = this.value;
this.off(handler);
return val;
}
},
hasDependencies: function hasDependencies() {
var hasDependencies = false;
if (this.bound) {
var meta = this.binder[canSymbol.for('can.meta')];
var listenHandlers = meta && meta.listenHandlers;
hasDependencies = !!listenHandlers.size();
}
return hasDependencies;
},
<API key>: function <API key>() {
if (this.bound) {
var meta = this.binder[canSymbol.for('can.meta')];
var listenHandlers = meta && meta.listenHandlers;
var keyDeps = new Map();
var valueDeps = new Set();
if (listenHandlers) {
canReflect.each(listenHandlers.root, function (events, obj) {
canReflect.each(events, function (queues, eventName) {
if (eventName === undefined) {
valueDeps.add(obj);
} else {
var entry = keyDeps.get(obj);
if (!entry) {
entry = new Set();
keyDeps.set(obj, entry);
}
entry.add(eventName);
}
});
});
if (valueDeps.size || keyDeps.size) {
var result = {};
if (keyDeps.size) {
result.keyDependencies = keyDeps;
}
if (valueDeps.size) {
result.valueDependencies = valueDeps;
}
return result;
}
}
}
}
});
canReflect.assignSymbols(ResolverObservable.prototype, {
'can.getValue': ResolverObservable.prototype.get,
'can.setValue': ResolverObservable.prototype.set,
'can.isMapLike': false,
'can.getPriority': function () {
return this.priority || 0;
},
'can.setPriority': function (newPriority) {
this.priority = newPriority;
},
'can.<API key>': ResolverObservable.prototype.hasDependencies,
'can.<API key>': ResolverObservable.prototype.<API key>
});
module.exports = ResolverObservable;
});
/*can-event-queue@1.0.1#type/type*/
define('can-event-queue/type/type', [
'require',
'exports',
'module',
'can-reflect',
'can-symbol',
'can-key-tree',
'can-queues'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var KeyTree = require('can-key-tree');
var queues = require('can-queues');
var metaSymbol = canSymbol.for('can.meta');
function addHandlers(obj, meta) {
if (!meta.lifecycleHandlers) {
meta.lifecycleHandlers = new KeyTree([
Object,
Array
]);
}
if (!meta.<API key>) {
meta.<API key> = new KeyTree([
Object,
Array
]);
}
}
function ensureMeta(obj) {
var meta = obj[metaSymbol];
if (!meta) {
meta = {};
canReflect.setKeyValue(obj, metaSymbol, meta);
}
addHandlers(obj, meta);
return meta;
}
var props = {};
function onOffAndDispatch(symbolName, dispatchName, handlersName) {
props['can.on' + symbolName] = function (handler, queueName) {
ensureMeta(this)[handlersName].add([
queueName || 'mutate',
handler
]);
};
props['can.off' + symbolName] = function (handler, queueName) {
ensureMeta(this)[handlersName].delete([
queueName || 'mutate',
handler
]);
};
props['can.' + dispatchName] = function (instance, arg) {
queues.enqueueByQueue(ensureMeta(this)[handlersName].getNode([]), this, [
instance,
arg
]);
};
}
onOffAndDispatch('InstancePatches', '<API key>', '<API key>');
onOffAndDispatch('InstanceBoundChange', '<API key>', 'lifecycleHandlers');
function mixinTypeBindings(obj) {
return canReflect.assignSymbols(obj, props);
}
Object.defineProperty(mixinTypeBindings, 'addHandlers', {
enumerable: false,
value: addHandlers
});
module.exports = mixinTypeBindings;
});
/*can-string-to-any@1.0.3#can-string-to-any*/
define('can-string-to-any', function (require, exports, module) {
'use strict';
module.exports = function (str) {
switch (str) {
case 'NaN':
case 'Infinity':
return +str;
case 'null':
return null;
case 'undefined':
return undefined;
case 'true':
case 'false':
return str === 'true';
default:
var val = +str;
if (!isNaN(val)) {
return val;
} else {
return str;
}
}
};
});
/*can-data-types@0.1.1#maybe-boolean/maybe-boolean*/
define('can-data-types/maybe-boolean/maybe-boolean', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
function toBoolean(val) {
if (val == null) {
return val;
}
if (val === 'false' || val === '0' || !val) {
return false;
}
return true;
}
module.exports = canReflect.assignSymbols(toBoolean, {
'can.new': toBoolean,
'can.getSchema': function () {
return {
type: 'Or',
values: [
true,
false,
undefined,
null
]
};
},
'can.getName': function () {
return 'MaybeBoolean';
},
'can.isMember': function (value) {
return value == null || typeof value === 'boolean';
}
});
});
/*can-data-types@0.1.1#maybe-date/maybe-date*/
define('can-data-types/maybe-date/maybe-date', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
function toDate(str) {
var type = typeof str;
if (type === 'string') {
str = Date.parse(str);
return isNaN(str) ? null : new Date(str);
} else if (type === 'number') {
return new Date(str);
} else {
return str;
}
}
function DateStringSet(dateStr) {
this.setValue = dateStr;
var date = toDate(dateStr);
this.value = date == null ? date : date.getTime();
}
DateStringSet.prototype.valueOf = function () {
return this.value;
};
canReflect.assignSymbols(DateStringSet.prototype, {
'can.serialize': function () {
return this.setValue;
}
});
module.exports = canReflect.assignSymbols(toDate, {
'can.new': toDate,
'can.getSchema': function () {
return {
type: 'Or',
values: [
Date,
undefined,
null
]
};
},
'can.ComparisonSetType': DateStringSet,
'can.getName': function () {
return 'MaybeDate';
},
'can.isMember': function (value) {
return value == null || value instanceof Date;
}
});
});
/*can-data-types@0.1.1#maybe-number/maybe-number*/
define('can-data-types/maybe-number/maybe-number', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
function toNumber(val) {
if (val == null) {
return val;
}
return +val;
}
module.exports = canReflect.assignSymbols(toNumber, {
'can.new': toNumber,
'can.getSchema': function () {
return {
type: 'Or',
values: [
Number,
undefined,
null
]
};
},
'can.getName': function () {
return 'MaybeNumber';
},
'can.isMember': function (value) {
return value == null || typeof value === 'number';
}
});
});
/*can-data-types@0.1.1#maybe-string/maybe-string*/
define('can-data-types/maybe-string/maybe-string', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
function toString(val) {
if (val == null) {
return val;
}
return '' + val;
}
module.exports = canReflect.assignSymbols(toString, {
'can.new': toString,
'can.getSchema': function () {
return {
type: 'Or',
values: [
String,
undefined,
null
]
};
},
'can.getName': function () {
return 'MaybeString';
},
'can.isMember': function (value) {
return value == null || typeof value === 'string';
}
});
});
/*can-define@2.3.5#can-define*/
define('can-define', [
'require',
'exports',
'module',
'can-namespace',
'can-symbol',
'can-reflect',
'can-observation',
'<API key>',
'<API key>/async/async',
'<API key>/settable/settable',
'<API key>/resolver/resolver',
'can-event-queue/map/map',
'can-event-queue/type/type',
'can-queues',
'can-assign',
'can-log/dev/dev',
'can-string-to-any',
'<API key>',
'can-data-types/maybe-boolean/maybe-boolean',
'can-data-types/maybe-date/maybe-date',
'can-data-types/maybe-number/maybe-number',
'can-data-types/maybe-string/maybe-string'
], function (require, exports, module) {
'use strict';
'format cjs';
var ns = require('can-namespace');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var Observation = require('can-observation');
var ObservationRecorder = require('<API key>');
var AsyncObservable = require('<API key>/async/async');
var SettableObservable = require('<API key>/settable/settable');
var ResolverObservable = require('<API key>/resolver/resolver');
var eventQueue = require('can-event-queue/map/map');
var addTypeEvents = require('can-event-queue/type/type');
var queues = require('can-queues');
var assign = require('can-assign');
var canLogDev = require('can-log/dev/dev');
var stringToAny = require('can-string-to-any');
var defineLazyValue = require('<API key>');
var MaybeBoolean = require('can-data-types/maybe-boolean/maybe-boolean'), MaybeDate = require('can-data-types/maybe-date/maybe-date'), MaybeNumber = require('can-data-types/maybe-number/maybe-number'), MaybeString = require('can-data-types/maybe-string/maybe-string');
var newSymbol = canSymbol.for('can.new'), serializeSymbol = canSymbol.for('can.serialize');
var eventsProto, define, make, makeDefinition, <API key>, <API key>;
function isDefineType(func) {
return func && (func.canDefineType === true || func[newSymbol]);
}
var peek = ObservationRecorder.ignore(canReflect.getValue.bind(canReflect));
var <API key> = Object.defineProperty;
<API key> = function (obj, prop, definition) {
if (definition.get) {
Object.defineProperty(definition.get, 'name', {
value: 'get ' + canReflect.getName(obj) + '.' + prop,
writable: true
});
}
if (definition.set) {
Object.defineProperty(definition.set, 'name', { value: 'set ' + canReflect.getName(obj) + '.' + prop });
}
return Object.defineProperty(obj, prop, definition);
};
function <API key>(obj, prop, value) {
Object.defineProperty(obj, prop, {
configurable: true,
enumerable: false,
writable: true,
value: value
});
}
function <API key>(map, cb) {
for (var prop in map) {
if (map.hasOwnProperty(prop)) {
cb.call(map, prop, Object.<API key>(map, prop));
}
}
}
function cleanUpDefinition(prop, definition, shouldWarn) {
if (definition.value !== undefined && (typeof definition.value !== 'function' || definition.value.length === 0)) {
if (shouldWarn) {
canLogDev.warn('can-define: Change the \'value\' definition for ' + prop + ' to \'default\'.');
}
definition.default = definition.value;
delete definition.value;
}
if (definition.Value !== undefined) {
if (shouldWarn) {
canLogDev.warn('can-define: Change the \'Value\' definition for ' + prop + ' to \'Default\'.');
}
definition.Default = definition.Value;
delete definition.Value;
}
}
function isValueResolver(definition) {
return typeof definition.value === 'function' && definition.value.length;
}
module.exports = define = ns.define = function (typePrototype, defines, baseDefine) {
var prop, dataInitializers = Object.create(baseDefine ? baseDefine.dataInitializers : null), <API key> = Object.create(baseDefine ? baseDefine.<API key> : null);
var result = <API key>(defines, baseDefine);
result.dataInitializers = dataInitializers;
result.<API key> = <API key>;
canReflect.eachKey(result.definitions, function (definition, property) {
define.property(typePrototype, property, definition, dataInitializers, <API key>, result.defaultDefinition);
});
if (typePrototype.hasOwnProperty('_data')) {
for (prop in dataInitializers) {
defineLazyValue(typePrototype._data, prop, dataInitializers[prop].bind(typePrototype), true);
}
} else {
defineLazyValue(typePrototype, '_data', function () {
var map = this;
var data = {};
for (var prop in dataInitializers) {
defineLazyValue(data, prop, dataInitializers[prop].bind(map), true);
}
return data;
});
}
if (typePrototype.hasOwnProperty('_computed')) {
for (prop in <API key>) {
defineLazyValue(typePrototype._computed, prop, <API key>[prop].bind(typePrototype));
}
} else {
defineLazyValue(typePrototype, '_computed', function () {
var map = this;
var data = Object.create(null);
for (var prop in <API key>) {
defineLazyValue(data, prop, <API key>[prop].bind(map));
}
return data;
});
}
for (prop in eventsProto) {
Object.defineProperty(typePrototype, prop, {
enumerable: false,
value: eventsProto[prop],
configurable: true,
writable: true
});
}
Object.defineProperty(typePrototype, '_define', {
enumerable: false,
value: result,
configurable: true,
writable: true
});
var iteratorSymbol = canSymbol.iterator || canSymbol.for('iterator');
if (!typePrototype[iteratorSymbol]) {
<API key>(typePrototype, iteratorSymbol, function () {
return new define.Iterator(this);
});
}
return result;
};
var onlyType = function (obj) {
for (var prop in obj) {
if (prop !== 'type') {
return false;
}
}
return true;
};
define.extensions = function () {
};
define.property = function (typePrototype, prop, definition, dataInitializers, <API key>, defaultDefinition) {
var propertyDefinition = define.extensions.apply(this, arguments);
if (propertyDefinition) {
definition = makeDefinition(prop, propertyDefinition, defaultDefinition || {});
}
var type = definition.type;
if (type && canReflect.isConstructorLike(type) && !isDefineType(type)) {
canLogDev.warn('can-define: the definition for ' + prop + (typePrototype.constructor.shortName ? ' on ' + typePrototype.constructor.shortName : '') + ' uses a constructor for "type". Did you mean "Type"?');
}
if (type && onlyType(definition) && type === define.types['*']) {
<API key>(typePrototype, prop, {
get: make.get.data(prop),
set: make.set.events(prop, make.get.data(prop), make.set.data(prop), make.eventType.data(prop)),
enumerable: true,
configurable: true
});
return;
}
definition.type = type;
var dataProperty = definition.get || isValueResolver(definition) ? 'computed' : 'data', reader = make.read[dataProperty](prop), getter = make.get[dataProperty](prop), setter = make.set[dataProperty](prop), getInitialValue;
if (definition.get) {
Object.defineProperty(definition.get, 'name', { value: canReflect.getName(typePrototype) + '\'s ' + prop + ' getter' });
}
if (definition.set) {
Object.defineProperty(definition.set, 'name', { value: canReflect.getName(typePrototype) + '\'s ' + prop + ' setter' });
}
if (isValueResolver(definition)) {
Object.defineProperty(definition.value, 'name', { value: canReflect.getName(typePrototype) + '\'s ' + prop + ' value' });
}
var typeConvert = function (val) {
return val;
};
if (definition.Type) {
typeConvert = make.set.Type(prop, definition.Type, typeConvert);
}
if (type) {
typeConvert = make.set.type(prop, type, typeConvert);
}
var eventsSetter = make.set.events(prop, reader, setter, make.eventType[dataProperty](prop));
if (isValueResolver(definition)) {
<API key>[prop] = make.valueResolver(prop, definition, typeConvert);
} else if (definition.default !== undefined || definition.Default !== undefined) {
if (definition.default !== null && typeof definition.default === 'object') {
canLogDev.warn('can-define: The default value for ' + prop + ' is set to an object. This will be shared by all instances of the DefineMap. Use a function that returns the object instead.');
}
if (definition.default && canReflect.isConstructorLike(definition.default)) {
canLogDev.warn('can-define: The "default" for ' + prop + ' is set to a constructor. Did you mean "Default" instead?');
}
getInitialValue = ObservationRecorder.ignore(make.get.defaultValue(prop, definition, typeConvert, eventsSetter));
}
if (definition.get) {
<API key>[prop] = make.compute(prop, definition.get, getInitialValue);
} else if (getInitialValue) {
dataInitializers[prop] = getInitialValue;
}
if (definition.get && definition.set) {
setter = make.set.setter(prop, definition.set, make.read.lastSet(prop), setter, true);
} else if (definition.set) {
setter = make.set.setter(prop, definition.set, reader, eventsSetter, false);
} else if (dataProperty === 'data') {
setter = eventsSetter;
} else if (definition.get && definition.get.length < 1) {
setter = function () {
canLogDev.warn('can-define: Set value for property ' + prop + (typePrototype.constructor.shortName ? ' on ' + typePrototype.constructor.shortName : '') + ' ignored, as its definition has a zero-argument getter and no setter');
};
}
if (type) {
setter = make.set.type(prop, type, setter);
}
if (definition.Type) {
setter = make.set.Type(prop, definition.Type, setter);
}
<API key>(typePrototype, prop, {
get: getter,
set: setter,
enumerable: 'serialize' in definition ? !!definition.serialize : !definition.get,
configurable: true
});
};
define.<API key> = function (constructor) {
constructor[canSymbol.for('can.defineInstanceKey')] = function (property, value) {
var defineResult = this.prototype._define;
if (typeof value === 'object') {
cleanUpDefinition(property, value, false);
}
var definition = <API key>(property, value, defineResult.defaultDefinition);
if (definition && typeof definition === 'object') {
define.property(constructor.prototype, property, definition, defineResult.dataInitializers, defineResult.<API key>, defineResult.defaultDefinition);
defineResult.definitions[property] = definition;
} else {
defineResult.methods[property] = definition;
}
};
};
define.Constructor = function (defines, sealed) {
var constructor = function (props) {
Object.defineProperty(this, '__inSetup', {
configurable: true,
enumerable: false,
value: true,
writable: true
});
define.setup.call(this, props, sealed);
this.__inSetup = false;
};
var result = define(constructor.prototype, defines);
addTypeEvents(constructor);
define.<API key>(constructor, result);
return constructor;
};
make = {
computeObj: function (map, prop, observable) {
var computeObj = {
oldValue: undefined,
compute: observable,
count: 0,
handler: function (newVal) {
var oldValue = computeObj.oldValue;
computeObj.oldValue = newVal;
map.dispatch({
type: prop,
target: map
}, [
newVal,
oldValue
]);
}
};
return computeObj;
},
valueResolver: function (prop, definition, typeConvert) {
return function () {
var map = this;
var computeObj = make.computeObj(map, prop, new ResolverObservable(definition.value, map));
Object.defineProperty(computeObj.handler, 'name', { value: canReflect.getName(definition.value).replace('value', 'event emitter') });
return computeObj;
};
},
compute: function (prop, get, defaultValueFn) {
return function () {
var map = this, defaultValue = defaultValueFn && defaultValueFn.call(this), observable, computeObj;
if (get.length === 0) {
observable = new Observation(get, map);
} else if (get.length === 1) {
observable = new SettableObservable(get, map, defaultValue);
} else {
observable = new AsyncObservable(get, map, defaultValue);
}
computeObj = make.computeObj(map, prop, observable);
Object.defineProperty(computeObj.handler, 'name', { value: canReflect.getName(get).replace('getter', 'event emitter') });
return computeObj;
};
},
set: {
data: function (prop) {
return function (newVal) {
this._data[prop] = newVal;
};
},
computed: function (prop) {
return function (val) {
canReflect.setValue(this._computed[prop].compute, val);
};
},
events: function (prop, getCurrent, setData, eventType) {
return function (newVal) {
if (this.__inSetup) {
setData.call(this, newVal);
} else {
var current = getCurrent.call(this);
if (newVal !== current) {
setData.call(this, newVal);
this.dispatch({
patches: [{
type: 'set',
key: prop,
value: newVal
}],
type: prop,
target: this,
reasonLog: [
canReflect.getName(this) + '\'s',
prop,
'changed to',
newVal,
'from',
current
]
}, [
newVal,
current
]);
}
}
};
},
setter: function (prop, setter, getCurrent, setEvents, hasGetter) {
return function (value) {
var asyncTimer;
var self = this;
queues.batch.start();
var setterCalled = false, current = getCurrent.call(this), setValue = setter.call(this, value, function (value) {
setEvents.call(self, value);
setterCalled = true;
clearTimeout(asyncTimer);
}, current);
if (setterCalled) {
queues.batch.stop();
} else {
if (hasGetter) {
if (setValue !== undefined) {
if (current !== setValue) {
setEvents.call(this, setValue);
}
queues.batch.stop();
} else if (setter.length === 0) {
setEvents.call(this, value);
queues.batch.stop();
return;
} else if (setter.length === 1) {
queues.batch.stop();
} else {
asyncTimer = setTimeout(function () {
canLogDev.warn('can/map/setter.js: Setter "' + prop + '" did not return a value or call the setter callback.');
}, canLogDev.warnTimeout);
queues.batch.stop();
return;
}
} else {
if (setValue !== undefined) {
setEvents.call(this, setValue);
queues.batch.stop();
} else if (setter.length === 0) {
setEvents.call(this, value);
queues.batch.stop();
return;
} else if (setter.length === 1) {
setEvents.call(this, undefined);
queues.batch.stop();
} else {
asyncTimer = setTimeout(function () {
canLogDev.warn('can/map/setter.js: Setter "' + prop + '" did not return a value or call the setter callback.');
}, canLogDev.warnTimeout);
queues.batch.stop();
return;
}
}
}
};
},
type: function (prop, type, set) {
function setter(newValue) {
return set.call(this, type.call(this, newValue, prop));
}
if (isDefineType(type)) {
if (type.canDefineType) {
return setter;
} else {
return function setter(newValue) {
return set.call(this, canReflect.convert(newValue, type));
};
}
}
if (typeof type === 'object') {
return make.set.Type(prop, type, set);
} else {
return setter;
}
},
Type: function (prop, Type, set) {
if (Array.isArray(Type) && define.DefineList) {
Type = define.DefineList.extend({ '#': Type[0] });
} else if (typeof Type === 'object') {
if (define.DefineMap) {
Type = define.DefineMap.extend(Type);
} else {
Type = define.Constructor(Type);
}
}
return function (newValue) {
if (newValue instanceof Type || newValue == null) {
return set.call(this, newValue);
} else {
return set.call(this, new Type(newValue));
}
};
}
},
eventType: {
data: function (prop) {
return function (newVal, oldVal) {
return oldVal !== undefined || this._data.hasOwnProperty(prop) ? 'set' : 'add';
};
},
computed: function () {
return function () {
return 'set';
};
}
},
read: {
data: function (prop) {
return function () {
return this._data[prop];
};
},
computed: function (prop) {
return function () {
return canReflect.getValue(this._computed[prop].compute);
};
},
lastSet: function (prop) {
return function () {
var observable = this._computed[prop].compute;
if (observable.lastSetValue) {
return canReflect.getValue(observable.lastSetValue);
}
};
}
},
get: {
defaultValue: function (prop, definition, typeConvert, callSetter) {
return function () {
var value = definition.default;
if (value !== undefined) {
if (typeof value === 'function') {
value = value.call(this);
}
value = typeConvert(value);
} else {
var Default = definition.Default;
if (Default) {
value = typeConvert(new Default());
}
}
if (definition.set) {
var VALUE;
var sync = true;
var setter = make.set.setter(prop, definition.set, function () {
}, function (value) {
if (sync) {
VALUE = value;
} else {
callSetter.call(this, value);
}
}, definition.get);
setter.call(this, value);
sync = false;
return VALUE;
}
return value;
};
},
data: function (prop) {
return function () {
if (!this.__inSetup) {
ObservationRecorder.add(this, prop);
}
return this._data[prop];
};
},
computed: function (prop) {
return function (val) {
var compute = this._computed[prop].compute;
if (ObservationRecorder.isRecording()) {
ObservationRecorder.add(this, prop);
if (!canReflect.isBound(compute)) {
Observation.temporarilyBind(compute);
}
}
return peek(compute);
};
}
}
};
define.behaviors = [
'get',
'set',
'value',
'Value',
'type',
'Type',
'serialize'
];
var <API key> = function (definition, behavior, value) {
if (behavior === 'enumerable') {
definition.serialize = !!value;
} else if (behavior === 'type') {
var behaviorDef = value;
if (typeof behaviorDef === 'string') {
behaviorDef = define.types[behaviorDef];
if (typeof behaviorDef === 'object' && !isDefineType(behaviorDef)) {
assign(definition, behaviorDef);
behaviorDef = behaviorDef[behavior];
}
}
if (typeof behaviorDef !== 'undefined') {
definition[behavior] = behaviorDef;
}
} else {
definition[behavior] = value;
}
};
makeDefinition = function (prop, def, defaultDefinition) {
var definition = {};
canReflect.eachKey(def, function (value, behavior) {
<API key>(definition, behavior, value);
});
canReflect.eachKey(defaultDefinition, function (value, prop) {
if (definition[prop] === undefined) {
if (prop !== 'type' && prop !== 'Type') {
definition[prop] = value;
}
}
});
if (def.Type) {
var value = def.Type;
var serialize = value[serializeSymbol];
if (serialize) {
definition.serialize = function (val) {
return serialize.call(val);
};
}
if (value[newSymbol]) {
definition.type = value[newSymbol];
delete definition.Type;
}
}
if (typeof def.type !== 'string') {
if (!definition.type && !definition.Type) {
var defaultsCopy = canReflect.assignMap({}, defaultDefinition);
definition = canReflect.assignMap(defaultsCopy, definition);
}
if (canReflect.size(definition) === 0) {
definition.type = define.types['*'];
}
}
cleanUpDefinition(prop, definition, true);
return definition;
};
<API key> = function (prop, value, defaultDefinition) {
var definition;
if (typeof value === 'string') {
definition = { type: value };
} else if (value && (value[serializeSymbol] || value[newSymbol])) {
definition = { Type: value };
} else if (typeof value === 'function') {
if (canReflect.isConstructorLike(value)) {
definition = { Type: value };
}
} else if (Array.isArray(value)) {
definition = { Type: value };
} else if (canReflect.isPlainObject(value)) {
definition = value;
}
if (definition) {
return makeDefinition(prop, definition, defaultDefinition);
} else {
return value;
}
};
<API key> = function (defines, baseDefines) {
var definitions = Object.create(baseDefines ? baseDefines.definitions : null);
var methods = {};
var defaults = defines['*'], defaultDefinition;
if (defaults) {
delete defines['*'];
defaultDefinition = <API key>('*', defaults, {});
} else {
defaultDefinition = Object.create(null);
}
<API key>(defines, function (prop, propertyDescriptor) {
var value;
if (propertyDescriptor.get || propertyDescriptor.set) {
value = {
get: propertyDescriptor.get,
set: propertyDescriptor.set
};
} else {
value = propertyDescriptor.value;
}
if (prop === 'constructor') {
methods[prop] = value;
return;
} else {
var result = <API key>(prop, value, defaultDefinition);
if (result && typeof result === 'object' && canReflect.size(result) > 0) {
definitions[prop] = result;
} else {
if (typeof result === 'function') {
methods[prop] = result;
} else if (typeof result !== 'undefined') {
canLogDev.error(prop + (this.constructor.shortName ? ' on ' + this.constructor.shortName : '') + ' does not match a supported propDefinition. See: https://canjs.com/doc/can-define.types.propDefinition.html');
}
}
}
});
if (defaults) {
defines['*'] = defaults;
}
return {
definitions: definitions,
methods: methods,
defaultDefinition: defaultDefinition
};
};
eventsProto = eventQueue({});
function setupComputed(instance, eventName) {
var computedBinding = instance._computed && instance._computed[eventName];
if (computedBinding && computedBinding.compute) {
if (!computedBinding.count) {
computedBinding.count = 1;
canReflect.onValue(computedBinding.compute, computedBinding.handler, 'notify');
computedBinding.oldValue = canReflect.getValue(computedBinding.compute);
} else {
computedBinding.count++;
}
}
}
function teardownComputed(instance, eventName) {
var computedBinding = instance._computed && instance._computed[eventName];
if (computedBinding) {
if (computedBinding.count === 1) {
computedBinding.count = 0;
canReflect.offValue(computedBinding.compute, computedBinding.handler, 'notify');
} else {
computedBinding.count
}
}
}
var canMetaSymbol = canSymbol.for('can.meta');
assign(eventsProto, {
_eventSetup: function () {
},
_eventTeardown: function () {
},
addEventListener: function (eventName, handler, queue) {
setupComputed(this, eventName);
return eventQueue.addEventListener.apply(this, arguments);
},
removeEventListener: function (eventName, handler) {
teardownComputed(this, eventName);
return eventQueue.removeEventListener.apply(this, arguments);
}
});
eventsProto.on = eventsProto.bind = eventsProto.addEventListener;
eventsProto.off = eventsProto.unbind = eventsProto.removeEventListener;
var onKeyValueSymbol = canSymbol.for('can.onKeyValue');
var offKeyValueSymbol = canSymbol.for('can.offKeyValue');
canReflect.assignSymbols(eventsProto, {
'can.onKeyValue': function (key) {
setupComputed(this, key);
return eventQueue[onKeyValueSymbol].apply(this, arguments);
},
'can.offKeyValue': function (key) {
teardownComputed(this, key);
return eventQueue[offKeyValueSymbol].apply(this, arguments);
}
});
delete eventsProto.one;
define.setup = function (props, sealed) {
Object.defineProperty(this, 'constructor', {
value: this.constructor,
enumerable: false,
writable: false
});
Object.defineProperty(this, canMetaSymbol, {
value: Object.create(null),
enumerable: false,
writable: false
});
var definitions = this._define.definitions;
var instanceDefinitions = Object.create(null);
var map = this;
canReflect.eachKey(props, function (value, prop) {
if (definitions[prop] !== undefined) {
map[prop] = value;
} else {
var def = define.<API key>(prop);
instanceDefinitions[prop] = {};
<API key>(map, prop, def);
map[prop] = define.types.observable(value);
}
});
if (canReflect.size(instanceDefinitions) > 0) {
<API key>(this, '<API key>', instanceDefinitions);
}
this._data;
this._computed;
if (sealed !== false) {
Object.seal(this);
}
};
define.replaceWith = defineLazyValue;
define.eventsProto = eventsProto;
define.<API key> = <API key>;
define.make = make;
define.<API key> = <API key>;
var simpleGetterSetters = {};
define.<API key> = function (prop) {
if (simpleGetterSetters[prop] === undefined) {
var setter = make.set.events(prop, make.get.data(prop), make.set.data(prop), make.eventType.data(prop));
simpleGetterSetters[prop] = {
get: make.get.data(prop),
set: function (newVal) {
return setter.call(this, define.types.observable(newVal));
},
enumerable: true
};
}
return simpleGetterSetters[prop];
};
define.Iterator = function (obj) {
this.obj = obj;
this.definitions = Object.keys(obj._define.definitions);
this.instanceDefinitions = obj.<API key> ? Object.keys(obj.<API key>) : Object.keys(obj);
this.hasGet = typeof obj.get === 'function';
};
define.Iterator.prototype.next = function () {
var key;
if (this.definitions.length) {
key = this.definitions.shift();
var def = this.obj._define.definitions[key];
if (def.get) {
return this.next();
}
} else if (this.instanceDefinitions.length) {
key = this.instanceDefinitions.shift();
} else {
return {
value: undefined,
done: true
};
}
return {
value: [
key,
this.hasGet ? this.obj.get(key) : this.obj[key]
],
done: false
};
};
function isObservableValue(obj) {
return canReflect.isValueLike(obj) && canReflect.isObservableLike(obj);
}
define.types = {
'date': MaybeDate,
'number': MaybeNumber,
'boolean': MaybeBoolean,
'observable': function (newVal) {
if (Array.isArray(newVal) && define.DefineList) {
newVal = new define.DefineList(newVal);
} else if (canReflect.isPlainObject(newVal) && define.DefineMap) {
newVal = new define.DefineMap(newVal);
}
return newVal;
},
'stringOrObservable': function (newVal) {
if (Array.isArray(newVal)) {
return new define.DefaultList(newVal);
} else if (canReflect.isPlainObject(newVal)) {
return new define.DefaultMap(newVal);
} else {
return canReflect.convert(newVal, define.types.string);
}
},
'htmlbool': function (val) {
if (val === '') {
return true;
}
return !!stringToAny(val);
},
'*': function (val) {
return val;
},
'any': function (val) {
return val;
},
'string': MaybeString,
'compute': {
set: function (newValue, setVal, setErr, oldValue) {
if (isObservableValue(newValue)) {
return newValue;
}
if (isObservableValue(oldValue)) {
canReflect.setValue(oldValue, newValue);
return oldValue;
}
return newValue;
},
get: function (value) {
return isObservableValue(value) ? canReflect.getValue(value) : value;
}
}
};
define.updateSchemaKeys = function (schema, definitions) {
for (var prop in definitions) {
var definition = definitions[prop];
if (definition.serialize !== false) {
if (definition.type) {
schema.keys[prop] = definition.type;
} else {
schema.keys[prop] = function (val) {
return val;
};
}
if (definitions[prop].identity === true) {
schema.identity.push(prop);
}
}
}
return schema;
};
});
/*can-string@0.0.5#can-string*/
define('can-string', function (require, exports, module) {
'use strict';
var strUndHash = /_|-/, strColons = /\=\=/, strWords = /([A-Z]+)([A-Z][a-z])/g, strLowUp = /([a-z\d])([A-Z])/g, strDash = /([a-z\d])([A-Z])/g, strQuote = /"/g, strSingleQuote = /'/g, strHyphenMatch = /-+(.)?/g, strCamelMatch = /[a-z][A-Z]/g, convertBadValues = function (content) {
var isInvalid = content === null || content === undefined || isNaN(content) && '' + content === 'NaN';
return '' + (isInvalid ? '' : content);
};
var string = {
esc: function (content) {
return convertBadValues(content).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(strQuote, '"').replace(strSingleQuote, ''');
},
capitalize: function (s) {
return s.charAt(0).toUpperCase() + s.slice(1);
},
camelize: function (str) {
return convertBadValues(str).replace(strHyphenMatch, function (match, chr) {
return chr ? chr.toUpperCase() : '';
});
},
hyphenate: function (str) {
return convertBadValues(str).replace(strCamelMatch, function (str) {
return str.charAt(0) + '-' + str.charAt(1).toLowerCase();
});
},
underscore: function (s) {
return s.replace(strColons, '/').replace(strWords, '$1_$2').replace(strLowUp, '$1_$2').replace(strDash, '_').toLowerCase();
},
undHash: strUndHash
};
module.exports = string;
});
/*can-construct@3.4.4#can-construct*/
define('can-construct', [
'require',
'exports',
'module',
'can-reflect',
'can-log/dev/dev',
'can-namespace',
'can-string'
], function (require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
var dev = require('can-log/dev/dev');
var namespace = require('can-namespace');
var CanString = require('can-string');
var reservedWords = {
'abstract': true,
'boolean': true,
'break': true,
'byte': true,
'case': true,
'catch': true,
'char': true,
'class': true,
'const': true,
'continue': true,
'debugger': true,
'default': true,
'delete': true,
'do': true,
'double': true,
'else': true,
'enum': true,
'export': true,
'extends': true,
'false': true,
'final': true,
'finally': true,
'float': true,
'for': true,
'function': true,
'goto': true,
'if': true,
'implements': true,
'import': true,
'in': true,
'instanceof': true,
'int': true,
'interface': true,
'let': true,
'long': true,
'native': true,
'new': true,
'null': true,
'package': true,
'private': true,
'protected': true,
'public': true,
'return': true,
'short': true,
'static': true,
'super': true,
'switch': true,
'synchronized': true,
'this': true,
'throw': true,
'throws': true,
'transient': true,
'true': true,
'try': true,
'typeof': true,
'var': true,
'void': true,
'volatile': true,
'while': true,
'with': true
};
var <API key> = /[^A-Z0-9_]/gi;
var initializing = 0;
var namedCtor = function (cache) {
return function (name, fn) {
return (name in cache ? cache[name] : cache[name] = new Function('__', 'function ' + name + '(){return __.apply(this,arguments)};return ' + name))(fn);
};
}({});
var Construct = function () {
if (arguments.length) {
return Construct.extend.apply(Construct, arguments);
}
};
var canGetDescriptor;
try {
Object.<API key>({});
canGetDescriptor = true;
} catch (e) {
canGetDescriptor = false;
}
var getDescriptor = function (newProps, name) {
var descriptor = Object.<API key>(newProps, name);
if (descriptor && (descriptor.get || descriptor.set)) {
return descriptor;
}
return null;
}, inheritGetterSetter = function (newProps, oldProps, addTo) {
addTo = addTo || newProps;
var descriptor;
for (var name in newProps) {
if (descriptor = getDescriptor(newProps, name)) {
this._defineProperty(addTo, oldProps, name, descriptor);
} else {
Construct._overwrite(addTo, oldProps, name, newProps[name]);
}
}
}, simpleInherit = function (newProps, oldProps, addTo) {
addTo = addTo || newProps;
for (var name in newProps) {
Construct._overwrite(addTo, oldProps, name, newProps[name]);
}
};
canReflect.assignMap(Construct, {
constructorExtends: true,
newInstance: function () {
var inst = this.instance(), args;
if (inst.setup) {
Object.defineProperty(inst, '__inSetup', {
configurable: true,
enumerable: false,
value: true,
writable: true
});
args = inst.setup.apply(inst, arguments);
if (args instanceof Construct.ReturnValue) {
return args.value;
}
inst.__inSetup = false;
}
if (inst.init) {
inst.init.apply(inst, args || arguments);
}
return inst;
},
_inherit: canGetDescriptor ? inheritGetterSetter : simpleInherit,
_defineProperty: function (what, oldProps, propName, descriptor) {
Object.defineProperty(what, propName, descriptor);
},
_overwrite: function (what, oldProps, propName, val) {
Object.defineProperty(what, propName, {
value: val,
configurable: true,
enumerable: true,
writable: true
});
},
setup: function (base) {
var defaults = canReflect.assignDeepMap({}, base.defaults);
this.defaults = canReflect.assignDeepMap(defaults, this.defaults);
},
instance: function () {
initializing = 1;
var inst = new this();
initializing = 0;
return inst;
},
extend: function (name, staticProperties, instanceProperties) {
var shortName = name, klass = staticProperties, proto = instanceProperties;
if (typeof shortName !== 'string') {
proto = klass;
klass = shortName;
shortName = null;
}
if (!proto) {
proto = klass;
klass = null;
}
proto = proto || {};
var _super_class = this, _super = this.prototype, Constructor, prototype;
prototype = this.instance();
Construct._inherit(proto, _super, prototype);
if (shortName) {
} else if (klass && klass.shortName) {
shortName = klass.shortName;
} else if (this.shortName) {
shortName = this.shortName;
}
var constructorName = shortName ? shortName.replace(<API key>, '_') : 'Constructor';
if (reservedWords[constructorName]) {
constructorName = CanString.capitalize(constructorName);
}
function init() {
if (!initializing) {
if (!this || this.constructor !== Constructor && arguments.length && Constructor.constructorExtends) {
dev.warn('can/construct/construct.js: extending a Construct without calling extend');
}
return (!this || this.constructor !== Constructor) && arguments.length && Constructor.constructorExtends ? Constructor.extend.apply(Constructor, arguments) : Constructor.newInstance.apply(Constructor, arguments);
}
}
Constructor = typeof namedCtor === 'function' ? namedCtor(constructorName, init) : function () {
return init.apply(this, arguments);
};
for (var propName in _super_class) {
if (_super_class.hasOwnProperty(propName)) {
Constructor[propName] = _super_class[propName];
}
}
Construct._inherit(klass, _super_class, Constructor);
canReflect.assignMap(Constructor, {
constructor: Constructor,
prototype: prototype
});
if (shortName !== undefined) {
if (Object.<API key>) {
var desc = Object.<API key>(Constructor, 'name');
if (!desc || desc.configurable) {
Object.defineProperty(Constructor, 'name', {
writable: true,
value: shortName,
configurable: true
});
}
}
Constructor.shortName = shortName;
}
Constructor.prototype.constructor = Constructor;
var t = [_super_class].concat(Array.prototype.slice.call(arguments)), args = Constructor.setup.apply(Constructor, t);
if (Constructor.init) {
Constructor.init.apply(Constructor, args || t);
}
return Constructor;
},
ReturnValue: function (value) {
this.value = value;
}
});
Construct.prototype.setup = function () {
};
Construct.prototype.init = function () {
};
module.exports = namespace.Construct = Construct;
});
/*can-define@2.3.5#define-helpers/define-helpers*/
define('can-define/define-helpers/define-helpers', [
'require',
'exports',
'module',
'can-define',
'can-reflect',
'can-queues'
], function (require, exports, module) {
var define = require('can-define');
var canReflect = require('can-reflect');
var queues = require('can-queues');
var returnFirstArg = function (arg) {
return arg;
};
var defineHelpers = {
defineExpando: function (map, prop, value) {
var constructorDefines = map._define.definitions;
if (constructorDefines && constructorDefines[prop]) {
return;
}
var instanceDefines = map.<API key>;
if (!instanceDefines) {
if (Object.isSealed(map)) {
return;
}
Object.defineProperty(map, '<API key>', {
configurable: true,
enumerable: false,
value: {}
});
instanceDefines = map.<API key>;
}
if (!instanceDefines[prop]) {
var defaultDefinition = map._define.defaultDefinition || { type: define.types.observable };
define.property(map, prop, defaultDefinition, {}, {});
if (defaultDefinition.type) {
map._data[prop] = define.make.set.type(prop, defaultDefinition.type, returnFirstArg).call(map, value);
} else {
map._data[prop] = define.types.observable(value);
}
instanceDefines[prop] = defaultDefinition;
queues.batch.start();
map.dispatch({
type: 'can.keys',
target: map
});
if (map._data[prop] !== undefined) {
map.dispatch({
type: prop,
target: map,
patches: [{
type: 'set',
key: prop,
value: map._data[prop]
}]
}, [
map._data[prop],
undefined
]);
}
queues.batch.stop();
return true;
}
},
reflectSerialize: function (unwrapped) {
var <API key> = this._define.definitions;
var defaultDefinition = this._define.defaultDefinition;
this.forEach(function (val, name) {
var propDef = <API key>[name];
if (propDef && typeof propDef.serialize === 'function') {
val = propDef.serialize.call(this, val, name);
} else if (defaultDefinition && typeof defaultDefinition.serialize === 'function') {
val = defaultDefinition.serialize.call(this, val, name);
} else {
val = canReflect.serialize(val);
}
if (val !== undefined) {
unwrapped[name] = val;
}
}, this);
return unwrapped;
},
reflectUnwrap: function (unwrapped) {
this.forEach(function (value, key) {
if (value !== undefined) {
unwrapped[key] = canReflect.unwrap(value);
}
});
return unwrapped;
}
};
module.exports = defineHelpers;
});
/*can-define@2.3.5#ensure-meta*/
define('can-define/ensure-meta', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
module.exports = function ensureMeta(obj) {
var metaSymbol = canSymbol.for('can.meta');
var meta = obj[metaSymbol];
if (!meta) {
meta = {};
canReflect.setKeyValue(obj, metaSymbol, meta);
}
return meta;
};
});
/*can-define@2.3.5#map/map*/
define('can-define/map/map', [
'require',
'exports',
'module',
'can-construct',
'can-define',
'can-define/define-helpers/define-helpers',
'<API key>',
'can-namespace',
'can-log',
'can-log/dev/dev',
'can-reflect',
'can-symbol',
'can-queues',
'can-define/ensure-meta',
'can-log/dev/dev',
'can-event-queue/type/type'
], function (require, exports, module) {
'use strict';
var Construct = require('can-construct');
var define = require('can-define');
var defineHelpers = require('can-define/define-helpers/define-helpers');
var ObservationRecorder = require('<API key>');
var ns = require('can-namespace');
var canLog = require('can-log');
var canLogDev = require('can-log/dev/dev');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var queues = require('can-queues');
var ensureMeta = require('can-define/ensure-meta');
var dev = require('can-log/dev/dev');
var addTypeEvents = require('can-event-queue/type/type');
var keysForDefinition = function (definitions) {
var keys = [];
for (var prop in definitions) {
var definition = definitions[prop];
if (typeof definition !== 'object' || ('serialize' in definition ? !!definition.serialize : !definition.get)) {
keys.push(prop);
}
}
return keys;
};
function assign(source) {
queues.batch.start();
canReflect.assignMap(this, source || {});
queues.batch.stop();
}
function update(source) {
queues.batch.start();
canReflect.updateMap(this, source || {});
queues.batch.stop();
}
function assignDeep(source) {
queues.batch.start();
canReflect.assignDeepMap(this, source || {});
queues.batch.stop();
}
function updateDeep(source) {
queues.batch.start();
canReflect.updateDeepMap(this, source || {});
queues.batch.stop();
}
function setKeyValue(key, value) {
var defined = defineHelpers.defineExpando(this, key, value);
if (!defined) {
this[key] = value;
}
}
function getKeyValue(key) {
var value = this[key];
if (value !== undefined || key in this || Object.isSealed(this)) {
return value;
} else {
ObservationRecorder.add(this, key);
return this[key];
}
}
var getSchemaSymbol = canSymbol.for('can.getSchema');
function getSchema() {
var def = this.prototype._define;
var definitions = def ? def.definitions : {};
var schema = {
type: 'map',
identity: [],
keys: {}
};
return define.updateSchemaKeys(schema, definitions);
}
var DefineMap = Construct.extend('DefineMap', {
setup: function (base) {
var key, prototype = this.prototype;
if (DefineMap) {
var result = define(prototype, prototype, base.prototype._define);
define.<API key>(this, result);
addTypeEvents(this);
for (key in DefineMap.prototype) {
define.<API key>(prototype, key, prototype[key]);
}
this.prototype.setup = function (props) {
define.setup.call(this, props || {}, this.constructor.seal);
};
} else {
for (key in prototype) {
define.<API key>(prototype, key, prototype[key]);
}
}
define.<API key>(prototype, 'constructor', this);
this[getSchemaSymbol] = getSchema;
}
}, {
setup: function (props, sealed) {
if (!this._define) {
Object.defineProperty(this, '_define', {
enumerable: false,
value: { definitions: {} }
});
Object.defineProperty(this, '_data', {
enumerable: false,
value: {}
});
}
define.setup.call(this, props || {}, sealed === true);
},
get: function (prop) {
if (prop) {
return getKeyValue.call(this, prop);
} else {
return canReflect.unwrap(this, Map);
}
},
set: function (prop, value) {
if (typeof prop === 'object') {
canLogDev.warn('can-define/map/map.prototype.set is deprecated; please use can-define/map/map.prototype.assign or can-define/map/map.prototype.update instead');
if (value === true) {
updateDeep.call(this, prop);
} else {
assignDeep.call(this, prop);
}
} else {
setKeyValue.call(this, prop, value);
}
return this;
},
assignDeep: function (prop) {
assignDeep.call(this, prop);
return this;
},
updateDeep: function (prop) {
updateDeep.call(this, prop);
return this;
},
assign: function (prop) {
assign.call(this, prop);
return this;
},
update: function (prop) {
update.call(this, prop);
return this;
},
serialize: function () {
return canReflect.serialize(this, Map);
},
forEach: function () {
var forEach = function (list, cb, thisarg) {
return canReflect.eachKey(list, cb, thisarg);
}, noObserve = ObservationRecorder.ignore(forEach);
return function (cb, thisarg, observe) {
return observe === false ? noObserve(this, cb, thisarg) : forEach(this, cb, thisarg);
};
}(),
'*': { type: define.types.observable },
log: function (key) {
var instance = this;
var quoteString = function quoteString(x) {
return typeof x === 'string' ? JSON.stringify(x) : x;
};
var meta = ensureMeta(instance);
var allowed = meta.allowedLogKeysSet || new Set();
meta.allowedLogKeysSet = allowed;
if (key) {
allowed.add(key);
}
meta._log = function (event, data) {
var type = event.type;
if (type === 'can.keys' || key && !allowed.has(type)) {
return;
}
dev.log(canReflect.getName(instance), '\n key ', quoteString(type), '\n is ', quoteString(data[0]), '\n was ', quoteString(data[1]));
};
}
});
canReflect.assignSymbols(DefineMap.prototype, {
'can.isMapLike': true,
'can.isListLike': false,
'can.isValueLike': false,
'can.getKeyValue': getKeyValue,
'can.setKeyValue': setKeyValue,
'can.deleteKeyValue': function (prop) {
this.set(prop, undefined);
return this;
},
'can.getOwnKeys': function () {
var keys = canReflect.<API key>(this);
if (this._computed) {
var computedKeys = canReflect.getOwnKeys(this._computed);
var key;
for (var i = 0; i < computedKeys.length; i++) {
key = computedKeys[i];
if (keys.indexOf(key) < 0) {
keys.push(key);
}
}
}
return keys;
},
'can.<API key>': function () {
ObservationRecorder.add(this, 'can.keys');
return keysForDefinition(this._define.definitions).concat(keysForDefinition(this.<API key>));
},
'can.hasOwnKey': function (key) {
return Object.hasOwnProperty.call(this._define.definitions, key);
},
'can.hasKey': function (key) {
return !!this._define.definitions[key];
},
'can.assignDeep': assignDeep,
'can.updateDeep': updateDeep,
'can.unwrap': defineHelpers.reflectUnwrap,
'can.serialize': defineHelpers.reflectSerialize,
'can.keyHasDependencies': function (key) {
return !!(this._computed && this._computed[key] && this._computed[key].compute);
},
'can.getKeyDependencies': function (key) {
var ret;
if (this._computed && this._computed[key] && this._computed[key].compute) {
ret = {};
ret.valueDependencies = new Set([this._computed[key].compute]);
}
return ret;
},
'can.getName': function () {
return canReflect.getName(this.constructor) + '{}';
}
});
canReflect.setKeyValue(DefineMap.prototype, canSymbol.iterator, function () {
return new define.Iterator(this);
});
for (var prop in define.eventsProto) {
DefineMap[prop] = define.eventsProto[prop];
Object.defineProperty(DefineMap.prototype, prop, {
enumerable: false,
value: define.eventsProto[prop],
writable: true
});
}
var eventsProtoSymbols = '<API key>' in Object ? Object.<API key>(define.eventsProto) : [
canSymbol.for('can.onKeyValue'),
canSymbol.for('can.offKeyValue')
];
eventsProtoSymbols.forEach(function (sym) {
Object.defineProperty(DefineMap.prototype, sym, {
enumerable: false,
value: define.eventsProto[sym],
writable: true
});
});
define.DefineMap = DefineMap;
Object.defineProperty(DefineMap.prototype, 'toObject', {
enumerable: false,
writable: true,
value: function () {
canLog.warn('Use DefineMap::get instead of DefineMap::toObject');
return this.get();
}
});
module.exports = ns.DefineMap = DefineMap;
});
/*can-diff@1.0.4#list/list*/
define('can-diff/list/list', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
var slice = [].slice;
function defaultIdentity(a, b) {
return a === b;
}
function <API key>(typeSchema) {
if (typeSchema.identity && typeSchema.identity.length) {
return function identityCheck(a, b) {
var aId = canReflect.getIdentity(a, typeSchema), bId = canReflect.getIdentity(b, typeSchema);
return aId === bId;
};
} else {
return defaultIdentity;
}
}
function <API key>(listSchema) {
return listSchema.values != null ? <API key>(canReflect.getSchema(listSchema.values)) : defaultIdentity;
}
function makeIdentity(oldList, oldListLength) {
var listSchema = canReflect.getSchema(oldList), typeSchema;
if (listSchema != null) {
if (listSchema.values != null) {
typeSchema = canReflect.getSchema(listSchema.values);
} else {
return defaultIdentity;
}
}
if (typeSchema == null && oldListLength > 0) {
typeSchema = canReflect.getSchema(canReflect.getKeyValue(oldList, 0));
}
if (typeSchema) {
return <API key>(typeSchema);
} else {
return defaultIdentity;
}
}
function reverseDiff(oldDiffStopIndex, newDiffStopIndex, oldList, newList, identity) {
var oldIndex = oldList.length - 1, newIndex = newList.length - 1;
while (oldIndex > oldDiffStopIndex && newIndex > newDiffStopIndex) {
var oldItem = oldList[oldIndex], newItem = newList[newIndex];
if (identity(oldItem, newItem)) {
oldIndex
newIndex
continue;
} else {
return [{
type: 'splice',
index: newDiffStopIndex,
deleteCount: oldIndex - oldDiffStopIndex + 1,
insert: slice.call(newList, newDiffStopIndex, newIndex + 1)
}];
}
}
return [{
type: 'splice',
index: newDiffStopIndex,
deleteCount: oldIndex - oldDiffStopIndex + 1,
insert: slice.call(newList, newDiffStopIndex, newIndex + 1)
}];
}
module.exports = function (oldList, newList, schemaOrIdentity) {
var oldIndex = 0, newIndex = 0, oldLength = canReflect.size(oldList), newLength = canReflect.size(newList), patches = [];
var schemaType = typeof schemaOrIdentity, identity;
if (schemaType === 'function') {
identity = schemaOrIdentity;
} else if (schemaOrIdentity != null) {
if (schemaOrIdentity.type === 'map') {
identity = <API key>(schemaOrIdentity);
} else {
identity = <API key>(schemaOrIdentity);
}
} else {
identity = makeIdentity(oldList, oldLength);
}
while (oldIndex < oldLength && newIndex < newLength) {
var oldItem = oldList[oldIndex], newItem = newList[newIndex];
if (identity(oldItem, newItem)) {
oldIndex++;
newIndex++;
continue;
}
if (newIndex + 1 < newLength && identity(oldItem, newList[newIndex + 1])) {
patches.push({
index: newIndex,
deleteCount: 0,
insert: [newList[newIndex]],
type: 'splice'
});
oldIndex++;
newIndex += 2;
continue;
} else if (oldIndex + 1 < oldLength && identity(oldList[oldIndex + 1], newItem)) {
patches.push({
index: newIndex,
deleteCount: 1,
insert: [],
type: 'splice'
});
oldIndex += 2;
newIndex++;
continue;
} else {
patches.push.apply(patches, reverseDiff(oldIndex, newIndex, oldList, newList, identity));
return patches;
}
}
if (newIndex === newLength && oldIndex === oldLength) {
return patches;
}
patches.push({
type: 'splice',
index: newIndex,
deleteCount: oldLength - oldIndex,
insert: slice.call(newList, newIndex)
});
return patches;
};
});
/*can-cid@1.1.2#can-cid*/
define('can-cid', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
var namespace = require('can-namespace');
var _cid = 0;
var domExpando = 'can' + new Date();
var cid = function (object, name) {
var propertyName = object.nodeName ? domExpando : '_cid';
if (!object[propertyName]) {
_cid++;
object[propertyName] = (name || '') + _cid;
}
return object[propertyName];
};
cid.domExpando = domExpando;
cid.get = function (object) {
var type = typeof object;
var isObject = type !== null && (type === 'object' || type === 'function');
return isObject ? cid(object) : type + ':' + object;
};
if (namespace.cid) {
throw new Error('You can\'t have two versions of can-cid, check your dependencies');
} else {
module.exports = namespace.cid = cid;
}
});
/*<API key>@1.0.0#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-cid'
], function (require, exports, module) {
(function (global, require, exports, module) {
var CID = require('can-cid');
var singleReference;
function getKeyName(key, extraKey) {
var keyName = extraKey ? CID(key) + ':' + extraKey : CID(key);
return keyName || key;
}
singleReference = {
set: function (obj, key, value, extraKey) {
obj[getKeyName(key, extraKey)] = value;
},
getAndDelete: function (obj, key, extraKey) {
var keyName = getKeyName(key, extraKey);
var value = obj[keyName];
delete obj[keyName];
return value;
}
};
module.exports = singleReference;
}(function () {
return this;
}(), require, exports, module));
});
/*can-define@2.3.5#list/list*/
define('can-define/list/list', [
'require',
'exports',
'module',
'can-construct',
'can-define',
'can-queues',
'can-event-queue/type/type',
'<API key>',
'can-log',
'can-log/dev/dev',
'can-define/define-helpers/define-helpers',
'can-log/dev/dev',
'can-define/ensure-meta',
'can-assign',
'can-diff/list/list',
'can-namespace',
'can-reflect',
'can-symbol',
'<API key>'
], function (require, exports, module) {
var Construct = require('can-construct');
var define = require('can-define');
var make = define.make;
var queues = require('can-queues');
var addTypeEvents = require('can-event-queue/type/type');
var ObservationRecorder = require('<API key>');
var canLog = require('can-log');
var canLogDev = require('can-log/dev/dev');
var defineHelpers = require('can-define/define-helpers/define-helpers');
var dev = require('can-log/dev/dev');
var ensureMeta = require('can-define/ensure-meta');
var assign = require('can-assign');
var diff = require('can-diff/list/list');
var ns = require('can-namespace');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var singleReference = require('<API key>');
var splice = [].splice;
var runningNative = false;
var identity = function (x) {
return x;
};
var <API key> = 'can.patches';
var makeFilterCallback = function (props) {
return function (item) {
for (var prop in props) {
if (item[prop] !== props[prop]) {
return false;
}
}
return true;
};
};
var onKeyValue = define.eventsProto[canSymbol.for('can.onKeyValue')];
var offKeyValue = define.eventsProto[canSymbol.for('can.offKeyValue')];
var getSchemaSymbol = canSymbol.for('can.getSchema');
function getSchema() {
var definitions = this.prototype._define.definitions;
var schema = {
type: 'list',
keys: {}
};
schema = define.updateSchemaKeys(schema, definitions);
if (schema.keys['
schema.values = definitions['#'].Type;
delete schema.keys['
}
return schema;
}
var DefineList = Construct.extend('DefineList', {
setup: function (base) {
if (DefineList) {
addTypeEvents(this);
var prototype = this.prototype;
var result = define(prototype, prototype, base.prototype._define);
define.<API key>(this, result);
var itemsDefinition = result.definitions['#'] || result.defaultDefinition;
if (itemsDefinition) {
if (itemsDefinition.Type) {
this.prototype.__type = make.set.Type('*', itemsDefinition.Type, identity);
} else if (itemsDefinition.type) {
this.prototype.__type = make.set.type('*', itemsDefinition.type, identity);
}
}
this[getSchemaSymbol] = getSchema;
}
}
}, {
setup: function (items) {
if (!this._define) {
Object.defineProperty(this, '_define', {
enumerable: false,
value: {
definitions: {
length: { type: 'number' },
_length: { type: 'number' }
}
}
});
Object.defineProperty(this, '_data', {
enumerable: false,
value: {}
});
}
define.setup.call(this, {}, false);
Object.defineProperty(this, '_length', {
enumerable: false,
configurable: true,
writable: true,
value: 0
});
if (items) {
this.splice.apply(this, [
0,
0
].concat(canReflect.toArray(items)));
}
},
__type: define.types.observable,
_triggerChange: function (attr, how, newVal, oldVal) {
var index = +attr;
if (!isNaN(index)) {
var itemsDefinition = this._define.definitions['
var patches;
if (how === 'add') {
if (itemsDefinition && typeof itemsDefinition.added === 'function') {
ObservationRecorder.ignore(itemsDefinition.added).call(this, newVal, index);
}
patches = [{
type: 'splice',
insert: newVal,
index: index,
deleteCount: 0
}];
this.dispatch({
type: how,
patches: patches,
reasonLog: [
canReflect.getName(this),
'added',
newVal,
'at',
index
]
}, [
newVal,
index
]);
} else if (how === 'remove') {
if (itemsDefinition && typeof itemsDefinition.removed === 'function') {
ObservationRecorder.ignore(itemsDefinition.removed).call(this, oldVal, index);
}
patches = [{
type: 'splice',
index: index,
deleteCount: oldVal.length
}];
this.dispatch({
type: how,
patches: patches,
reasonLog: [
canReflect.getName(this),
'remove',
oldVal,
'at',
index
]
}, [
oldVal,
index
]);
} else {
this.dispatch(how, [
newVal,
index
]);
}
} else {
this.dispatch({
type: '' + attr,
target: this
}, [
newVal,
oldVal
]);
}
},
get: function (index) {
if (arguments.length) {
if (isNaN(index)) {
ObservationRecorder.add(this, index);
} else {
ObservationRecorder.add(this, 'length');
}
return this[index];
} else {
return canReflect.unwrap(this, Map);
}
},
set: function (prop, value) {
if (typeof prop !== 'object') {
prop = isNaN(+prop) || prop % 1 ? prop : +prop;
if (typeof prop === 'number') {
if (typeof prop === 'number' && prop > this._length - 1) {
var newArr = new Array(prop + 1 - this._length);
newArr[newArr.length - 1] = value;
this.push.apply(this, newArr);
return newArr;
}
this.splice(prop, 1, value);
} else {
var defined = defineHelpers.defineExpando(this, prop, value);
if (!defined) {
this[prop] = value;
}
}
} else {
canLogDev.warn('can-define/list/list.prototype.set is deprecated; please use can-define/list/list.prototype.assign or can-define/list/list.prototype.update instead');
if (canReflect.isListLike(prop)) {
if (value) {
this.replace(prop);
} else {
canReflect.assignList(this, prop);
}
} else {
canReflect.assignMap(this, prop);
}
}
return this;
},
assign: function (prop) {
if (canReflect.isListLike(prop)) {
canReflect.assignList(this, prop);
} else {
canReflect.assignMap(this, prop);
}
return this;
},
update: function (prop) {
if (canReflect.isListLike(prop)) {
canReflect.updateList(this, prop);
} else {
canReflect.updateMap(this, prop);
}
return this;
},
assignDeep: function (prop) {
if (canReflect.isListLike(prop)) {
canReflect.assignDeepList(this, prop);
} else {
canReflect.assignDeepMap(this, prop);
}
return this;
},
updateDeep: function (prop) {
if (canReflect.isListLike(prop)) {
canReflect.updateDeepList(this, prop);
} else {
canReflect.updateDeepMap(this, prop);
}
return this;
},
_items: function () {
var arr = [];
this._each(function (item) {
arr.push(item);
});
return arr;
},
_each: function (callback) {
for (var i = 0, len = this._length; i < len; i++) {
callback(this[i], i);
}
},
splice: function (index, howMany) {
var args = canReflect.toArray(arguments), added = [], i, len, listIndex, allSame = args.length > 2, oldLength = this._length;
index = index || 0;
for (i = 0, len = args.length - 2; i < len; i++) {
listIndex = i + 2;
args[listIndex] = this.__type(args[listIndex], listIndex);
added.push(args[listIndex]);
if (this[i + index] !== args[listIndex]) {
allSame = false;
}
}
if (allSame && this._length <= added.length) {
return added;
}
if (howMany === undefined) {
howMany = args[1] = this._length - index;
}
runningNative = true;
var removed = splice.apply(this, args);
runningNative = false;
queues.batch.start();
if (howMany > 0) {
this._triggerChange('' + index, 'remove', undefined, removed);
}
if (args.length > 2) {
this._triggerChange('' + index, 'add', added, removed);
}
this.dispatch('length', [
this._length,
oldLength
]);
queues.batch.stop();
return removed;
},
serialize: function () {
return canReflect.serialize(this, Map);
},
log: function (key) {
var instance = this;
var quoteString = function quoteString(x) {
return typeof x === 'string' ? JSON.stringify(x) : x;
};
var meta = ensureMeta(instance);
var allowed = meta.allowedLogKeysSet || new Set();
meta.allowedLogKeysSet = allowed;
if (key) {
allowed.add(key);
}
meta._log = function (event, data) {
var type = event.type;
if (type === 'can.onPatches' || key && !allowed.has(type)) {
return;
}
if (type === 'add' || type === 'remove') {
dev.log(canReflect.getName(instance), '\n how ', quoteString(type), '\n what ', quoteString(data[0]), '\n index ', quoteString(data[1]));
} else {
dev.log(canReflect.getName(instance), '\n key ', quoteString(type), '\n is ', quoteString(data[0]), '\n was ', quoteString(data[1]));
}
};
}
});
for (var prop in define.eventsProto) {
Object.defineProperty(DefineList.prototype, prop, {
enumerable: false,
value: define.eventsProto[prop],
writable: true
});
}
var eventsProtoSymbols = '<API key>' in Object ? Object.<API key>(define.eventsProto) : [
canSymbol.for('can.onKeyValue'),
canSymbol.for('can.offKeyValue')
];
eventsProtoSymbols.forEach(function (sym) {
Object.defineProperty(DefineList.prototype, sym, {
enumerable: false,
value: define.eventsProto[sym],
writable: true
});
});
var getArgs = function (args) {
return args[0] && Array.isArray(args[0]) ? args[0] : canReflect.toArray(args);
};
canReflect.eachKey({
push: 'length',
unshift: 0
}, function (where, name) {
var orig = [][name];
DefineList.prototype[name] = function () {
var args = [], len = where ? this._length : 0, i = arguments.length, res, val;
while (i
val = arguments[i];
args[i] = this.__type(val, i);
}
runningNative = true;
res = orig.apply(this, args);
runningNative = false;
if (!this.comparator || args.length) {
queues.batch.start();
this._triggerChange('' + len, 'add', args, undefined);
this.dispatch('length', [
this._length,
len
]);
queues.batch.stop();
}
return res;
};
});
canReflect.eachKey({
pop: 'length',
shift: 0
}, function (where, name) {
var orig = [][name];
DefineList.prototype[name] = function () {
if (!this._length) {
return undefined;
}
var args = getArgs(arguments), len = where && this._length ? this._length - 1 : 0, oldLength = this._length ? this._length : 0, res;
runningNative = true;
res = orig.apply(this, args);
runningNative = false;
queues.batch.start();
this._triggerChange('' + len, 'remove', undefined, [res]);
this.dispatch('length', [
this._length,
oldLength
]);
queues.batch.stop();
return res;
};
});
canReflect.eachKey({
'map': 3,
'filter': 3,
'reduce': 4,
'reduceRight': 4,
'every': 3,
'some': 3
}, function a(fnLength, fnName) {
DefineList.prototype[fnName] = function () {
var self = this;
var args = [].slice.call(arguments, 0);
var callback = args[0];
var thisArg = args[fnLength - 1] || self;
if (typeof callback === 'object') {
callback = makeFilterCallback(callback);
}
args[0] = function () {
var cbArgs = [].slice.call(arguments, 0);
cbArgs[fnLength - 3] = self.get(cbArgs[fnLength - 2]);
return callback.apply(thisArg, cbArgs);
};
var ret = Array.prototype[fnName].apply(this, args);
if (fnName === 'map') {
return new DefineList(ret);
} else if (fnName === 'filter') {
return new self.constructor(ret);
} else {
return ret;
}
};
});
assign(DefineList.prototype, {
indexOf: function (item, fromIndex) {
for (var i = fromIndex || 0, len = this.length; i < len; i++) {
if (this.get(i) === item) {
return i;
}
}
return -1;
},
lastIndexOf: function (item, fromIndex) {
fromIndex = typeof fromIndex === 'undefined' ? this.length - 1 : fromIndex;
for (var i = fromIndex; i >= 0; i
if (this.get(i) === item) {
return i;
}
}
return -1;
},
join: function () {
ObservationRecorder.add(this, 'length');
return [].join.apply(this, arguments);
},
reverse: function () {
var list = [].reverse.call(this._items());
return this.replace(list);
},
slice: function () {
ObservationRecorder.add(this, 'length');
var temp = Array.prototype.slice.apply(this, arguments);
return new this.constructor(temp);
},
concat: function () {
var args = [];
canReflect.eachIndex(arguments, function (arg) {
if (canReflect.isListLike(arg)) {
var arr = Array.isArray(arg) ? arg : canReflect.toArray(arg);
arr.forEach(function (innerArg) {
args.push(this.__type(innerArg));
}, this);
} else {
args.push(this.__type(arg));
}
}, this);
return new this.constructor(Array.prototype.concat.apply(canReflect.toArray(this), args));
},
forEach: function (cb, thisarg) {
var item;
for (var i = 0, len = this.length; i < len; i++) {
item = this.get(i);
if (cb.call(thisarg || item, item, i, this) === false) {
break;
}
}
return this;
},
replace: function (newList) {
var patches = diff(this, newList);
queues.batch.start();
for (var i = 0, len = patches.length; i < len; i++) {
this.splice.apply(this, [
patches[i].index,
patches[i].deleteCount
].concat(patches[i].insert));
}
queues.batch.stop();
return this;
},
sort: function (compareFunction) {
var sorting = Array.prototype.slice.call(this);
Array.prototype.sort.call(sorting, compareFunction);
this.splice.apply(this, [
0,
sorting.length
].concat(sorting));
return this;
}
});
for (var prop in define.eventsProto) {
DefineList[prop] = define.eventsProto[prop];
Object.defineProperty(DefineList.prototype, prop, {
enumerable: false,
value: define.eventsProto[prop],
writable: true
});
}
Object.defineProperty(DefineList.prototype, 'length', {
get: function () {
if (!this.__inSetup) {
ObservationRecorder.add(this, 'length');
}
return this._length;
},
set: function (newVal) {
if (runningNative) {
this._length = newVal;
return;
}
if (newVal == null || isNaN(+newVal) || newVal === this._length) {
return;
}
if (newVal > this._length - 1) {
var newArr = new Array(newVal - this._length);
this.push.apply(this, newArr);
} else {
this.splice(newVal);
}
},
enumerable: true
});
DefineList.prototype.attr = function (prop, value) {
canLog.warn('DefineMap::attr shouldn\'t be called');
if (arguments.length === 0) {
return this.get();
} else if (prop && typeof prop === 'object') {
return this.set.apply(this, arguments);
} else if (arguments.length === 1) {
return this.get(prop);
} else {
return this.set(prop, value);
}
};
DefineList.prototype.item = function (index, value) {
if (arguments.length === 1) {
return this.get(index);
} else {
return this.set(index, value);
}
};
DefineList.prototype.items = function () {
canLog.warn('DefineList::get should should be used instead of DefineList::items');
return this.get();
};
canReflect.assignSymbols(DefineList.prototype, {
'can.<API key>': true,
'can.isMapLike': true,
'can.isListLike': true,
'can.isValueLike': false,
'can.getKeyValue': DefineList.prototype.get,
'can.setKeyValue': DefineList.prototype.set,
'can.onKeyValue': function (key, handler, queue) {
var translationHandler;
if (isNaN(key)) {
return onKeyValue.apply(this, arguments);
} else {
translationHandler = function () {
handler(this[key]);
};
Object.defineProperty(translationHandler, 'name', { value: 'translationHandler(' + key + ')::' + canReflect.getName(this) + '.onKeyValue(\'length\',' + canReflect.getName(handler) + ')' });
singleReference.set(handler, this, translationHandler, key);
return onKeyValue.call(this, 'length', translationHandler, queue);
}
},
'can.offKeyValue': function (key, handler, queue) {
var translationHandler;
if (isNaN(key)) {
return offKeyValue.apply(this, arguments);
} else {
translationHandler = singleReference.getAndDelete(handler, this, key);
return offKeyValue.call(this, 'length', translationHandler, queue);
}
},
'can.deleteKeyValue': function (prop) {
prop = isNaN(+prop) || prop % 1 ? prop : +prop;
if (typeof prop === 'number') {
this.splice(prop, 1);
} else if (prop === 'length' || prop === '_length') {
return;
} else {
this.set(prop, undefined);
}
return this;
},
'can.assignDeep': function (source) {
queues.batch.start();
canReflect.assignList(this, source);
queues.batch.stop();
},
'can.updateDeep': function (source) {
queues.batch.start();
this.replace(source);
queues.batch.stop();
},
'can.keyHasDependencies': function (key) {
return !!(this._computed && this._computed[key] && this._computed[key].compute);
},
'can.getKeyDependencies': function (key) {
var ret;
if (this._computed && this._computed[key] && this._computed[key].compute) {
ret = {};
ret.valueDependencies = new Set([this._computed[key].compute]);
}
return ret;
},
'can.splice': function (index, deleteCount, insert) {
this.splice.apply(this, [
index,
deleteCount
].concat(insert));
},
'can.onPatches': function (handler, queue) {
this[canSymbol.for('can.onKeyValue')](<API key>, handler, queue);
},
'can.offPatches': function (handler, queue) {
this[canSymbol.for('can.offKeyValue')](<API key>, handler, queue);
},
'can.getName': function () {
return canReflect.getName(this.constructor) + '[]';
}
});
canReflect.setKeyValue(DefineList.prototype, canSymbol.iterator, function () {
var index = -1;
if (typeof this._length !== 'number') {
this._length = 0;
}
return {
next: function () {
index++;
return {
value: this[index],
done: index >= this._length
};
}.bind(this)
};
});
define.DefineList = DefineList;
module.exports = ns.DefineList = DefineList;
});
/*can@5.0.0-pre.3#es/can-define*/
define('can/es/can-define', [
'exports',
'can-define',
'can-define/map/map',
'can-define/list/list'
], function (exports, _canDefine, _map, _list) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'define', {
enumerable: true,
get: function () {
return <API key>(_canDefine).default;
}
});
Object.defineProperty(exports, 'DefineMap', {
enumerable: true,
get: function () {
return <API key>(_map).default;
}
});
Object.defineProperty(exports, 'DefineList', {
enumerable: true,
get: function () {
return <API key>(_list).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-namespace*/
define('can/es/can-namespace', [
'exports',
'can-namespace'
], function (exports, _canNamespace) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canNamespace).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-key@0.5.0#utils*/
define('can-key/utils', function (require, exports, module) {
var utils = {
isContainer: function (current) {
var type = typeof current;
return current && (type === 'object' || type === 'function');
},
strReplacer: /\{([^\}]+)\}/g,
parts: function (name) {
if (Array.isArray(name)) {
return name;
} else {
return typeof name !== 'undefined' ? (name + '').replace(/\[/g, '.').replace(/]/g, '').split('.') : [];
}
}
};
module.exports = utils;
});
/*can-key@0.5.0#get/get*/
define('can-key/get/get', [
'require',
'exports',
'module',
'can-reflect',
'can-key/utils'
], function (require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
var utils = require('can-key/utils');
function get(obj, name) {
var parts = utils.parts(name);
var length = parts.length, current, i, container;
if (!length) {
return obj;
}
current = obj;
for (i = 0; i < length && utils.isContainer(current) && current !== null; i++) {
container = current;
current = canReflect.getKeyValue(container, parts[i]);
}
return current;
}
module.exports = get;
});
/*can-key@0.5.0#delete/delete*/
define('can-key/delete/delete', [
'require',
'exports',
'module',
'can-reflect',
'can-key/utils'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var utils = require('can-key/utils');
module.exports = function deleteAtPath(data, path) {
var parts = utils.parts(path);
var current = data;
for (var i = 0; i < parts.length - 1; i++) {
if (current) {
current = canReflect.getKeyValue(current, parts[i]);
}
}
if (current) {
canReflect.deleteKeyValue(current, parts[parts.length - 1]);
}
};
});
/*can-key@0.5.0#sub/sub*/
define('can-key/sub/sub', [
'require',
'exports',
'module',
'can-key/utils',
'can-key/get/get',
'can-reflect',
'can-key/delete/delete'
], function (require, exports, module) {
var utils = require('can-key/utils');
var get = require('can-key/get/get');
var canReflect = require('can-reflect');
var deleteKey = require('can-key/delete/delete');
module.exports = function sub(str, data, remove) {
var obs = [];
str = str || '';
obs.push(str.replace(utils.strReplacer, function (whole, inside) {
var ob = get(data, inside);
if (remove === true) {
deleteKey(data, inside);
}
if (ob === undefined || ob === null) {
obs = null;
return '';
}
if (!canReflect.isPrimitive(ob) && obs) {
obs.push(ob);
return '';
}
return '' + ob;
}));
return obs === null ? obs : obs.length <= 1 ? obs[0] : obs;
};
});
/*can-query-logic@0.8.11#src/set*/
define('can-query-logic/src/set', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var set;
var addSerializeToThis = function (obj) {
return canReflect.assignSymbols(obj, {
'can.serialize': function () {
return this;
}
});
};
function reverseArgs(fn) {
return function (first, second) {
return fn.call(this, second, first);
};
}
var <API key> = canSymbol.for('can.setComparisons');
function addComparators(type1, type2, comparators) {
var comparisons = type1[<API key>];
if (!type1[<API key>]) {
comparisons = type1[<API key>] = new Map();
}
var subMap = comparisons.get(type1);
if (!subMap) {
subMap = new Map();
comparisons.set(type1, subMap);
}
var existingComparators = subMap.get(type2);
if (existingComparators) {
for (var prop in comparators) {
if (existingComparators.hasOwnProperty(prop)) {
console.warn('Overwriting ' + type1.name + ' ' + prop + ' ' + type2.name + ' comparitor');
}
existingComparators[prop] = comparators[prop];
}
} else {
subMap.set(type2, comparators);
}
}
function Identity() {
}
var typeMap = {
'number': Identity,
'string': Identity,
'undefined': Identity,
'boolean': Identity
};
var get = {};
[
'intersection',
'difference',
'union'
].forEach(function (prop) {
get[prop] = function (forwardComparators, value1, value2) {
if (value2 === set.UNIVERSAL) {
if (prop === 'intersection') {
return value1;
}
if (prop === 'union') {
return set.UNIVERSAL;
}
if (prop === 'difference') {
return set.EMPTY;
}
}
if (value1 === set.UNIVERSAL) {
if (prop === 'intersection') {
return value1;
}
if (prop === 'union') {
return set.UNIVERSAL;
}
}
if (forwardComparators && forwardComparators[prop]) {
var result = forwardComparators[prop](value1, value2);
if (result === undefined && forwardComparators.undefinedIsEmptySet === true) {
return set.EMPTY;
} else {
return result;
}
} else {
throw new Error('Unable to perform ' + prop + ' between ' + set.getType(value1).name + ' and ' + set.getType(value2).name);
}
};
});
set = {
UNIVERSAL: canReflect.assignSymbols({ name: 'UNIVERSAL' }, {
'can.serialize': function () {
return this;
},
'can.isMember': function () {
return true;
}
}),
EMPTY: canReflect.assignSymbols({ name: 'EMPTY' }, {
'can.serialize': function () {
return this;
},
'can.isMember': function () {
return false;
}
}),
UNDEFINABLE: addSerializeToThis({ name: 'UNDEFINABLE' }),
UNKNOWABLE: addSerializeToThis({ name: 'UNKNOWABLE' }),
Identity: Identity,
isSpecial: function (setA) {
return setA === set.UNIVERSAL || setA === set.EMPTY || setA === set.UNDEFINABLE || setA === set.UNKNOWABLE;
},
<API key>: function (setA) {
if (setA !== set.EMPTY && setA !== set.UNDEFINABLE && setA !== set.UNKNOWABLE) {
return setA;
} else {
return false;
}
},
getType: function (value) {
if (value === set.UNIVERSAL) {
return set.UNIVERSAL;
}
if (value === set.EMPTY) {
return set.EMPTY;
}
if (value === set.UNKNOWABLE) {
return set.UNKNOWABLE;
}
if (value === null) {
return Identity;
}
if (typeMap.hasOwnProperty(typeof value)) {
return typeMap[typeof value];
}
return value.constructor;
},
ownAndMemberValue: function (startOwnValue, startMemberValue) {
if (startOwnValue != null || startMemberValue != null) {
var ownValue = startOwnValue != null ? startOwnValue.valueOf() : startOwnValue, memberValue = startMemberValue != null ? startMemberValue.valueOf() : startMemberValue;
if (startOwnValue == null || startMemberValue == null) {
return {
own: ownValue,
member: memberValue
};
}
if (ownValue.constructor !== memberValue.constructor) {
memberValue = new startOwnValue.constructor(memberValue).valueOf();
}
return {
own: ownValue,
member: memberValue
};
}
return {
own: startMemberValue,
member: startOwnValue
};
},
getComparisons: function (Type1, Type2) {
var comparisons = Type1[<API key>];
if (comparisons) {
var subMap = comparisons.get(Type1);
if (subMap) {
return subMap.get(Type2);
}
}
},
hasComparisons: function (Type) {
return !!Type[<API key>];
},
defineComparison: function (type1, type2, comparators) {
addComparators(type1, type2, comparators);
if (type1 !== type2) {
var reverse = {};
for (var prop in comparators) {
if (prop !== 'difference') {
reverse[prop] = reverseArgs(comparators[prop]);
}
}
addComparators(type2, type1, reverse);
}
},
isSubset: function (value1, value2) {
if (value1 === value2) {
return true;
}
var Type1 = set.getType(value1), Type2 = set.getType(value2);
var forwardComparators = set.getComparisons(Type1, Type2);
if (forwardComparators) {
var intersection = get.intersection(forwardComparators, value1, value2);
var difference = get.difference(forwardComparators, value1, value2);
if (intersection === set.UNKNOWABLE || difference === set.UNKNOWABLE) {
return undefined;
} else if (intersection !== set.EMPTY && difference === set.EMPTY) {
return true;
} else {
return false;
}
} else {
throw new Error('Unable to perform subset comparison between ' + Type1.name + ' and ' + Type2.name);
}
},
isProperSubset: function (setA, setB) {
return set.isSubset(setA, setB) && !set.isEqual(setA, setB);
},
isEqual: function (value1, value2) {
if (value1 === set.UNKNOWABLE || value2 === set.UNKNOWABLE) {
return set.UNKNOWABLE;
}
var isSpecial1 = set.isSpecial(value1), isSpecial2 = set.isSpecial(value2);
if (isSpecial1 && isSpecial2) {
return isSpecial1 === isSpecial2;
}
var Type1 = set.getType(value1), Type2 = set.getType(value2);
if (value1 === value2) {
return true;
}
var forwardComparators = set.getComparisons(Type1, Type2);
var reverseComparators = set.getComparisons(Type2, Type1);
if (forwardComparators && reverseComparators) {
var intersection = get.intersection(forwardComparators, value1, value2);
var difference = get.difference(forwardComparators, value1, value2);
if (intersection !== set.EMPTY && difference === set.EMPTY) {
var reverseIntersection = get.intersection(reverseComparators, value2, value1);
var reverseDifference = get.difference(reverseComparators, value2, value1);
return reverseIntersection !== set.EMPTY && reverseDifference === set.EMPTY;
} else {
return false;
}
} else {
var values = set.ownAndMemberValue(value1, value2);
if (canReflect.isPrimitive(values.own) && canReflect.isPrimitive(values.member)) {
return values.own === values.member;
} else {
throw new Error('Unable to perform equal comparison between ' + Type1.name + ' and ' + Type2.name);
}
}
},
union: function (value1, value2) {
if (value1 === set.UNIVERSAL || value2 === set.UNIVERSAL) {
return set.UNIVERSAL;
}
if (value1 === set.EMPTY) {
return value2;
} else if (value2 === set.EMPTY) {
return value1;
}
if (value1 === set.UNKNOWABLE || value2 === set.UNKNOWABLE) {
return set.UNKNOWABLE;
}
var Type1 = set.getType(value1), Type2 = set.getType(value2);
var forwardComparators = set.getComparisons(Type1, Type2);
return get.union(forwardComparators, value1, value2);
},
intersection: function (value1, value2) {
if (value1 === set.UNIVERSAL) {
return value2;
}
if (value2 === set.UNIVERSAL) {
return value1;
}
if (value1 === set.EMPTY || value2 === set.EMPTY) {
return set.EMPTY;
}
if (value1 === set.UNKNOWABLE || value2 === set.UNKNOWABLE) {
return set.UNKNOWABLE;
}
var Type1 = set.getType(value1), Type2 = set.getType(value2);
var forwardComparators = set.getComparisons(Type1, Type2);
if (forwardComparators) {
return get.intersection(forwardComparators, value1, value2);
} else {
throw new Error('Unable to perform intersection comparison between ' + Type1.name + ' and ' + Type2.name);
}
},
difference: function (value1, value2) {
if (value1 === set.EMPTY) {
return set.EMPTY;
}
if (value2 === set.EMPTY) {
return value1;
}
if (value1 === set.UNKNOWABLE || value2 === set.UNKNOWABLE) {
return set.UNKNOWABLE;
}
var Type1 = set.getType(value1), Type2 = set.getType(value2);
var forwardComparators = set.getComparisons(Type1, Type2);
if (forwardComparators) {
return get.difference(forwardComparators, value1, value2);
} else {
throw new Error('Unable to perform difference comparison between ' + Type1.name + ' and ' + Type2.name);
}
},
indexWithEqual: function (arr, value) {
for (var i = 0, len = arr.length; i < len; i++) {
if (set.isEqual(arr[i], value)) {
return i;
}
}
return -1;
}
};
function <API key>(v1, v2) {
return v1 === v2 ? v1 : set.EMPTY;
}
function identityDifference(v1, v2) {
return v1 === v2 ? set.EMPTY : v1;
}
function identityUnion(v1, v2) {
return v1 === v2 ? v1 : set.UNDEFINABLE;
}
var identityComparitor = {
intersection: <API key>,
difference: identityDifference,
union: identityUnion
};
set.defineComparison(Identity, Identity, identityComparitor);
set.defineComparison(set.UNIVERSAL, set.UNIVERSAL, identityComparitor);
module.exports = set;
});
/*can-fixture@3.0.0-pre.11#data-from-url*/
define('can-fixture/data-from-url', function (require, exports, module) {
var replacer = /\{([^\}]+)\}/g;
module.exports = function dataFromUrl(fixtureUrl, url) {
if (!fixtureUrl) {
return {};
}
var order = [], fixtureUrlAdjusted = fixtureUrl.replace('.', '\\.').replace('?', '\\?'), res = new RegExp(fixtureUrlAdjusted.replace(replacer, function (whole, part) {
order.push(part);
return '([^/]+)';
}) + '$').exec(url), data = {};
if (!res) {
return null;
}
res.shift();
order.forEach(function (name) {
data[name] = res.shift();
});
return data;
};
});
/*can-query-logic@0.8.11#src/<API key>*/
define('can-query-logic/src/<API key>', [
'require',
'exports',
'module',
'can-query-logic/src/set'
], function (require, exports, module) {
var SET = require('can-query-logic/src/set');
function getValue(value) {
return value == null ? value : value.valueOf();
}
module.exports = function <API key>(arr1, arr2) {
var set = new Set();
var intersection = [];
var union = [];
var difference = arr1.slice(0);
arr1.forEach(function (value) {
set.add(getValue(value));
union.push(value);
});
arr2.forEach(function (value) {
if (set.has(getValue(value))) {
intersection.push(value);
var index = SET.indexWithEqual(difference, value);
if (index !== -1) {
difference.splice(index, 1);
}
} else {
union.push(value);
}
});
return {
intersection: intersection,
union: union,
difference: difference
};
};
});
/*can-query-logic@0.8.11#src/types/comparisons*/
define('can-query-logic/src/types/comparisons', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/<API key>',
'can-symbol'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var <API key> = require('can-query-logic/src/<API key>');
var canSymbol = require('can-symbol');
var isMemberSymbol = canSymbol.for('can.isMember');
var comparisons = {
In: function In(values) {
this.values = values;
},
NotIn: function NotIn(values) {
this.values = values;
},
GreaterThan: function GreaterThan(value) {
this.value = value;
},
GreaterThanEqual: function GreaterThanEqual(value) {
this.value = value;
},
LessThan: function LessThan(value) {
this.value = value;
},
LessThanEqual: function LessThanEqual(value) {
this.value = value;
},
And: function ValueAnd(ands) {
this.values = ands;
},
Or: function ValueOr(ors) {
this.values = ors;
}
};
comparisons.Or.prototype.orValues = function () {
return this.values;
};
comparisons.In.test = function (values, b) {
return values.some(function (value) {
var values = set.ownAndMemberValue(value, b);
return values.own === values.member;
});
};
comparisons.NotIn.test = function (values, b) {
return !comparisons.In.test(values, b);
};
comparisons.NotIn.testValue = function (value, b) {
return !comparisons.In.testValue(value, b);
};
function nullIsFalse(test) {
return function (arg1, arg2) {
if (arg1 == null || arg2 == null) {
return false;
} else {
return test(arg1, arg2);
}
};
}
function nullIsFalseTwoIsOk(test) {
return function (arg1, arg2) {
if (arg1 === arg2) {
return true;
} else if (arg1 == null || arg2 == null) {
return false;
} else {
return test(arg1, arg2);
}
};
}
comparisons.GreaterThan.test = nullIsFalse(function (a, b) {
return a > b;
});
comparisons.GreaterThanEqual.test = nullIsFalseTwoIsOk(function (a, b) {
return a >= b;
});
comparisons.LessThan.test = nullIsFalse(function (a, b) {
return a < b;
});
comparisons.LessThanEqual.test = nullIsFalseTwoIsOk(function (a, b) {
return a <= b;
});
function <API key>(value) {
var values = set.ownAndMemberValue(this.value, value);
return this.constructor.test(values.member, values.own);
}
[
comparisons.GreaterThan,
comparisons.GreaterThanEqual,
comparisons.LessThan,
comparisons.LessThanEqual,
comparisons.LessThan
].forEach(function (Type) {
Type.prototype.isMember = <API key>;
});
function <API key>(value) {
return this.constructor.test(this.values, value);
}
[
comparisons.In,
comparisons.NotIn
].forEach(function (Type) {
Type.prototype.isMember = <API key>;
});
comparisons.And.prototype.isMember = function (value) {
return this.values.every(function (and) {
return and.isMember(value);
});
};
comparisons.Or.prototype.isMember = function (value) {
return this.values.some(function (and) {
return and.isMember(value);
});
};
Object.keys(comparisons).forEach(function (name) {
comparisons[name].prototype[isMemberSymbol] = comparisons[name].prototype.isMember;
});
function makeNot(Type) {
return {
test: function (vA, vB) {
return !Type.test(vA, vB);
}
};
}
function makeEnum(type, Type, emptyResult) {
return function (a, b) {
var result = <API key>(a.values, b.values);
if (result[type].length) {
return new Type(result[type]);
} else {
return emptyResult || set.EMPTY;
}
};
}
function isUniversal(aSet) {
return set.isEqual(set.UNIVERSAL, aSet);
}
function swapArgs(fn) {
return function (a, b) {
return fn(b, a);
};
}
function makeSecondValue(Type, prop) {
return function (universe, value) {
return new Type(value[prop || 'value']);
};
}
function returnBiggerValue(gtA, gtB) {
if (gtA.value < gtB.value) {
return gtB;
} else {
return gtA;
}
}
function returnSmallerValue(gtA, gtB) {
if (gtA.value > gtB.value) {
return gtB;
} else {
return gtA;
}
}
function makeAndIf(Comparison, Type) {
return function (ltA, ltB) {
if (Comparison.test(ltA.value, ltB.value)) {
return makeAnd([
ltA,
new Type(ltB.value)
]);
} else {
return set.EMPTY;
}
};
}
function <API key>(Comparison, Type) {
var elseCase = makeAndIf(Comparison, Type);
return function (a, b) {
if (a.value === b.value) {
return new is.In([a.value]);
} else {
return elseCase(a, b);
}
};
}
function <API key>(Comparison, Type, defaultReturn) {
return function (inSet, gt) {
var values = inSet.values.filter(function (value) {
return Comparison.test(gt, value);
});
return values.length ? new Type(values) : defaultReturn || set.EMPTY;
};
}
function <API key>(Comparison, Type, defaultReturn) {
return function (inSet, gt) {
var values = inSet.values.filter(function (value) {
return Comparison.test(value, gt.value);
});
return values.length ? new Type(values) : defaultReturn || set.EMPTY;
};
}
var isMemberTest = {
test: function isMemberTest(set, value) {
return set.isMember(value);
}
};
var returnTrue = {
test: function returnTrue() {
return true;
}
};
var returnFalse = {
test: function returnFalse() {
return false;
}
};
function isOr(value) {
return value instanceof is.Or;
}
function isAnd(value) {
return value instanceof is.And;
}
function isAndOrOr(value) {
return isAnd(value) || isOr(value);
}
function <API key>(options) {
return function (inSet, gt) {
var values = inSet.values.filter(function (value) {
return options.values.test(value, gt.value);
});
var range = options.with ? new options.with(gt.value) : gt;
return values.length ? options.combinedUsing([
new options.arePut(values),
range
]) : range;
};
}
function <API key>(options) {
return function (inSet, gt) {
var values = inSet.values.filter(function (value) {
return options.values.test(gt, value);
});
var range;
if (options.complement) {
range = set.difference(set.UNIVERSAL, gt);
} else if (options.with) {
range = new options.with(gt.value);
} else {
range = gt;
}
return values.length ? options.combinedUsing([
new options.arePut(values),
range
]) : range;
};
}
function makeOrUnless(Comparison, result) {
return function (setA, setB) {
if (Comparison.test(setA.value, setB.value)) {
return result || set.UNIVERSAL;
} else {
return makeOr([
setA,
setB
]);
}
};
}
function makeAndUnless(Comparison, result) {
return function (setA, setB) {
if (Comparison.test(setA.value, setB.value)) {
return result || set.EMPTY;
} else {
return makeAnd([
setA,
setB
]);
}
};
}
function <API key>(Comparison) {
return function (setA, setB) {
if (Comparison.test(setA.value, setB.value)) {
return set.difference(set.UNIVERSAL, setB);
} else {
return setA;
}
};
}
function makeAnd(ands) {
return comparisons.And ? new comparisons.And(ands) : set.UNDEFINABLE;
}
function makeOr(ors) {
return comparisons.Or ? new comparisons.Or(ors) : set.UNDEFINABLE;
}
var is = comparisons;
var In_RANGE = {
union: <API key>({
values: makeNot(isMemberTest),
arePut: is.In,
combinedUsing: makeOr
}),
intersection: <API key>(isMemberTest, is.In, set.EMPTY),
difference: <API key>(makeNot(isMemberTest), is.In, set.EMPTY)
};
var RANGE_IN = {
difference: swapArgs(<API key>({
values: isMemberTest,
arePut: is.NotIn,
combinedUsing: makeAnd
}))
};
var NotIn_RANGE = function () {
return {
union: <API key>(makeNot(isMemberTest), is.NotIn, set.UNIVERSAL),
intersection: <API key>({
values: isMemberTest,
arePut: is.NotIn,
combinedUsing: makeAnd
}),
difference: <API key>({
values: makeNot(isMemberTest),
arePut: is.NotIn,
combinedUsing: makeAnd,
complement: true
})
};
};
var RANGE_NotIn = { difference: swapArgs(<API key>(isMemberTest, is.In, set.EMPTY)) };
var RANGE_And_Union = function (gt, and) {
var union1 = set.union(gt, and.values[0]);
var union2 = set.union(gt, and.values[1]);
if (!isAndOrOr(union1) && !isAndOrOr(union2)) {
return set.intersection(union1, union2);
} else {
return new is.Or([
gt,
and
]);
}
};
var <API key> = function (gt, and) {
var and1 = and.values[0], and2 = and.values[1];
var intersection1 = set.intersection(gt, and1);
var intersection2 = set.intersection(gt, and2);
if (intersection1 === set.EMPTY || intersection2 === set.EMPTY) {
return set.EMPTY;
}
if (!isAndOrOr(intersection1)) {
return new set.intersection(intersection1, and2);
}
if (!isAndOrOr(intersection2)) {
return new set.intersection(intersection2, and1);
} else {
return new is.And([
gt,
and
]);
}
};
var <API key> = function (gt, and) {
var and1 = and.values[0], and2 = and.values[1];
var difference1 = set.difference(gt, and1);
var difference2 = set.difference(gt, and2);
if (difference1 === set.EMPTY) {
return difference2;
}
if (difference2 === set.EMPTY) {
return difference1;
}
return new is.Or([
difference1,
difference2
]);
};
var <API key> = function (and, gt) {
var and1 = and.values[0], and2 = and.values[1];
var difference1 = set.difference(and1, gt);
var difference2 = set.difference(and2, gt);
return set.intersection(difference1, difference2);
};
var RANGE_Or = {
union: function (gt, or) {
var or1 = or.values[0], or2 = or.values[1];
var union1 = set.union(gt, or1);
if (!isAndOrOr(union1)) {
return set.union(union1, or2);
}
var union2 = set.union(gt, or2);
if (!isAndOrOr(union2)) {
return set.union(or1, union2);
} else {
return new is.Or([
gt,
or
]);
}
},
intersection: function (gt, or) {
var or1 = or.values[0], or2 = or.values[1];
var intersection1 = set.intersection(gt, or1);
var intersection2 = set.intersection(gt, or2);
if (intersection1 === set.EMPTY) {
return intersection2;
}
if (intersection2 === set.EMPTY) {
return intersection1;
}
return set.union(intersection1, intersection2);
},
difference: function (gt, or) {
var or1 = or.values[0], or2 = or.values[1];
var difference1 = set.difference(gt, or1);
var difference2 = set.difference(gt, or2);
return set.intersection(difference1, difference2);
}
};
var Or_RANGE = {
difference: function (or, gt) {
var or1 = or.values[0], or2 = or.values[1];
var difference1 = set.difference(or1, gt);
var difference2 = set.difference(or2, gt);
return set.union(difference1, difference2);
}
};
var comparators = {
In_In: {
union: makeEnum('union', is.In),
intersection: makeEnum('intersection', is.In),
difference: makeEnum('difference', is.In)
},
UNIVERSAL_In: { difference: makeSecondValue(is.NotIn, 'values') },
In_NotIn: {
union: swapArgs(makeEnum('difference', is.NotIn, set.UNIVERSAL)),
intersection: makeEnum('difference', is.In),
difference: makeEnum('intersection', is.In)
},
NotIn_In: { difference: makeEnum('union', is.NotIn) },
In_GreaterThan: In_RANGE,
GreaterThan_In: RANGE_IN,
In_GreaterThanEqual: In_RANGE,
GreaterThanEqual_In: RANGE_IN,
In_LessThan: In_RANGE,
LessThan_In: RANGE_IN,
In_LessThanEqual: In_RANGE,
LessThanEqual_In: RANGE_IN,
In_And: In_RANGE,
And_In: RANGE_IN,
In_Or: In_RANGE,
Or_In: RANGE_IN,
NotIn_NotIn: {
union: makeEnum('intersection', is.NotIn, set.UNIVERSAL),
intersection: makeEnum('union', is.NotIn),
difference: makeEnum('difference', is.In)
},
UNIVERSAL_NotIn: { difference: makeSecondValue(is.In, 'values') },
NotIn_GreaterThan: NotIn_RANGE(),
GreaterThan_NotIn: RANGE_NotIn,
<API key>: NotIn_RANGE(),
<API key>: RANGE_NotIn,
NotIn_LessThan: NotIn_RANGE(),
LessThan_NotIn: RANGE_NotIn,
NotIn_LessThanEqual: NotIn_RANGE(),
LessThanEqual_NotIn: RANGE_NotIn,
NotIn_And: NotIn_RANGE(),
And_NotIn: RANGE_NotIn,
NotIn_Or: NotIn_RANGE(),
Or_NotIn: RANGE_NotIn,
<API key>: {
union: returnSmallerValue,
intersection: returnBiggerValue,
difference: makeAndIf(is.LessThan, is.LessThanEqual)
},
<API key>: { difference: makeSecondValue(is.LessThanEqual) },
<API key>: {
union: returnSmallerValue,
intersection: returnBiggerValue,
difference: makeAndIf(is.LessThan, is.LessThan)
},
<API key>: { difference: <API key>(is.LessThan, is.LessThanEqual) },
<API key>: {
union: makeOrUnless(is.LessThan),
intersection: makeAndUnless(is.GreaterThan),
difference: <API key>(is.LessThan)
},
<API key>: { difference: <API key>(is.GreaterThan) },
<API key>: {
union: makeOrUnless(is.LessThanEqual),
intersection: makeAndUnless(is.GreaterThanEqual),
difference: <API key>(is.LessThanEqual)
},
<API key>: { difference: <API key>(is.GreaterThanEqual) },
GreaterThan_And: {
union: RANGE_And_Union,
intersection: <API key>,
difference: <API key>
},
And_GreaterThan: { difference: <API key> },
GreaterThan_Or: RANGE_Or,
Or_GreaterThan: Or_RANGE,
<API key>: {
union: returnSmallerValue,
intersection: returnBiggerValue,
difference: makeAndIf(is.LessThan, is.LessThan)
},
<API key>: { difference: makeSecondValue(is.LessThan) },
<API key>: {
union: makeOrUnless(is.LessThanEqual),
intersection: makeAndUnless(is.GreaterThanEqual),
difference: <API key>(is.LessThanEqual)
},
<API key>: { difference: <API key>(is.GreaterThanEqual) },
<API key>: {
union: makeOrUnless(is.LessThanEqual),
intersection: function () {
var makeAnd = makeAndUnless(is.GreaterThan);
return function <API key>(gte, lte) {
var inSet = new is.In([gte.value]);
if (inSet.isMember(lte.value)) {
return inSet;
} else {
return makeAnd(gte, lte);
}
};
}(),
difference: <API key>(is.LessThanEqual)
},
<API key>: { difference: <API key>(is.GreaterThanEqual) },
<API key>: {
union: RANGE_And_Union,
intersection: <API key>,
difference: <API key>
},
<API key>: { difference: <API key> },
GreaterThanEqual_Or: RANGE_Or,
Or_GreaterThanEqual: Or_RANGE,
LessThan_LessThan: {
union: returnBiggerValue,
intersection: returnSmallerValue,
difference: makeAndIf(is.GreaterThan, is.GreaterThanEqual)
},
UNIVERSAL_LessThan: { difference: makeSecondValue(is.GreaterThanEqual) },
<API key>: {
union: returnBiggerValue,
intersection: returnSmallerValue,
difference: makeAndIf(is.GreaterThan, is.GreaterThan)
},
<API key>: { difference: <API key>(is.GreaterThanEqual, is.GreaterThanEqual) },
LessThan_And: {
union: RANGE_And_Union,
intersection: <API key>,
difference: <API key>
},
And_LessThan: { difference: <API key> },
LessThan_Or: RANGE_Or,
Or_LessThan: Or_RANGE,
<API key>: {
union: returnBiggerValue,
intersection: returnSmallerValue,
difference: function (lteA, lteB) {
if (lteA.value >= lteB.value) {
return makeAnd([
lteA,
new is.GreaterThan(lteB.value)
]);
} else {
return set.EMPTY;
}
}
},
<API key>: { difference: makeSecondValue(is.GreaterThan) },
LessThanEqual_And: {
union: RANGE_And_Union,
intersection: <API key>,
difference: <API key>
},
And_LessThanEqual: { difference: <API key> },
LessThanEqual_Or: RANGE_Or,
Or_LessThanEqual: Or_RANGE,
And_And: {
union: function (and1, and2) {
var union1 = set.union(and1, and2.values[0]);
var union2 = set.union(and1, and2.values[1]);
if (isAndOrOr(union1) || isAndOrOr(union2)) {
union1 = set.union(and2, and1.values[0]);
union2 = set.union(and2, and1.values[1]);
}
if (isAndOrOr(union1) || isAndOrOr(union2)) {
return new is.Or([
and1,
and2
]);
} else {
return set.intersection(union1, union2);
}
},
intersection: function (and1, and2) {
var intersection1 = set.intersection(and1.values[0], and2.values[0]);
var intersection2 = set.intersection(and1.values[1], and2.values[1]);
if (!isAndOrOr(intersection1) || !isAndOrOr(intersection2)) {
return set.intersection(intersection1, intersection2);
}
intersection1 = set.intersection(and1.values[0], and2.values[1]);
intersection2 = set.intersection(and1.values[1], and2.values[0]);
if (!isAndOrOr(intersection1) || !isAndOrOr(intersection2)) {
return set.intersection(intersection1, intersection2);
} else {
return new is.And([
and1,
and2
]);
}
},
difference: function () {
return function (and1, and2) {
var d1 = set.difference(and1, and2.values[0]);
var d2 = set.difference(and1, and2.values[1]);
return set.union(d1, d2);
};
}()
},
And_Or: {
union: function (and, or) {
var aUnion = set.union(and.values[0], or);
var bUnion = set.union(and.values[1], or);
if (!isAndOrOr(aUnion) || !isAndOrOr(bUnion)) {
return set.intersection(aUnion, bUnion);
}
return new is.Or([
and,
or
]);
},
intersection: function (and, or) {
var aIntersection = set.intersection(and, or.values[0]);
var bIntersection = set.intersection(and, or.values[1]);
if (!isOr(aIntersection) && !isOr(bIntersection)) {
return set.union(aIntersection, bIntersection);
}
return new is.And([
and,
or
]);
},
difference: function (and, or) {
var aDiff = set.difference(and, or.values[0]);
var bDiff = set.difference(and, or.values[1]);
return set.intersection(aDiff, bDiff);
}
},
Or_And: {
difference: function (or, and) {
var aDiff = set.difference(or, and.values[0]);
var bDiff = set.difference(or, and.values[1]);
return set.union(aDiff, bDiff);
}
},
UNIVERSAL_And: {
difference: function (universe, and) {
var inverseFirst = set.difference(universe, and.values[0]), inverseSecond = set.difference(universe, and.values[1]);
return set.union(inverseFirst, inverseSecond);
}
},
Or_Or: {
union: function (or1, or2) {
var union1 = set.union(or1.values[0], or2.values[0]);
var union2 = set.union(or1.values[1], or2.values[1]);
if (!isAndOrOr(union1) || !isAndOrOr(union2)) {
return set.union(union1, union2);
}
union1 = set.union(or1.values[0], or2.values[1]);
union2 = set.union(or1.values[1], or2.values[0]);
if (!isAndOrOr(union1) || !isAndOrOr(union2)) {
return set.union(union1, union2);
} else {
return new is.Or([
or1,
or2
]);
}
},
intersection: function (or1, or2) {
var c = or2.values[0], d = or2.values[1];
var intersection1 = set.intersection(or1, c);
var intersection2 = set.intersection(or1, d);
if (!isOr(intersection1) || !isOr(intersection2)) {
return set.union(intersection1, intersection2);
}
intersection1 = set.union(or2, or1.values[0]);
intersection2 = set.union(or2, or1.values[1]);
if (!isOr(intersection1) || !isOr(intersection2)) {
return set.union(intersection1, intersection2);
} else {
return new is.Or([
or1,
or2
]);
}
},
difference: function (or1, or2) {
var d1 = set.difference(or1, or2.values[0]);
var d2 = set.difference(or1, or2.values[1]);
return set.intersection(d1, d2);
}
},
UNIVERSAL_Or: {
difference: function (universe, or) {
var inverseFirst = set.difference(universe, or.values[0]), inverseSecond = set.difference(universe, or.values[1]);
return set.intersection(inverseFirst, inverseSecond);
}
}
};
var names = Object.keys(comparisons);
names.forEach(function (name1, i) {
if (!comparators[name1 + '_' + name1]) {
console.warn('no ' + name1 + '_' + name1);
} else {
set.defineComparison(comparisons[name1], comparisons[name1], comparators[name1 + '_' + name1]);
}
if (!comparators['UNIVERSAL_' + name1]) {
console.warn('no UNIVERSAL_' + name1);
} else {
set.defineComparison(set.UNIVERSAL, comparisons[name1], comparators['UNIVERSAL_' + name1]);
}
for (var j = i + 1; j < names.length; j++) {
var name2 = names[j];
if (!comparators[name1 + '_' + name2]) {
console.warn('no ' + name1 + '_' + name2);
} else {
set.defineComparison(comparisons[name1], comparisons[name2], comparators[name1 + '_' + name2]);
}
if (!comparators[name2 + '_' + name1]) {
console.warn('no ' + name2 + '_' + name1);
} else {
set.defineComparison(comparisons[name2], comparisons[name1], comparators[name2 + '_' + name1]);
}
}
});
module.exports = comparisons;
});
/*can-query-logic@0.8.11#src/types/<API key>*/
define('can-query-logic/src/types/<API key>', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/types/comparisons'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var is = require('can-query-logic/src/types/comparisons');
module.exports = function (min, max) {
function <API key>(start, end) {
this.start = arguments.length > 0 ? +start : min;
this.end = arguments.length > 1 ? +end : max;
this.range = new is.And([
new is.GreaterThanEqual(this.start),
new is.LessThanEqual(this.end)
]);
}
var universeRange = new <API key>(min, max);
function isUniversal(range) {
return set.isSubset(universeRange.range, range.range);
}
function rangeFromAnd(aSet) {
var values = {};
aSet.values.forEach(function (value) {
if (value instanceof is.GreaterThanEqual) {
values.start = value.value;
}
if (value instanceof is.GreaterThan) {
values.start = value.value + 1;
}
if (value instanceof is.LessThanEqual) {
values.end = value.value;
}
if (value instanceof is.LessThan) {
values.end = value.value - 1;
}
});
if ('start' in values && 'end' in values) {
return new <API key>(values.start, values.end);
}
}
function toRange(aSet) {
var range;
if (aSet instanceof is.And) {
range = rangeFromAnd(aSet);
}
if (aSet instanceof is.Or) {
var first = rangeFromAnd(aSet.values[0]), second = rangeFromAnd(aSet.values[1]);
if (first && second) {
var firstValues = first.range.values, secondValues = second.range.values;
if (firstValues[1].value + 1 === secondValues[0].value) {
range = new <API key>(firstValues[0].value, secondValues[1].value);
} else if (secondValues[1].value + 1 === firstValues[0].value) {
range = new <API key>(secondValues[0].value, firstValues[1].value);
} else {
return set.UNDEFINABLE;
}
} else {
return set.UNDEFINABLE;
}
}
if (range && isUniversal(range)) {
return set.UNIVERSAL;
} else {
return range;
}
}
function intersection(range1, range2) {
var intersection = toRange(set.intersection(range1.range, range2.range));
if (intersection) {
return intersection;
} else {
return set.EMPTY;
}
}
function difference(range1, range2) {
var difference = toRange(set.difference(range1.range, range2.range));
if (difference) {
return difference;
} else {
return set.EMPTY;
}
}
set.defineComparison(<API key>, <API key>, {
union: function (range1, range2) {
var union = toRange(set.union(range1.range, range2.range));
if (union) {
return union;
} else {
return set.EMPTY;
}
},
intersection: intersection,
difference: difference
});
set.defineComparison(set.UNIVERSAL, <API key>, {
difference: function (universe, range) {
if (isUniversal(range)) {
return set.EMPTY;
} else {
return difference(universeRange, range);
}
}
});
return <API key>;
};
});
/*can-query-logic@0.8.11#src/types/types*/
define('can-query-logic/src/types/types', function (require, exports, module) {
module.exports = {};
});
/*can-query-logic@0.8.11#src/types/values-or*/
define('can-query-logic/src/types/values-or', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/types/types'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var types = require('can-query-logic/src/types/types');
function ValuesOr(values) {
this.values = values;
}
ValuesOr.prototype.isMember = function (props) {
return this.values.some(function (value) {
return value && value.isMember ? value.isMember(props) : value === props;
});
};
set.defineComparison(set.UNIVERSAL, ValuesOr, {
difference: function () {
return set.UNDEFINABLE;
}
});
module.exports = types.ValuesOr = ValuesOr;
});
/*can-query-logic@0.8.11#src/types/values-not*/
define('can-query-logic/src/types/values-not', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/types/types'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var keysLogic = require('can-query-logic/src/types/types');
function NotIdentity(value) {
this.value = value;
}
var Identity = set.Identity;
set.defineComparison(set.UNIVERSAL, Identity, {
difference: function (universe, value) {
return new NotIdentity(value);
}
});
set.defineComparison(set.UNIVERSAL, NotIdentity, {
difference: function (universe, not) {
return not.value;
}
});
set.defineComparison(NotIdentity, NotIdentity, {});
set.defineComparison(NotIdentity, Identity, {
union: function (not, primitive) {
if (set.isEqual(not.value, primitive)) {
return set.UNIVERSAL;
} else {
throw new Error('Not,Identity Union is not filled out');
}
},
intersection: function (not, primitive) {
return set.isEqual(!not.value, primitive) ? primitive : set.EMPTY;
},
difference: function difference(not, primitive) {
if (set.isEqual(not.value, primitive)) {
return not;
} else {
return set.UNDEFINABLE;
}
}
});
set.defineComparison(Identity, NotIdentity, {
difference: function (primitive, not) {
if (set.isEqual(primitive, not.value)) {
return primitive;
} else {
return set.UNDEFINABLE;
}
}
});
module.exports = keysLogic.Not = NotIdentity;
});
/*can-query-logic@0.8.11#src/types/keys-and*/
define('can-query-logic/src/types/keys-and', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-assign',
'can-query-logic/src/<API key>',
'can-reflect',
'can-key/get/get',
'can-symbol',
'can-reflect',
'can-query-logic/src/types/types'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var assign = require('can-assign');
var <API key> = require('can-query-logic/src/<API key>');
var canReflect = require('can-reflect');
var canGet = require('can-key/get/get');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var keysLogic = require('can-query-logic/src/types/types');
function KeysAnd(values) {
var vals = this.values = {};
canReflect.eachKey(values, function (value, key) {
if (canReflect.isPlainObject(value) && !set.isSpecial(value)) {
vals[key] = new KeysAnd(value);
} else {
vals[key] = value;
}
});
}
var isMemberSymbol = canSymbol.for('can.isMember');
KeysAnd.prototype.isMember = function (props, root, rootKey) {
var equal = true;
var preKey = rootKey ? rootKey + '.' : '';
canReflect.eachKey(this.values, function (value, key) {
var isMember = value && (value[isMemberSymbol] || value.isMember);
if (isMember) {
if (!isMember.call(value, canGet(props, key), root || props, preKey + key)) {
equal = false;
}
} else {
if (value !== canGet(props, key)) {
equal = false;
}
}
});
return equal;
};
function <API key>(setA) {
return set.isEqual(setA, set.UNIVERSAL) ? set.UNIVERSAL : setA;
}
var MISSING = {};
function eachInUnique(a, acb, b, bcb, defaultReturn) {
var bCopy = assign({}, b), res;
for (var prop in a) {
res = acb(prop, a[prop], prop in b ? b[prop] : MISSING, a, b);
if (res !== undefined) {
return res;
}
delete bCopy[prop];
}
for (prop in bCopy) {
res = bcb(prop, MISSING, b[prop], a, b);
if (res !== undefined) {
return res;
}
}
return defaultReturn;
}
function keyDiff(valuesA, valuesB) {
var keyResults = <API key>(Object.keys(valuesA), Object.keys(valuesB));
return {
aOnlyKeys: keyResults.difference,
aAndBKeys: keyResults.intersection,
bOnlyKeys: <API key>(Object.keys(valuesB), Object.keys(valuesA)).difference
};
}
function notEmpty(value) {
return value !== set.EMPTY;
}
function difference(objA, objB) {
var valuesA = objA.values, valuesB = objB.values, diff = keyDiff(valuesA, valuesB), aOnlyKeys = diff.aOnlyKeys, aAndBKeys = diff.aAndBKeys, bOnlyKeys = diff.bOnlyKeys;
var sharedKeysAndValues = {}, <API key> = {}, <API key> = {};
aAndBKeys.forEach(function (key) {
var difference = set.difference(valuesA[key], valuesB[key]);
if (difference === set.EMPTY) {
sharedKeysAndValues[key] = valuesA[key];
} else {
var intersection = set.intersection(valuesA[key], valuesB[key]);
var isProductable = intersection !== set.EMPTY;
if (isProductable) {
<API key>[key] = {
difference: difference,
intersection: intersection
};
} else {
<API key>[key] = valuesA[key];
}
}
});
var productAbleKeys = Object.keys(<API key>);
var <API key>;
if (productAbleKeys.length === 1) {
<API key> = {};
<API key>[productAbleKeys[0]] = <API key>[productAbleKeys[0]].difference;
}
if (Object.keys(<API key>).length) {
return objA;
}
if (aOnlyKeys.length === 0 && bOnlyKeys.length === 0) {
if (productAbleKeys.length > 1) {
return set.UNDEFINABLE;
} else if (productAbleKeys.length === 1) {
assign(sharedKeysAndValues, <API key>);
return new KeysAnd(sharedKeysAndValues);
} else {
return set.EMPTY;
}
}
if (aOnlyKeys.length > 0 && bOnlyKeys.length === 0) {
if (productAbleKeys.length > 1) {
return set.UNDEFINABLE;
} else if (productAbleKeys.length === 1) {
assign(sharedKeysAndValues, <API key>);
aOnlyKeys.forEach(function (key) {
sharedKeysAndValues[key] = valuesA[key];
});
return new KeysAnd(sharedKeysAndValues);
} else {
return set.EMPTY;
}
}
if (aOnlyKeys.length === 0 && bOnlyKeys.length > 0) {
if (productAbleKeys.length > 1) {
return set.UNDEFINABLE;
}
var productAbleOr;
if (productAbleKeys.length === 1) {
var productableKey = productAbleKeys[0];
productAbleOr = assign({}, sharedKeysAndValues);
productAbleOr[productableKey] = <API key>[productableKey].difference;
sharedKeysAndValues[productableKey] = <API key>[productableKey].intersection;
}
var ands = bOnlyKeys.map(function (key) {
var shared = assign({}, sharedKeysAndValues);
var result = shared[key] = set.difference(set.UNIVERSAL, valuesB[key]);
return result === set.EMPTY ? result : new KeysAnd(shared);
}).filter(notEmpty);
if (productAbleOr) {
ands.push(new KeysAnd(productAbleOr));
}
if (ands.length > 1) {
return new keysLogic.ValuesOr(ands);
} else if (ands.length === 1) {
return ands[0];
} else {
return set.EMPTY;
}
}
if (aOnlyKeys.length > 0 && bOnlyKeys.length > 0) {
if (productAbleKeys.length) {
throw new Error('Can\'t handle any productable keys right now');
}
aOnlyKeys.forEach(function (key) {
sharedKeysAndValues[key] = valuesA[key];
});
if (bOnlyKeys.length === 1) {
var key = bOnlyKeys[0];
var shared = assign({}, sharedKeysAndValues);
shared[key] = set.difference(set.UNIVERSAL, valuesB[key]);
return new KeysAnd(shared);
} else {
return set.UNDEFINABLE;
}
}
}
set.defineComparison(KeysAnd, KeysAnd, {
union: function (objA, objB) {
var diff = keyDiff(objA.values, objB.values);
var <API key> = [], sameKeys = {};
diff.aAndBKeys.forEach(function (key) {
if (!set.isEqual(objA.values[key], objB.values[key])) {
<API key>.push(key);
} else {
sameKeys[key] = objA.values[key];
}
});
if (!diff.aOnlyKeys.length && !diff.bOnlyKeys.length) {
if (<API key>.length === 1) {
var keyValue = <API key>[0];
var result = sameKeys[keyValue] = set.union(objA.values[keyValue], objB.values[keyValue]);
return canReflect.size(sameKeys) === 1 && set.isEqual(result, set.UNIVERSAL) ? set.UNIVERSAL : new KeysAnd(sameKeys);
} else if (<API key>.length === 0) {
return objA;
}
}
if (<API key>.length === 0) {
if (diff.aOnlyKeys.length > 0 && diff.bOnlyKeys.length === 0) {
return <API key>(objB);
} else if (diff.aOnlyKeys.length === 0 && diff.bOnlyKeys.length > 0) {
return <API key>(objA);
}
}
return new keysLogic.ValuesOr([
objA,
objB
]);
},
intersection: function (objA, objB) {
var valuesA = objA.values, valuesB = objB.values, foundEmpty = false;
var resultValues = {};
eachInUnique(valuesA, function (prop, aVal, bVal) {
resultValues[prop] = bVal === MISSING ? aVal : set.intersection(aVal, bVal);
if (resultValues[prop] === set.EMPTY) {
foundEmpty = true;
}
}, valuesB, function (prop, aVal, bVal) {
resultValues[prop] = bVal;
if (resultValues[prop] === set.EMPTY) {
foundEmpty = true;
}
});
if (foundEmpty) {
return set.EMPTY;
} else {
return new KeysAnd(resultValues);
}
},
difference: difference
});
set.defineComparison(set.UNIVERSAL, KeysAnd, {
difference: function (universe, and) {
return difference({ values: {} }, and);
}
});
module.exports = keysLogic.KeysAnd = KeysAnd;
});
/*can-query-logic@0.8.11#src/types/and-or-not*/
define('can-query-logic/src/types/and-or-not', [
'require',
'exports',
'module',
'can-query-logic/src/types/values-or',
'can-query-logic/src/types/values-not',
'can-query-logic/src/types/keys-and'
], function (require, exports, module) {
var ValuesOr = require('can-query-logic/src/types/values-or');
var ValuesNot = require('can-query-logic/src/types/values-not');
var KeysAnd = require('can-query-logic/src/types/keys-and');
module.exports = {
KeysAnd: KeysAnd,
ValuesOr: ValuesOr,
ValuesNot: ValuesNot
};
});
/*can-query-logic@0.8.11#src/helpers*/
define('can-query-logic/src/helpers', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var defaultCompare = {
$gt: function (valueA, valueB) {
return valueA > valueB;
},
$lt: function (valueA, valueB) {
return valueA < valueB;
}
};
var helpers = {
uniqueConcat: function (itemsA, itemsB, getId) {
var ids = new Set();
return itemsA.concat(itemsB).filter(function (item) {
var id = getId(item);
if (!ids.has(id)) {
ids.add(id);
return true;
} else {
return false;
}
});
},
getIndex: function (compare, items, props) {
if (!items || !items.length) {
return undefined;
}
if (compare(props, items[0]) === -1) {
return 0;
} else if (compare(props, items[items.length - 1]) === 1) {
return items.length;
}
var low = 0, high = items.length;
while (low < high) {
var mid = low + high >>> 1, item = items[mid], computed = compare(props, item);
if (computed === -1) {
high = mid;
} else {
low = mid + 1;
}
}
return high;
},
sortData: function (sortPropValue) {
if (sortPropValue[0] === '-') {
return {
prop: sortPropValue.slice(1),
desc: true
};
} else {
return {
prop: sortPropValue,
desc: false
};
}
},
defaultCompare: defaultCompare,
sorter: function (sortPropValue, sorters) {
var data = helpers.sortData(sortPropValue);
var compare;
if (sorters && sorters[data.prop]) {
compare = sorters[data.prop];
} else {
compare = defaultCompare;
}
return function (item1, item2) {
var item1Value = canReflect.getKeyValue(item1, data.prop);
var item2Value = canReflect.getKeyValue(item2, data.prop);
var temp;
if (data.desc) {
temp = item1Value;
item1Value = item2Value;
item2Value = temp;
}
if (compare.$lt(item1Value, item2Value)) {
return -1;
}
if (compare.$gt(item1Value, item2Value)) {
return 1;
}
return 0;
};
},
valueHydrator: function (value) {
if (canReflect.isBuiltIn(value)) {
return value;
} else {
throw new Error('can-query-logic doesn\'t support comparison operator: ' + JSON.stringify(value));
}
}
};
module.exports = helpers;
});
/*can-query-logic@0.8.11#src/types/basic-query*/
define('can-query-logic/src/types/basic-query', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/types/<API key>',
'can-assign',
'can-reflect',
'can-query-logic/src/types/and-or-not',
'can-query-logic/src/helpers',
'<API key>',
'can-symbol'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var <API key> = require('can-query-logic/src/types/<API key>');
var assign = require('can-assign');
var canReflect = require('can-reflect');
var andOrNot = require('can-query-logic/src/types/and-or-not');
var helpers = require('can-query-logic/src/helpers');
var defineLazyValue = require('<API key>');
var canSymbol = require('can-symbol');
var isMemberSymbol = canSymbol.for('can.isMember');
var KeysAnd = andOrNot.KeysAnd, Or = andOrNot.ValuesOr, Not = andOrNot.ValuesNot;
var RecordRange = <API key>(0, Infinity);
function makeSort(schemaKeys, hydrateAndValue) {
var sorters = {};
canReflect.eachKey(schemaKeys, function (schemaProp, key) {
sorters[key] = {
$gt: function (valueA, valueB) {
var $gt = hydrateAndValue({ $gt: valueB }, key, schemaProp, helpers.valueHydrator);
return $gt[isMemberSymbol](valueA);
},
$lt: function (valueA, valueB) {
var $lt = hydrateAndValue({ $lt: valueB }, key, schemaProp, helpers.valueHydrator);
return $lt[isMemberSymbol](valueA);
}
};
});
function Sort(key) {
this.key = key;
this.compare = helpers.sorter(key, sorters);
}
function <API key>(v1, v2) {
return v1.key === v2.key ? v1 : set.EMPTY;
}
function identityDifference(v1, v2) {
return v1.key === v2.key ? set.EMPTY : v1;
}
function identityUnion(v1, v2) {
return v1.key === v2.key ? v1 : set.UNDEFINABLE;
}
set.defineComparison(Sort, Sort, {
intersection: <API key>,
difference: identityDifference,
union: identityUnion
});
return Sort;
}
var DefaultSort = makeSort({});
function BasicQuery(query) {
assign(this, query);
if (!this.filter) {
this.filter = set.UNIVERSAL;
}
if (!this.page) {
this.page = new RecordRange();
}
if (!this.sort) {
this.sort = 'id';
}
if (typeof this.sort === 'string') {
this.sort = new DefaultSort(this.sort);
}
}
BasicQuery.KeysAnd = KeysAnd;
BasicQuery.Or = Or;
BasicQuery.Not = Not;
BasicQuery.RecordRange = RecordRange;
BasicQuery.makeSort = makeSort;
canReflect.assignMap(BasicQuery.prototype, {
count: function () {
return this.page.end - this.page.start + 1;
},
sortData: function (data) {
return data.slice(0).sort(this.sort.compare);
},
<API key>: function (bData, parentQuery) {
if (parentQuery) {
if (!set.isSubset(this, parentQuery)) {
throw new Error('can-query-logic: Unable to get members from a set that is not a superset of the current set.');
}
} else {
parentQuery = new BasicQuery();
}
var aData = bData.filter(function (data) {
return this.filter.isMember(data);
}, this);
var count = aData.length;
if (count && this.sort.key !== parentQuery.sort.key) {
aData = this.sortData(aData);
}
var thisIsUniversal = set.isEqual(this.page, set.UNIVERSAL), parentIsUniversal = set.isEqual(parentQuery.page, set.UNIVERSAL);
if (parentIsUniversal) {
if (thisIsUniversal) {
return {
data: aData,
count: count
};
} else {
return {
data: aData.slice(this.page.start, this.page.end + 1),
count: count
};
}
} else if (this.sort.key === parentQuery.sort.key && set.isEqual(parentQuery.filter, this.filter)) {
return {
data: aData.slice(this.page.start - parentQuery.page.start, this.page.end - parentQuery.page.start + 1),
count: count
};
} else {
throw new Error('can-query-logic: Unable to get members from the parent set for this subset.');
}
},
filterFrom: function (bData, parentQuery) {
return this.<API key>(bData, parentQuery).data;
},
merge: function (b, aItems, bItems, getId) {
var union = set.union(this, b);
if (union === set.UNDEFINABLE) {
return undefined;
} else {
var combined = helpers.uniqueConcat(aItems, bItems, getId);
return union.sortData(combined);
}
},
index: function (props, items) {
var data = helpers.sortData(this.sort.key);
if (!canReflect.hasOwnKey(props, data.prop)) {
return undefined;
}
return helpers.getIndex(this.sort.compare, items, props);
},
isMember: function (props) {
return this.filter.isMember(props);
},
removePagination: function () {
this.page = new RecordRange();
}
});
var CLAUSE_TYPES = [
'filter',
'page',
'sort'
];
function <API key>(queryA, queryB) {
var differentTypes = [];
CLAUSE_TYPES.forEach(function (clause) {
if (!set.isEqual(queryA[clause], queryB[clause])) {
differentTypes.push(clause);
}
});
return differentTypes;
}
function isSubset(subLetter, superLetter, meta) {
if (meta[subLetter + 'FilterIsSubset']) {
if (meta[superLetter + 'PageIsUniversal']) {
return true;
} else {
return meta[subLetter + 'PageIsSubset'] && meta.sortIsEqual;
}
} else {
return false;
}
}
function MetaInformation(queryA, queryB) {
this.queryA = queryA;
this.queryB = queryB;
}
canReflect.eachKey({
'pageIsEqual': function () {
return set.isEqual(this.queryA.page, this.queryB.page);
},
'aPageIsUniversal': function () {
return set.isEqual(this.queryA.page, set.UNIVERSAL);
},
'bPageIsUniversal': function () {
return set.isEqual(this.queryB.page, set.UNIVERSAL);
},
'pagesAreUniversal': function () {
return this.pageIsEqual && this.aPageIsUniversal;
},
'sortIsEqual': function () {
return this.queryA.sort.key === this.queryB.sort.key;
},
'aFilterIsSubset': function () {
return set.isSubset(this.queryA.filter, this.queryB.filter);
},
'bFilterIsSubset': function () {
return set.isSubset(this.queryB.filter, this.queryA.filter);
},
'aPageIsSubset': function () {
return set.isSubset(this.queryA.page, this.queryB.page);
},
'bPageIsSubset': function () {
return set.isSubset(this.queryB.page, this.queryA.page);
},
'filterIsEqual': function () {
return set.isEqual(this.queryA.filter, this.queryB.filter);
},
'aIsSubset': function () {
return isSubset('a', 'b', this);
},
'bIsSubset': function () {
return isSubset('b', 'a', this);
}
}, function (def, prop) {
defineLazyValue(MetaInformation.prototype, prop, def);
});
function metaInformation(queryA, queryB) {
var meta = new MetaInformation(queryA, queryB);
return meta;
}
set.defineComparison(BasicQuery, BasicQuery, {
union: function (queryA, queryB) {
var meta = metaInformation(queryA, queryB);
var filterUnion = set.union(queryA.filter, queryB.filter);
if (meta.pagesAreUniversal) {
return new BasicQuery({
filter: filterUnion,
sort: meta.sortIsEqual ? queryA.sort.key : undefined
});
}
if (meta.filterIsEqual) {
if (meta.sortIsEqual) {
return new BasicQuery({
filter: queryA.filter,
sort: queryA.sort.key,
page: set.union(queryA.page, queryB.page)
});
} else {
if (meta.aIsSubset) {
return queryB;
} else if (meta.bIsSubset) {
return queryA;
}
return set.UNDEFINABLE;
}
} else {
throw new Error('different filters, non-universal pages');
}
},
intersection: function (queryA, queryB) {
var meta = metaInformation(queryA, queryB);
if (meta.pagesAreUniversal) {
var filterResult = set.intersection(queryA.filter, queryB.filter);
if (set.<API key>(filterResult)) {
return new BasicQuery({
filter: filterResult,
sort: meta.sortIsEqual ? queryA.sort.key : undefined
});
} else {
return filterResult;
}
}
if (set.intersection(queryA.filter, queryB.filter) === set.EMPTY) {
return set.EMPTY;
}
if (meta.filterIsEqual) {
if (meta.sortIsEqual) {
return new BasicQuery({
filter: queryA.filter,
sort: queryA.sort.key,
page: set.intersection(queryA.page, queryB.page)
});
} else {
if (meta.aIsSubset) {
return queryA;
} else if (meta.bIsSubset) {
return queryB;
}
return set.UNKNOWABLE;
}
} else {
if (meta.aIsSubset) {
return queryA;
} else if (meta.bIsSubset) {
return queryB;
} else {
return set.UNDEFINABLE;
}
}
},
difference: function (queryA, queryB) {
var differentClauses = <API key>(queryA, queryB);
var meta = metaInformation(queryA, queryB);
var clause;
if (differentClauses.length > 1) {
if (meta.aIsSubset) {
return set.EMPTY;
}
if (meta.pagesAreUniversal) {
return new BasicQuery({
filter: set.difference(queryA.filter, queryB.filter),
sort: queryA.sort.key
});
}
return set.UNDEFINABLE;
} else {
switch (clause = differentClauses[0]) {
case undefined: {
return set.EMPTY;
}
case 'sort': {
if (meta.pagesAreUniversal) {
return set.EMPTY;
} else {
return set.UNKNOWABLE;
}
}
case 'page':
case 'filter': {
var result = set.difference(queryA[clause], queryB[clause]);
if (set.isSpecial(result)) {
return result;
} else {
var query = {
filter: queryA.filter,
page: queryA.page,
sort: queryA.sort.key
};
query[clause] = result;
return new BasicQuery(query);
}
}
}
}
}
});
module.exports = BasicQuery;
});
/*can-query-logic@0.8.11#src/serializer*/
define('can-query-logic/src/serializer', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var Serializer = function (entries) {
this.serializers = new Map(entries || []);
this.serialize = this.serialize.bind(this);
};
Serializer.prototype.add = function (serializers) {
canReflect.assign(this.serializers, serializers instanceof Serializer ? serializers.serializers : serializers);
};
Serializer.prototype.serialize = function (item) {
if (!item) {
return item;
}
var Type = item.constructor;
var serializer = this.serializers.get(Type);
if (!serializer) {
return canReflect.serialize(item);
} else {
return serializer(item, this.serialize);
}
};
module.exports = Serializer;
});
/*can-query-logic@0.8.11#src/serializers/comparisons*/
define('can-query-logic/src/serializers/comparisons', [
'require',
'exports',
'module',
'can-query-logic/src/types/comparisons',
'can-query-logic/src/serializer',
'can-reflect'
], function (require, exports, module) {
var is = require('can-query-logic/src/types/comparisons');
var Serializer = require('can-query-logic/src/serializer');
var canReflect = require('can-reflect');
function makeNew(Constructor) {
return function (value) {
return new Constructor(value);
};
}
var hydrateMap = {};
function addHydrateFrom(key, hydrate) {
hydrateMap[key] = function (value, unknownHydrator) {
return hydrate(unknownHydrator ? unknownHydrator(value[key]) : value[key]);
};
Object.defineProperty(hydrateMap[key], 'name', {
value: 'hydrate ' + key,
writable: true
});
}
function <API key>(key, hydrate) {
hydrateMap[key] = function (value, unknownHydrator) {
var clones = value[key];
if (unknownHydrator) {
clones = clones.map(function (value) {
return unknownHydrator(value);
});
}
return hydrate(clones);
};
Object.defineProperty(hydrateMap[key], 'name', {
value: 'hydrate ' + key,
writable: true
});
}
addHydrateFrom('$eq', function (value) {
return new is.In([value]);
});
addHydrateFrom('$ne', function (value) {
return new is.NotIn([value]);
});
addHydrateFrom('$gt', makeNew(is.GreaterThan));
addHydrateFrom('$gte', makeNew(is.GreaterThanEqual));
<API key>('$in', makeNew(is.In));
addHydrateFrom('$lt', makeNew(is.LessThan));
addHydrateFrom('$lte', makeNew(is.LessThanEqual));
<API key>('$nin', makeNew(is.GreaterThan));
var serializer = new Serializer([
[
is.In,
function (isIn, serialize) {
return isIn.values.length === 1 ? serialize(isIn.values[0]) : { $in: isIn.values.map(serialize) };
}
],
[
is.NotIn,
function (notIn, serialize) {
return notIn.values.length === 1 ? { $ne: serialize(notIn.values[0]) } : { $nin: notIn.values.map(serialize) };
}
],
[
is.GreaterThan,
function (gt, serialize) {
return { $gt: serialize(gt.value) };
}
],
[
is.GreaterThanEqual,
function (gte, serialize) {
return { $gte: serialize(gte.value) };
}
],
[
is.LessThan,
function (lt, serialize) {
return { $lt: serialize(lt.value) };
}
],
[
is.LessThanEqual,
function (lt, serialize) {
return { $lte: serialize(lt.value) };
}
],
[
is.And,
function (and, serialize) {
var obj = {};
and.values.forEach(function (clause) {
canReflect.assignMap(obj, serialize(clause));
});
return obj;
}
]
]);
module.exports = {
hydrate: function (value, hydrateUnknown) {
if (!hydrateUnknown) {
hydrateUnknown = function () {
throw new Error('can-query-logic doesn\'t recognize operator: ' + JSON.stringify(value));
};
}
if (Array.isArray(value)) {
return new is.In(value);
} else if (value && typeof value === 'object') {
var keys = Object.keys(value);
var <API key> = keys.every(function (key) {
return hydrateMap[key];
});
if (<API key>) {
var andClauses = keys.map(function (key) {
var part = {};
part[key] = value[key];
var hydrator = hydrateMap[key];
return hydrator(part, hydrateUnknown);
});
if (andClauses.length > 1) {
return new is.And(andClauses);
} else {
return andClauses[0];
}
} else {
return hydrateUnknown(value);
}
} else {
return new is.In([value]);
}
},
serializer: serializer
};
});
/*can-query-logic@0.8.11#src/schema-helpers*/
define('can-query-logic/src/schema-helpers', [
'require',
'exports',
'module',
'can-reflect',
'can-query-logic/src/set',
'can-symbol'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var set = require('can-query-logic/src/set');
var canSymbol = require('can-symbol');
var schemaHelpers;
module.exports = schemaHelpers = {
isRangedType: function (Type) {
return Type && canReflect.isConstructorLike(Type) && !set.hasComparisons(Type) && !Type[canSymbol.for('can.SetType')] && Type.prototype.valueOf && Type.prototype.valueOf !== Object.prototype.valueOf;
},
categorizeOrValues: function categorizeOrValues(values) {
var categories = {
primitives: [],
valueOfTypes: [],
others: []
};
values.forEach(function (value) {
if (canReflect.isPrimitive(value)) {
categories.primitives.push(value);
} else if (schemaHelpers.isRangedType(value)) {
categories.valueOfTypes.push(value);
} else {
categories.others.push(value);
}
});
return categories;
}
};
});
/*can-query-logic@0.8.11#src/types/make-maybe*/
define('can-query-logic/src/types/make-maybe', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/types/comparisons',
'can-reflect',
'can-query-logic/src/schema-helpers',
'can-symbol'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var is = require('can-query-logic/src/types/comparisons');
var canReflect = require('can-reflect');
var schemaHelpers = require('can-query-logic/src/schema-helpers');
var canSymbol = require('can-symbol');
var <API key> = canSymbol.for('can.ComparisonSetType');
var isMemberSymbol = canSymbol.for('can.isMember');
function splitByRangeAndEnum(maybeUniverse, rangeToBeSplit) {
var enumSet;
if (rangeToBeSplit instanceof is.And) {
var sets = rangeToBeSplit.values.map(function (setInAnd) {
return splitByRangeAndEnum(maybeUniverse, setInAnd);
});
return sets.reduce(function (last, maybe) {
return {
range: set.intersection(last.range, maybe.range),
enum: set.intersection(last.enum, maybe.enum)
};
}, {
range: set.UNIVERSAL,
enum: maybeUniverse
});
} else if (rangeToBeSplit instanceof is.In) {
var shouldBeInValues = rangeToBeSplit.values.filter(function (value) {
return maybeUniverse.isMember(value);
});
if (shouldBeInValues.length) {
var valuesCopy = rangeToBeSplit.values.slice(0);
canReflect.removeValues(valuesCopy, shouldBeInValues);
return {
enum: new is.In(shouldBeInValues),
range: valuesCopy.length ? new is.In(valuesCopy) : set.EMPTY
};
} else {
return {
enum: set.EMPTY,
range: rangeToBeSplit
};
}
} else if (rangeToBeSplit instanceof is.NotIn) {
enumSet = set.intersection(maybeUniverse, rangeToBeSplit);
var rangeValues = rangeToBeSplit.values.filter(function (value) {
return !maybeUniverse.isMember(value);
});
return {
range: rangeValues.length ? new is.NotIn(rangeValues) : set.UNIVERSAL,
enum: enumSet
};
} else {
return {
enum: set.EMPTY,
range: rangeToBeSplit
};
}
}
function makeMaybe(inValues, makeChildType) {
var maybeUniverse = new is.In(inValues);
function Maybe(values) {
var result = splitByRangeAndEnum(maybeUniverse, values.range);
this.range = result.range || set.EMPTY;
if (values.enum) {
if (result.enum !== set.EMPTY) {
this.enum = set.union(result.enum, values.enum);
} else {
this.enum = values.enum;
}
} else {
this.enum = result.enum;
}
if (this.enum === set.EMPTY && this.range === set.EMPTY) {
return set.EMPTY;
}
}
Maybe.prototype.orValues = function () {
var values = [];
if (this.range !== set.EMPTY) {
values.push(this.range);
}
if (this.enum !== set.EMPTY) {
values.push(this.enum);
}
return values;
};
Maybe.prototype[isMemberSymbol] = function isMember() {
var rangeIsMember = this.range[isMemberSymbol] || this.range.isMember, enumIsMember = this.enum[isMemberSymbol] || this.enum.isMember;
return rangeIsMember.apply(this.range, arguments) || enumIsMember.apply(this.enum, arguments);
};
set.defineComparison(Maybe, Maybe, {
union: function (maybeA, maybeB) {
var enumSet = set.union(maybeA.enum, maybeB.enum);
var range = set.union(maybeA.range, maybeB.range);
return new Maybe({
enum: enumSet,
range: range
});
},
difference: function (maybeA, maybeB) {
var enumSet = set.difference(maybeA.enum, maybeB.enum);
var range = set.difference(maybeA.range, maybeB.range);
return new Maybe({
enum: enumSet,
range: range
});
},
intersection: function (maybeA, maybeB) {
var enumSet = set.intersection(maybeA.enum, maybeB.enum);
var range = set.intersection(maybeA.range, maybeB.range);
return new Maybe({
enum: enumSet,
range: range
});
}
});
Maybe.inValues = inValues;
set.defineComparison(set.UNIVERSAL, Maybe, {
difference: function (universe, maybe) {
var primary, secondary;
if (maybe.range === set.UNIVERSAL) {
return new Maybe({
range: maybe.range,
enum: set.difference(maybeUniverse, maybe.enum)
});
}
if (maybe.enum === set.EMPTY) {
var rangeSet = set.difference(set.UNIVERSAL, maybe.range);
var notPresent = set.difference(maybeUniverse, maybe.range);
var enumSet = set.difference(notPresent, rangeSet);
return new Maybe({
range: rangeSet,
enum: enumSet
});
} else {
primary = set.difference(universe, maybe.range);
secondary = set.difference(maybeUniverse, maybe.enum);
}
return new Maybe({
enum: secondary,
range: primary
});
}
});
makeChildType = makeChildType || function (v) {
return v;
};
Maybe.hydrate = function (value, childHydrate) {
return new Maybe({ range: childHydrate(value, makeChildType) });
};
return Maybe;
}
makeMaybe.canMakeMaybeSetType = function (Type) {
var schema = canReflect.getSchema(Type);
if (schema && schema.type === 'Or') {
var categories = schemaHelpers.categorizeOrValues(schema.values);
return categories.valueOfTypes.length === 1 && categories.valueOfTypes.length + categories.primitives.length === schema.values.length;
}
return false;
};
makeMaybe.makeMaybeSetTypes = function (Type) {
var schema = canReflect.getSchema(Type);
var categories = schemaHelpers.categorizeOrValues(schema.values);
var ComparisonSetType;
if (Type[<API key>]) {
ComparisonSetType = Type[<API key>];
} else {
ComparisonSetType = function (value) {
this.value = canReflect.new(Type, value);
};
ComparisonSetType.prototype.valueOf = function () {
return this.value;
};
canReflect.assignSymbols(ComparisonSetType.prototype, {
'can.serialize': function () {
return this.value;
}
});
Object.defineProperty(ComparisonSetType, 'name', { value: 'Or[' + categories.valueOfTypes[0].name + ',' + categories.primitives.map(String).join(' ') + ']' });
}
return {
Maybe: makeMaybe(categories.primitives, function <API key>(value) {
return new ComparisonSetType(value);
}),
ComparisonSetType: ComparisonSetType
};
};
module.exports = makeMaybe;
});
/*can-query-logic@0.8.11#src/types/make-enum*/
define('can-query-logic/src/types/make-enum', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-query-logic/src/<API key>',
'can-query-logic/src/schema-helpers',
'can-reflect',
'can-symbol'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var <API key> = require('can-query-logic/src/<API key>');
var schemaHelpers = require('can-query-logic/src/schema-helpers');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var setTypeSymbol = canSymbol.for('can.SetType'), isMemberSymbol = canSymbol.for('can.isMember'), newSymbol = canSymbol.for('can.new');
function makeEnumSetType(allValues, hydrate) {
function Enum(values) {
var arr = Array.isArray(values) ? values : [values];
this.values = hydrate ? arr.map(hydrate) : arr;
}
canReflect.assignSymbols(Enum.prototype, {
'can.serialize': function () {
return this.values.length === 1 ? this.values[0] : this.values;
}
});
Enum.prototype[isMemberSymbol] = function (value) {
return this.values.some(function (val) {
return set.isEqual(val, value);
});
};
Enum.UNIVERSAL = new Enum(allValues);
var difference = function (enum1, enum2) {
var result = <API key>(enum1.values, enum2.values);
if (result.difference.length) {
return new Enum(result.difference);
} else {
return set.EMPTY;
}
};
set.defineComparison(Enum, Enum, {
union: function (enum1, enum2) {
var result = <API key>(enum1.values, enum2.values);
if (result.union.length) {
return new Enum(result.union);
} else {
return set.EMPTY;
}
},
intersection: function (enum1, enum2) {
var result = <API key>(enum1.values, enum2.values);
if (result.intersection.length) {
return new Enum(result.intersection);
} else {
return set.EMPTY;
}
},
difference: difference
});
set.defineComparison(Enum, set.UNIVERSAL, {
difference: function (enumA) {
return difference(enumA, { values: allValues.slice(0) });
}
});
set.defineComparison(set.UNIVERSAL, Enum, {
difference: function (universe, enumB) {
return difference({ values: allValues.slice(0) }, enumB);
}
});
return Enum;
}
function makeEnum(Type, allValues, hydrate) {
var Enum = makeEnumSetType(allValues, hydrate);
Type[setTypeSymbol] = Enum;
Type[isMemberSymbol] = function (value) {
return allValues.some(function (val) {
return set.isEqual(val, value);
});
};
return Enum;
}
makeEnum.canMakeEnumSetType = function (Type) {
var schema = canReflect.getSchema(Type);
if (schema && schema.type === 'Or') {
var categories = schemaHelpers.categorizeOrValues(schema.values);
return categories.primitives.length === schema.values.length;
}
return false;
};
makeEnum.makeEnumSetType = function (Type) {
var schema = canReflect.getSchema(Type);
var categories = schemaHelpers.categorizeOrValues(schema.values);
var hydrate = Type[newSymbol] ? Type[newSymbol].bind(Type) : undefined;
return makeEnumSetType(categories.primitives, hydrate);
};
module.exports = makeEnum;
});
/*can-query-logic@0.8.11#src/serializers/basic-query*/
define('can-query-logic/src/serializers/basic-query', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect',
'can-query-logic/src/types/basic-query',
'can-query-logic/src/set',
'can-query-logic/src/serializers/comparisons',
'can-query-logic/src/serializer',
'can-query-logic/src/types/comparisons',
'can-query-logic/src/types/make-maybe',
'can-query-logic/src/types/make-enum',
'can-log/dev/dev',
'can-query-logic/src/helpers'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var BasicQuery = require('can-query-logic/src/types/basic-query');
var set = require('can-query-logic/src/set');
var <API key> = require('can-query-logic/src/serializers/comparisons');
var Serializer = require('can-query-logic/src/serializer');
var is = require('can-query-logic/src/types/comparisons');
var makeMaybe = require('can-query-logic/src/types/make-maybe');
var makeEnum = require('can-query-logic/src/types/make-enum');
var logDev = require('can-log/dev/dev');
var helpers = require('can-query-logic/src/helpers');
var setTypeSymbol = canSymbol.for('can.SetType');
var schemaSymbol = canSymbol.for('can.getSchema');
var defaultQuery = new BasicQuery({});
function getSchemaProperties(value) {
var constructor = value.constructor;
if (constructor && constructor[schemaSymbol]) {
var schema = constructor[schemaSymbol]();
return schema.keys || {};
} else {
return {};
}
}
function hydrateFilter(values, schemaProperties, hydrateUnknown) {
if (values && typeof values === 'object' && '$or' in values) {
return hydrateOrs(values.$or, schemaProperties, hydrateUnknown);
} else {
return hydrateAndValues(values, schemaProperties, hydrateUnknown);
}
}
var setTypeMap = new WeakMap();
function hydrateAndValue(value, prop, SchemaType, hydrateChild) {
if (SchemaType) {
var SetType = SchemaType[setTypeSymbol];
if (SetType) {
if (SetType.hydrate) {
return SetType.hydrate(value, <API key>.hydrate);
} else if (set.hasComparisons(SetType)) {
return new SetType(value);
} else {
return <API key>.hydrate(value, function (value) {
return new SetType(value);
});
}
} else {
if (makeEnum.canMakeEnumSetType(SchemaType)) {
if (!setTypeMap.has(SchemaType)) {
setTypeMap.set(SchemaType, makeEnum.makeEnumSetType(SchemaType));
}
SetType = setTypeMap.get(SchemaType);
return new SetType(value);
} else if (makeMaybe.canMakeMaybeSetType(SchemaType)) {
if (!setTypeMap.has(SchemaType)) {
setTypeMap.set(SchemaType, makeMaybe.makeMaybeSetTypes(SchemaType));
}
SetType = setTypeMap.get(SchemaType).Maybe;
return SetType.hydrate(value, <API key>.hydrate);
} else {
return <API key>.hydrate(value, hydrateChild);
}
}
} else {
return <API key>.hydrate(value, hydrateChild);
}
}
function hydrateAndValues(values, schemaProperties, hydrateUnknown) {
schemaProperties = schemaProperties || {};
function hydrateChild(value) {
if (value) {
if (Array.isArray(value)) {
return value.map(hydrateUnknown);
} else if (canReflect.isPlainObject(value)) {
return hydrateAndValues(value, getSchemaProperties(value));
}
}
if (hydrateUnknown) {
return hydrateUnknown(value);
} else {
return value;
}
}
var clone = {};
canReflect.eachKey(values, function (value, prop) {
clone[prop] = hydrateAndValue(value, prop, schemaProperties[prop], hydrateChild);
});
return new BasicQuery.KeysAnd(clone);
}
function combineAnds(ands) {
var firstKeys = Object.keys(ands[0].values);
var keys = {};
var keysCompare = new is.In(firstKeys);
firstKeys.map(function (key) {
keys[key] = [];
});
var sameKeys = ands.every(function (and) {
if (!set.isEqual(keysCompare, new is.In(Object.keys(and.values)))) {
return false;
}
canReflect.eachKey(and.values, function (value, key) {
keys[key].push(value);
});
return true;
});
if (!sameKeys) {
return;
}
var unequalKeys = [];
firstKeys.forEach(function (key) {
var isEqual = keys[key].reduce(function (newSet, lastSetOrFalse) {
if (lastSetOrFalse === false) {
return false;
}
if (lastSetOrFalse === undefined) {
return newSet;
}
var res = set.isEqual(newSet, lastSetOrFalse);
return res ? newSet : false;
});
if (!isEqual) {
unequalKeys.push(key);
}
});
if (unequalKeys.length !== 1) {
return;
}
var unionKey = unequalKeys[0];
var unioned = keys[unionKey].reduce(function (cur, last) {
return set.union(cur, last);
}, set.EMPTY);
var result = {};
firstKeys.map(function (key) {
result[key] = keys[key][0];
});
result[unionKey] = unioned;
return new BasicQuery.KeysAnd(result);
}
function hydrateOrs(values, schemaProperties, hydrateUnknown) {
var comparisons = values.map(function (value) {
return hydrateAndValues(value, schemaProperties, hydrateUnknown);
});
var combined = combineAnds(comparisons);
if (combined) {
return combined;
}
return new BasicQuery.Or(comparisons);
}
module.exports = function (schema) {
var id = schema.identity && schema.identity[0];
var keys = schema.keys;
var serializeMap = [
[
BasicQuery.Or,
function (or, serializer) {
return or.values.map(function (value) {
return serializer(value);
});
}
],
[
BasicQuery.KeysAnd,
function (and, serializer) {
var ors = [];
var result = {};
canReflect.eachKey(and.values, function (value, key) {
if (typeof value.orValues === 'function') {
canReflect.addValues(ors, value.orValues().map(function (orValue) {
var result = {};
result[key] = serializer(orValue);
return result;
}));
} else {
result[key] = serializer(value);
}
});
if (ors.length) {
if (ors.length === 1) {
return ors[0];
} else {
return {
$or: ors.map(function (orPart) {
return canReflect.assign(canReflect.serialize(result), orPart);
})
};
}
} else {
return result;
}
}
],
[
BasicQuery.RecordRange,
function (range) {
return {
start: range.start,
end: range.end
};
}
],
[
BasicQuery,
function (basicQuery, childSerializer) {
var filter = set.isEqual(basicQuery.filter, set.UNIVERSAL) ? {} : childSerializer(basicQuery.filter);
var res = {};
if (canReflect.size(filter) !== 0) {
res.filter = filter;
}
if (!set.isEqual(basicQuery.page, defaultQuery.page)) {
res.page = { start: basicQuery.page.start };
if (basicQuery.page.end !== defaultQuery.page.end) {
res.page.end = basicQuery.page.end;
}
}
if (basicQuery.sort.key !== id) {
res.sort = basicQuery.sort.key;
}
return res;
}
]
];
var Sort = BasicQuery.makeSort(keys, hydrateAndValue);
var serializer = new Serializer(serializeMap);
serializer.add(<API key>.serializer);
return {
hydrate: function (data) {
var AcceptedFields = makeEnum(function () {
}, [
'filter',
'sort',
'page'
]);
var diff = set.difference(new AcceptedFields(Object.keys(data)), AcceptedFields.UNIVERSAL);
if (diff.values && diff.values.length) {
logDev.warn('can-query-logic: Ignoring keys: ' + diff.values.join(', ') + '.');
}
var filter = canReflect.serialize(data.filter);
var filterAnd = hydrateFilter(filter, keys, helpers.valueHydrator);
var query = { filter: filterAnd };
if (data.page) {
query.page = new BasicQuery.RecordRange(data.page.start, data.page.end);
}
if (data.sort) {
query.sort = new Sort(data.sort);
} else {
query.sort = new Sort(id);
}
return new BasicQuery(query);
},
serializer: serializer
};
};
});
/*can-query-logic@0.8.11#can-query-logic*/
define('can-query-logic', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-symbol',
'can-reflect',
'can-query-logic/src/serializers/basic-query',
'can-query-logic/src/types/basic-query',
'can-query-logic/src/types/comparisons',
'can-query-logic/src/types/make-enum'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var <API key> = require('can-query-logic/src/serializers/basic-query');
var BasicQuery = require('can-query-logic/src/types/basic-query');
var valueComparisons = require('can-query-logic/src/types/comparisons');
var schemaSymbol = canSymbol.for('can.getSchema');
var newSymbol = canSymbol.for('can.new');
var makeEnum = require('can-query-logic/src/types/make-enum');
function QueryLogic(Type, options) {
Type = Type || {};
var passedHydrator = options && options.toQuery;
var passedSerializer = options && options.toParams;
var schema;
if (Type[schemaSymbol]) {
schema = Type[schemaSymbol]();
} else {
schema = Type;
}
var id = schema.identity && schema.identity[0];
if (!id) {
schema.identity = ['id'];
}
var converter = <API key>(schema), hydrate, serialize;
if (passedHydrator) {
hydrate = function (query) {
return converter.hydrate(passedHydrator(query));
};
} else {
hydrate = converter.hydrate;
}
if (passedSerializer) {
serialize = function (query) {
return passedSerializer(converter.serializer.serialize(query));
};
} else {
serialize = converter.serializer.serialize;
}
this.hydrate = hydrate;
this.serialize = serialize;
this.schema = schema;
}
function makeNewSet(prop) {
return function (qA, qB) {
var queryA = this.hydrate(qA), queryB = this.hydrate(qB);
var unionQuery = set[prop](queryA, queryB);
return this.serialize(unionQuery);
};
}
function makeReturnValue(prop) {
return function (qA, qB) {
var queryA = this.hydrate(qA), queryB = this.hydrate(qB);
return set[prop](queryA, queryB);
};
}
canReflect.assignSymbols(QueryLogic.prototype, {
'can.getSchema': function () {
return this.schema;
}
});
canReflect.assign(QueryLogic.prototype, {
union: makeNewSet('union'),
difference: makeNewSet('difference'),
intersection: makeNewSet('intersection'),
isEqual: makeReturnValue('isEqual'),
isProperSubset: makeReturnValue('isProperSubset'),
isSubset: makeReturnValue('isSubset'),
isSpecial: set.isSpecial,
<API key>: set.<API key>,
count: function (a) {
var queryA = this.hydrate(a);
return queryA.page.end - queryA.page.start + 1;
},
identityKeys: function () {
console.warn('you probably can get the identity keys some other way');
return this.schema.identity;
},
filterMembers: function (a, b, bData) {
var queryA = this.hydrate(a);
if (arguments.length >= 3) {
var queryB = this.hydrate(b);
return queryA.filterFrom(bData, queryB);
} else {
return queryA.filterFrom(b);
}
},
<API key>: function (a, b, bData) {
var queryA = this.hydrate(a), queryB = this.hydrate(b);
return queryA.<API key>(bData, queryB);
},
unionMembers: function (a, b, aData, bData) {
var queryA = this.hydrate(a), queryB = this.hydrate(b);
var schema = this.schema;
return queryA.merge(queryB, aData, bData, function (obj) {
return canReflect.getIdentity(obj, schema);
});
},
isMember: function (query, props) {
return this.hydrate(query).isMember(props);
},
memberIdentity: function (props) {
console.warn('you probably can get the member identity some other way');
return canReflect.getIdentity(props, this.schema);
},
index: function (query, items, props) {
return this.hydrate(query).index(props, items);
},
insert: function (query, items, item) {
var index = this.index(query, items, item);
if (index === undefined) {
index = items.length;
}
var copy = items.slice(0);
copy.splice(index, 0, item);
return copy;
},
isPaginated: function (query) {
var basicQuery = this.hydrate(query);
return !set.isEqual(basicQuery.page, set.UNIVERSAL);
},
removePagination: function (query) {
var basicQuery = this.hydrate(query);
basicQuery.removePagination();
return this.serialize(basicQuery);
}
});
QueryLogic.UNIVERSAL = set.UNIVERSAL;
QueryLogic.EMPTY = set.EMPTY;
QueryLogic.UNDEFINABLE = set.UNDEFINABLE;
QueryLogic.UNKNOWABLE = set.UNKNOWABLE;
QueryLogic.makeEnum = function (values) {
var Type = function () {
};
Type[newSymbol] = function (val) {
return val;
};
makeEnum(Type, values);
return Type;
};
QueryLogic.defineComparison = set.defineComparison;
QueryLogic.isSpecial = set.isSpecial;
QueryLogic.<API key> = QueryLogic.<API key>;
QueryLogic.KeysAnd = BasicQuery.KeysAnd;
QueryLogic.ValuesOr = BasicQuery.Or;
QueryLogic.In = valueComparisons.In;
QueryLogic.NotIn = valueComparisons.NotIn;
QueryLogic.GreaterThan = valueComparisons.GreaterThan;
QueryLogic.GreaterThanEqual = valueComparisons.GreaterThanEqual;
QueryLogic.LessThan = valueComparisons.LessThan;
QueryLogic.LessThanEqual = valueComparisons.LessThanEqual;
QueryLogic.ValueAnd = valueComparisons.And;
QueryLogic.ValueOr = valueComparisons.Or;
module.exports = QueryLogic;
});
/*can-fixture@3.0.0-pre.11#matches*/
define('can-fixture/matches', [
'require',
'exports',
'module',
'can-query-logic/src/set',
'can-reflect',
'can-fixture/data-from-url',
'can-query-logic'
], function (require, exports, module) {
var set = require('can-query-logic/src/set');
var canReflect = require('can-reflect');
var dataFromUrl = require('can-fixture/data-from-url');
var QueryLogic = require('can-query-logic');
function deepEqual(a, b) {
if (a === b) {
return true;
} else if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length) {
return false;
} else {
return a.every(function (aVal, i) {
return deepEqual(aVal, b[i]);
});
}
} else if (a && b && canReflect.isPlainObject(a) && canReflect.isPlainObject(b)) {
var aKeys = Object.keys(a), bKeys = Object.keys(b);
if (aKeys.length === bKeys.length) {
for (var prop in a) {
if (!b.hasOwnProperty(prop)) {
return false;
}
if (!deepEqual(a[prop], b[prop])) {
return false;
}
}
return true;
} else {
return false;
}
} else {
return false;
}
}
function deepMatches(a, b) {
if (a === b) {
return true;
} else if (Array.isArray(a) && Array.isArray(b)) {
return a.every(function (aVal, i) {
return deepMatches(aVal, b[i]);
});
} else if (a && b && canReflect.isPlainObject(a) && canReflect.isPlainObject(b)) {
for (var prop in a) {
if (!b.hasOwnProperty(prop)) {
return false;
}
if (!deepMatches(a[prop], b[prop])) {
return false;
}
}
return true;
} else {
return false;
}
}
function removeFixtureAndXHR(query) {
if (query.fixture || query.xhr || query.data) {
var clone = canReflect.serialize(query);
delete clone.fixture;
delete clone.xhr;
delete clone.data;
return clone;
} else {
return query;
}
}
function <API key>(v1, v2) {
return v1.value === v2.value ? v1 : set.EMPTY;
}
function identityDifference(v1, v2) {
return v1.value === v2.value ? set.EMPTY : v1;
}
function identityUnion(v1, v2) {
return v1.value === v2.value ? v1 : set.UNDEFINABLE;
}
var identityComparitor = {
intersection: <API key>,
difference: identityDifference,
union: identityUnion
};
function makeComparatorType(compare) {
var Type = function () {
};
var SetType = function (value) {
this.value = value;
};
SetType.prototype.isMember = function (value, root, keys) {
return compare(this.value, value, root, keys);
};
canReflect.assignSymbols(Type, { 'can.SetType': SetType });
set.defineComparison(SetType, SetType, identityComparitor);
set.defineComparison(set.UNIVERSAL, SetType, {
difference: function () {
return set.UNDEFINABLE;
}
});
return Type;
}
function quickEqual(queryA, queryB) {
var dataA = queryA.data, dataB = queryB.data;
if (dataA && dataB) {
if (!deepMatches(dataA, dataB)) {
return false;
}
}
var q1 = new QueryLogic.KeysAnd(removeFixtureAndXHR(queryA)), q2 = new QueryLogic.KeysAnd(removeFixtureAndXHR(queryB));
return set.isEqual(q1, q2);
}
function quickSubset(queryA, queryB) {
return set.isSubset(new QueryLogic.KeysAnd(queryA), new QueryLogic.KeysAnd(queryB));
}
var types = {};
canReflect.eachKey({
IsEmptyOrNull: function (a, b) {
if (a == null && canReflect.size(b) === 0) {
return true;
} else if (b == null && canReflect.size(a) === 0) {
return true;
} else {
return quickEqual(a, b);
}
},
isEmptyOrSubset: function (a, b) {
if (a == null && canReflect.size(b) === 0) {
return true;
} else if (b == null && canReflect.size(a) === 0) {
return true;
} else {
return quickSubset(a, b);
}
},
TemplateUrl: function (a, b) {
return !!dataFromUrl(a, b);
},
StringIgnoreCase: function (a, b) {
return b && a ? a.toLowerCase() === b.toLowerCase() : b === a;
},
Ignore: function () {
return true;
}
}, function (compare, name) {
types[name] = makeComparatorType(compare);
});
var schema = {
identity: ['id'],
keys: {
url: types.TemplateUrl,
fixture: types.Ignore,
xhr: types.Ignore,
type: types.StringIgnoreCase,
method: types.StringIgnoreCase,
helpers: types.Ignore,
headers: types.IsEmptyOrNull,
data: types.IsEmptyOrSubset
}
};
var query = new QueryLogic(schema);
module.exports = {
fixture: quickEqual,
request: function (requestData, fixtureData) {
return query.isMember({ filter: fixtureData }, requestData);
},
matches: function (settings, fixture, exact) {
if (exact) {
return this.fixture(settings, fixture);
} else {
return this.request(settings, fixture);
}
},
makeComparatorType: makeComparatorType
};
});
/*can-memory-store@1.0.0#make-simple-store*/
define('can-memory-store/make-simple-store', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
function getItems(data) {
if (Array.isArray(data)) {
return data;
} else {
return data.data;
}
}
function indexOf(records, identity, queryLogic) {
var schema = canReflect.getSchema(queryLogic);
for (var i = 0; i < records.length; i++) {
if (identity === canReflect.getIdentity(records[i], schema)) {
return i;
}
}
return -1;
}
function makeSimpleStore(baseConnection) {
baseConnection.constructor = makeSimpleStore;
var behavior = Object.create(baseConnection);
return canReflect.assignMap(behavior, {
getRecordFromParams: function (record) {
var id = canReflect.getIdentity(record, this.queryLogic.schema);
return this.getRecord(id);
},
log: function () {
this._log = true;
},
getSets: function () {
return this.getQueries();
},
getQueries: function () {
return Promise.resolve(this.getQueriesSync());
},
getQueriesSync: function () {
return this.getQueryDataSync().map(function (queryData) {
return queryData.query;
});
},
getListData: function (query) {
query = query || {};
var listData = this.getListDataSync(query);
if (listData) {
return Promise.resolve(listData);
}
return Promise.reject({
title: 'no data',
status: '404',
detail: 'No data available for this query.\nAvailable queries: ' + JSON.stringify(this.getQueriesSync())
});
},
<API key>: function (superSetQueryData) {
var records = this.getAllRecords();
var <API key> = this.queryLogic.removePagination(superSetQueryData.query);
var <API key> = this.queryLogic.<API key>(<API key>, {}, records);
var startIndex = indexOf(<API key>.data, superSetQueryData.startIdentity, this.queryLogic);
var <API key> = <API key>.data.slice(startIndex, startIndex + this.queryLogic.count(superSetQueryData.query));
return {
count: <API key>.data.length,
data: <API key>
};
},
getListDataSync: function (query) {
var queryData = this.getQueryDataSync(), superSetQueryData, isPaginated = this.queryLogic.isPaginated(query);
for (var i = 0; i < queryData.length; i++) {
var checkSet = queryData[i].query;
if (this.queryLogic.isSubset(query, checkSet)) {
superSetQueryData = queryData[i];
}
}
var records = this.getAllRecords();
if (isPaginated && this.queryLogic.isPaginated(superSetQueryData.query)) {
var result = this.<API key>(superSetQueryData);
return this.queryLogic.<API key>(query, superSetQueryData.query, result.data);
}
var matching = this.queryLogic.<API key>(query, {}, records);
if (matching && matching.count) {
return matching;
}
if (superSetQueryData) {
return {
count: 0,
data: []
};
}
},
updateListData: function (data, query) {
var queryData = this.getQueryDataSync();
query = query || {};
var clonedData = canReflect.serialize(data);
var records = getItems(clonedData);
this.updateRecordsSync(records);
var isPaginated = this.queryLogic.isPaginated(query);
var identity = records.length ? canReflect.getIdentity(records[0], this.queryLogic.schema) : undefined;
if (isPaginated) {
for (var i = 0; i < queryData.length; i++) {
var checkSet = queryData[i].query;
var union = this.queryLogic.union(checkSet, query);
if (this.queryLogic.<API key>(union)) {
var siblingRecords = this.<API key>(queryData[i]);
var res = this.queryLogic.unionMembers(checkSet, query, siblingRecords.data, records);
identity = canReflect.getIdentity(res[0], this.queryLogic.schema);
queryData[i] = {
query: union,
startIdentity: identity
};
this.updateQueryDataSync(queryData);
return Promise.resolve();
}
}
queryData.push({
query: query,
startIdentity: identity
});
this.updateQueryDataSync(queryData);
return Promise.resolve();
}
var allRecords = this.getAllRecords();
var curretMatching = this.queryLogic.filterMembers(query, allRecords);
if (curretMatching.length) {
var toBeDeleted = new Map();
curretMatching.forEach(function (record) {
toBeDeleted.set(canReflect.getIdentity(record, this.queryLogic.schema), record);
}, this);
records.forEach(function (record) {
toBeDeleted.delete(canReflect.getIdentity(record, this.queryLogic.schema));
}, this);
this.destroyRecords(canReflect.toArray(toBeDeleted.values()));
}
var allQueries = this.getQueryDataSync();
var notSubsets = allQueries.filter(function (existingQueryData) {
return !this.queryLogic.isSubset(existingQueryData.query, query);
}, this), superSets = notSubsets.filter(function (existingQueryData) {
return this.queryLogic.isSubset(query, existingQueryData.query);
}, this);
if (superSets.length) {
this.updateQueryDataSync(notSubsets);
} else {
this.updateQueryDataSync(notSubsets.concat([{
query: query,
startIdentity: identity
}]));
}
return Promise.resolve();
},
getData: function (params) {
var id = canReflect.getIdentity(params, canReflect.getSchema(this.queryLogic));
var res = this.getRecord(id);
if (res) {
return Promise.resolve(res);
} else {
return Promise.reject({
title: 'no data',
status: '404',
detail: 'No record with matching identity (' + id + ').'
});
}
},
createData: function (record) {
this.updateRecordsSync([record]);
return Promise.resolve(canReflect.assignMap({}, this.getRecordFromParams(record)));
},
updateData: function (record) {
if (this.<API key> && !this.getRecordFromParams(record)) {
var id = canReflect.getIdentity(record, this.queryLogic.schema);
return Promise.reject({
title: 'no data',
status: '404',
detail: 'No record with matching identity (' + id + ').'
});
}
this.updateRecordsSync([record]);
return Promise.resolve(canReflect.assignMap({}, this.getRecordFromParams(record)));
},
destroyData: function (record) {
var id = canReflect.getIdentity(record, this.queryLogic.schema), savedRecord = this.getRecordFromParams(record);
if (this.<API key> && !savedRecord) {
return Promise.reject({
title: 'no data',
status: '404',
detail: 'No record with matching identity (' + id + ').'
});
}
this.destroyRecords([record]);
return Promise.resolve(canReflect.assignMap({}, savedRecord || record));
}
});
}
module.exports = makeSimpleStore;
});
/*can-memory-store@1.0.0#can-memory-store*/
define('can-memory-store', [
'require',
'exports',
'module',
'can-reflect',
'can-namespace',
'can-memory-store/make-simple-store'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var namespace = require('can-namespace');
var makeSimpleStore = require('can-memory-store/make-simple-store');
module.exports = namespace.memoryStore = function memoryStore(baseConnection) {
baseConnection.constructor = memoryStore;
var behavior = Object.create(makeSimpleStore(baseConnection));
canReflect.assignMap(behavior, {
clear: function () {
this._instances = {};
this._queries = [];
},
_queryData: [],
updateQueryDataSync: function (queries) {
this._queryData = queries;
},
getQueryDataSync: function () {
return this._queryData;
},
_instances: {},
getRecord: function (id) {
return this._instances[id];
},
getAllRecords: function () {
var records = [];
for (var id in this._instances) {
records.push(this._instances[id]);
}
return records;
},
destroyRecords: function (records) {
canReflect.eachIndex(records, function (record) {
var id = canReflect.getIdentity(record, this.queryLogic.schema);
delete this._instances[id];
}, this);
},
updateRecordsSync: function (records) {
records.forEach(function (record) {
var id = canReflect.getIdentity(record, this.queryLogic.schema);
this._instances[id] = record;
}, this);
}
});
return behavior;
};
});
/*can-fixture@3.0.0-pre.11#store*/
define('can-fixture/store', [
'require',
'exports',
'module',
'can-query-logic',
'can-reflect',
'can-memory-store'
], function (require, exports, module) {
var QueryLogic = require('can-query-logic');
var canReflect = require('can-reflect');
var memoryStore = require('can-memory-store');
var connectToConnection = function (method, convert) {
return function (req, res) {
this.connection[method](convert.call(this, req.data)).then(function (data) {
res(data);
}, function (err) {
res(parseInt(err.status, 10), err);
});
};
};
var makeMakeItems = function (baseItems, idProp) {
return function () {
var items = [], maxId = 0;
baseItems.forEach(function (item) {
items.push(canReflect.serialize(item));
maxId = Math.max(item[idProp], maxId);
});
return {
maxId: maxId,
items: items
};
};
};
var stringToAny = function (str) {
switch (str) {
case 'NaN':
case 'Infinity':
return +str;
case 'null':
return null;
case 'undefined':
return undefined;
case 'true':
case 'false':
return str === 'true';
default:
var val = +str;
if (!isNaN(val)) {
return val;
} else {
return str;
}
}
};
var Store = function (connection, makeItems, idProp) {
var schema = connection.queryLogic.schema;
var identityKey = schema.identity[0], keys = schema.keys;
if (!keys || !keys[identityKey]) {
console.warn('No type specified for identity key. Going to convert strings to reasonable type.');
}
this.connection = connection;
this.makeItems = makeItems;
this.idProp = idProp;
this.reset();
for (var method in Store.prototype) {
this[method] = this[method].bind(this);
}
};
var doNotConvert = function (v) {
return v;
};
function typeConvert(data) {
var schema = this.connection.queryLogic.schema;
var identityKey = schema.identity[0], keys = schema.keys;
if (!keys || !keys[identityKey]) {
keys = {};
keys[identityKey] = function (value) {
return typeof value === 'string' ? stringToAny(value) : value;
};
}
var copy = {};
canReflect.eachKey(data, function (value, key) {
if (keys[key]) {
copy[key] = canReflect.convert(value, keys[key]);
} else {
copy[key] = value;
}
});
return copy;
}
canReflect.assignMap(Store.prototype, {
getListData: connectToConnection('getListData', doNotConvert),
getData: connectToConnection('getData', typeConvert),
createData: function (req, res) {
var idProp = this.idProp;
req.data[idProp] = ++this.maxId;
this.connection.createData(typeConvert.call(this, req.data)).then(function (data) {
res(data);
}, function (err) {
res(403, err);
});
},
createInstance: function (record) {
var idProp = this.idProp;
if (!(idProp in record)) {
record[idProp] = ++this.maxId;
}
return this.connection.createData(record);
},
updateData: connectToConnection('updateData', typeConvert),
updateInstance: function (record) {
return this.connection.updateData(record);
},
destroyInstance: function (record) {
return this.connection.destroyData(record);
},
destroyData: connectToConnection('destroyData', typeConvert),
reset: function (newItems) {
if (newItems) {
this.makeItems = makeMakeItems(newItems, this.idProp);
}
var itemData = this.makeItems();
this.maxId = itemData.maxId;
this.connection.updateListData(itemData.items, {});
},
get: function (params) {
var id = this.connection.queryLogic.memberIdentity(params);
return this.connection.getRecord(id);
},
getList: function (set) {
return this.connection.getListDataSync(set);
}
});
function <API key>(obj) {
return obj && 'identityKeys' in obj;
}
Store.make = function (count, make, queryLogic) {
var makeItems, idProp;
if (typeof count === 'number') {
if (!queryLogic) {
queryLogic = new QueryLogic({});
} else if (!<API key>(queryLogic)) {
queryLogic = new QueryLogic(queryLogic);
}
idProp = queryLogic.identityKeys()[0] || 'id';
makeItems = function () {
var items = [];
var maxId = 0;
for (var i = 0; i < count; i++) {
var item = make(i, items);
if (!item[idProp]) {
item[idProp] = i;
}
maxId = Math.max(item[idProp], maxId);
items.push(item);
}
return {
maxId: maxId,
items: items
};
};
} else if (Array.isArray(count)) {
queryLogic = make;
if (!queryLogic) {
queryLogic = new QueryLogic({});
} else if (!<API key>(queryLogic)) {
queryLogic = new QueryLogic(queryLogic);
}
idProp = queryLogic.identityKeys()[0] || 'id';
makeItems = makeMakeItems(count, idProp);
}
var connection = memoryStore({
queryLogic: queryLogic,
<API key>: true
});
return new Store(connection, makeItems, idProp);
};
module.exports = Store;
});
/*can-fixture@3.0.0-pre.11#core*/
define('can-fixture/core', [
'require',
'exports',
'module',
'can-key/sub/sub',
'can-reflect',
'can-fixture/matches',
'can-log',
'can-log/dev/dev',
'can-fixture/data-from-url',
'can-fixture/store'
], function (require, exports, module) {
var sub = require('can-key/sub/sub');
var canReflect = require('can-reflect');
var matches = require('can-fixture/matches');
var canLog = require('can-log');
var canDev = require('can-log/dev/dev');
var dataFromUrl = require('can-fixture/data-from-url');
require('can-fixture/store');
var fixtures = [];
exports.fixtures = fixtures;
function isStoreLike(fixture) {
return fixture && (fixture.getData || fixture.getListData);
}
var methodMapping = {
item: {
'GET': 'getData',
'PUT': 'updateData',
'DELETE': 'destroyData'
},
list: {
'GET': 'getListData',
'POST': 'createData'
}
};
function getMethodAndPath(route) {
var matches = route.match(/(GET|POST|PUT|DELETE|PATCH) (.+)/i);
if (!matches) {
return [
undefined,
route
];
}
var method = matches[1];
var path = matches[2];
return [
method,
path
];
}
function inferIdProp(url) {
var wrappedInBraces = /\{(.*)\}/;
var matches = url.match(wrappedInBraces);
var isUniqueMatch = matches && matches.length === 2;
if (isUniqueMatch) {
return matches[1];
}
}
function getItemAndListUrls(url, idProp) {
idProp = idProp || inferIdProp(url);
if (!idProp) {
return [
undefined,
url
];
}
var itemRegex = new RegExp('\\/\\{' + idProp + '\\}.*');
var rootIsItemUrl = itemRegex.test(url);
var listUrl = rootIsItemUrl ? url.replace(itemRegex, '') : url;
var itemUrl = rootIsItemUrl ? url : url.trim() + '/{' + idProp + '}';
return [
itemUrl,
listUrl
];
}
function addStoreFixture(root, store) {
var settings = {};
var typeAndUrl = getMethodAndPath(root);
var type = typeAndUrl[0];
var url = typeAndUrl[1];
var itemAndListUrls = getItemAndListUrls(url, store.idProp);
var itemUrl = itemAndListUrls[0];
var listUrl = itemAndListUrls[1];
if (type) {
var warning = ['fixture("' + root + '", fixture) must use a store method, not a store directly.'];
if (itemUrl) {
var itemAction = methodMapping.item[type];
if (itemAction) {
settings[type + ' ' + itemUrl] = store[itemAction];
var itemWarning = 'Replace with fixture("' + type + ' ' + itemUrl + '", fixture.' + itemAction + ') for items.';
warning.push(itemWarning);
}
}
var listAction = methodMapping.list[type];
if (listAction) {
settings[type + ' ' + listUrl] = store[listAction];
var listWarning = 'Replace with fixture("' + type + ' ' + listUrl + '", fixture.' + listAction + ') for lists.';
warning.push(listWarning);
}
var message = warning.join(' ');
canDev.warn(message);
} else {
var itemMapping = methodMapping.item;
for (var itemMethod in itemMapping) {
var storeItemMethod = itemMapping[itemMethod];
settings[itemMethod + ' ' + itemUrl] = store[storeItemMethod];
}
var listMapping = methodMapping.list;
for (var listMethod in listMapping) {
var storeListMethod = listMapping[listMethod];
settings[listMethod + ' ' + listUrl] = store[storeListMethod];
}
}
return settings;
}
function <API key>(route) {
var typeAndUrl = getMethodAndPath(route);
var type = typeAndUrl[0];
var url = typeAndUrl[1];
if (type) {
return {
type: type,
url: url
};
}
return { url: url };
}
function upsertFixture(fixtureList, settings, fixture) {
var index = exports.index(settings, true);
if (index > -1) {
fixtures.splice(index, 1);
}
if (fixture == null) {
return;
}
if (typeof fixture === 'object') {
var data = fixture;
fixture = function () {
return data;
};
}
settings.fixture = fixture;
fixtures.unshift(settings);
}
exports.add = function (settings, fixture) {
if (fixture === undefined) {
canReflect.eachKey(settings, function (fixture, url) {
exports.add(url, fixture);
});
return;
}
if (isStoreLike(fixture)) {
settings = addStoreFixture(settings, fixture);
exports.add(settings);
return;
}
if (typeof settings === 'string') {
settings = <API key>(settings);
}
upsertFixture(fixtures, settings, fixture);
};
var $fixture = exports.add;
$fixture.on = true;
$fixture.delay = 10;
function FixtureResponse(fixture, response) {
this.statusCode = response[0];
this.responseBody = response[1];
this.headers = response[2];
this.statusText = response[3];
this.fixture = fixture;
}
exports.callDynamicFixture = function (xhrSettings, fixtureSettings, cb) {
xhrSettings.data = fixtureSettings.data;
var response = function () {
var res = exports.extractResponse.apply(xhrSettings, arguments);
canLog.log('can-fixture: ' + xhrSettings.type.toUpperCase() + ' ' + xhrSettings.url + ' ', xhrSettings.data, ' => ', new FixtureResponse(fixtureSettings.fixture, res));
return cb.apply(this, res);
};
var callFixture = function () {
var result = fixtureSettings.fixture(xhrSettings, response, xhrSettings.headers, fixtureSettings);
if (result !== undefined) {
response(200, result);
}
};
if (!xhrSettings.async) {
callFixture();
return null;
} else {
return setTimeout(callFixture, $fixture.delay);
}
};
exports.index = function (settings, exact) {
for (var i = 0; i < fixtures.length; i++) {
if (matches.matches(settings, fixtures[i], exact)) {
return i;
}
}
return -1;
};
exports.get = function (xhrSettings) {
if (!$fixture.on) {
return;
}
var index = exports.index(xhrSettings, true);
if (index === -1) {
index = exports.index(xhrSettings, false);
}
var fixtureSettings = index >= 0 ? canReflect.assignMap({}, fixtures[index]) : undefined;
if (fixtureSettings) {
var url = fixtureSettings.fixture, data = dataFromUrl(fixtureSettings.url, xhrSettings.url);
if (typeof fixtureSettings.fixture === 'string') {
if (data) {
url = sub(url, data);
}
fixtureSettings.url = url;
fixtureSettings.data = null;
fixtureSettings.type = 'GET';
if (!fixtureSettings.error) {
fixtureSettings.error = function (xhr, error, message) {
throw 'fixtures.js Error ' + error + ' ' + message;
};
}
} else if (canReflect.isPlainObject(xhrSettings.data) || xhrSettings.data == null) {
var xhrData = canReflect.assignMap({}, xhrSettings.data || {});
fixtureSettings.data = canReflect.assignMap(xhrData, data);
} else {
fixtureSettings.data = xhrSettings.data;
}
}
return fixtureSettings;
};
exports.matches = matches;
exports.extractResponse = function (status, response, headers, statusText) {
if (typeof status !== 'number') {
headers = response;
response = status;
status = 200;
}
if (typeof headers === 'string') {
statusText = headers;
headers = {};
}
return [
status,
response,
headers,
statusText
];
};
});
/*can-deparam@1.1.1#can-deparam*/
define('can-deparam', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
var namespace = require('can-namespace');
var digitTest = /^\d+$/, keyBreaker = /([^\[\]]+)|(\[\])/g, paramTest = /([^?#]*)(#.*)?$/, entityRegex = /%([^0-9a-f][0-9a-f]|[0-9a-f][^0-9a-f]|[^0-9a-f][^0-9a-f])/i, prep = function (str) {
str = str.replace(/\+/g, ' ');
try {
return decodeURIComponent(str);
} catch (e) {
return decodeURIComponent(str.replace(entityRegex, function (match, hex) {
return '%25' + hex;
}));
}
};
function isArrayLikeName(name) {
return digitTest.test(name) || name === '[]';
}
function idenity(value) {
return value;
}
module.exports = namespace.deparam = function (params, valueDeserializer) {
valueDeserializer = valueDeserializer || idenity;
var data = {}, pairs, lastPart;
if (params && paramTest.test(params)) {
pairs = params.split('&');
pairs.forEach(function (pair) {
var parts = pair.split('='), key = prep(parts.shift()), value = prep(parts.join('=')), current = data;
if (key) {
parts = key.match(keyBreaker);
for (var j = 0, l = parts.length - 1; j < l; j++) {
var currentName = parts[j], nextName = parts[j + 1], currentIsArray = isArrayLikeName(currentName) && current instanceof Array;
if (!current[currentName]) {
if (currentIsArray) {
current.push(isArrayLikeName(nextName) ? [] : {});
} else {
current[currentName] = isArrayLikeName(nextName) ? [] : {};
}
}
if (currentIsArray) {
current = current[current.length - 1];
} else {
current = current[currentName];
}
}
lastPart = parts.pop();
if (isArrayLikeName(lastPart)) {
current.push(valueDeserializer(value));
} else {
current[lastPart] = valueDeserializer(value);
}
}
});
}
return data;
};
});
/*can-fixture@3.0.0-pre.11#xhr*/
define('can-fixture/xhr', [
'require',
'exports',
'module',
'can-fixture/core',
'can-deparam',
'can-reflect',
'can-log'
], function (require, exports, module) {
(function (global, require, exports, module) {
var fixtureCore = require('can-fixture/core');
var deparam = require('can-deparam');
var canReflect = require('can-reflect');
var canLog = require('can-log');
var XHR = XMLHttpRequest, GLOBAL = typeof global !== 'undefined' ? global : window;
var props = [
'type',
'url',
'async',
'response',
'responseText',
'responseType',
'responseXML',
'responseURL',
'status',
'statusText',
'readyState'
];
var events = [
'abort',
'error',
'load',
'loadend',
'loadstart',
'progress',
'readystatechange'
];
(function () {
var x = new XHR();
for (var prop in x) {
if (prop.indexOf('on') === 0) {
if (events.indexOf(prop.substr(2)) === -1) {
events.push(prop.substr(2));
}
} else if (props.indexOf(prop) === -1 && typeof x[prop] !== 'function') {
props.push(prop);
}
}
}());
function callEvents(xhr, ev) {
var evs = xhr.__events[ev] || [], fn;
for (var i = 0, len = evs.length; i < len; i++) {
fn = evs[i];
fn.call(xhr);
}
}
GLOBAL.XMLHttpRequest = function () {
var mockXHR = this;
var realXHR = new XHR();
this._xhr = realXHR;
this._requestHeaders = {};
this.__events = {};
events.forEach(function (eventName) {
realXHR['on' + eventName] = function () {
callEvents(mockXHR, eventName);
if (mockXHR['on' + eventName]) {
return mockXHR['on' + eventName].apply(mockXHR, arguments);
}
};
});
this.onload = null;
};
GLOBAL.XMLHttpRequest._XHR = XHR;
canReflect.assignMap(XMLHttpRequest.prototype, {
setRequestHeader: function (name, value) {
this._requestHeaders[name] = value;
},
open: function (type, url, async) {
this.type = type;
this.url = url;
this.async = async === false ? false : true;
},
<API key>: function () {
return this._xhr.<API key>.apply(this._xhr, arguments);
},
addEventListener: function (ev, fn) {
var evs = this.__events[ev] = this.__events[ev] || [];
evs.push(fn);
},
removeEventListener: function (ev, fn) {
var evs = this.__events[ev] = this.__events[ev] || [];
var idx = evs.indexOf(fn);
if (idx >= 0) {
evs.splice(idx, 1);
}
},
<API key>: function (val) {
this._disableHeaderCheck = !!val;
},
getResponseHeader: function (key) {
return this._xhr.getResponseHeader(key);
},
abort: function () {
var xhr = this._xhr;
if (this.timeoutId !== undefined) {
clearTimeout(this.timeoutId);
xhr.open(this.type, this.url, this.async === false ? false : true);
xhr.send();
}
return xhr.abort();
},
send: function (data) {
var type = this.type.toLowerCase() || 'get';
var xhrSettings = {
url: this.url,
data: data,
headers: this._requestHeaders,
type: type,
method: type,
async: this.async,
xhr: this
};
if (!xhrSettings.data && xhrSettings.type === 'get' || xhrSettings.type === 'delete') {
xhrSettings.data = deparam(xhrSettings.url.split('?')[1]);
xhrSettings.url = xhrSettings.url.split('?')[0];
}
if (typeof xhrSettings.data === 'string') {
try {
xhrSettings.data = JSON.parse(xhrSettings.data);
} catch (e) {
xhrSettings.data = deparam(xhrSettings.data);
}
}
var fixtureSettings = fixtureCore.get(xhrSettings);
var mockXHR = this;
if (fixtureSettings && typeof fixtureSettings.fixture === 'function') {
this.timeoutId = fixtureCore.callDynamicFixture(xhrSettings, fixtureSettings, function (status, body, headers, statusText) {
body = typeof body === 'string' ? body : JSON.stringify(body);
mockXHR._xhr = {
open: function () {
},
send: function () {
},
abort: function () {
},
getResponseHeader: function () {
}
};
canReflect.assignMap(mockXHR, {
readyState: 4,
status: status
});
var success = status >= 200 && status < 300 || status === 304;
if (success) {
canReflect.assignMap(mockXHR, {
statusText: statusText || 'OK',
responseText: body
});
} else {
canReflect.assignMap(mockXHR, {
statusText: statusText || 'error',
responseText: body
});
}
mockXHR.<API key> = function () {
var ret = [];
canReflect.eachKey(headers || {}, function (value, name) {
Array.prototype.push.apply(ret, [
name,
': ',
value,
'\r\n'
]);
});
return ret.join('');
};
if (mockXHR.onreadystatechange) {
mockXHR.onreadystatechange({ target: mockXHR });
}
callEvents(mockXHR, 'progress');
if (mockXHR.onprogress) {
mockXHR.onprogress();
}
callEvents(mockXHR, 'load');
if (mockXHR.onload) {
mockXHR.onload();
}
callEvents(mockXHR, 'loadend');
if (mockXHR.onloadend) {
mockXHR.onloadend();
}
});
return;
}
var makeRequest = function () {
mockXHR._xhr.open(mockXHR._xhr.type, mockXHR._xhr.url, mockXHR._xhr.async);
if (mockXHR._requestHeaders) {
Object.keys(mockXHR._requestHeaders).forEach(function (key) {
mockXHR._xhr.setRequestHeader(key, mockXHR._requestHeaders[key]);
});
}
return mockXHR._xhr.send(data);
};
if (fixtureSettings && typeof fixtureSettings.fixture === 'number') {
canLog.log('can-fixture: ' + xhrSettings.url + ' => delay ' + fixtureSettings.fixture + 'ms');
this.timeoutId = setTimeout(makeRequest, fixtureSettings.fixture);
return;
}
if (fixtureSettings) {
canLog.log('can-fixture: ' + xhrSettings.url + ' => ' + fixtureSettings.url);
canReflect.assignMap(mockXHR, fixtureSettings);
}
return makeRequest();
}
});
props.forEach(function (prop) {
Object.defineProperty(XMLHttpRequest.prototype, prop, {
get: function () {
return this._xhr[prop];
},
set: function (newVal) {
try {
this._xhr[prop] = newVal;
} catch (e) {
}
}
});
});
}(function () {
return this;
}(), require, exports, module));
});
/*can-fixture@3.0.0-pre.11#fixture*/
define('can-fixture', [
'require',
'exports',
'module',
'can-fixture/core',
'can-fixture/store',
'can-fixture/xhr',
'can-reflect',
'can-namespace'
], function (require, exports, module) {
var core = require('can-fixture/core');
var fixture = core.add;
var Store = require('can-fixture/store');
require('can-fixture/xhr');
var canReflect = require('can-reflect');
var ns = require('can-namespace');
var noop = function () {
};
canReflect.assignMap(fixture, {
rand: function randomize(arr, min, max) {
if (typeof arr === 'number') {
if (typeof min === 'number') {
return arr + Math.floor(Math.random() * (min - arr + 1));
} else {
return Math.floor(Math.random() * (arr + 1));
}
}
var choices = arr.slice(0);
if (min === undefined) {
min = 1;
max = choices.length;
} else if (max === undefined) {
max = min;
}
var result = [];
var selectedCount = min + Math.round(randomize(max - min));
for (var i = 0; i < selectedCount; i++) {
var selectedIndex = randomize(choices.length - 1), selected = choices.splice(selectedIndex, 1)[0];
result.push(selected);
}
return result;
},
xhr: function (xhr) {
return canReflect.assignMap({}, {
abort: noop,
<API key>: function () {
return '';
},
getResponseHeader: function () {
return '';
},
open: noop,
overrideMimeType: noop,
readyState: 4,
responseText: '',
responseXML: null,
send: noop,
setRequestHeader: noop,
status: 200,
statusText: 'OK'
}, xhr);
},
store: Store.make,
fixtures: core.fixtures
});
if (typeof window !== 'undefined' && typeof require.resolve !== 'function') {
window.fixture = fixture;
}
module.exports = ns.fixture = fixture;
});
/*can@5.0.0-pre.3#es/can-fixture*/
define('can/es/can-fixture', [
'exports',
'can-fixture'
], function (exports, _canFixture) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canFixture).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-connect@3.0.0-pre.15#helpers/weak-reference-map*/
define('can-connect/helpers/weak-reference-map', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var assign = require('can-reflect').assignMap;
var WeakReferenceMap = function () {
this.set = {};
};
assign(WeakReferenceMap.prototype, {
has: function (key) {
return !!this.set[key];
},
addReference: function (key, item, referenceCount) {
if (typeof key === 'undefined') {
throw new Error('can-connect: You must provide a key to store a value in a WeakReferenceMap');
}
var data = this.set[key];
if (!data) {
data = this.set[key] = {
item: item,
referenceCount: 0,
key: key
};
}
data.referenceCount += referenceCount || 1;
},
referenceCount: function (key) {
var data = this.set[key];
if (data) {
return data.referenceCount;
}
},
deleteReference: function (key) {
var data = this.set[key];
if (data) {
data.referenceCount
if (data.referenceCount === 0) {
delete this.set[key];
}
}
},
get: function (key) {
var data = this.set[key];
if (data) {
return data.item;
}
},
forEach: function (cb) {
for (var id in this.set) {
cb(this.set[id].item, id);
}
}
});
module.exports = WeakReferenceMap;
});
/*can-diff@1.0.4#<API key>/<API key>*/
define('can-diff/<API key>/<API key>', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
module.exports = function <API key>(obj, data, schema) {
if (!schema) {
schema = canReflect.getSchema(obj);
}
if (!schema) {
throw new Error('can-diff/update-except-id is unable to update without a schema.');
}
schema.identity.forEach(function (key) {
var id = canReflect.getKeyValue(obj, key);
if (id !== undefined) {
canReflect.setKeyValue(data, key, id);
}
});
canReflect.updateDeep(obj, data);
};
});
/*can-connect@3.0.0-pre.15#helpers/id-merge*/
define('can-connect/helpers/id-merge', [
'require',
'exports',
'module',
'can-diff/list/list',
'can-reflect'
], function (require, exports, module) {
var map = [].map;
var diffList = require('can-diff/list/list');
var canReflect = require('can-reflect');
module.exports = function (list, update, id, make) {
var patches = diffList(list, update, function (a, b) {
return id(a) === id(b);
});
patches.forEach(function (patch) {
canReflect.splice(list, patch.index, patch.deleteCount, patch.insert.map(make));
});
};
});
/*can-connect@3.0.0-pre.15#behavior*/
define('can-connect/behavior', function (require, exports, module) {
'use strict';
var behaviorsMap = {};
function behavior(name, behavior) {
if (typeof name !== 'string') {
behavior = name;
name = undefined;
}
var behaviorMixin = function (base) {
var Behavior = function () {
};
Object.defineProperty(Behavior, 'name', {
value: name,
configurable: true
});
Behavior.prototype = base;
var newBehavior = new Behavior();
var res = typeof behavior === 'function' ? behavior.apply(newBehavior, arguments) : behavior;
for (var prop in res) {
if (res.hasOwnProperty(prop)) {
Object.defineProperty(newBehavior, prop, Object.<API key>(res, prop));
} else {
newBehavior[prop] = res[prop];
}
}
newBehavior.__behaviorName = name;
return newBehavior;
};
if (name) {
behaviorMixin.behaviorName = name;
behaviorsMap[name] = behaviorMixin;
}
behaviorMixin.isBehavior = true;
return behaviorMixin;
}
behavior.map = behaviorsMap;
module.exports = behavior;
});
/*can-connect@3.0.0-pre.15#constructor/constructor*/
define('can-connect/constructor/constructor', [
'require',
'exports',
'module',
'can-reflect',
'can-connect/helpers/weak-reference-map',
'can-diff/<API key>/<API key>',
'can-connect/helpers/id-merge',
'can-connect/behavior'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var makeArray = canReflect.toArray;
var assign = canReflect.assignMap;
var WeakReferenceMap = require('can-connect/helpers/weak-reference-map');
var <API key> = require('can-diff/<API key>/<API key>');
var idMerge = require('can-connect/helpers/id-merge');
var behavior = require('can-connect/behavior');
module.exports = behavior('constructor', function (baseConnection) {
var behavior = {
cidStore: new WeakReferenceMap(),
_cid: 0,
get: function (params) {
var self = this;
return this.getData(params).then(function (data) {
return self.hydrateInstance(data);
});
},
getList: function (set) {
set = set || {};
var self = this;
return this.getListData(set).then(function (data) {
return self.hydrateList(data, set);
});
},
hydrateList: function (listData, set) {
if (Array.isArray(listData)) {
listData = { data: listData };
}
var arr = [];
for (var i = 0; i < listData.data.length; i++) {
arr.push(this.hydrateInstance(listData.data[i]));
}
listData.data = arr;
if (this.list) {
return this.list(listData, set);
} else {
var list = listData.data.slice(0);
list[this.listQueryProp || '__listQuery'] = set;
copyMetadata(listData, list);
return list;
}
},
hydrateInstance: function (props) {
if (this.instance) {
return this.instance(props);
} else {
return assign({}, props);
}
},
save: function (instance) {
var serialized = this.serializeInstance(instance);
var id = this.id(instance);
var self = this;
if (id === undefined) {
var cid = this._cid++;
this.cidStore.addReference(cid, instance);
return this.createData(serialized, cid).then(function (data) {
if (data !== undefined) {
self.createdInstance(instance, data);
}
self.cidStore.deleteReference(cid, instance);
return instance;
});
} else {
return this.updateData(serialized).then(function (data) {
if (data !== undefined) {
self.updatedInstance(instance, data);
}
return instance;
});
}
},
destroy: function (instance) {
var serialized = this.serializeInstance(instance), self = this;
return this.destroyData(serialized).then(function (data) {
if (data !== undefined) {
self.destroyedInstance(instance, data);
}
return instance;
});
},
createdInstance: function (instance, props) {
assign(instance, props);
},
updatedInstance: function (instance, data) {
<API key>(instance, data, this.queryLogic.schema);
},
updatedList: function (list, listData, set) {
var instanceList = [];
for (var i = 0; i < listData.data.length; i++) {
instanceList.push(this.hydrateInstance(listData.data[i]));
}
idMerge(list, instanceList, this.id.bind(this), this.hydrateInstance.bind(this));
copyMetadata(listData, list);
},
destroyedInstance: function (instance, data) {
<API key>(instance, data, this.queryLogic.schema);
},
serializeInstance: function (instance) {
return assign({}, instance);
},
serializeList: function (list) {
var self = this;
return makeArray(list).map(function (instance) {
return self.serializeInstance(instance);
});
},
isNew: function (instance) {
var id = this.id(instance);
return !(id || id === 0);
}
};
return behavior;
});
function copyMetadata(listData, list) {
for (var prop in listData) {
if (prop !== 'data') {
if (typeof list.set === 'function') {
list.set(prop, listData[prop]);
} else if (typeof list.attr === 'function') {
list.attr(prop, listData[prop]);
} else {
list[prop] = listData[prop];
}
}
}
}
});
/*can-diff@1.0.4#<API key>/<API key>*/
define('can-diff/<API key>/<API key>', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
module.exports = function <API key>(obj, data, schema) {
if (!schema) {
schema = canReflect.getSchema(obj);
}
if (!schema) {
throw new Error('can-diff/update-except-id is unable to update without a schema.');
}
schema.identity.forEach(function (key) {
var id = canReflect.getKeyValue(obj, key);
if (id !== undefined) {
canReflect.setKeyValue(data, key, id);
}
});
canReflect.assignDeep(obj, data);
};
});
/*can-diff@1.0.4#merge-deep/merge-deep*/
define('can-diff/merge-deep/merge-deep', [
'require',
'exports',
'module',
'can-reflect',
'can-diff/list/list'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var diffList = require('can-diff/list/list');
function smartMerge(instance, props) {
props = canReflect.serialize(props);
if (canReflect.<API key>(instance)) {
mergeList(instance, props);
} else {
mergeMap(instance, props);
}
return instance;
}
function mergeMap(instance, data) {
canReflect.eachKey(instance, function (value, prop) {
if (!canReflect.hasKey(data, prop)) {
canReflect.deleteKeyValue(instance, prop);
return;
}
var newValue = canReflect.getKeyValue(data, prop);
canReflect.deleteKeyValue(data, prop);
if (canReflect.isPrimitive(value)) {
canReflect.setKeyValue(instance, prop, newValue);
return;
}
var newValueIsList = Array.isArray(newValue), currentValueIsList = canReflect.<API key>(value);
if (currentValueIsList && newValueIsList) {
mergeList(value, newValue);
} else if (!newValueIsList && !currentValueIsList && canReflect.isMapLike(value) && canReflect.isPlainObject(newValue)) {
var schema = canReflect.getSchema(value);
if (schema && schema.identity && schema.identity.length) {
var id = canReflect.getIdentity(value, schema);
if (id != null && id === canReflect.getIdentity(newValue, schema)) {
mergeMap(value, newValue);
return;
}
}
canReflect.setKeyValue(instance, prop, canReflect.new(value.constructor, newValue));
} else {
canReflect.setKeyValue(instance, prop, newValue);
}
});
canReflect.eachKey(data, function (value, prop) {
canReflect.setKeyValue(instance, prop, value);
});
}
function mergeList(list, data) {
var ItemType, itemSchema;
var listSchema = canReflect.getSchema(list);
if (listSchema) {
ItemType = listSchema.values;
}
if (ItemType) {
itemSchema = canReflect.getSchema(ItemType);
}
if (!itemSchema && canReflect.size(list) > 0) {
itemSchema = canReflect.getSchema(canReflect.getKeyValue(list, 0));
}
var identity;
if (itemSchema && itemSchema.identity && itemSchema.identity.length) {
identity = function (a, b) {
var aId = canReflect.getIdentity(a, itemSchema), bId = canReflect.getIdentity(b, itemSchema);
var eq = aId === bId;
if (eq) {
mergeMap(a, b);
}
return eq;
};
} else {
identity = function (a, b) {
var eq = a === b;
if (eq) {
mergeMap(a, b);
}
return eq;
};
}
var patches = diffList(list, data, identity);
var hydrate = ItemType ? canReflect.new.bind(canReflect, ItemType) : function (v) {
return v;
};
if (!patches.length) {
return list;
}
patches.forEach(function (patch) {
applyPatch(list, patch, hydrate);
});
}
function applyPatch(list, patch, makeInstance) {
var insert = makeInstance && patch.insert.map(function (val) {
return makeInstance(val);
}) || patch.insert;
var args = [
patch.index,
patch.deleteCount
].concat(insert);
list.splice.apply(list, args);
return list;
}
smartMerge.applyPatch = applyPatch;
module.exports = smartMerge;
});
/*<API key>@1.0.2#index*/
define('<API key>', function (require, exports, module) {
'use strict';
function flatten(arrays) {
return arrays.reduce(function (ret, val) {
return ret.concat(val);
}, []);
}
function <API key>(interfacePropArrays) {
var props = flatten(interfacePropArrays);
return function (base) {
var missingProps = props.reduce(function (missing, prop) {
return prop in base ? missing : missing.concat(prop);
}, []);
return missingProps.length ? {
message: 'missing expected properties',
related: missingProps
} : undefined;
};
}
module.exports = <API key>;
});
/*can-connect@3.0.0-pre.15#helpers/validate*/
define('can-connect/helpers/validate', [
'require',
'exports',
'module',
'<API key>'
], function (require, exports, module) {
var <API key> = require('<API key>');
module.exports = function (extendingBehavior, interfaces) {
var validatedBehaviour = <API key>(extendingBehavior, 0, interfaces, function (errors, baseBehavior) {
throw new <API key>(baseBehavior, extendingBehavior, errors);
});
Object.keys(extendingBehavior).forEach(function (k) {
validatedBehaviour[k] = extendingBehavior[k];
});
validatedBehaviour.__interfaces = interfaces;
return validatedBehaviour;
};
function <API key>(func, argIndex, interfaces, errorHandler) {
return function () {
var errors = <API key>(interfaces)(arguments[argIndex]);
if (errors && errorHandler) {
errorHandler(errors, arguments[argIndex]);
}
return func.apply(this, arguments);
};
}
function <API key>(baseBehavior, extendingBehavior, missingProps) {
var extendingName = extendingBehavior.behaviorName || 'anonymous behavior', baseName = baseBehavior.__behaviorName || 'anonymous behavior', message = 'can-connect: Extending behavior "' + extendingName + '" found base behavior "' + baseName + '" was missing required properties: ' + JSON.stringify(missingProps.related), instance = new Error(message);
if (Object.setPrototypeOf) {
Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
}
return instance;
}
<API key>.prototype = Object.create(Error.prototype, { constructor: { value: Error } });
if (Object.setPrototypeOf) {
Object.setPrototypeOf(<API key>, Error);
} else {
<API key>.__proto__ = Error;
}
});
/*can-connect@3.0.0-pre.15#can/map/map*/
define('can-connect/can/map/map', [
'require',
'exports',
'module',
'can-reflect',
'can-queues',
'can-event-queue/map/map',
'<API key>',
'can-symbol',
'can-query-logic',
'can-log/dev/dev',
'can-connect/behavior',
'can-diff/<API key>/<API key>',
'can-diff/<API key>/<API key>',
'can-diff/merge-deep/merge-deep',
'can-symbol',
'can-connect/helpers/validate'
], function (require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
var each = canReflect.each;
var isPlainObject = canReflect.isPlainObject;
var queues = require('can-queues');
var eventQueue = require('can-event-queue/map/map');
var ObservationRecorder = require('<API key>');
var canSymbol = require('can-symbol');
var QueryLogic = require('can-query-logic');
var dev = require('can-log/dev/dev');
var behavior = require('can-connect/behavior');
var <API key> = require('can-diff/<API key>/<API key>');
var <API key> = require('can-diff/<API key>/<API key>');
var smartMerge = require('can-diff/merge-deep/merge-deep');
var canSymbol = require('can-symbol');
var getNameSymbol = canSymbol.for('can.getName');
function <API key>(dest, source, schema) {
if (!schema) {
schema = canReflect.getSchema(dest);
}
if (!schema) {
throw new Error('can-connect/can/map/ is unable to update without a schema.');
}
schema.identity.forEach(function (key) {
var id = canReflect.getKeyValue(dest, key);
if (id !== undefined) {
canReflect.setKeyValue(source, key, id);
}
});
smartMerge(dest, source);
}
var canMapBehavior = behavior('can/map', function (baseConnection) {
var behavior = {
init: function () {
if (!this.Map) {
throw new Error('can-connect/can/map/map must be configured with a Map type');
}
if (!this[getNameSymbol]) {
this[getNameSymbol] = function () {
if (this.name) {
return 'Connection{' + this.name + '}';
} else if (this.Map) {
return 'Connection{' + canReflect.getName(this.Map) + '}';
} else if (typeof this.url === 'string') {
return 'Connection{' + this.url + '}';
} else {
return 'Connection{}';
}
};
}
this.List = this.List || this.Map.List;
if (!this.List) {
throw new Error('can-connect/can/map/map - ' + canReflect.getName(this) + ' must be configured with a List type.');
}
overwrite(this, this.Map, mapOverwrites);
overwrite(this, this.List, listOverwrites);
if (!this.queryLogic) {
this.queryLogic = new QueryLogic(this.Map);
}
var connection = this;
if (this.Map[canSymbol.for('can.<API key>')]) {
var <API key> = function (instance, isBound) {
var method = isBound ? '<API key>' : '<API key>';
if (connection[method]) {
connection[method](instance);
}
};
Object.defineProperty(<API key>, 'name', {
value: canReflect.getName(this.Map) + ' boundChange',
configurable: true
});
this.Map[canSymbol.for('can.<API key>')](<API key>);
} else {
console.warn('can-connect/can/map is unable to listen to <API key> on the Map type');
}
if (this.List[canSymbol.for('can.<API key>')]) {
var <API key> = function (list, isBound) {
var method = isBound ? 'addListReference' : 'deleteListReference';
if (connection[method]) {
connection[method](list);
}
};
Object.defineProperty(<API key>, 'name', {
value: canReflect.getName(this.List) + ' boundChange',
configurable: true
});
this.List[canSymbol.for('can.<API key>')](<API key>);
} else {
console.warn('can-connect/can/map is unable to listen to <API key> on the List type');
}
if (this.Map[canSymbol.for('can.onInstancePatches')]) {
this.Map[canSymbol.for('can.onInstancePatches')](function <API key>(instance, patches) {
patches.forEach(function (patch) {
if ((patch.type === 'add' || patch.type === 'set') && patch.key === connection.idProp && instance[canSymbol.for('can.isBound')]()) {
connection.<API key>(instance);
}
});
});
} else {
console.warn('can-connect/can/map is unable to listen to onInstancePatches on the Map type');
}
baseConnection.init.apply(this, arguments);
},
serializeInstance: function (instance) {
return canReflect.serialize(instance);
},
serializeList: function (list) {
return canReflect.serialize(list);
},
instance: function (props) {
var _Map = this.Map;
return new _Map(props);
},
list: function (listData, set) {
var _List = this.List || this.Map && this.Map.List;
var list = new _List(listData.data);
canReflect.eachKey(listData, function (val, prop) {
if (prop !== 'data') {
canReflect.setKeyValue(list, prop, val);
}
});
list[this.listQueryProp] = set;
return list;
},
updatedList: function (list, listData, set) {
queues.batch.start();
queues.mutateQueue.enqueue(baseConnection.updatedList, this, arguments, {
reasonLog: [
'set',
set,
'list',
list,
'updated with',
listData
]
});
queues.batch.stop();
},
save: function (instance) {
canReflect.setKeyValue(instance, '_saving', true);
var done = function () {
canReflect.setKeyValue(instance, '_saving', false);
};
var base = baseConnection.save.apply(this, arguments);
base.then(done, done);
return base;
},
destroy: function (instance) {
canReflect.setKeyValue(instance, '_destroying', true);
var done = function () {
canReflect.setKeyValue(instance, '_destroying', false);
};
var base = baseConnection.destroy.apply(this, arguments);
base.then(done, done);
return base;
}
};
each([
'created',
'updated',
'destroyed'
], function (funcName) {
behavior[funcName + 'Instance'] = function (instance, props) {
if (props && typeof props === 'object') {
if (funcName === 'destroyed' && canReflect.size(props) === 0) {
} else {
if (this.constructor.removeAttr) {
<API key>(instance, props, this.queryLogic.schema);
} else if (this.<API key>) {
<API key>(instance, props, this.queryLogic.schema);
} else {
<API key>(instance, props, this.queryLogic.schema);
}
}
}
if (funcName === 'created' && this.<API key>) {
this.<API key>(instance);
}
canMapBehavior.<API key>(funcName, instance);
};
});
return behavior;
});
canMapBehavior.<API key> = function (funcName, instance) {
var constructor = instance.constructor;
queues.batch.start();
eventQueue.dispatch.call(instance, {
type: funcName,
target: instance
});
if (this.id) {
dev.log('can-connect/can/map/map.js - ' + (constructor.shortName || this.name) + ' ' + this.id(instance) + ' ' + funcName);
}
eventQueue.dispatch.call(constructor, funcName, [instance]);
queues.batch.stop();
};
var mapOverwrites = {
static: {
getList: function (base, connection) {
return function (set) {
return connection.getList(set);
};
},
findAll: function (base, connection) {
return function (set) {
return connection.getList(set);
};
},
get: function (base, connection) {
return function (params) {
return connection.get(params);
};
},
findOne: function (base, connection) {
return function (params) {
return connection.get(params);
};
}
},
prototype: {
isNew: function (base, connection) {
return function () {
return connection.isNew(this);
};
},
isSaving: function (base, connection) {
return function () {
return !!canReflect.getKeyValue(this, '_saving');
};
},
isDestroying: function (base, connection) {
return function () {
return !!canReflect.getKeyValue(this, '_destroying');
};
},
save: function (base, connection) {
return function (success, error) {
var promise = connection.save(this);
promise.then(success, error);
return promise;
};
},
destroy: function (base, connection) {
return function (success, error) {
var promise;
if (this.isNew()) {
promise = Promise.resolve(this);
connection.destroyedInstance(this, {});
} else {
promise = connection.destroy(this);
}
promise.then(success, error);
return promise;
};
}
},
properties: {
_saving: {
enumerable: false,
value: false,
configurable: true,
writable: true
},
_destroying: {
enumerable: false,
value: false,
configurable: true,
writable: true
}
}
};
var listOverwrites = {
static: {
_bubbleRule: function (base, connection) {
return function (eventName, list) {
var bubbleRules = base(eventName, list);
bubbleRules.push('destroyed');
return bubbleRules;
};
}
},
prototype: {
setup: function (base, connection) {
return function (params) {
if (isPlainObject(params) && !Array.isArray(params)) {
this[connection.listQueryProp] = params;
base.apply(this);
this.replace(canReflect.isPromise(params) ? params : connection.getList(params));
} else {
base.apply(this, arguments);
}
};
}
},
properties: {}
};
var overwrite = function (connection, Constructor, overwrites) {
var prop;
for (prop in overwrites.properties) {
canReflect.defineInstanceKey(Constructor, prop, overwrites.properties[prop]);
}
for (prop in overwrites.prototype) {
Constructor.prototype[prop] = overwrites.prototype[prop](Constructor.prototype[prop], connection);
}
if (overwrites.static) {
for (prop in overwrites.static) {
Constructor[prop] = overwrites.static[prop](Constructor[prop], connection);
}
}
};
module.exports = canMapBehavior;
var validate = require('can-connect/helpers/validate');
module.exports = validate(canMapBehavior, [
'id',
'get',
'updatedList',
'destroy',
'save',
'getList'
]);
});
/*can-connect@3.0.0-pre.15#data/parse/parse*/
define('can-connect/data/parse/parse', [
'require',
'exports',
'module',
'can-reflect',
'can-key/get/get',
'can-connect/behavior'
], function (require, exports, module) {
var each = require('can-reflect').each;
var getObject = require('can-key/get/get');
var behavior = require('can-connect/behavior');
module.exports = behavior('data/parse', function (baseConnection) {
var behavior = {
parseListData: function (responseData) {
if (baseConnection.parseListData) {
responseData = baseConnection.parseListData.apply(this, arguments);
}
var result;
if (Array.isArray(responseData)) {
result = { data: responseData };
} else {
var prop = this.parseListProp || 'data';
responseData.data = getObject(responseData, prop);
result = responseData;
if (prop !== 'data') {
delete responseData[prop];
}
if (!Array.isArray(result.data)) {
throw new Error('Could not get any raw data while converting using .parseListData');
}
}
var arr = [];
for (var i = 0; i < result.data.length; i++) {
arr.push(this.parseInstanceData(result.data[i]));
}
result.data = arr;
return result;
},
parseInstanceData: function (props) {
if (baseConnection.parseInstanceData) {
props = baseConnection.parseInstanceData.apply(this, arguments) || props;
}
return this.parseInstanceProp ? getObject(props, this.parseInstanceProp) || props : props;
}
};
each(pairs, function (parseFunction, name) {
behavior[name] = function (params) {
var self = this;
return baseConnection[name].call(this, params).then(function () {
return self[parseFunction].apply(self, arguments);
});
};
});
return behavior;
});
var pairs = {
getListData: 'parseListData',
getData: 'parseInstanceData',
createData: 'parseInstanceData',
updateData: 'parseInstanceData',
destroyData: 'parseInstanceData'
};
});
/*can-parse-uri@1.1.0#can-parse-uri*/
define('can-parse-uri', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
var namespace = require('can-namespace');
module.exports = namespace.parseURI = function (url) {
var m = String(url).replace(/^\s+|\s+$/g, '').match(/^([^:\/?#]+:)?(\/\/(?:[^:@]*(?::[^:@]*)?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);
return m ? {
href: m[0] || '',
protocol: m[1] || '',
authority: m[2] || '',
host: m[3] || '',
hostname: m[4] || '',
port: m[5] || '',
pathname: m[6] || '',
search: m[7] || '',
hash: m[8] || ''
} : null;
};
});
/*can-param@1.0.4#can-param*/
define('can-param', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
var namespace = require('can-namespace');
function buildParam(prefix, obj, add) {
if (Array.isArray(obj)) {
for (var i = 0, l = obj.length; i < l; ++i) {
buildParam(prefix + '[]', obj[i], add);
}
} else if (obj && typeof obj === 'object') {
for (var name in obj) {
buildParam(prefix + '[' + name + ']', obj[name], add);
}
} else {
add(prefix, obj);
}
}
module.exports = namespace.param = function param(object) {
var pairs = [], add = function (key, value) {
pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
};
for (var name in object) {
buildParam(name, object[name], add);
}
return pairs.join('&').replace(/%20/g, '+');
};
});
/*can-ajax@1.1.4#can-ajax*/
define('can-ajax', [
'require',
'exports',
'module',
'can-globals/global/global',
'can-reflect',
'can-namespace',
'can-parse-uri',
'can-param'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var Global = require('can-globals/global/global');
var canReflect = require('can-reflect');
var namespace = require('can-namespace');
var parseURI = require('can-parse-uri');
var param = require('can-param');
var xhrs = [
function () {
return new XMLHttpRequest();
},
function () {
return new ActiveXObject('Microsoft.XMLHTTP');
},
function () {
return new ActiveXObject('MSXML2.XMLHTTP.3.0');
},
function () {
return new ActiveXObject('MSXML2.XMLHTTP');
}
], _xhrf = null;
var originUrl = parseURI(Global().location.href);
var globalSettings = {};
var makeXhr = function () {
if (_xhrf != null) {
return _xhrf();
}
for (var i = 0, l = xhrs.length; i < l; i++) {
try {
var f = xhrs[i], req = f();
if (req != null) {
_xhrf = f;
return req;
}
} catch (e) {
continue;
}
}
return function () {
};
};
var contentTypes = {
json: 'application/json',
form: 'application/<API key>'
};
var _xhrResp = function (xhr, options) {
switch (options.dataType || xhr.getResponseHeader('Content-Type').split(';')[0]) {
case 'text/xml':
case 'xml':
return xhr.responseXML;
case 'text/json':
case 'application/json':
case 'text/javascript':
case 'application/javascript':
case 'application/x-javascript':
case 'json':
return xhr.responseText && JSON.parse(xhr.responseText);
default:
return xhr.responseText;
}
};
function ajax(o) {
var xhr = makeXhr(), timer, n = 0;
var deferred = {};
var promise = new Promise(function (resolve, reject) {
deferred.resolve = resolve;
deferred.reject = reject;
});
var requestUrl;
promise.abort = function () {
xhr.abort();
};
o = [
{
userAgent: 'XMLHttpRequest',
lang: 'en',
type: 'GET',
data: null,
dataType: 'json'
},
globalSettings,
o
].reduce(function (a, b, i) {
return canReflect.assignDeep(a, b);
});
if (!o.contentType) {
o.contentType = o.type.toUpperCase() === 'GET' ? contentTypes.form : contentTypes.json;
}
if (o.crossDomain == null) {
try {
requestUrl = parseURI(o.url);
o.crossDomain = !!(requestUrl.protocol && requestUrl.protocol !== originUrl.protocol || requestUrl.host && requestUrl.host !== originUrl.host);
} catch (e) {
o.crossDomain = true;
}
}
if (o.timeout) {
timer = setTimeout(function () {
xhr.abort();
if (o.timeoutFn) {
o.timeoutFn(o.url);
}
}, o.timeout);
}
xhr.onreadystatechange = function () {
try {
if (xhr.readyState === 4) {
if (timer) {
clearTimeout(timer);
}
if (xhr.status < 300) {
if (o.success) {
o.success(_xhrResp(xhr, o));
}
} else if (o.error) {
o.error(xhr, xhr.status, xhr.statusText);
}
if (o.complete) {
o.complete(xhr, xhr.statusText);
}
if (xhr.status >= 200 && xhr.status < 300) {
deferred.resolve(_xhrResp(xhr, o));
} else {
deferred.reject(xhr);
}
} else if (o.progress) {
o.progress(++n);
}
} catch (e) {
deferred.reject(e);
}
};
var url = o.url, data = null, type = o.type.toUpperCase();
var isJsonContentType = o.contentType === contentTypes.json;
var isPost = type === 'POST' || type === 'PUT';
if (!isPost && o.data) {
url += '?' + (isJsonContentType ? JSON.stringify(o.data) : param(o.data));
}
xhr.open(type, url);
var isSimpleCors = o.crossDomain && [
'GET',
'POST',
'HEAD'
].indexOf(type) !== -1;
if (isPost) {
data = isJsonContentType && !isSimpleCors ? typeof o.data === 'object' ? JSON.stringify(o.data) : o.data : param(o.data);
var setContentType = isJsonContentType && !isSimpleCors ? 'application/json' : 'application/<API key>';
xhr.setRequestHeader('Content-Type', setContentType);
} else {
xhr.setRequestHeader('Content-Type', o.contentType);
}
if (!isSimpleCors) {
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
}
if (o.xhrFields) {
for (var f in o.xhrFields) {
xhr[f] = o.xhrFields[f];
}
}
xhr.send(data);
return promise;
}
module.exports = namespace.ajax = ajax;
module.exports.ajaxSetup = function (o) {
globalSettings = o || {};
};
}(function () {
return this;
}(), require, exports, module));
});
/*can-key@0.5.0#replace-with/replace-with*/
define('can-key/replace-with/replace-with', [
'require',
'exports',
'module',
'can-key/utils',
'can-key/get/get',
'can-key/delete/delete'
], function (require, exports, module) {
var utils = require('can-key/utils');
var get = require('can-key/get/get');
var deleteKey = require('can-key/delete/delete');
module.exports = function (str, data, replacer, <API key>) {
return str.replace(utils.strReplacer, function (whole, path) {
var value = get(data, path);
if (<API key>) {
deleteKey(data, path);
}
return replacer ? replacer(path, value) : value;
});
};
});
/*can-util@3.11.5#js/is-array-like/is-array-like*/
define('can-util/js/is-array-like/is-array-like', function (require, exports, module) {
'use strict';
function isArrayLike(obj) {
var type = typeof obj;
if (type === 'string') {
return true;
} else if (type === 'number') {
return false;
}
var length = obj && type !== 'boolean' && typeof obj !== 'number' && 'length' in obj && obj.length;
return typeof obj !== 'function' && (length === 0 || typeof length === 'number' && length > 0 && length - 1 in obj);
}
module.exports = isArrayLike;
});
/*can-util@3.11.5#js/is-iterable/is-iterable*/
define('can-util/js/is-iterable/is-iterable', [
'require',
'exports',
'module',
'can-symbol'
], function (require, exports, module) {
'use strict';
var canSymbol = require('can-symbol');
module.exports = function (obj) {
return obj && !!obj[canSymbol.iterator || canSymbol.for('iterator')];
};
});
/*can-util@3.11.5#js/each/each*/
define('can-util/js/each/each', [
'require',
'exports',
'module',
'can-util/js/is-array-like/is-array-like',
'can-util/js/is-iterable/is-iterable',
'can-symbol'
], function (require, exports, module) {
'use strict';
var isArrayLike = require('can-util/js/is-array-like/is-array-like');
var has = Object.prototype.hasOwnProperty;
var isIterable = require('can-util/js/is-iterable/is-iterable');
var canSymbol = require('can-symbol');
function each(elements, callback, context) {
var i = 0, key, len, item;
if (elements) {
if (isArrayLike(elements)) {
for (len = elements.length; i < len; i++) {
item = elements[i];
if (callback.call(context || item, item, i, elements) === false) {
break;
}
}
} else if (isIterable(elements)) {
var iter = elements[canSymbol.iterator || canSymbol.for('iterator')]();
var res, value;
while (!(res = iter.next()).done) {
value = res.value;
callback.call(context || elements, Array.isArray(value) ? value[1] : value, value[0]);
}
} else if (typeof elements === 'object') {
for (key in elements) {
if (has.call(elements, key) && callback.call(context || elements[key], elements[key], key, elements) === false) {
break;
}
}
}
}
return elements;
}
module.exports = each;
});
/*can-make-rest@0.1.3#can-make-rest*/
define('can-make-rest', [
'require',
'exports',
'module',
'can-util/js/each/each'
], function (require, exports, module) {
var each = require('can-util/js/each/each');
var methodMapping = {
item: {
'GET': 'getData',
'PUT': 'updateData',
'DELETE': 'destroyData'
},
list: {
'GET': 'getListData',
'POST': 'createData'
}
};
function inferIdProp(url) {
var wrappedInBraces = /\{(.*)\}/;
var matches = url.match(wrappedInBraces);
var isUniqueMatch = matches && matches.length === 2;
if (isUniqueMatch) {
return matches[1];
}
}
function getItemAndListUrls(url, idProp) {
idProp = idProp || inferIdProp(url) || 'id';
var itemRegex = new RegExp('\\/\\{' + idProp + '\\}.*');
var rootIsItemUrl = itemRegex.test(url);
var listUrl = rootIsItemUrl ? url.replace(itemRegex, '') : url;
var itemUrl = rootIsItemUrl ? url : url.trim() + '/{' + idProp + '}';
return {
item: itemUrl,
list: listUrl
};
}
module.exports = function (url, idProp) {
var data = {};
each(getItemAndListUrls(url, idProp), function (url, type) {
each(methodMapping[type], function (interfaceMethod, method) {
data[interfaceMethod] = {
method: method,
url: url
};
});
});
return data;
};
});
/*can-connect@3.0.0-pre.15#helpers/make-promise*/
define('can-connect/helpers/make-promise', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
module.exports = function (obj) {
if (obj && typeof obj.then === 'function' && !canReflect.isPromise(obj)) {
return new Promise(function (resolve, reject) {
obj.then(resolve, reject);
});
} else {
return obj;
}
};
});
/*can-connect@3.0.0-pre.15#data/url/url*/
define('can-connect/data/url/url', [
'require',
'exports',
'module',
'can-ajax',
'can-key/replace-with/replace-with',
'can-reflect',
'can-log/dev/dev',
'can-connect/behavior',
'can-make-rest',
'can-connect/helpers/make-promise',
'can-connect/helpers/validate'
], function (require, exports, module) {
var ajax = require('can-ajax');
var replaceWith = require('can-key/replace-with/replace-with');
var canReflect = require('can-reflect');
var dev = require('can-log/dev/dev');
var behavior = require('can-connect/behavior');
var makeRest = require('can-make-rest');
var defaultRest = makeRest('/resource/{id}');
var makePromise = require('can-connect/helpers/make-promise');
var urlBehavior = behavior('data/url', function (baseConnection) {
var behavior = {};
canReflect.eachKey(defaultRest, function (defaultData, dataInterfaceName) {
behavior[dataInterfaceName] = function (params) {
var meta = methodMetaData[dataInterfaceName];
if (typeof this.url === 'object') {
if (typeof this.url[dataInterfaceName] === 'function') {
return makePromise(this.url[dataInterfaceName](params));
} else if (this.url[dataInterfaceName]) {
var promise = makeAjax(this.url[dataInterfaceName], params, defaultData.method, this.ajax || ajax, findContentType(this.url, defaultData.method), meta);
return makePromise(promise);
}
}
var resource = typeof this.url === 'string' ? this.url : this.url.resource;
if (resource) {
var idProps = canReflect.getSchema(this.queryLogic).identity;
var <API key> = resource.replace(/\/+$/, '');
var result = makeRest(<API key>, idProps[0])[dataInterfaceName];
return makePromise(makeAjax(result.url, params, result.method, this.ajax || ajax, findContentType(this.url, result.method), meta));
}
return baseConnection[name].call(this, params);
};
});
return behavior;
});
var methodMetaData = {
getListData: {},
getData: {},
createData: {},
updateData: {},
destroyData: { includeData: false }
};
var findContentType = function (url, method) {
if (typeof url === 'object' && url.contentType) {
var acceptableType = url.contentType === 'application/<API key>' || url.contentType === 'application/json';
if (acceptableType) {
return url.contentType;
} else {
dev.warn('Unacceptable contentType on can-connect request. ' + 'Use \'application/json\' or \'application/<API key>\'');
}
}
return method === 'GET' ? 'application/<API key>' : 'application/json';
};
function urlParamEncoder(key, value) {
return encodeURIComponent(value);
}
var makeAjax = function (ajaxOb, data, type, ajax, contentType, reqOptions) {
var params = {};
if (typeof ajaxOb === 'string') {
var parts = ajaxOb.split(/\s+/);
params.url = parts.pop();
if (parts.length) {
params.type = parts.pop();
}
} else {
canReflect.assignMap(params, ajaxOb);
}
params.data = typeof data === 'object' && !Array.isArray(data) ? canReflect.assignMap(params.data || {}, data) : data;
params.url = replaceWith(params.url, params.data, urlParamEncoder, true);
params.contentType = contentType;
if (reqOptions.includeData === false) {
delete params.data;
}
return ajax(canReflect.assignMap({
type: type || 'post',
dataType: 'json'
}, params));
};
module.exports = urlBehavior;
var validate = require('can-connect/helpers/validate');
module.exports = validate(urlBehavior, ['url']);
});
/*can-connect@3.0.0-pre.15#base/base*/
define('can-connect/base/base', [
'require',
'exports',
'module',
'can-connect/behavior',
'can-reflect',
'can-symbol'
], function (require, exports, module) {
var behavior = require('can-connect/behavior');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
module.exports = behavior('base', function (baseConnection) {
var setQueryLogic;
return {
id: function (instance) {
if (this.queryLogic) {
return canReflect.getIdentity(instance, this.queryLogic.schema);
} else if (this.idProp) {
return instance[this.idProp];
} else {
throw new Error('can-connect/base/base - Please add a queryLogic option.');
}
},
listQuery: function (list) {
return list[this.listQueryProp];
},
listQueryProp: canSymbol.for('can.listQuery'),
init: function () {
},
get queryLogic() {
if (setQueryLogic) {
return setQueryLogic;
} else if (baseConnection.queryLogic) {
return baseConnection.queryLogic;
} else if (baseConnection.algebra) {
return baseConnection.algebra;
}
},
set queryLogic(newVal) {
setQueryLogic = newVal;
}
};
});
});
/*can-rest-model@0.1.4#can-rest-model*/
define('can-rest-model', [
'require',
'exports',
'module',
'can-connect/constructor/constructor',
'can-connect/can/map/map',
'can-connect/data/parse/parse',
'can-connect/data/url/url',
'can-namespace',
'can-connect/base/base'
], function (require, exports, module) {
var constructor = require('can-connect/constructor/constructor');
var canMap = require('can-connect/can/map/map');
var dataParse = require('can-connect/data/parse/parse');
var dataUrl = require('can-connect/data/url/url');
var namespace = require('can-namespace');
var base = require('can-connect/base/base');
function restModel(options) {
var connection = [
base,
dataUrl,
dataParse,
constructor,
canMap
].reduce(function (prev, behavior) {
return behavior(prev);
}, options);
connection.init();
return connection;
}
module.exports = namespace.restModel = restModel;
});
/*can@5.0.0-pre.3#es/can-rest-model*/
define('can/es/can-rest-model', [
'exports',
'can-rest-model'
], function (exports, _canRestModel) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canRestModel).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-connect@3.0.0-pre.15#connect*/
define('can-connect/connect', [
'require',
'exports',
'module',
'can-reflect',
'can-connect/behavior'
], function (require, exports, module) {
var assign = require('can-reflect').assignMap;
var behavior = require('can-connect/behavior');
var connect = function (behaviors, options) {
behaviors = behaviors.map(function (behavior, index) {
var sortedIndex = -1;
if (typeof behavior === 'string') {
sortedIndex = connect.order.indexOf(behavior);
behavior = behavior.map[behavior];
} else if (behavior.isBehavior) {
sortedIndex = connect.order.indexOf(behavior.behaviorName);
} else {
behavior = connect.behavior(behavior);
}
return {
originalIndex: index,
sortedIndex: sortedIndex,
behavior: behavior
};
});
behaviors.sort(function (b1, b2) {
if (~b1.sortedIndex && ~b2.sortedIndex) {
return b1.sortedIndex - b2.sortedIndex;
}
return b1.originalIndex - b2.originalIndex;
});
behaviors = behaviors.map(function (b) {
return b.behavior;
});
var behavior = connect.base(connect.behavior('options', function () {
return options;
})());
behaviors.forEach(function (behave) {
behavior = behave(behavior);
});
if (behavior.init) {
behavior.init();
}
return behavior;
};
connect.order = [
'data/localstorage-cache',
'data/url',
'data/parse',
'cache-requests',
'data/combine-requests',
'constructor',
'constructor/store',
'can/map',
'can/ref',
'fall-through-cache',
'data/worker',
'real-time',
'data/callbacks-cache',
'data/callbacks',
'constructor/callbacks-once'
];
connect.behavior = behavior;
module.exports = connect;
});
/*can-connect@3.0.0-pre.15#can-connect*/
define('can-connect', [
'require',
'exports',
'module',
'can-connect/connect',
'can-connect/base/base',
'can-namespace'
], function (require, exports, module) {
var connect = require('can-connect/connect');
var base = require('can-connect/base/base');
var ns = require('can-namespace');
connect.base = base;
module.exports = ns.connect = connect;
});
/*can-connect@3.0.0-pre.15#helpers/weak-reference-set*/
define('can-connect/helpers/weak-reference-set', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var assign = require('can-reflect').assignMap;
var WeakReferenceSet = function () {
this.set = [];
};
assign(WeakReferenceSet.prototype, {
has: function (item) {
return this._getIndex(item) !== -1;
},
addReference: function (item, referenceCount) {
var index = this._getIndex(item);
var data = this.set[index];
if (!data) {
data = {
item: item,
referenceCount: 0
};
this.set.push(data);
}
data.referenceCount += referenceCount || 1;
},
deleteReference: function (item) {
var index = this._getIndex(item);
var data = this.set[index];
if (data) {
data.referenceCount
if (data.referenceCount === 0) {
this.set.splice(index, 1);
}
}
},
delete: function (item) {
var index = this._getIndex(item);
if (index !== -1) {
this.set.splice(index, 1);
}
},
get: function (item) {
var data = this.set[this._getIndex(item)];
if (data) {
return data.item;
}
},
referenceCount: function (item) {
var data = this.set[this._getIndex(item)];
if (data) {
return data.referenceCount;
}
},
_getIndex: function (item) {
var index;
this.set.every(function (data, i) {
if (data.item === item) {
index = i;
return false;
}
});
return index !== undefined ? index : -1;
},
forEach: function (cb) {
return this.set.forEach(cb);
}
});
module.exports = WeakReferenceSet;
});
/*can-connect@3.0.0-pre.15#helpers/sorted-set-json*/
define('can-connect/helpers/sorted-set-json', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
module.exports = function (set) {
if (set == null) {
return set;
} else {
return JSON.stringify(canReflect.cloneKeySort(set));
}
};
});
/*can-connect@3.0.0-pre.15#constructor/store/store*/
define('can-connect/constructor/store/store', [
'require',
'exports',
'module',
'can-connect',
'can-connect/helpers/weak-reference-map',
'can-connect/helpers/weak-reference-set',
'can-connect/helpers/sorted-set-json',
'can-event-queue/map/map',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var WeakReferenceMap = require('can-connect/helpers/weak-reference-map');
var WeakReferenceSet = require('can-connect/helpers/weak-reference-set');
var sortedSetJSON = require('can-connect/helpers/sorted-set-json');
var eventQueue = require('can-event-queue/map/map');
var pendingRequests = 0;
var noRequestsTimer = null;
var requests = {
increment: function (connection) {
pendingRequests++;
clearTimeout(noRequestsTimer);
},
decrement: function (connection) {
pendingRequests
if (pendingRequests === 0) {
noRequestsTimer = setTimeout(function () {
requests.dispatch('end');
}, module.exports.requestCleanupDelay);
}
if (pendingRequests < 0) {
pendingRequests = 0;
}
},
count: function () {
return pendingRequests;
}
};
eventQueue(requests);
var constructorStore = connect.behavior('constructor/store', function (baseConnection) {
var behavior = {
instanceStore: new WeakReferenceMap(),
newInstanceStore: new WeakReferenceSet(),
listStore: new WeakReferenceMap(),
init: function () {
if (baseConnection.init) {
baseConnection.init.apply(this, arguments);
}
if (!this.hasOwnProperty('_requestInstances')) {
this._requestInstances = {};
}
if (!this.hasOwnProperty('_requestLists')) {
this._requestLists = {};
}
requests.on('end', function <API key>() {
var id;
for (id in this._requestInstances) {
this.instanceStore.deleteReference(id);
}
this._requestInstances = {};
for (id in this._requestLists) {
this.listStore.deleteReference(id);
this._requestLists[id].forEach(this.<API key>.bind(this));
}
this._requestLists = {};
}.bind(this));
},
_finishedRequest: function () {
requests.decrement(this);
},
<API key>: function (instance, id) {
var ID = id || this.id(instance);
if (ID === undefined) {
this.newInstanceStore.addReference(instance);
} else {
this.instanceStore.addReference(ID, instance);
}
},
createdInstance: function (instance, props) {
baseConnection.createdInstance.apply(this, arguments);
this.<API key>(instance);
},
<API key>: function (instance) {
var ID = this.id(instance);
if (this.newInstanceStore.has(instance) && ID !== undefined) {
var referenceCount = this.newInstanceStore.referenceCount(instance);
this.newInstanceStore.delete(instance);
this.instanceStore.addReference(ID, instance, referenceCount);
}
},
addInstanceMetaData: function (instance, name, value) {
var data = this.instanceStore.set[this.id(instance)];
if (data) {
data[name] = value;
}
},
getInstanceMetaData: function (instance, name) {
var data = this.instanceStore.set[this.id(instance)];
if (data) {
return data[name];
}
},
<API key>: function (instance, name) {
var data = this.instanceStore.set[this.id(instance)];
delete data[name];
},
<API key>: function (instance) {
var ID = this.id(instance);
if (ID === undefined) {
this.newInstanceStore.deleteReference(instance);
} else {
this.instanceStore.deleteReference(this.id(instance), instance);
}
},
addListReference: function (list, set) {
var id = sortedSetJSON(set || this.listQuery(list));
if (id) {
this.listStore.addReference(id, list);
list.forEach(function (instance) {
this.<API key>(instance);
}.bind(this));
}
},
deleteListReference: function (list, set) {
var id = sortedSetJSON(set || this.listQuery(list));
if (id) {
this.listStore.deleteReference(id, list);
list.forEach(this.<API key>.bind(this));
}
},
hydratedInstance: function (instance) {
if (requests.count() > 0) {
var id = this.id(instance);
if (!this._requestInstances[id]) {
this.<API key>(instance);
this._requestInstances[id] = instance;
}
}
},
hydrateInstance: function (props) {
var id = this.id(props);
if ((id || id === 0) && this.instanceStore.has(id)) {
var storeInstance = this.instanceStore.get(id);
this.updatedInstance(storeInstance, props);
return storeInstance;
}
var instance = baseConnection.hydrateInstance.call(this, props);
this.hydratedInstance(instance);
return instance;
},
hydratedList: function (list, set) {
if (requests.count() > 0) {
var id = sortedSetJSON(set || this.listQuery(list));
if (id) {
if (!this._requestLists[id]) {
this.addListReference(list, set);
this._requestLists[id] = list;
}
}
}
},
hydrateList: function (listData, set) {
set = set || this.listQuery(listData);
var id = sortedSetJSON(set);
if (id && this.listStore.has(id)) {
var storeList = this.listStore.get(id);
this.updatedList(storeList, listData, set);
return storeList;
}
var list = baseConnection.hydrateList.call(this, listData, set);
this.hydratedList(list, set);
return list;
},
getList: function (listQuery) {
var self = this;
requests.increment(this);
var promise = baseConnection.getList.call(this, listQuery);
promise.then(function (instances) {
self._finishedRequest();
}, function () {
self._finishedRequest();
});
return promise;
},
get: function (params) {
var self = this;
requests.increment(this);
var promise = baseConnection.get.call(this, params);
promise.then(function (instance) {
self._finishedRequest();
}, function () {
self._finishedRequest();
});
return promise;
},
save: function (instance) {
var self = this;
requests.increment(this);
var updating = !this.isNew(instance);
if (updating) {
this.<API key>(instance);
}
var promise = baseConnection.save.call(this, instance);
promise.then(function (instances) {
if (updating) {
self.<API key>(instance);
}
self._finishedRequest();
}, function () {
self._finishedRequest();
});
return promise;
},
destroy: function (instance) {
var self = this;
this.<API key>(instance);
requests.increment(this);
var promise = baseConnection.destroy.call(this, instance);
promise.then(function (instance) {
self._finishedRequest();
self.<API key>(instance);
}, function () {
self._finishedRequest();
});
return promise;
},
updatedList: function (list, listData, set) {
var oldList = list.slice(0);
if (!listData.data && typeof listData.length === 'number') {
listData = { data: listData };
}
if (baseConnection.updatedList) {
baseConnection.updatedList.call(this, list, listData, set);
list.forEach(function (instance) {
this.<API key>(instance);
}.bind(this));
} else if (listData.data) {
listData.data.forEach(function (instance) {
this.<API key>(instance);
}.bind(this));
}
oldList.forEach(this.<API key>.bind(this));
}
};
return behavior;
});
constructorStore.requests = requests;
constructorStore.requestCleanupDelay = 10;
module.exports = constructorStore;
var validate = require('can-connect/helpers/validate');
module.exports = validate(constructorStore, [
'hydrateInstance',
'hydrateList',
'getList',
'get',
'save',
'destroy'
]);
});
/*can-connect@3.0.0-pre.15#can/ref/ref*/
define('can-connect/can/ref/ref', [
'require',
'exports',
'module',
'can-connect',
'can-connect/helpers/weak-reference-map',
'<API key>',
'can-connect/constructor/store/store',
'can-define',
'can-reflect'
], function (require, exports, module) {
var connect = require('can-connect');
var WeakReferenceMap = require('can-connect/helpers/weak-reference-map');
var ObservationRecorder = require('<API key>');
var constructorStore = require('can-connect/constructor/store/store');
var define = require('can-define');
var canReflect = require('can-reflect');
var makeRef = function (connection) {
var idProp = canReflect.getSchema(connection.queryLogic).identity[0];
var Ref = function () {
return function (id, value) {
if (typeof id === 'object') {
value = id;
id = value[idProp];
}
var storeRef = Ref.store.get(id);
if (storeRef) {
if (value && !storeRef._value) {
if (value instanceof connection.Map) {
storeRef._value = value;
} else {
storeRef._value = connection.hydrateInstance(value);
}
}
return storeRef;
}
this[idProp] = id;
if (value) {
if (value instanceof connection.Map) {
this._value = value;
} else {
this._value = connection.hydrateInstance(value);
}
}
if (constructorStore.requests.count() > 0) {
if (!Ref._requestInstances[id]) {
Ref.store.addReference(id, this);
Ref._requestInstances[id] = this;
}
}
};
}();
Ref.store = new WeakReferenceMap();
Ref._requestInstances = {};
Ref.type = function (ref) {
if (ref && typeof ref !== 'object') {
return new Ref(ref);
} else {
return new Ref(ref[idProp], ref);
}
};
var defs = {
promise: {
get: function () {
if (this._value) {
return Promise.resolve(this._value);
} else {
var props = {};
props[idProp] = this[idProp];
return connection.Map.get(props);
}
}
},
_state: {
get: function (lastSet, resolve) {
if (resolve) {
this.promise.then(function () {
resolve('resolved');
}, function () {
resolve('rejected');
});
}
return 'pending';
}
},
value: {
get: function (lastSet, resolve) {
if (this._value) {
return this._value;
} else if (resolve) {
this.promise.then(function (value) {
resolve(value);
});
}
}
},
reason: {
get: function (lastSet, resolve) {
if (this._value) {
return undefined;
} else {
this.promise.catch(function (value) {
resolve(value);
});
}
}
}
};
defs[idProp] = {
type: '*',
set: function () {
this._value = undefined;
}
};
define(Ref.prototype, defs);
Ref.prototype.unobservedId = ObservationRecorder.ignore(function () {
return this[idProp];
});
Ref.prototype.isResolved = function () {
return !!this._value || this._state === 'resolved';
};
Ref.prototype.isRejected = function () {
return this._state === 'rejected';
};
Ref.prototype.isPending = function () {
return !this._value && (this._state !== 'resolved' || this._state !== 'rejected');
};
Ref.prototype.serialize = function () {
return this[idProp];
};
canReflect.assignSymbols(Ref.prototype, {
'can.serialize': Ref.prototype.serialize,
'can.getName': function () {
return canReflect.getName(this.constructor) + '{' + this[idProp] + '}';
}
});
var baseEventSetup = Ref.prototype._eventSetup;
Ref.prototype._eventSetup = function () {
Ref.store.addReference(this.unobservedId(), this);
return baseEventSetup.apply(this, arguments);
};
var baseTeardown = Ref.prototype._eventTeardown;
Ref.prototype._eventTeardown = function () {
Ref.store.deleteReference(this.unobservedId(), this);
return baseTeardown.apply(this, arguments);
};
constructorStore.requests.on('end', function () {
for (var id in Ref._requestInstances) {
Ref.store.deleteReference(id);
}
Ref._requestInstances = {};
});
Object.defineProperty(Ref, 'name', {
value: canReflect.getName(connection.Map) + 'Ref',
configurable: true
});
return Ref;
};
module.exports = connect.behavior('can/ref', function (baseConnection) {
return {
init: function () {
baseConnection.init.apply(this, arguments);
this.Map.Ref = makeRef(this);
}
};
});
});
/*can-connect@3.0.0-pre.15#data/callbacks/callbacks*/
define('can-connect/data/callbacks/callbacks', [
'require',
'exports',
'module',
'can-connect',
'can-reflect',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var each = require('can-reflect').each;
var pairs = {
getListData: 'gotListData',
createData: 'createdData',
updateData: 'updatedData',
destroyData: 'destroyedData'
};
var <API key> = connect.behavior('data/callbacks', function (baseConnection) {
var behavior = {};
each(pairs, function (callbackName, name) {
behavior[name] = function (params, cid) {
var self = this;
return baseConnection[name].call(this, params).then(function (data) {
if (self[callbackName]) {
return self[callbackName].call(self, data, params, cid);
} else {
return data;
}
});
};
});
return behavior;
});
module.exports = <API key>;
var validate = require('can-connect/helpers/validate');
module.exports = validate(<API key>, [
'getListData',
'createData',
'updateData',
'destroyData'
]);
});
/*can-connect@3.0.0-pre.15#data/callbacks-cache/callbacks-cache*/
define('can-connect/data/callbacks-cache/callbacks-cache', [
'require',
'exports',
'module',
'can-connect',
'can-reflect',
'can-reflect',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var assign = require('can-reflect').assignMap;
var each = require('can-reflect').each;
var pairs = {
createdData: 'createData',
updatedData: 'updateData',
destroyedData: 'destroyData'
};
var callbackCache = connect.behavior('data/callbacks-cache', function (baseConnection) {
var behavior = {};
each(pairs, function (crudMethod, dataCallback) {
behavior[dataCallback] = function (data, params, cid) {
this.cacheConnection[crudMethod](assign(assign({}, params), data));
if (baseConnection[dataCallback]) {
return baseConnection[dataCallback].call(this, data, params, cid);
} else {
return data;
}
};
});
return behavior;
});
module.exports = callbackCache;
var validate = require('can-connect/helpers/validate');
module.exports = validate(callbackCache, []);
});
/*can-connect@3.0.0-pre.15#helpers/get-items*/
define('can-connect/helpers/get-items', function (require, exports, module) {
module.exports = function (data) {
if (Array.isArray(data)) {
return data;
} else {
return data.data;
}
};
});
/*can-connect@3.0.0-pre.15#helpers/deferred*/
define('can-connect/helpers/deferred', function (require, exports, module) {
module.exports = function () {
var def = {};
def.promise = new Promise(function (resolve, reject) {
def.resolve = resolve;
def.reject = reject;
});
return def;
};
});
/*can-connect@3.0.0-pre.15#data/combine-requests/combine-requests*/
define('can-connect/data/combine-requests/combine-requests', [
'require',
'exports',
'module',
'can-connect',
'can-connect/helpers/get-items',
'can-reflect',
'can-connect/helpers/deferred',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var getItems = require('can-connect/helpers/get-items');
var canReflect = require('can-reflect');
var makeDeferred = require('can-connect/helpers/deferred');
var forEach = [].forEach;
var combineRequests = connect.behavior('data/combine-requests', function (baseConnection) {
var pendingRequests;
return {
<API key>: function (pendingRequests) {
var self = this;
pendingRequests.sort(function (pReq1, pReq2) {
if (self.queryLogic.isSubset(pReq1.set, pReq2.set)) {
return 1;
} else if (self.queryLogic.isSubset(pReq2.set, pReq1.set)) {
return -1;
} else {
return 0;
}
});
var combineData = [];
var current;
doubleLoop(pendingRequests, {
start: function (pendingRequest) {
current = {
set: pendingRequest.set,
pendingRequests: [pendingRequest]
};
combineData.push(current);
},
iterate: function (pendingRequest) {
var combined = self.queryLogic.union(current.set, pendingRequest.set);
if (self.queryLogic.<API key>(combined)) {
current.set = combined;
current.pendingRequests.push(pendingRequest);
return true;
}
}
});
return Promise.resolve(combineData);
},
time: 1,
getListData: function (set) {
set = set || {};
var self = this;
if (!pendingRequests) {
pendingRequests = [];
setTimeout(function () {
var combineDataPromise = self.<API key>(pendingRequests);
pendingRequests = null;
combineDataPromise.then(function (combinedData) {
forEach.call(combinedData, function (combined) {
var combinedSet = canReflect.serialize(combined.set);
baseConnection.getListData(combinedSet).then(function (data) {
if (combined.pendingRequests.length === 1) {
combined.pendingRequests[0].deferred.resolve(data);
} else {
forEach.call(combined.pendingRequests, function (pending) {
pending.deferred.resolve({ data: self.queryLogic.filterMembers(pending.set, combined.set, getItems(data)) });
});
}
}, function (err) {
if (combined.pendingRequests.length === 1) {
combined.pendingRequests[0].deferred.reject(err);
} else {
forEach.call(combined.pendingRequests, function (pending) {
pending.deferred.reject(err);
});
}
});
});
});
}, this.time || 1);
}
var deferred = makeDeferred();
pendingRequests.push({
deferred: deferred,
set: set
});
return deferred.promise;
}
};
});
module.exports = combineRequests;
var validate = require('can-connect/helpers/validate');
module.exports = validate(combineRequests, ['getListData']);
var doubleLoop = function (arr, callbacks) {
var i = 0;
while (i < arr.length) {
callbacks.start(arr[i]);
var j = i + 1;
while (j < arr.length) {
if (callbacks.iterate(arr[j]) === true) {
arr.splice(j, 1);
} else {
j++;
}
}
i++;
}
};
});
/*can-local-store@1.0.0#can-local-store*/
define('can-local-store', [
'require',
'exports',
'module',
'can-reflect',
'can-memory-store/make-simple-store',
'can-namespace'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var makeSimpleStore = require('can-memory-store/make-simple-store');
var namespace = require('can-namespace');
module.exports = namespace.localStore = function localStore(baseConnection) {
baseConnection.constructor = localStore;
var behavior = Object.create(makeSimpleStore(baseConnection));
canReflect.assignMap(behavior, {
clear: function () {
localStorage.removeItem(this.name + '/queries');
localStorage.removeItem(this.name + '/records');
this._recordsMap = null;
return Promise.resolve();
},
updateQueryDataSync: function (queries) {
localStorage.setItem(this.name + '/queries', JSON.stringify(queries));
},
getQueryDataSync: function () {
return JSON.parse(localStorage.getItem(this.name + '/queries')) || [];
},
getRecord: function (id) {
if (!this._recordsMap) {
this.getAllRecords();
}
return this._recordsMap[id];
},
getAllRecords: function () {
if (!this.<API key> || !this._recordsMap) {
var recordsMap = JSON.parse(localStorage.getItem(this.name + '/records')) || {};
this._recordsMap = recordsMap;
}
var records = [];
for (var id in this._recordsMap) {
records.push(this._recordsMap[id]);
}
return records;
},
destroyRecords: function (records) {
if (!this._recordsMap) {
this.getAllRecords();
}
canReflect.eachIndex(records, function (record) {
var id = canReflect.getIdentity(record, this.queryLogic.schema);
delete this._recordsMap[id];
}, this);
localStorage.setItem(this.name + '/records', JSON.stringify(this._recordsMap));
},
updateRecordsSync: function (records) {
if (!this._recordsMap) {
this.getAllRecords();
}
records.forEach(function (record) {
var id = canReflect.getIdentity(record, this.queryLogic.schema);
this._recordsMap[id] = record;
}, this);
localStorage.setItem(this.name + '/records', JSON.stringify(this._recordsMap));
}
});
return behavior;
};
});
/*can-connect@3.0.0-pre.15#data/localstorage-cache/localstorage-cache*/
define('can-connect/data/localstorage-cache/localstorage-cache', [
'require',
'exports',
'module',
'can-local-store'
], function (require, exports, module) {
var memoryStore = require('can-local-store');
module.exports = memoryStore;
});
/*can-connect@3.0.0-pre.15#fall-through-cache/fall-through-cache*/
define('can-connect/fall-through-cache/fall-through-cache', [
'require',
'exports',
'module',
'can-connect',
'can-connect/helpers/sorted-set-json',
'can-log',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var sortedSetJSON = require('can-connect/helpers/sorted-set-json');
var canLog = require('can-log');
var fallThroughCache = connect.behavior('fall-through-cache', function (baseConnection) {
var behavior = {
hydrateList: function (listData, set) {
set = set || this.listQuery(listData);
var id = sortedSetJSON(set);
var list = baseConnection.hydrateList.call(this, listData, set);
if (this.<API key>[id]) {
this.<API key>[id].shift()(list);
if (!this.<API key>[id].length) {
delete this.<API key>[id];
}
}
return list;
},
<API key>: {},
_getHydrateList: function (set, callback) {
var id = sortedSetJSON(set);
if (!this.<API key>[id]) {
this.<API key>[id] = [];
}
this.<API key>[id].push(callback);
},
getListData: function (set) {
set = set || {};
var self = this;
return this.cacheConnection.getListData(set).then(function (data) {
self._getHydrateList(set, function (list) {
self.addListReference(list, set);
setTimeout(function () {
baseConnection.getListData.call(self, set).then(function (listData) {
self.cacheConnection.updateListData(listData, set);
self.updatedList(list, listData, set);
self.deleteListReference(list, set);
}, function (e) {
canLog.log('REJECTED', e);
});
}, 1);
});
return data;
}, function () {
var listData = baseConnection.getListData.call(self, set);
listData.then(function (listData) {
self.cacheConnection.updateListData(listData, set);
});
return listData;
});
},
hydrateInstance: function (props) {
var id = this.id(props);
var instance = baseConnection.hydrateInstance.apply(this, arguments);
if (this.<API key>[id]) {
this.<API key>[id].shift()(instance);
if (!this.<API key>[id].length) {
delete this.<API key>[id];
}
}
return instance;
},
<API key>: {},
_getMakeInstance: function (id, callback) {
if (!this.<API key>[id]) {
this.<API key>[id] = [];
}
this.<API key>[id].push(callback);
},
getData: function (params) {
var self = this;
return this.cacheConnection.getData(params).then(function (instanceData) {
self._getMakeInstance(self.id(instanceData) || self.id(params), function (instance) {
self.<API key>(instance);
setTimeout(function () {
baseConnection.getData.call(self, params).then(function (instanceData2) {
self.cacheConnection.updateData(instanceData2);
self.updatedInstance(instance, instanceData2);
self.<API key>(instance);
}, function (e) {
canLog.log('REJECTED', e);
});
}, 1);
});
return instanceData;
}, function () {
var listData = baseConnection.getData.call(self, params);
listData.then(function (instanceData) {
self.cacheConnection.updateData(instanceData);
});
return listData;
});
}
};
return behavior;
});
module.exports = fallThroughCache;
var validate = require('can-connect/helpers/validate');
module.exports = validate(fallThroughCache, [
'hydrateList',
'hydrateInstance',
'getListData',
'getData'
]);
});
/*can-diff@1.0.4#index-by-identity/index-by-identity*/
define('can-diff/index-by-identity/index-by-identity', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
module.exports = function (items, item, schema) {
var length = canReflect.size(items);
if (!schema && length > 0) {
schema = canReflect.getSchema(items[0]);
}
if (!schema) {
schema = canReflect.getSchema(item);
}
if (!schema) {
throw new Error('No schema to use to get identity.');
}
var id = canReflect.getIdentity(item, schema);
for (var i = 0; i < length; i++) {
var connId = canReflect.getIdentity(items[i], schema);
if (id === connId) {
return i;
}
}
return -1;
};
});
/*can-connect@3.0.0-pre.15#real-time/real-time*/
define('can-connect/real-time/real-time', [
'require',
'exports',
'module',
'can-connect',
'can-diff/index-by-identity/index-by-identity',
'can-log/dev/dev',
'can-symbol',
'can-reflect'
], function (require, exports, module) {
var connect = require('can-connect');
var indexByIdentity = require('can-diff/index-by-identity/index-by-identity');
var canDev = require('can-log/dev/dev');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var spliceSymbol = canSymbol.for('can.splice');
function updateList(list, getRecord, currentIndex, newIndex) {
if (currentIndex === -1) {
if (newIndex !== -1) {
canReflect.splice(list, newIndex, 0, [getRecord()]);
}
} else {
if (newIndex === -1) {
canReflect.splice(list, currentIndex, 1, []);
} else if (newIndex !== currentIndex) {
if (currentIndex < newIndex) {
canReflect.splice(list, newIndex, 0, [getRecord()]);
canReflect.splice(list, currentIndex, 1, []);
} else {
canReflect.splice(list, currentIndex, 1, []);
canReflect.splice(list, newIndex, 0, [getRecord()]);
}
} else {
}
}
}
function updateListWithItem(list, recordData, currentIndex, newIndex, connection, set) {
if (list[spliceSymbol] !== undefined) {
updateList(list, function () {
return connection.hydrateInstance(recordData);
}, currentIndex, newIndex);
} else {
var copy = connection.serializeList(list);
updateList(copy, function () {
return recordData;
}, currentIndex, newIndex);
connection.updatedList(list, { data: copy }, set);
}
}
module.exports = connect.behavior('real-time', function (baseConnection) {
var createPromise = Promise.resolve();
return {
createData: function () {
var promise = baseConnection.createData.apply(this, arguments);
var cleanPromise = promise.catch(function () {
return '';
});
createPromise = Promise.all([
createPromise,
cleanPromise
]);
return promise;
},
createInstance: function (props) {
var self = this;
return new Promise(function (resolve, reject) {
createPromise.then(function () {
setTimeout(function () {
var id = self.id(props);
var instance = self.instanceStore.get(id);
var serialized;
if (instance) {
resolve(self.updateInstance(props));
} else {
instance = self.hydrateInstance(props);
serialized = self.serializeInstance(instance);
self.<API key>(instance);
Promise.resolve(self.createdData(props, serialized)).then(function () {
self.<API key>(instance);
resolve(instance);
});
}
}, 1);
});
});
},
createdData: function (props, params, cid) {
var instance;
if (cid !== undefined) {
instance = this.cidStore.get(cid);
} else {
instance = this.instanceStore.get(this.id(props));
}
this.<API key>(instance, this.id(props));
this.createdInstance(instance, props);
create.call(this, this.serializeInstance(instance));
this.<API key>(instance);
return undefined;
},
updatedData: function (props, params) {
var instance = this.instanceStore.get(this.id(params));
this.updatedInstance(instance, props);
update.call(this, this.serializeInstance(instance));
return undefined;
},
updateInstance: function (props) {
var id = this.id(props);
var instance = this.instanceStore.get(id);
if (!instance) {
instance = this.hydrateInstance(props);
}
this.<API key>(instance);
var serialized = this.serializeInstance(instance), self = this;
return Promise.resolve(this.updatedData(props, serialized)).then(function () {
self.<API key>(instance);
return instance;
});
},
destroyedData: function (props, params) {
var id = this.id(params || props);
var instance = this.instanceStore.get(id);
if (!instance) {
instance = this.hydrateInstance(props);
}
var serialized = this.serializeInstance(instance);
this.destroyedInstance(instance, props);
destroy.call(this, serialized);
return undefined;
},
destroyInstance: function (props) {
var id = this.id(props);
var instance = this.instanceStore.get(id);
if (!instance) {
instance = this.hydrateInstance(props);
}
this.<API key>(instance);
var serialized = this.serializeInstance(instance), self = this;
return Promise.resolve(this.destroyedData(props, serialized)).then(function () {
self.<API key>(instance);
return instance;
});
},
gotListData: function (items, set) {
var self = this;
if (this.queryLogic) {
if (Array.isArray(items)) {
items = { data: items };
}
for (var item, i = 0, l = items.data.length; i < l; i++) {
item = items.data[i];
if (!self.queryLogic.isMember(set, item)) {
var msg = 'One or more items were retrieved which do not match the \'Set\' parameters used to load them. ' + 'Read the docs for more information: https://canjs.com/doc/can-query-logic.html#<API key>' + '\n\nBelow are the \'query\' parameters:' + '\n' + canDev.stringify(set) + '\n\nAnd below is an item which does not match those parameters:' + '\n' + canDev.stringify(item);
canDev.warn(msg);
break;
}
}
}
return Promise.resolve(items);
}
};
});
var create = function (props) {
var self = this;
this.listStore.forEach(function (list, id) {
var set = JSON.parse(id);
var index = indexByIdentity(list, props, self.queryLogic.schema);
if (self.queryLogic.isMember(set, props)) {
var newIndex = self.queryLogic.index(set, list, props);
updateListWithItem(list, props, index, newIndex, self, set);
}
});
};
var update = function (props) {
var self = this;
this.listStore.forEach(function (list, id) {
var set = JSON.parse(id);
var currentIndex = indexByIdentity(list, props, self.queryLogic.schema);
if (self.queryLogic.isMember(set, props)) {
var newIndex = self.queryLogic.index(set, list, props);
updateListWithItem(list, props, currentIndex, newIndex, self, set);
} else if (currentIndex !== -1) {
updateListWithItem(list, props, currentIndex, -1, self, set);
}
});
};
var destroy = function (props) {
var self = this;
this.listStore.forEach(function (list, id) {
var set = JSON.parse(id);
var currentIndex = indexByIdentity(list, props, self.queryLogic.schema);
if (currentIndex !== -1) {
updateListWithItem(list, props, currentIndex, -1, self, set);
}
});
};
});
/*can-connect@3.0.0-pre.15#constructor/callbacks-once/callbacks-once*/
define('can-connect/constructor/callbacks-once/callbacks-once', [
'require',
'exports',
'module',
'can-connect',
'can-connect/helpers/sorted-set-json',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var sortedSetJSON = require('can-connect/helpers/sorted-set-json');
var forEach = [].forEach;
var callbacks = [
'createdInstance',
'updatedInstance',
'destroyedInstance'
];
var <API key> = connect.behavior('constructor/callbacks-once', function (baseConnection) {
var behavior = {};
forEach.call(callbacks, function (name) {
behavior[name] = function (instance, data) {
var lastSerialized = this.getInstanceMetaData(instance, 'last-data-' + name);
var serialize = sortedSetJSON(data);
if (lastSerialized !== serialize) {
var result = baseConnection[name].apply(this, arguments);
this.addInstanceMetaData(instance, 'last-data-' + name, serialize);
return result;
}
};
});
return behavior;
});
module.exports = <API key>;
var validate = require('can-connect/helpers/validate');
module.exports = validate(<API key>, callbacks);
});
/*can-super-model@1.0.0#can-super-model*/
define('can-super-model', [
'require',
'exports',
'module',
'can-connect',
'can-connect/constructor/constructor',
'can-connect/can/map/map',
'can-connect/can/ref/ref',
'can-connect/constructor/store/store',
'can-connect/data/callbacks/callbacks',
'can-connect/data/callbacks-cache/callbacks-cache',
'can-connect/data/combine-requests/combine-requests',
'can-connect/data/localstorage-cache/localstorage-cache',
'can-connect/data/parse/parse',
'can-connect/data/url/url',
'can-connect/fall-through-cache/fall-through-cache',
'can-connect/real-time/real-time',
'can-connect/constructor/callbacks-once/callbacks-once',
'can-namespace',
'can-reflect',
'can-query-logic'
], function (require, exports, module) {
var connect = require('can-connect');
var connectConstructor = require('can-connect/constructor/constructor');
var canMap = require('can-connect/can/map/map');
var canRef = require('can-connect/can/ref/ref');
var constructorStore = require('can-connect/constructor/store/store');
var dataCallbacks = require('can-connect/data/callbacks/callbacks');
var callbacksCache = require('can-connect/data/callbacks-cache/callbacks-cache');
var combineRequests = require('can-connect/data/combine-requests/combine-requests');
var localCache = require('can-connect/data/localstorage-cache/localstorage-cache');
var dataParse = require('can-connect/data/parse/parse');
var dataUrl = require('can-connect/data/url/url');
var fallThroughCache = require('can-connect/fall-through-cache/fall-through-cache');
var realTime = require('can-connect/real-time/real-time');
var callbacksOnce = require('can-connect/constructor/callbacks-once/callbacks-once');
var namespace = require('can-namespace');
var canReflect = require('can-reflect');
var QueryLogic = require('can-query-logic');
function superModel(options) {
options = canReflect.assignDeep({}, options);
if (!options.name) {
options.name = canReflect.getName(options.Map) + '.connection';
}
if (!options.queryLogic) {
options.queryLogic = new QueryLogic(options.Map);
}
var behaviors = [
connectConstructor,
canMap,
canRef,
constructorStore,
dataCallbacks,
combineRequests,
dataParse,
dataUrl,
realTime,
callbacksOnce
];
if (typeof localStorage !== 'undefined') {
if (!options.cacheConnection) {
options.cacheConnection = connect([localCache], {
name: options.name + '.cacheConnection',
idProp: options.idProp,
queryLogic: options.queryLogic
});
}
behaviors.push(callbacksCache, fallThroughCache);
}
return connect(behaviors, options);
}
module.exports = namespace.superModel = superModel;
});
/*can@5.0.0-pre.3#es/can-super-model*/
define('can/es/can-super-model', [
'exports',
'can-super-model'
], function (exports, _canSuperModel) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canSuperModel).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*<API key>@0.1.1#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-connect',
'can-connect/constructor/constructor',
'can-connect/can/map/map',
'can-connect/constructor/store/store',
'can-connect/data/callbacks/callbacks',
'can-connect/data/parse/parse',
'can-connect/data/url/url',
'can-connect/real-time/real-time',
'can-connect/constructor/callbacks-once/callbacks-once',
'can-namespace'
], function (require, exports, module) {
var connect = require('can-connect');
var constructor = require('can-connect/constructor/constructor');
var canMap = require('can-connect/can/map/map');
var constructorStore = require('can-connect/constructor/store/store');
var dataCallbacks = require('can-connect/data/callbacks/callbacks');
var dataParse = require('can-connect/data/parse/parse');
var dataUrl = require('can-connect/data/url/url');
var realTime = require('can-connect/real-time/real-time');
var callbacksOnce = require('can-connect/constructor/callbacks-once/callbacks-once');
var namespace = require('can-namespace');
function realtimeRestModel(options) {
var behaviors = [
constructor,
canMap,
constructorStore,
dataCallbacks,
dataParse,
dataUrl,
realTime,
callbacksOnce
];
return connect(behaviors, options);
}
module.exports = namespace.realtimeRestModel = realtimeRestModel;
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, <API key>) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-query-logic*/
define('can/es/can-query-logic', [
'exports',
'can-query-logic'
], function (exports, _canQueryLogic) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canQueryLogic).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-reflect-promise@2.0.1#can-reflect-promise*/
define('can-reflect-promise', [
'require',
'exports',
'module',
'can-reflect',
'can-symbol',
'<API key>',
'can-queues',
'can-key-tree',
'can-log/dev/dev'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var ObservationRecorder = require('<API key>');
var queues = require('can-queues');
var KeyTree = require('can-key-tree');
var dev = require('can-log/dev/dev');
var getKeyValueSymbol = canSymbol.for('can.getKeyValue'), observeDataSymbol = canSymbol.for('can.meta');
var <API key> = {
isPending: true,
state: 'pending',
isResolved: false,
isRejected: false,
value: undefined,
reason: undefined
};
function setVirtualProp(promise, property, value) {
var observeData = promise[observeDataSymbol];
var old = observeData[property];
observeData[property] = value;
queues.enqueueByQueue(observeData.handlers.getNode([property]), promise, [
value,
old
], function () {
return {};
}, [
'Promise',
promise,
'resolved with value',
value,
'and changed virtual property: ' + property
]);
}
function initPromise(promise) {
var observeData = promise[observeDataSymbol];
if (!observeData) {
Object.defineProperty(promise, observeDataSymbol, {
enumerable: false,
configurable: false,
writable: false,
value: Object.create(<API key>)
});
observeData = promise[observeDataSymbol];
observeData.handlers = new KeyTree([
Object,
Object,
Array
]);
}
promise.then(function (value) {
queues.batch.start();
setVirtualProp(promise, 'isPending', false);
setVirtualProp(promise, 'isResolved', true);
setVirtualProp(promise, 'value', value);
setVirtualProp(promise, 'state', 'resolved');
queues.batch.stop();
}, function (reason) {
queues.batch.start();
setVirtualProp(promise, 'isPending', false);
setVirtualProp(promise, 'isRejected', true);
setVirtualProp(promise, 'reason', reason);
setVirtualProp(promise, 'state', 'rejected');
queues.batch.stop();
dev.error('Failed promise:', reason);
});
}
function setupPromise(value) {
var oldPromiseFn;
var proto = 'getPrototypeOf' in Object ? Object.getPrototypeOf(value) : value.__proto__;
if (value[getKeyValueSymbol] && value[observeDataSymbol]) {
return;
}
if (proto === null || proto === Object.prototype) {
proto = value;
if (typeof proto.promise === 'function') {
oldPromiseFn = proto.promise;
proto.promise = function () {
var result = oldPromiseFn.call(proto);
setupPromise(result);
return result;
};
}
}
canReflect.assignSymbols(proto, {
'can.getKeyValue': function (key) {
if (!this[observeDataSymbol]) {
initPromise(this);
}
ObservationRecorder.add(this, key);
switch (key) {
case 'state':
case 'isPending':
case 'isResolved':
case 'isRejected':
case 'value':
case 'reason':
return this[observeDataSymbol][key];
default:
return this[key];
}
},
'can.getValue': function () {
return this[getKeyValueSymbol]('value');
},
'can.isValueLike': false,
'can.onKeyValue': function (key, handler, queue) {
if (!this[observeDataSymbol]) {
initPromise(this);
}
this[observeDataSymbol].handlers.add([
key,
queue || 'mutate',
handler
]);
},
'can.offKeyValue': function (key, handler, queue) {
if (!this[observeDataSymbol]) {
initPromise(this);
}
this[observeDataSymbol].handlers.delete([
key,
queue || 'mutate',
handler
]);
}
});
}
module.exports = setupPromise;
});
/*can-stache-key@1.3.2#can-stache-key*/
define('can-stache-key', [
'require',
'exports',
'module',
'<API key>',
'can-log/dev/dev',
'can-symbol',
'can-reflect',
'can-reflect-promise'
], function (require, exports, module) {
var ObservationRecorder = require('<API key>');
var dev = require('can-log/dev/dev');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var canReflectPromise = require('can-reflect-promise');
var getValueSymbol = canSymbol.for('can.getValue');
var setValueSymbol = canSymbol.for('can.setValue');
var isValueLikeSymbol = canSymbol.for('can.isValueLike');
var peek = ObservationRecorder.ignore(canReflect.getKeyValue.bind(canReflect));
var observeReader;
var bindName = Function.prototype.bind;
bindName = function (source) {
var fn = Function.prototype.bind.call(this, source);
Object.defineProperty(fn, 'name', { value: canReflect.getName(source) + '.' + canReflect.getName(this) });
return fn;
};
var isAt = function (index, reads) {
var prevRead = reads[index - 1];
return prevRead && prevRead.at;
};
var readValue = function (value, index, reads, options, state, prev) {
var usedValueReader;
do {
usedValueReader = false;
for (var i = 0, len = observeReader.valueReaders.length; i < len; i++) {
if (observeReader.valueReaders[i].test(value, index, reads, options)) {
value = observeReader.valueReaders[i].read(value, index, reads, options, state, prev);
}
}
} while (usedValueReader);
return value;
};
var specialRead = {
index: true,
key: true,
event: true,
element: true,
viewModel: true
};
var <API key> = function (options, state, getObserves, value, index) {
if (options.foundObservable && !state.foundObservable) {
if (ObservationRecorder.trapsCount()) {
ObservationRecorder.addMany(getObserves());
options.foundObservable(value, index);
state.foundObservable = true;
}
}
};
var objHasKeyAtIndex = function (obj, reads, index) {
return !!(reads && reads.length && canReflect.hasKey(obj, reads[index].key));
};
observeReader = {
read: function (parent, reads, options) {
options = options || {};
var state = { foundObservable: false };
var getObserves;
if (options.foundObservable) {
getObserves = ObservationRecorder.trap();
}
var cur = readValue(parent, 0, reads, options, state), type, prev, readLength = reads.length, i = 0, last, parentHasKey;
<API key>(options, state, getObserves, parent, 0);
while (i < readLength) {
prev = cur;
for (var r = 0, readersLength = observeReader.propertyReaders.length; r < readersLength; r++) {
var reader = observeReader.propertyReaders[r];
if (reader.test(cur)) {
cur = reader.read(cur, reads[i], i, options, state);
break;
}
}
<API key>(options, state, getObserves, prev, i);
last = cur;
i = i + 1;
cur = readValue(cur, i, reads, options, state, prev);
<API key>(options, state, getObserves, prev, i - 1);
type = typeof cur;
if (i < reads.length && (cur === null || cur === undefined)) {
parentHasKey = objHasKeyAtIndex(prev, reads, i - 1);
if (options.earlyExit && !parentHasKey) {
options.earlyExit(prev, i - 1, cur);
}
return {
value: undefined,
parent: prev,
parentHasKey: parentHasKey,
foundLastParent: false
};
}
}
parentHasKey = objHasKeyAtIndex(prev, reads, reads.length - 1);
if (cur === undefined && !parentHasKey) {
if (options.earlyExit) {
options.earlyExit(prev, i - 1);
}
}
return {
value: cur,
parent: prev,
parentHasKey: parentHasKey,
foundLastParent: true
};
},
get: function (parent, reads, options) {
return observeReader.read(parent, observeReader.reads(reads), options || {}).value;
},
valueReadersMap: {},
valueReaders: [
{
name: 'function',
test: function (value) {
return value && canReflect.isFunctionLike(value) && !canReflect.isConstructorLike(value);
},
read: function (value, i, reads, options, state, prev) {
if (options.<API key> && canReflect.isObservableLike(prev) && canReflect.isMapLike(prev)) {
dev.warn('can-stache-key: read() called with `<API key>: true`.');
return value.apply(prev, options.args || []);
}
return options.proxyMethods !== false ? bindName.call(value, prev) : value;
}
},
{
name: 'isValueLike',
test: function (value, i, reads, options) {
return value && value[getValueSymbol] && value[isValueLikeSymbol] !== false && (options.foundAt || !isAt(i, reads));
},
read: function (value, i, reads, options) {
if (options.readCompute === false && i === reads.length) {
return value;
}
return canReflect.getValue(value);
},
write: function (base, newVal) {
if (base[setValueSymbol]) {
base[setValueSymbol](newVal);
} else if (base.set) {
base.set(newVal);
} else {
base(newVal);
}
}
}
],
propertyReadersMap: {},
propertyReaders: [
{
name: 'map',
test: function (value) {
if (canReflect.isPromise(value) || typeof value === 'object' && value && typeof value.then === 'function') {
canReflectPromise(value);
}
return canReflect.isObservableLike(value) && canReflect.isMapLike(value);
},
read: function (value, prop) {
var res = canReflect.getKeyValue(value, prop.key);
if (res !== undefined) {
return res;
} else {
return value[prop.key];
}
},
write: canReflect.setKeyValue
},
{
name: 'object',
test: function () {
return true;
},
read: function (value, prop, i, options) {
if (value == null) {
return undefined;
} else {
if (typeof value === 'object') {
if (prop.key in value) {
return value[prop.key];
}
if (prop.at && specialRead[prop.key] && '@' + prop.key in value) {
options.foundAt = true;
dev.warn('Use %' + prop.key + ' in place of @' + prop.key + '.');
return undefined;
}
} else {
return value[prop.key];
}
}
},
write: function (base, prop, newVal) {
var propValue = base[prop];
if (newVal != null && typeof newVal === 'object' && canReflect.isMapLike(propValue)) {
dev.warn('can-stache-key: Merging data into "' + prop + '" because its parent is non-observable');
canReflect.update(propValue, newVal);
} else if (propValue != null && propValue[setValueSymbol] !== undefined) {
canReflect.setValue(propValue, newVal);
} else {
base[prop] = newVal;
}
}
}
],
reads: function (keyArg) {
var key = '' + keyArg;
var keys = [];
var last = 0;
var at = false;
if (key.charAt(0) === '@') {
last = 1;
at = true;
}
var keyToAdd = '';
for (var i = last; i < key.length; i++) {
var character = key.charAt(i);
if (character === '.' || character === '@') {
if (key.charAt(i - 1) !== '\\') {
keys.push({
key: keyToAdd,
at: at
});
at = character === '@';
keyToAdd = '';
} else {
keyToAdd = keyToAdd.substr(0, keyToAdd.length - 1) + '.';
}
} else {
keyToAdd += character;
}
}
keys.push({
key: keyToAdd,
at: at
});
return keys;
},
write: function (parent, key, value, options) {
var keys = typeof key === 'string' ? observeReader.reads(key) : key;
var last;
options = options || {};
if (keys.length > 1) {
last = keys.pop();
parent = observeReader.read(parent, keys, options).value;
keys.push(last);
} else {
last = keys[0];
}
if (!parent) {
return;
}
var keyValue = peek(parent, last.key);
if (observeReader.valueReadersMap.isValueLike.test(keyValue, keys.length - 1, keys, options)) {
observeReader.valueReadersMap.isValueLike.write(keyValue, value, options);
} else {
if (observeReader.valueReadersMap.isValueLike.test(parent, keys.length - 1, keys, options)) {
parent = parent[getValueSymbol]();
}
if (observeReader.propertyReadersMap.map.test(parent)) {
observeReader.propertyReadersMap.map.write(parent, last.key, value, options);
} else if (observeReader.propertyReadersMap.object.test(parent)) {
observeReader.propertyReadersMap.object.write(parent, last.key, value, options);
if (options.observation) {
options.observation.update();
}
}
}
}
};
observeReader.propertyReaders.forEach(function (reader) {
observeReader.propertyReadersMap[reader.name] = reader;
});
observeReader.valueReaders.forEach(function (reader) {
observeReader.valueReadersMap[reader.name] = reader;
});
observeReader.set = observeReader.write;
module.exports = observeReader;
});
/*can-globals@1.1.1#location/location*/
define('can-globals/location/location', [
'require',
'exports',
'module',
'can-globals/global/global',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
require('can-globals/global/global');
var globals = require('can-globals/<API key>');
globals.define('location', function () {
return globals.getKeyValue('global').location;
});
module.exports = globals.makeExport('location');
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#mutation-observer/mutation-observer*/
define('can-globals/mutation-observer/mutation-observer', [
'require',
'exports',
'module',
'can-globals/global/global',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
require('can-globals/global/global');
var globals = require('can-globals/<API key>');
globals.define('MutationObserver', function () {
var GLOBAL = globals.getKeyValue('global');
return GLOBAL.MutationObserver || GLOBAL.<API key> || GLOBAL.MozMutationObserver;
});
module.exports = globals.makeExport('MutationObserver');
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#custom-elements/custom-elements*/
define('can-globals/custom-elements/custom-elements', [
'require',
'exports',
'module',
'can-globals/global/global',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
require('can-globals/global/global');
var globals = require('can-globals/<API key>');
globals.define('customElements', function () {
var GLOBAL = globals.getKeyValue('global');
return GLOBAL.customElements;
});
module.exports = globals.makeExport('customElements');
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#can-globals*/
define('can-globals', [
'require',
'exports',
'module',
'can-globals/<API key>',
'can-globals/global/global',
'can-globals/document/document',
'can-globals/location/location',
'can-globals/mutation-observer/mutation-observer',
'can-globals/is-browser-window/is-browser-window',
'can-globals/is-node/is-node',
'can-globals/custom-elements/custom-elements'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals/<API key>');
require('can-globals/global/global');
require('can-globals/document/document');
require('can-globals/location/location');
require('can-globals/mutation-observer/mutation-observer');
require('can-globals/is-browser-window/is-browser-window');
require('can-globals/is-node/is-node');
require('can-globals/custom-elements/custom-elements');
module.exports = globals;
}(function () {
return this;
}(), require, exports, module));
});
/*can-dom-mutate@1.0.4#-util*/
define('can-dom-mutate/-util', [
'require',
'exports',
'module',
'can-globals/document/document'
], function (require, exports, module) {
(function (global, require, exports, module) {
var getDocument = require('can-globals/document/document');
var push = Array.prototype.push;
function eliminate(array, item) {
var index = array.indexOf(item);
if (index >= 0) {
array.splice(index, 1);
}
}
function isInDocument(node) {
var root = getDocument().documentElement;
if (root === node) {
return true;
}
return root.contains(node);
}
function isDocumentElement(node) {
return getDocument().documentElement === node;
}
function isFragment(node) {
return !!(node && node.nodeType === 11);
}
function getChildren(parentNode) {
var nodes = [];
var node = parentNode.firstChild;
while (node) {
nodes.push(node);
node = node.nextSibling;
}
return nodes;
}
function getParents(node) {
var nodes;
if (isFragment(node)) {
nodes = getChildren(node);
} else {
nodes = [node];
}
return nodes;
}
function getAllNodes(node) {
var nodes = getParents(node);
var cLen = nodes.length;
for (var c = 0; c < cLen; c++) {
var element = nodes[c];
if (element.<API key>) {
var descendants = element.<API key>('*');
push.apply(nodes, descendants);
}
}
return nodes;
}
function subscription(fn) {
return function _subscription() {
var disposal = fn.apply(this, arguments);
var isDisposed = false;
return function _disposal() {
if (isDisposed) {
var fnName = fn.name || fn.displayName || 'an anonymous function';
var message = 'Disposal function returned by ' + fnName + ' called more than once.';
throw new Error(message);
}
disposal.apply(this, arguments);
isDisposed = true;
};
};
}
module.exports = {
eliminate: eliminate,
isInDocument: isInDocument,
getDocument: getDocument,
isDocumentElement: isDocumentElement,
isFragment: isFragment,
getParents: getParents,
getAllNodes: getAllNodes,
getChildren: getChildren,
subscription: subscription
};
}(function () {
return this;
}(), require, exports, module));
});
/*can-dom-mutate@1.0.4#can-dom-mutate*/
define('can-dom-mutate', [
'require',
'exports',
'module',
'can-globals',
'can-globals/global/global',
'can-globals/mutation-observer/mutation-observer',
'can-dom-mutate/-util'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals');
var getRoot = require('can-globals/global/global');
var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
var setImmediate = getRoot().setImmediate || function (cb) {
return setTimeout(cb, 0);
};
var util = require('can-dom-mutate/-util');
var getDocument = util.getDocument;
var eliminate = util.eliminate;
var subscription = util.subscription;
var isDocumentElement = util.isDocumentElement;
var getAllNodes = util.getAllNodes;
var push = Array.prototype.push;
var slice = Array.prototype.slice;
var domMutate;
var dataStore = new WeakMap();
function getRelatedData(node, key) {
var data = dataStore.get(node);
if (data) {
return data[key];
}
}
function setRelatedData(node, key, targetListenersMap) {
var data = dataStore.get(node) || dataStore.set(node, {}).get(node);
data[key] = targetListenersMap;
}
function deleteRelatedData(node, key) {
var data = dataStore.get(node);
return delete data[key];
}
function batch(processBatchItems, shouldDeduplicate) {
var waitingBatch = [];
var waitingCalls = [];
var dispatchSet = new Set();
var isPrimed = false;
return function batchAdd(items, callback) {
if (shouldDeduplicate) {
for (var i = 0; i < items.length; i++) {
var item = items[i];
var target = item.target;
if (!dispatchSet.has(target)) {
waitingBatch.push(item);
dispatchSet.add(target);
}
}
} else {
push.apply(waitingBatch, items);
}
if (callback) {
waitingCalls.push(callback);
}
var shouldPrime = !isPrimed && waitingBatch.length > 0;
if (shouldPrime) {
isPrimed = true;
setImmediate(function processBatch() {
var currentBatch = waitingBatch;
waitingBatch = [];
var currentCalls = waitingCalls;
waitingCalls = [];
if (shouldDeduplicate) {
dispatchSet = new Set();
}
isPrimed = false;
processBatchItems(currentBatch);
var callCount = currentCalls.length;
for (var c = 0; c < callCount; c++) {
currentCalls[c]();
}
});
}
};
}
function <API key>(target, key) {
var doc = getDocument();
var data = getRelatedData(doc, key);
if (data) {
return data.listeners;
}
}
function getTargetListeners(target, key) {
var doc = getDocument();
var targetListenersMap = getRelatedData(doc, key);
if (!targetListenersMap) {
return;
}
return targetListenersMap.get(target);
}
function addTargetListener(target, key, listener) {
var doc = getDocument();
var targetListenersMap = getRelatedData(doc, key);
if (!targetListenersMap) {
targetListenersMap = new Map();
setRelatedData(doc, key, targetListenersMap);
}
var targetListeners = targetListenersMap.get(target);
if (!targetListeners) {
targetListeners = [];
targetListenersMap.set(target, targetListeners);
}
targetListeners.push(listener);
}
function <API key>(target, key, listener) {
var doc = getDocument();
var targetListenersMap = getRelatedData(doc, key);
if (!targetListenersMap) {
return;
}
var targetListeners = targetListenersMap.get(target);
if (!targetListeners) {
return;
}
eliminate(targetListeners, listener);
if (targetListeners.length === 0) {
targetListenersMap['delete'](target);
if (targetListenersMap.size === 0) {
deleteRelatedData(doc, key);
}
}
}
function fire(callbacks, arg) {
var safeCallbacks = slice.call(callbacks, 0);
var safeCallbackCount = safeCallbacks.length;
for (var i = 0; i < safeCallbackCount; i++) {
safeCallbacks[i](arg);
}
}
function dispatch(listenerKey, documentDataKey) {
return function dispatchEvents(events) {
for (var e = 0; e < events.length; e++) {
var event = events[e];
var target = event.target;
var targetListeners = getTargetListeners(target, listenerKey);
if (targetListeners) {
fire(targetListeners, event);
}
if (!documentDataKey) {
continue;
}
var documentListeners = <API key>(target, documentDataKey);
if (documentListeners) {
fire(documentListeners, event);
}
}
};
}
function observeMutations(target, observerKey, config, handler) {
var observerData = getRelatedData(target, observerKey);
if (!observerData) {
observerData = { observingCount: 0 };
setRelatedData(target, observerKey, observerData);
}
var setupObserver = function () {
var MutationObserver = getMutationObserver();
if (MutationObserver) {
var Node = getRoot().Node;
var isRealNode = !!(Node && target instanceof Node);
if (isRealNode) {
var targetObserver = new MutationObserver(handler);
targetObserver.observe(target, config);
observerData.observer = targetObserver;
}
} else {
if (observerData.observer) {
observerData.observer.disconnect();
observerData.observer = null;
}
}
};
if (observerData.observingCount === 0) {
globals.onKeyValue('MutationObserver', setupObserver);
setupObserver();
}
observerData.observingCount++;
return function <API key>() {
var observerData = getRelatedData(target, observerKey);
if (observerData) {
observerData.observingCount
if (observerData.observingCount <= 0) {
if (observerData.observer) {
observerData.observer.disconnect();
}
deleteRelatedData(target, observerKey);
globals.offKeyValue('MutationObserver', setupObserver);
}
}
};
}
function handleTreeMutations(mutations) {
var mutationCount = mutations.length;
for (var m = 0; m < mutationCount; m++) {
var mutation = mutations[m];
var addedNodes = mutation.addedNodes;
var addedCount = addedNodes.length;
for (var a = 0; a < addedCount; a++) {
domMutate.<API key>(addedNodes[a]);
}
var removedNodes = mutation.removedNodes;
var removedCount = removedNodes.length;
for (var r = 0; r < removedCount; r++) {
domMutate.dispatchNodeRemoval(removedNodes[r]);
}
}
}
function <API key>(mutations) {
var mutationCount = mutations.length;
for (var m = 0; m < mutationCount; m++) {
var mutation = mutations[m];
if (mutation.type === 'attributes') {
var node = mutation.target;
var attributeName = mutation.attributeName;
var oldValue = mutation.oldValue;
domMutate.<API key>(node, attributeName, oldValue);
}
}
}
var treeMutationConfig = {
subtree: true,
childList: true
};
var <API key> = {
attributes: true,
attributeOldValue: true
};
function addNodeListener(listenerKey, observerKey, isAttributes) {
return subscription(function _addNodeListener(target, listener) {
var stopObserving;
if (isAttributes) {
stopObserving = observeMutations(target, observerKey, <API key>, <API key>);
} else {
stopObserving = observeMutations(getDocument(), observerKey, treeMutationConfig, handleTreeMutations);
}
addTargetListener(target, listenerKey, listener);
return function removeNodeListener() {
stopObserving();
<API key>(target, listenerKey, listener);
};
});
}
function addGlobalListener(globalDataKey, addNodeListener) {
return subscription(function <API key>(documentElement, listener) {
if (!isDocumentElement(documentElement)) {
throw new Error('Global mutation listeners must pass a documentElement');
}
var doc = getDocument();
var documentData = getRelatedData(doc, globalDataKey);
if (!documentData) {
documentData = { listeners: [] };
setRelatedData(doc, globalDataKey, documentData);
}
var listeners = documentData.listeners;
if (listeners.length === 0) {
documentData.removeListener = addNodeListener(doc, function () {
});
}
listeners.push(listener);
return function <API key>() {
var documentData = getRelatedData(doc, globalDataKey);
if (!documentData) {
return;
}
var listeners = documentData.listeners;
eliminate(listeners, listener);
if (listeners.length === 0) {
documentData.removeListener();
deleteRelatedData(doc, globalDataKey);
}
};
});
}
function toMutationEvents(nodes) {
var events = [];
for (var i = 0; i < nodes.length; i++) {
events.push({ target: nodes[i] });
}
return events;
}
var domMutationPrefix = 'domMutation';
var insertionDataKey = domMutationPrefix + 'InsertionData';
var removalDataKey = domMutationPrefix + 'RemovalData';
var <API key> = domMutationPrefix + 'AttributeChangeData';
var <API key> = domMutationPrefix + '<API key>';
var <API key> = domMutationPrefix + 'DocumentRemovalData';
var <API key> = domMutationPrefix + '<API key>';
var treeDataKey = domMutationPrefix + 'TreeData';
var attributeDataKey = domMutationPrefix + 'AttributeData';
var dispatchInsertion = batch(dispatch(insertionDataKey, <API key>), true);
var dispatchRemoval = batch(dispatch(removalDataKey, <API key>), true);
var <API key> = batch(dispatch(<API key>, <API key>));
var <API key> = addNodeListener(insertionDataKey, treeDataKey);
var <API key> = addNodeListener(removalDataKey, treeDataKey);
var <API key> = addNodeListener(<API key>, attributeDataKey, true);
var <API key> = addGlobalListener(<API key>, <API key>);
var addRemovalListener = addGlobalListener(<API key>, <API key>);
var <API key> = addGlobalListener(<API key>, <API key>);
domMutate = {
<API key>: function (node, callback) {
var events = toMutationEvents(getAllNodes(node));
dispatchInsertion(events, callback);
},
dispatchNodeRemoval: function (node, callback) {
var events = toMutationEvents(getAllNodes(node));
dispatchRemoval(events, callback);
},
<API key>: function (target, attributeName, oldValue, callback) {
<API key>([{
target: target,
attributeName: attributeName,
oldValue: oldValue
}], callback);
},
onNodeInsertion: <API key>,
onNodeRemoval: <API key>,
<API key>: <API key>,
onRemoval: addRemovalListener,
onInsertion: <API key>,
onAttributeChange: <API key>
};
module.exports = domMutate;
}(function () {
return this;
}(), require, exports, module));
});
/*can-control@4.1.0#can-control*/
define('can-control', [
'require',
'exports',
'module',
'can-construct',
'can-namespace',
'can-assign',
'can-stache-key',
'can-reflect',
'can-observation',
'can-event-queue/map/map',
'can-log/dev/dev',
'can-string',
'can-key/get/get',
'can-dom-mutate'
], function (require, exports, module) {
var Construct = require('can-construct');
var namespace = require('can-namespace');
var assign = require('can-assign');
var observeReader = require('can-stache-key');
var canReflect = require('can-reflect');
var Observation = require('can-observation');
var canEvent = require('can-event-queue/map/map');
var dev = require('can-log/dev/dev');
var string = require('can-string');
var get = require('can-key/get/get');
var domMutate = require('can-dom-mutate');
var processors;
var controlData = new WeakMap();
var bind = function (el, ev, callback, queue) {
canEvent.on.call(el, ev, callback, queue);
return function () {
canEvent.off.call(el, ev, callback, queue);
};
}, slice = [].slice, paramReplacer = /\{([^\}]+)\}/g, delegate = function (el, selector, ev, callback) {
canEvent.on.call(el, ev, selector, callback);
return function () {
canEvent.off.call(el, ev, selector, callback);
};
}, binder = function (el, ev, callback, selector) {
return selector ? delegate(el, selector.trim(), ev, callback) : bind(el, ev, callback);
}, basicProcessor;
var Control = Construct.extend('Control', {
setup: function () {
Construct.setup.apply(this, arguments);
if (Control) {
var control = this, funcName;
control.actions = {};
for (funcName in control.prototype) {
if (control._isAction(funcName)) {
control.actions[funcName] = control._action(funcName);
}
}
}
},
_shifter: function (context, name) {
var method = typeof name === 'string' ? context[name] : name;
if (typeof method !== 'function') {
method = context[method];
}
var Control = this;
function controlMethod() {
var wrapped = Control.wrapElement(this);
context.called = name;
return method.apply(context, [wrapped].concat(slice.call(arguments, 0)));
}
Object.defineProperty(controlMethod, 'name', { value: canReflect.getName(this) + '[' + name + ']' });
return controlMethod;
},
_isAction: function (methodName) {
var val = this.prototype[methodName], type = typeof val;
return methodName !== 'constructor' && (type === 'function' || type === 'string' && typeof this.prototype[val] === 'function') && !!(Control.isSpecial(methodName) || processors[methodName] || /[^\w]/.test(methodName));
},
_action: function (methodName, options, controlInstance) {
var readyCompute, unableToBind;
paramReplacer.lastIndex = 0;
if (options || !paramReplacer.test(methodName)) {
var controlActionData = function () {
var delegate;
var name = methodName.replace(paramReplacer, function (matched, key) {
var value, parent;
if (this._isDelegate(options, key)) {
delegate = this._getDelegate(options, key);
return '';
}
key = this.<API key>(key);
parent = this._lookup(options)[0];
value = observeReader.read(parent, observeReader.reads(key), { readCompute: false }).value;
if (value === undefined && typeof window !== 'undefined') {
value = get(window, key);
}
if (!parent || !(canReflect.isObservableLike(parent) && canReflect.isMapLike(parent)) && !value) {
unableToBind = true;
return null;
}
if (typeof value === 'string') {
return value;
} else {
delegate = value;
return '';
}
}.bind(this));
name = name.trim();
var parts = name.split(/\s+/g), event = parts.pop();
return {
processor: this.processors[event] || basicProcessor,
parts: [
name,
parts.join(' '),
event
],
delegate: delegate || undefined
};
};
Object.defineProperty(controlActionData, 'name', { value: canReflect.getName(controlInstance || this.prototype) + '[' + methodName + '].actionData' });
readyCompute = new Observation(controlActionData, this);
if (controlInstance) {
var handler = function (actionData) {
controlInstance._bindings.control[methodName](controlInstance.element);
controlInstance._bindings.control[methodName] = actionData.processor(actionData.delegate || controlInstance.element, actionData.parts[2], actionData.parts[1], methodName, controlInstance);
};
Object.defineProperty(handler, 'name', { value: canReflect.getName(controlInstance) + '[' + methodName + '].handler' });
canReflect.onValue(readyCompute, handler, 'mutate');
if (unableToBind) {
dev.log('can-control: No property found for handling ' + methodName);
}
controlInstance._bindings.readyComputes[methodName] = {
compute: readyCompute,
handler: handler
};
}
return readyCompute.get();
}
},
_lookup: function (options) {
return [
options,
window
];
},
<API key>: function (key) {
return key;
},
_isDelegate: function (options, key) {
return key === 'element';
},
_getDelegate: function (options, key) {
return undefined;
},
processors: {},
defaults: {},
convertElement: function (element) {
element = typeof element === 'string' ? document.querySelector(element) : element;
return this.wrapElement(element);
},
wrapElement: function (el) {
return el;
},
unwrapElement: function (el) {
return el;
},
isSpecial: function (eventName) {
return eventName === 'inserted' || eventName === 'removed';
}
}, {
setup: function (element, options) {
var cls = this.constructor, pluginname = cls.pluginName || cls.shortName, arr;
if (!element) {
throw new Error('Creating an instance of a named control without passing an element');
}
this.element = cls.convertElement(element);
if (pluginname && pluginname !== 'Control' && this.element.classList) {
this.element.classList.add(pluginname);
}
arr = controlData.get(this.element);
if (!arr) {
arr = [];
controlData.set(this.element, arr);
}
arr.push(this);
if (canReflect.isObservableLike(options) && canReflect.isMapLike(options)) {
for (var prop in cls.defaults) {
if (!options.hasOwnProperty(prop)) {
observeReader.set(options, prop, cls.defaults[prop]);
}
}
this.options = options;
} else {
this.options = assign(assign({}, cls.defaults), options);
}
this.on();
return [
this.element,
this.options
];
},
on: function (el, selector, eventName, func) {
if (!el) {
this.off();
var cls = this.constructor, bindings = this._bindings, actions = cls.actions, element = this.constructor.unwrapElement(this.element), destroyCB = Control._shifter(this, 'destroy'), funcName, ready;
for (funcName in actions) {
if (actions.hasOwnProperty(funcName)) {
ready = actions[funcName] || cls._action(funcName, this.options, this);
if (ready) {
bindings.control[funcName] = ready.processor(ready.delegate || element, ready.parts[2], ready.parts[1], funcName, this);
}
}
}
var removalDisposal = domMutate.onNodeRemoval(element, function () {
if (!element.ownerDocument.contains(element)) {
destroyCB();
}
});
bindings.user.push(function () {
if (removalDisposal) {
removalDisposal();
removalDisposal = undefined;
}
});
return bindings.user.length;
}
if (typeof el === 'string') {
func = eventName;
eventName = selector;
selector = el;
el = this.element;
}
if (func === undefined) {
func = eventName;
eventName = selector;
selector = null;
}
if (typeof func === 'string') {
func = Control._shifter(this, func);
}
this._bindings.user.push(binder(el, eventName, func, selector));
return this._bindings.user.length;
},
off: function () {
var el = this.constructor.unwrapElement(this.element), bindings = this._bindings;
if (bindings) {
(bindings.user || []).forEach(function (value) {
value(el);
});
canReflect.eachKey(bindings.control || {}, function (value) {
value(el);
});
canReflect.eachKey(bindings.readyComputes || {}, function (value) {
canReflect.offValue(value.compute, value.handler, 'mutate');
});
}
this._bindings = {
user: [],
control: {},
readyComputes: {}
};
},
destroy: function () {
if (this.element === null) {
dev.warn('can-control: Control already destroyed');
return;
}
var Class = this.constructor, pluginName = Class.pluginName || Class.shortName && string.underscore(Class.shortName), controls;
this.off();
if (pluginName && pluginName !== 'can_control' && this.element.classList) {
this.element.classList.remove(pluginName);
}
controls = controlData.get(this.element);
if (controls) {
controls.splice(controls.indexOf(this), 1);
}
this.element = null;
}
});
processors = Control.processors;
basicProcessor = function (el, event, selector, methodName, control) {
return binder(el, event, Control._shifter(control, methodName), selector);
};
[
'beforeremove',
'change',
'click',
'contextmenu',
'dblclick',
'keydown',
'keyup',
'keypress',
'mousedown',
'mousemove',
'mouseout',
'mouseover',
'mouseup',
'reset',
'resize',
'scroll',
'select',
'submit',
'focusin',
'focusout',
'mouseenter',
'mouseleave',
'touchstart',
'touchmove',
'touchcancel',
'touchend',
'touchleave',
'inserted',
'removed',
'dragstart',
'dragenter',
'dragover',
'dragleave',
'drag',
'drop',
'dragend'
].forEach(function (v) {
processors[v] = basicProcessor;
});
module.exports = namespace.Control = Control;
});
/*can-component@4.1.3#control/control*/
define('can-component/control/control', [
'require',
'exports',
'module',
'can-control',
'can-reflect'
], function (require, exports, module) {
var Control = require('can-control');
var canReflect = require('can-reflect');
var paramReplacer = /\{([^\}]+)\}/g;
var ComponentControl = Control.extend({
_lookup: function (options) {
return [
options.scope,
options,
window
];
},
<API key>: function (key) {
return key.replace(/^(scope|^viewModel)\./, '');
},
_isDelegate: function (options, key) {
return key === 'scope' || key === 'viewModel';
},
_getDelegate: function (options, key) {
return options[key];
},
_action: function (methodName, options, controlInstance) {
var hasObjectLookup;
paramReplacer.lastIndex = 0;
hasObjectLookup = paramReplacer.test(methodName);
if (!controlInstance && hasObjectLookup) {
return;
} else {
return Control._action.apply(this, arguments);
}
}
}, {
setup: function (el, options) {
this.scope = options.scope;
this.viewModel = options.viewModel;
return Control.prototype.setup.call(this, el, options);
},
off: function () {
if (this._bindings) {
canReflect.eachKey(this._bindings.readyComputes || {}, function (value) {
canReflect.offValue(value.compute, value.handler);
});
}
Control.prototype.off.apply(this, arguments);
this._bindings.readyComputes = {};
},
destroy: function () {
Control.prototype.destroy.apply(this, arguments);
if (typeof this.options.destroy === 'function') {
this.options.destroy.apply(this, arguments);
}
}
});
module.exports = ComponentControl;
});
/*<API key>@1.0.5#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-namespace',
'can-log/dev/dev'
], function (require, exports, module) {
var namespace = require('can-namespace');
var dev = require('can-log/dev/dev');
function each(items, callback) {
for (var i = 0; i < items.length; i++) {
callback(items[i], i);
}
}
function makeMap(str) {
var obj = {}, items = str.split(',');
each(items, function (name) {
obj[name] = true;
});
return obj;
}
var <API key> = makeMap('allowReorder,attributeName,attributeType,autoReverse,baseFrequency,baseProfile,calcMode,clipPathUnits,contentScriptType,contentStyleType,diffuseConstant,edgeMode,<API key>,filterRes,filterUnits,glyphRef,gradientTransform,gradientUnits,kernelMatrix,kernelUnitLength,keyPoints,keySplines,keyTimes,lengthAdjust,limitingConeAngle,markerHeight,markerUnits,markerWidth,maskContentUnits,maskUnits,patternContentUnits,patternTransform,patternUnits,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,repeatCount,repeatDur,requiredExtensions,requiredFeatures,specularConstant,specularExponent,spreadMethod,startOffset,stdDeviation,stitchTiles,surfaceScale,systemLanguage,tableValues,textLength,viewBox,viewTarget,xChannelSelector,yChannelSelector');
function <API key>(match, lowerCaseChar, upperCaseChar) {
return lowerCaseChar + '-' + upperCaseChar.toLowerCase();
}
function startsWith(allOfIt, startsWith) {
return allOfIt.indexOf(startsWith) === 0;
}
function endsWith(allOfIt, endsWith) {
return allOfIt.length - allOfIt.indexOf(endsWith) === endsWith.length;
}
var regexes = {
leftParens: /\(/g,
rightParens: /\)/g,
leftBrace: /\{/g,
rightBrace: /\}/g,
camelCase: /([a-z]|^)([A-Z])/g,
forwardSlash: /\
space: /\s/g,
uppercase: /[A-Z]/g,
<API key>: /:u:([a-z])/g,
caret: /\^/g,
dollar: /\$/g,
at: /@/g
};
var delimiters = {
prependUppercase: ':u:',
replaceSpace: ':s:',
replaceForwardSlash: ':f:',
replaceLeftParens: ':lp:',
replaceRightParens: ':rp:',
replaceLeftBrace: ':lb:',
replaceRightBrace: ':rb:',
replaceCaret: ':c:',
replaceDollar: ':d:',
replaceAt: ':at:'
};
var encoder = {};
encoder.encode = function (name) {
var encoded = name;
if (!<API key>[encoded] && encoded.match(regexes.camelCase)) {
if (startsWith(encoded, 'on:') || endsWith(encoded, ':to') || endsWith(encoded, ':from') || endsWith(encoded, ':bind') || endsWith(encoded, ':raw')) {
encoded = encoded.replace(regexes.uppercase, function (char) {
return delimiters.prependUppercase + char.toLowerCase();
});
} else if (startsWith(encoded, '(') || startsWith(encoded, '{')) {
encoded = encoded.replace(regexes.camelCase, <API key>);
dev.warn('<API key>: Found attribute with name: ' + name + '. Converting to: ' + encoded + '.');
}
}
encoded = encoded.replace(regexes.space, delimiters.replaceSpace).replace(regexes.forwardSlash, delimiters.replaceForwardSlash).replace(regexes.leftParens, delimiters.replaceLeftParens).replace(regexes.rightParens, delimiters.replaceRightParens).replace(regexes.leftBrace, delimiters.replaceLeftBrace).replace(regexes.rightBrace, delimiters.replaceRightBrace).replace(regexes.caret, delimiters.replaceCaret).replace(regexes.dollar, delimiters.replaceDollar).replace(regexes.at, delimiters.replaceAt);
return encoded;
};
encoder.decode = function (name) {
var decoded = name;
if (!<API key>[decoded] && decoded.match(regexes.<API key>)) {
if (startsWith(decoded, 'on:') || endsWith(decoded, ':to') || endsWith(decoded, ':from') || endsWith(decoded, ':bind') || endsWith(decoded, ':raw')) {
decoded = decoded.replace(regexes.<API key>, function (match, char) {
return char.toUpperCase();
});
}
}
decoded = decoded.replace(delimiters.replaceLeftParens, '(').replace(delimiters.replaceRightParens, ')').replace(delimiters.replaceLeftBrace, '{').replace(delimiters.replaceRightBrace, '}').replace(delimiters.replaceForwardSlash, '/').replace(delimiters.replaceSpace, ' ').replace(delimiters.replaceCaret, '^').replace(delimiters.replaceDollar, '$').replace(delimiters.replaceAt, '@');
return decoded;
};
if (namespace.encoder) {
throw new Error('You can\'t have two versions of <API key>, check your dependencies');
} else {
module.exports = namespace.encoder = encoder;
}
});
/*can-view-parser@4.0.2#can-view-parser*/
define('can-view-parser', [
'require',
'exports',
'module',
'can-namespace',
'can-log/dev/dev',
'<API key>'
], function (require, exports, module) {
var namespace = require('can-namespace'), dev = require('can-log/dev/dev'), encoder = require('<API key>');
function each(items, callback) {
for (var i = 0; i < items.length; i++) {
callback(items[i], i);
}
}
function makeMap(str) {
var obj = {}, items = str.split(',');
each(items, function (name) {
obj[name] = true;
});
return obj;
}
function handleIntermediate(intermediate, handler) {
for (var i = 0, len = intermediate.length; i < len; i++) {
var item = intermediate[i];
handler[item.tokenType].apply(handler, item.args);
}
return intermediate;
}
function countLines(input) {
return input.split('\n').length - 1;
}
var alphaNumeric = 'A-Za-z0-9', alphaNumericHU = '-:_' + alphaNumeric, magicStart = '{{', endTag = new RegExp('^<\\/([' + alphaNumericHU + ']+)[^>]*>'), magicMatch = new RegExp('\\{\\{(![\\s\\S]*?!|[\\s\\S]*?)\\}\\}\\}?', 'g'), space = /\s/, alphaRegex = new RegExp('[' + alphaNumeric + ']'), attributeRegexp = new RegExp('[' + alphaNumericHU + ']+s*=s*("[^"]*"|\'[^\']*\')');
var empty = makeMap('area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed');
var caseMattersElements = makeMap('altGlyph,altGlyphDef,altGlyphItem,animateColor,animateMotion,animateTransform,clipPath,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,foreignObject,glyphRef,linearGradient,radialGradient,textPath');
var closeSelf = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr');
var special = makeMap('script');
var tokenTypes = 'start,end,close,attrStart,attrEnd,attrValue,chars,comment,special,done'.split(',');
var startOppositesMap = {
'{': '}',
'(': ')'
};
var fn = function () {
};
var HTMLParser = function (html, handler, returnIntermediate) {
if (typeof html === 'object') {
return handleIntermediate(html, handler);
}
var intermediate = [];
handler = handler || {};
if (returnIntermediate) {
each(tokenTypes, function (name) {
var callback = handler[name] || fn;
handler[name] = function () {
if (callback.apply(this, arguments) !== false) {
var end = arguments.length;
if (arguments[end - 1] === undefined) {
end = arguments.length - 1;
}
end = arguments.length;
intermediate.push({
tokenType: name,
args: [].slice.call(arguments, 0, end)
});
}
};
});
}
function parseStartTag(tag, tagName, rest, unary) {
tagName = caseMattersElements[tagName] ? tagName : tagName.toLowerCase();
if (closeSelf[tagName] && stack.last() === tagName) {
parseEndTag('', tagName);
}
unary = empty[tagName] || !!unary;
handler.start(tagName, unary, lineNo);
if (!unary) {
stack.push(tagName);
}
HTMLParser.parseAttrs(rest, handler, lineNo);
lineNo += countLines(tag);
handler.end(tagName, unary, lineNo);
}
function parseEndTag(tag, tagName) {
var pos;
if (!tagName) {
pos = 0;
} else {
tagName = caseMattersElements[tagName] ? tagName : tagName.toLowerCase();
for (pos = stack.length - 1; pos >= 0; pos
if (stack[pos] === tagName) {
break;
}
}
}
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);
}
}
}
if (pos >= 0) {
for (var i = stack.length - 1; i >= pos; i
if (handler.close) {
handler.close(stack[i], lineNo);
}
}
stack.length = pos;
}
}
function parseMustache(mustache, inside) {
if (handler.special) {
handler.special(inside, lineNo);
}
}
var callChars = function () {
if (charsText) {
if (handler.chars) {
handler.chars(charsText, lineNo);
}
lineNo += countLines(charsText);
}
charsText = '';
};
var index, chars, match, lineNo, stack = [], last = html, charsText = '';
lineNo = 1;
stack.last = function () {
return this[this.length - 1];
};
while (html) {
chars = true;
if (!stack.last() || !special[stack.last()]) {
if (html.indexOf('<!
index = html.indexOf('
if (index >= 0) {
callChars();
if (handler.comment) {
handler.comment(html.substring(4, index), lineNo);
}
lineNo += countLines(html.substring(0, index + 3));
html = html.substring(index + 3);
chars = false;
}
} else if (html.indexOf('</') === 0) {
match = html.match(endTag);
if (match) {
callChars();
match[0].replace(endTag, parseEndTag);
lineNo += countLines(html.substring(0, match[0].length));
html = html.substring(match[0].length);
chars = false;
}
} else if (html.indexOf('<') === 0) {
var res = HTMLParser.searchStartTag(html);
if (res) {
callChars();
parseStartTag.apply(null, res.match);
html = res.html;
chars = false;
}
} else if (html.indexOf(magicStart) === 0) {
match = html.match(magicMatch);
if (match) {
callChars();
match[0].replace(magicMatch, parseMustache);
lineNo += countLines(html.substring(0, match[0].length));
html = html.substring(match[0].length);
}
}
if (chars) {
index = findBreak(html, magicStart);
if (index === 0 && html === last) {
charsText += html.charAt(0);
html = html.substr(1);
index = findBreak(html, magicStart);
}
var text = index < 0 ? html : html.substring(0, index);
html = index < 0 ? '' : html.substring(index);
if (text) {
charsText += text;
}
}
} else {
html = html.replace(new RegExp('([\\s\\S]*?)</' + stack.last() + '[^>]*>'), function (all, text) {
text = text.replace(/|<!\[CDATA\[([\s\S]*?)]]>/g, '$1$2');
if (handler.chars) {
handler.chars(text, lineNo);
}
lineNo += countLines(text);
return '';
});
parseEndTag('', stack.last());
}
if (html === last) {
throw new Error('Parse Error: ' + html);
}
last = html;
}
callChars();
parseEndTag();
handler.done(lineNo);
return intermediate;
};
var callAttrStart = function (state, curIndex, handler, rest, lineNo) {
var attrName = rest.substring(typeof state.nameStart === 'number' ? state.nameStart : curIndex, curIndex), newAttrName = encoder.encode(attrName);
state.attrStart = newAttrName;
handler.attrStart(state.attrStart, lineNo);
state.inName = false;
};
var callAttrEnd = function (state, curIndex, handler, rest, lineNo) {
if (state.valueStart !== undefined && state.valueStart < curIndex) {
var val = rest.substring(state.valueStart, curIndex);
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);
}
}
handler.attrValue(val, 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;
};
var findBreak = function (str, magicStart) {
var magicLength = magicStart.length;
for (var i = 0, len = str.length; i < len; i++) {
if (str[i] === '<' || str.substr(i, magicLength) === magicStart) {
return i;
}
}
return -1;
};
HTMLParser.parseAttrs = function (rest, handler, lineNo) {
if (!rest) {
return;
}
var i = 0;
var curIndex;
var state = {
inName: false,
nameStart: undefined,
inValue: false,
valueStart: undefined,
inQuote: false,
attrStart: undefined,
lookingForName: true,
lookingForValue: false,
lookingForEq: false
};
while (i < rest.length) {
curIndex = i;
var cur = rest.charAt(i);
i++;
if (magicStart === rest.substr(curIndex, magicStart.length)) {
if (state.inValue && curIndex > state.valueStart) {
handler.attrValue(rest.substring(state.valueStart, curIndex), lineNo);
} else if (state.inName && state.nameStart < curIndex) {
callAttrStart(state, curIndex, handler, rest, lineNo);
callAttrEnd(state, curIndex, handler, rest, lineNo);
} else if (state.lookingForValue) {
state.inValue = true;
} else if (state.lookingForEq && state.attrStart) {
callAttrEnd(state, curIndex, handler, rest, lineNo);
}
magicMatch.lastIndex = curIndex;
var match = magicMatch.exec(rest);
if (match) {
handler.special(match[1], lineNo);
i = curIndex + match[0].length;
if (state.inValue) {
state.valueStart = curIndex + match[0].length;
}
}
} else if (state.inValue) {
if (state.inQuote) {
if (cur === state.inQuote) {
callAttrEnd(state, curIndex, handler, rest, lineNo);
}
} else if (space.test(cur)) {
callAttrEnd(state, curIndex, handler, rest, lineNo);
}
} else if (cur === '=' && (state.lookingForEq || state.lookingForName || state.inName)) {
if (!state.attrStart) {
callAttrStart(state, curIndex, handler, rest, lineNo);
}
state.lookingForValue = true;
state.lookingForEq = false;
state.lookingForName = false;
} else if (state.inName) {
var started = rest[state.nameStart], otherStart, otherOpposite;
if (startOppositesMap[started] === cur) {
otherStart = started === '{' ? '(' : '{';
otherOpposite = startOppositesMap[otherStart];
if (rest[curIndex + 1] === otherOpposite) {
callAttrStart(state, curIndex + 2, handler, rest, lineNo);
i++;
} else {
callAttrStart(state, curIndex + 1, handler, rest, lineNo);
}
state.lookingForEq = true;
} else if (space.test(cur) && started !== '{' && started !== '(') {
callAttrStart(state, curIndex, handler, rest, lineNo);
state.lookingForEq = true;
}
} else if (state.lookingForName) {
if (!space.test(cur)) {
if (state.attrStart) {
callAttrEnd(state, curIndex, handler, rest, lineNo);
}
state.nameStart = curIndex;
state.inName = true;
}
} else if (state.lookingForValue) {
if (!space.test(cur)) {
state.lookingForValue = false;
state.inValue = true;
if (cur === '\'' || cur === '"') {
state.inQuote = cur;
state.valueStart = curIndex + 1;
} else {
state.valueStart = curIndex;
}
} else if (i === rest.length) {
callAttrEnd(state, curIndex, handler, rest, lineNo);
}
}
}
if (state.inName) {
callAttrStart(state, curIndex + 1, handler, rest, lineNo);
callAttrEnd(state, curIndex + 1, handler, rest, lineNo);
} else if (state.lookingForEq || state.lookingForValue || state.inValue) {
callAttrEnd(state, curIndex + 1, handler, rest, lineNo);
}
magicMatch.lastIndex = 0;
};
HTMLParser.searchStartTag = function (html) {
var closingIndex = html.indexOf('>');
var attributeRange = attributeRegexp.exec(html.substring(1));
var <API key> = 1;
while (attributeRange && closingIndex >= <API key> + attributeRange.index) {
<API key> += attributeRange.index + attributeRange[0].length;
while (closingIndex < <API key>) {
closingIndex += html.substring(closingIndex + 1).indexOf('>') + 1;
}
attributeRange = attributeRegexp.exec(html.substring(<API key>));
}
if (closingIndex === -1 || !alphaRegex.test(html[1])) {
return null;
}
var tagName, tagContent, match, rest = '', unary = '';
var startTag = html.substring(0, closingIndex + 1);
var isUnary = startTag[startTag.length - 2] === '/';
var spaceIndex = startTag.search(space);
if (isUnary) {
unary = '/';
tagContent = startTag.substring(1, startTag.length - 2).trim();
} else {
tagContent = startTag.substring(1, startTag.length - 1).trim();
}
if (spaceIndex === -1) {
tagName = tagContent;
} else {
spaceIndex
tagName = tagContent.substring(0, spaceIndex);
rest = tagContent.substring(spaceIndex);
}
match = [
startTag,
tagName,
rest,
unary
];
return {
match: match,
html: html.substring(startTag.length)
};
};
module.exports = namespace.HTMLParser = HTMLParser;
});
/*can-dom-mutate@1.0.4#node*/
define('can-dom-mutate/node', [
'require',
'exports',
'module',
'can-globals',
'can-dom-mutate',
'can-dom-mutate/-util'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals');
var domMutate = require('can-dom-mutate');
var util = require('can-dom-mutate/-util');
var isInDocument = util.isInDocument;
var getParents = util.getParents;
var synthetic = {
<API key>: function (container, node) {
if (isInDocument(node)) {
domMutate.<API key>(node);
}
},
dispatchNodeRemoval: function (container, node) {
if (isInDocument(container) && !isInDocument(node)) {
domMutate.dispatchNodeRemoval(node);
}
}
};
var compat = {
replaceChild: function (newChild, oldChild) {
var newChildren = getParents(newChild);
var result = this.replaceChild(newChild, oldChild);
synthetic.dispatchNodeRemoval(this, oldChild);
for (var i = 0; i < newChildren.length; i++) {
synthetic.<API key>(this, newChildren[i]);
}
return result;
},
setAttribute: function (name, value) {
var oldAttributeValue = this.getAttribute(name);
var result = this.setAttribute(name, value);
var newAttributeValue = this.getAttribute(name);
if (oldAttributeValue !== newAttributeValue) {
domMutate.<API key>(this, name, oldAttributeValue);
}
return result;
},
removeAttribute: function (name) {
var oldAttributeValue = this.getAttribute(name);
var result = this.removeAttribute(name);
if (oldAttributeValue) {
domMutate.<API key>(this, name, oldAttributeValue);
}
return result;
}
};
var compatData = [
[
'appendChild',
'Insertion'
],
[
'insertBefore',
'Insertion'
],
[
'removeChild',
'Removal'
]
];
compatData.forEach(function (pair) {
var nodeMethod = pair[0];
var dispatchMethod = 'dispatchNode' + pair[1];
compat[nodeMethod] = function (node) {
var nodes = getParents(node);
var result = this[nodeMethod].apply(this, arguments);
for (var i = 0; i < nodes.length; i++) {
synthetic[dispatchMethod](this, nodes[i]);
}
return result;
};
});
var normal = {};
var nodeMethods = [
'appendChild',
'insertBefore',
'removeChild',
'replaceChild',
'setAttribute',
'removeAttribute'
];
nodeMethods.forEach(function (methodName) {
normal[methodName] = function () {
return this[methodName].apply(this, arguments);
};
});
var mutate = {};
function setMutateStrategy(observer) {
var strategy = observer ? normal : compat;
for (var key in strategy) {
mutate[key] = strategy[key];
}
}
var mutationObserverKey = 'MutationObserver';
setMutateStrategy(globals.getKeyValue(mutationObserverKey));
globals.onKeyValue(mutationObserverKey, setMutateStrategy);
module.exports = mutate;
}(function () {
return this;
}(), require, exports, module));
});
/*can-view-nodelist@4.2.0#can-view-nodelist*/
define('can-view-nodelist', [
'require',
'exports',
'module',
'can-namespace',
'can-dom-mutate/node'
], function (require, exports, module) {
var namespace = require('can-namespace');
var domMutate = require('can-dom-mutate/node');
var nodeMap = new Map(), splice = [].splice, push = [].push, <API key> = function (list) {
var count = 0;
for (var i = 0, len = list.length; i < len; i++) {
var item = list[i];
if (item.nodeType) {
count++;
} else {
count += <API key>(item);
}
}
return count;
}, replacementMap = function (replacements) {
var map = new Map();
for (var i = 0, len = replacements.length; i < len; i++) {
var node = nodeLists.first(replacements[i]);
map.set(node, replacements[i]);
}
return map;
}, <API key> = function (list, rMap) {
rMap.forEach(function (replacement) {
list.newDeepChildren.push(replacement);
});
};
var nodeLists = {
update: function (nodeList, newNodes, oldNodes) {
if (!oldNodes) {
oldNodes = nodeLists.unregisterChildren(nodeList);
}
var arr = [];
for (var i = 0, ref = arr.length = newNodes.length; i < ref; i++) {
arr[i] = newNodes[i];
}
newNodes = arr;
var oldListLength = nodeList.length;
splice.apply(nodeList, [
0,
oldListLength
].concat(newNodes));
if (nodeList.replacements) {
nodeLists.nestReplacements(nodeList);
nodeList.deepChildren = nodeList.newDeepChildren;
nodeList.newDeepChildren = [];
} else {
nodeLists.nestList(nodeList);
}
return oldNodes;
},
nestReplacements: function (list) {
var index = 0, rMap = replacementMap(list.replacements), rCount = list.replacements.length;
while (index < list.length && rCount) {
var node = list[index], replacement = rMap.get(node);
if (replacement) {
rMap['delete'](node);
list.splice(index, <API key>(replacement), replacement);
rCount
}
index++;
}
if (rCount) {
<API key>(list, rMap);
}
list.replacements = [];
},
nestList: function (list) {
var index = 0;
while (index < list.length) {
var node = list[index], childNodeList = nodeMap.get(node);
if (childNodeList) {
if (childNodeList !== list) {
list.splice(index, <API key>(childNodeList), childNodeList);
}
} else {
nodeMap.set(node, list);
}
index++;
}
},
last: function (nodeList) {
var last = nodeList[nodeList.length - 1];
if (last.nodeType) {
return last;
} else {
return nodeLists.last(last);
}
},
first: function (nodeList) {
var first = nodeList[0];
if (first.nodeType) {
return first;
} else {
return nodeLists.first(first);
}
},
flatten: function (nodeList) {
var items = [];
for (var i = 0; i < nodeList.length; i++) {
var item = nodeList[i];
if (item.nodeType) {
items.push(item);
} else {
items.push.apply(items, nodeLists.flatten(item));
}
}
return items;
},
register: function (nodeList, unregistered, parent, directlyNested) {
nodeList.unregistered = unregistered;
nodeList.parentList = parent;
nodeList.nesting = parent && typeof parent.nesting !== 'undefined' ? parent.nesting + 1 : 0;
if (parent) {
nodeList.deepChildren = [];
nodeList.newDeepChildren = [];
nodeList.replacements = [];
if (parent !== true) {
if (directlyNested) {
parent.replacements.push(nodeList);
} else {
parent.newDeepChildren.push(nodeList);
}
}
} else {
nodeLists.nestList(nodeList);
}
return nodeList;
},
unregisterChildren: function (nodeList) {
var nodes = [];
for (var n = 0; n < nodeList.length; n++) {
var node = nodeList[n];
if (node.nodeType) {
if (!nodeList.replacements) {
nodeMap['delete'](node);
}
nodes.push(node);
} else {
push.apply(nodes, nodeLists.unregister(node, true));
}
}
var deepChildren = nodeList.deepChildren;
if (deepChildren) {
for (var l = 0; l < deepChildren.length; l++) {
nodeLists.unregister(deepChildren[l], true);
}
}
return nodes;
},
unregister: function (nodeList, isChild) {
var nodes = nodeLists.unregisterChildren(nodeList, true);
nodeList.isUnregistered = true;
if (nodeList.unregistered) {
var <API key> = nodeList.unregistered;
nodeList.replacements = nodeList.unregistered = null;
if (!isChild) {
var deepChildren = nodeList.parentList && nodeList.parentList.deepChildren;
if (deepChildren) {
var index = deepChildren.indexOf(nodeList);
if (index !== -1) {
deepChildren.splice(index, 1);
}
}
}
<API key>();
}
return nodes;
},
after: function (oldElements, newFrag) {
var last = oldElements[oldElements.length - 1];
if (last.nextSibling) {
domMutate.insertBefore.call(last.parentNode, newFrag, last.nextSibling);
} else {
domMutate.appendChild.call(last.parentNode, newFrag);
}
},
replace: function (oldElements, newFrag) {
var selectedValue, parentNode = oldElements[0].parentNode;
if (parentNode.nodeName.toUpperCase() === 'SELECT' && parentNode.selectedIndex >= 0) {
selectedValue = parentNode.value;
}
if (oldElements.length === 1) {
domMutate.replaceChild.call(parentNode, newFrag, oldElements[0]);
} else {
nodeLists.after(oldElements, newFrag);
nodeLists.remove(oldElements);
}
if (selectedValue !== undefined) {
parentNode.value = selectedValue;
}
},
remove: function (elementsToBeRemoved) {
var parent = elementsToBeRemoved[0] && elementsToBeRemoved[0].parentNode;
for (var i = 0; i < elementsToBeRemoved.length; i++) {
domMutate.removeChild.call(parent, elementsToBeRemoved[i]);
}
},
nodeMap: nodeMap
};
module.exports = namespace.nodeLists = nodeLists;
});
/*can-child-nodes@1.0.0#can-child-nodes*/
define('can-child-nodes', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
'use strict';
var namespace = require('can-namespace');
function childNodes(node) {
var childNodes = node.childNodes;
if ('length' in childNodes) {
return childNodes;
} else {
var cur = node.firstChild;
var nodes = [];
while (cur) {
nodes.push(cur);
cur = cur.nextSibling;
}
return nodes;
}
}
module.exports = namespace.childNodes = childNodes;
});
/*can-fragment@1.0.1#can-fragment*/
define('can-fragment', [
'require',
'exports',
'module',
'can-globals/document/document',
'can-namespace',
'can-reflect',
'can-child-nodes'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var getDocument = require('can-globals/document/document');
var namespace = require('can-namespace');
var canReflect = require('can-reflect');
var childNodes = require('can-child-nodes');
var fragmentRE = /^\s*<(\w+)[^>]*>/, toString = {}.toString;
function makeFragment(html, name, doc) {
if (name === undefined) {
name = fragmentRE.test(html) && RegExp.$1;
}
if (html && toString.call(html.replace) === '[object Function]') {
html = html.replace(/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, '<$1></$2>');
}
var container = doc.createElement('div'), temp = doc.createElement('div');
if (name === 'tbody' || name === 'tfoot' || name === 'thead' || name === 'colgroup') {
temp.innerHTML = '<table>' + html + '</table>';
container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild;
} else if (name === 'col') {
temp.innerHTML = '<table><colgroup>' + html + '</colgroup></table>';
container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild.firstChild;
} else if (name === 'tr') {
temp.innerHTML = '<table><tbody>' + html + '</tbody></table>';
container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild.firstChild;
} else if (name === 'td' || name === 'th') {
temp.innerHTML = '<table><tbody><tr>' + html + '</tr></tbody></table>';
container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild.firstChild.firstChild;
} else if (name === 'option') {
temp.innerHTML = '<select>' + html + '</select>';
container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild;
} else {
container.innerHTML = '' + html;
}
return [].slice.call(childNodes(container));
}
function fragment(html, doc) {
if (html && html.nodeType === 11) {
return html;
}
if (!doc) {
doc = getDocument();
} else if (doc.length) {
doc = doc[0];
}
var parts = makeFragment(html, undefined, doc), frag = (doc || document).<API key>();
for (var i = 0, length = parts.length; i < length; i++) {
frag.appendChild(parts[i]);
}
return frag;
}
var makeFrag = function (item, doc) {
var document = doc || getDocument();
var frag;
if (!item || typeof item === 'string') {
frag = fragment(item == null ? '' : '' + item, document);
} else if (item.nodeType === 11) {
return item;
} else if (typeof item.nodeType === 'number') {
frag = document.<API key>();
frag.appendChild(item);
return frag;
} else if (canReflect.isListLike(item)) {
frag = document.<API key>();
canReflect.eachIndex(item, function (item) {
frag.appendChild(makeFrag(item));
});
} else {
frag = fragment('' + item, document);
}
if (!childNodes(frag).length) {
frag.appendChild(document.createTextNode(''));
}
return frag;
};
module.exports = namespace.fragment = namespace.frag = makeFrag;
}(function () {
return this;
}(), require, exports, module));
});
/*can-view-callbacks@4.2.0#can-view-callbacks*/
define('can-view-callbacks', [
'require',
'exports',
'module',
'<API key>',
'can-log/dev/dev',
'can-globals/global/global',
'can-dom-mutate/node',
'can-namespace',
'can-view-nodelist',
'can-fragment',
'can-globals',
'can-symbol',
'can-reflect'
], function (require, exports, module) {
(function (global, require, exports, module) {
var ObservationRecorder = require('<API key>');
var dev = require('can-log/dev/dev');
var getGlobal = require('can-globals/global/global');
var domMutate = require('can-dom-mutate/node');
var namespace = require('can-namespace');
var nodeLists = require('can-view-nodelist');
var makeFrag = require('can-fragment');
var globals = require('can-globals');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var callbackMapSymbol = canSymbol.for('can.callbackMap');
if (process.env.NODE_ENV !== 'production') {
var requestedAttributes = {};
}
var tags = {};
var automountEnabled = function () {
return globals.getKeyValue('document').documentElement.getAttribute('data-can-automount') !== 'false';
};
var renderedElements = new WeakMap();
var <API key> = function (node) {
var tagName = node.tagName && node.tagName.toLowerCase();
var tagHandler = tags[tagName];
var children;
if (tagHandler && !renderedElements.has(node)) {
tagHandler(node, {});
}
if (node.<API key>) {
children = node.<API key>('*');
for (var k = 0, child; (child = children[k]) !== undefined; k++) {
<API key>(child);
}
}
};
var <API key> = false;
var <API key>;
var <API key> = function () {
if (<API key>) {
return;
}
var mutationHandler = function (mutationsList) {
var addedNodes;
for (var i = 0, mutation; (mutation = mutationsList[i]) !== undefined; i++) {
if (mutation.type === 'childList') {
addedNodes = mutation.addedNodes;
for (var j = 0, addedNode; (addedNode = addedNodes[j]) !== undefined; j++) {
if (!renderedElements.has(addedNode)) {
<API key>(addedNode);
}
}
}
}
};
var MutationObserver = globals.getKeyValue('MutationObserver');
if (MutationObserver) {
<API key> = new MutationObserver(mutationHandler);
<API key>.observe(getGlobal().document.documentElement, {
childList: true,
subtree: true
});
<API key> = true;
}
};
var <API key> = function (tagName) {
var nodes = getGlobal().document.<API key>(tagName);
for (var i = 0, node; (node = nodes[i]) !== undefined; i++) {
<API key>(node);
}
};
var attr = function (attributeName, attrHandler) {
if (attrHandler) {
if (typeof attributeName === 'string') {
attributes[attributeName] = attrHandler;
if (process.env.NODE_ENV !== 'production') {
if (requestedAttributes[attributeName]) {
dev.warn('can-view-callbacks: ' + attributeName + ' custom attribute behavior requested before it was defined. Make sure ' + attributeName + ' is defined before it is needed.');
}
}
} else {
regExpAttributes.push({
match: attributeName,
handler: attrHandler
});
if (process.env.NODE_ENV !== 'production') {
Object.keys(requestedAttributes).forEach(function (requested) {
if (attributeName.test(requested)) {
dev.warn('can-view-callbacks: ' + requested + ' custom attribute behavior requested before it was defined. Make sure ' + requested + ' is defined before it is needed.');
}
});
}
}
} else {
var cb = attributes[attributeName];
if (!cb) {
for (var i = 0, len = regExpAttributes.length; i < len; i++) {
var attrMatcher = regExpAttributes[i];
if (attrMatcher.match.test(attributeName)) {
return attrMatcher.handler;
}
}
}
if (process.env.NODE_ENV !== 'production') {
requestedAttributes[attributeName] = true;
}
return cb;
}
};
var attrs = function (attrMap) {
var map = canReflect.getKeyValue(attrMap, callbackMapSymbol) || attrMap;
if (attrMaps.has(map)) {
return;
} else {
attrMaps.set(map, true);
}
canReflect.eachKey(map, function (callback, exp) {
attr(exp, callback);
});
};
var attributes = {}, regExpAttributes = [], attrMaps = new WeakMap(), <API key> = /[-\:]/;
var defaultCallback = function () {
};
var tag = function (tagName, tagHandler) {
if (tagHandler) {
var GLOBAL = getGlobal();
var <API key> = <API key>.test(tagName), tagExists = typeof tags[tagName.toLowerCase()] !== 'undefined', customElementExists;
if (process.env.NODE_ENV !== 'production') {
if (tagExists) {
dev.warn('Custom tag: ' + tagName.toLowerCase() + ' is already defined');
}
if (!<API key> && tagName !== 'content') {
dev.warn('Custom tag: ' + tagName.toLowerCase() + ' hyphen missed');
}
}
if (GLOBAL.html5) {
GLOBAL.html5.elements += ' ' + tagName;
GLOBAL.html5.shivDocument();
}
tags[tagName.toLowerCase()] = tagHandler;
if (automountEnabled()) {
var customElements = globals.getKeyValue('customElements');
if (customElements) {
customElementExists = customElements.get(tagName.toLowerCase());
if (<API key> && !customElementExists) {
var CustomElement = function () {
return Reflect.construct(HTMLElement, [], CustomElement);
};
CustomElement.prototype = Object.create(HTMLElement.prototype);
CustomElement.prototype.connectedCallback = function () {
if (!renderedElements.has(this)) {
tags[tagName.toLowerCase()](this, {});
}
};
customElements.define(tagName, CustomElement);
}
} else {
<API key>();
<API key>(tagName);
}
} else if (<API key>) {
<API key>.disconnect();
}
} else {
var cb;
if (tagHandler === null) {
delete tags[tagName.toLowerCase()];
} else {
cb = tags[tagName.toLowerCase()];
}
if (!cb && <API key>.test(tagName)) {
cb = defaultCallback;
}
return cb;
}
};
var callbacks = {
_tags: tags,
_attributes: attributes,
_regExpAttributes: regExpAttributes,
defaultCallback: defaultCallback,
tag: tag,
attr: attr,
attrs: attrs,
tagHandler: function (el, tagName, tagData) {
var scope = tagData.scope, helperTagCallback = scope && scope.templateContext.tags.get(tagName), tagCallback = helperTagCallback || tags[tagName], res;
if (tagCallback) {
res = ObservationRecorder.ignore(tagCallback)(el, tagData);
renderedElements.set(el, true);
} else {
res = scope;
}
if (process.env.NODE_ENV !== 'production') {
if (!tagCallback) {
var GLOBAL = getGlobal();
var ceConstructor = GLOBAL.document.createElement(tagName).constructor;
if (ceConstructor === GLOBAL.HTMLElement || ceConstructor === GLOBAL.HTMLUnknownElement) {
dev.warn('can-view-callbacks: No custom element found for ' + tagName);
}
}
}
if (res && tagData.subtemplate) {
if (scope !== res) {
scope = scope.add(res);
}
var nodeList = nodeLists.register([], undefined, tagData.parentNodeList || true, false);
nodeList.expression = '<' + el.tagName + '>';
var result = tagData.subtemplate(scope, tagData.options, nodeList);
var frag = typeof result === 'string' ? makeFrag(result) : result;
domMutate.appendChild.call(el, frag);
}
}
};
namespace.view = namespace.view || {};
if (namespace.view.callbacks) {
throw new Error('You can\'t have two versions of can-view-callbacks, check your dependencies');
} else {
module.exports = namespace.view.callbacks = callbacks;
}
}(function () {
return this;
}(), require, exports, module));
});
/*can-view-target@4.0.1#can-view-target*/
define('can-view-target', [
'require',
'exports',
'module',
'can-globals/document/document',
'can-dom-mutate/node',
'can-namespace',
'can-globals/mutation-observer/mutation-observer'
], function (require, exports, module) {
(function (global, require, exports, module) {
var getDocument = require('can-globals/document/document');
var domMutate = require('can-dom-mutate/node');
var namespace = require('can-namespace');
var MUTATION_OBSERVER = require('can-globals/mutation-observer/mutation-observer');
var processNodes = function (nodes, paths, location, document) {
var frag = document.<API key>();
for (var i = 0, len = nodes.length; i < len; i++) {
var node = nodes[i];
frag.appendChild(processNode(node, paths, location.concat(i), document));
}
return frag;
}, keepsTextNodes = typeof document !== 'undefined' && function () {
var testFrag = document.<API key>();
var div = document.createElement('div');
div.appendChild(document.createTextNode(''));
div.appendChild(document.createTextNode(''));
testFrag.appendChild(div);
var cloned = testFrag.cloneNode(true);
return cloned.firstChild.childNodes.length === 2;
}(), clonesWork = typeof document !== 'undefined' && function () {
var el = document.createElement('a');
el.innerHTML = '<xyz></xyz>';
var clone = el.cloneNode(true);
var works = clone.innerHTML === '<xyz></xyz>';
var MO, observer;
if (works) {
el = document.<API key>();
el.appendChild(document.createTextNode('foo-bar'));
MO = MUTATION_OBSERVER();
if (MO) {
observer = new MO(function () {
});
observer.observe(document.documentElement, {
childList: true,
subtree: true
});
clone = el.cloneNode(true);
observer.disconnect();
} else {
clone = el.cloneNode(true);
}
return clone.childNodes.length === 1;
}
return works;
}(), namespacesWork = typeof document !== 'undefined' && !!document.createElementNS;
var cloneNode = clonesWork ? function (el) {
return el.cloneNode(true);
} : function (node) {
var document = node.ownerDocument;
var copy;
if (node.nodeType === 1) {
if (node.namespaceURI !== 'http:
copy = document.createElementNS(node.namespaceURI, node.nodeName);
} else {
copy = document.createElement(node.nodeName);
}
} else if (node.nodeType === 3) {
copy = document.createTextNode(node.nodeValue);
} else if (node.nodeType === 8) {
copy = document.createComment(node.nodeValue);
} else if (node.nodeType === 11) {
copy = document.<API key>();
}
if (node.attributes) {
var attributes = node.attributes;
for (var i = 0; i < attributes.length; i++) {
var attribute = attributes[i];
if (attribute && attribute.specified) {
domMutate.setAttribute.call(copy, attribute.nodeName || attribute.name, attribute.nodeValue || attribute.value);
}
}
}
if (node && node.firstChild) {
var child = node.firstChild;
while (child) {
copy.appendChild(cloneNode(child));
child = child.nextSibling;
}
}
return copy;
};
function processNode(node, paths, location, document) {
var callback, loc = location, nodeType = typeof node, el, p, i, len;
var getCallback = function () {
if (!callback) {
callback = {
path: location,
callbacks: []
};
paths.push(callback);
loc = [];
}
return callback;
};
if (nodeType === 'object') {
if (node.tag) {
if (namespacesWork && node.namespace) {
el = document.createElementNS(node.namespace, node.tag);
} else {
el = document.createElement(node.tag);
}
if (node.attrs) {
for (var attrName in node.attrs) {
var value = node.attrs[attrName];
if (typeof value === 'function') {
getCallback().callbacks.push({ callback: value });
} else {
domMutate.setAttribute.call(el, attrName, value);
}
}
}
if (node.attributes) {
for (i = 0, len = node.attributes.length; i < len; i++) {
getCallback().callbacks.push({ callback: node.attributes[i] });
}
}
if (node.children && node.children.length) {
if (callback) {
p = callback.paths = [];
} else {
p = paths;
}
el.appendChild(processNodes(node.children, p, loc, document));
}
} else if (node.comment) {
el = document.createComment(node.comment);
if (node.callbacks) {
for (i = 0, len = node.attributes.length; i < len; i++) {
getCallback().callbacks.push({ callback: node.callbacks[i] });
}
}
}
} else if (nodeType === 'string') {
el = document.createTextNode(node);
} else if (nodeType === 'function') {
if (keepsTextNodes) {
el = document.createTextNode('');
getCallback().callbacks.push({ callback: node });
} else {
el = document.createComment('~');
getCallback().callbacks.push({
callback: function () {
var el = document.createTextNode('');
domMutate.replaceChild.call(this.parentNode, el, this);
return node.apply(el, arguments);
}
});
}
}
return el;
}
function getCallbacks(el, pathData, elementCallbacks) {
var path = pathData.path, callbacks = pathData.callbacks, paths = pathData.paths, child = el, pathLength = path ? path.length : 0, pathsLength = paths ? paths.length : 0;
for (var i = 0; i < pathLength; i++) {
child = child.childNodes.item(path[i]);
}
for (i = 0; i < pathsLength; i++) {
getCallbacks(child, paths[i], elementCallbacks);
}
elementCallbacks.push({
element: child,
callbacks: callbacks
});
}
function hydrateCallbacks(callbacks, args) {
var len = callbacks.length, callbacksLength, callbackElement, callbackData;
for (var i = 0; i < len; i++) {
callbackData = callbacks[i];
callbacksLength = callbackData.callbacks.length;
callbackElement = callbackData.element;
for (var c = 0; c < callbacksLength; c++) {
callbackData.callbacks[c].callback.apply(callbackElement, args);
}
}
}
function makeTarget(nodes, doc) {
var paths = [];
var frag = processNodes(nodes, paths, [], doc || getDocument());
return {
paths: paths,
clone: frag,
hydrate: function () {
var cloned = cloneNode(this.clone);
var args = [];
for (var a = 0, ref = args.length = arguments.length; a < ref; a++) {
args[a] = arguments[a];
}
var callbacks = [];
for (var i = 0; i < paths.length; i++) {
getCallbacks(cloned, paths[i], callbacks);
}
hydrateCallbacks(callbacks, args);
return cloned;
}
};
}
makeTarget.keepsTextNodes = keepsTextNodes;
makeTarget.cloneNode = cloneNode;
namespace.view = namespace.view || {};
module.exports = namespace.view.target = makeTarget;
}(function () {
return this;
}(), require, exports, module));
});
/*can-simple-map@4.1.1#can-simple-map*/
define('can-simple-map', [
'require',
'exports',
'module',
'can-construct',
'can-event-queue/map/map',
'can-queues',
'<API key>',
'can-reflect',
'can-log/dev/dev',
'can-symbol'
], function (require, exports, module) {
var Construct = require('can-construct');
var eventQueue = require('can-event-queue/map/map');
var queues = require('can-queues');
var ObservationRecorder = require('<API key>');
var canReflect = require('can-reflect');
var dev = require('can-log/dev/dev');
var canSymbol = require('can-symbol');
var ensureMeta = function ensureMeta(obj) {
var metaSymbol = canSymbol.for('can.meta');
var meta = obj[metaSymbol];
if (!meta) {
meta = {};
canReflect.setKeyValue(obj, metaSymbol, meta);
}
return meta;
};
var SimpleMap = Construct.extend('SimpleMap', {
setup: function (initialData) {
this._data = {};
if (initialData && typeof initialData === 'object') {
this.attr(initialData);
}
},
attr: function (prop, value) {
var self = this;
if (arguments.length === 0) {
ObservationRecorder.add(this, 'can.keys');
var data = {};
canReflect.eachKey(this._data, function (value, prop) {
ObservationRecorder.add(this, prop);
data[prop] = value;
}, this);
return data;
} else if (arguments.length > 1) {
var had = this._data.hasOwnProperty(prop);
var old = this._data[prop];
this._data[prop] = value;
if (old !== value) {
if (typeof this._log === 'function') {
this._log(prop, value, old);
}
this.dispatch({
keyChanged: !had ? prop : undefined,
type: prop,
reasonLog: [
canReflect.getName(this) + '\'s',
prop,
'changed to',
value,
'from',
old
]
}, [
value,
old
]);
}
} else if (typeof prop === 'object') {
queues.batch.start();
canReflect.eachKey(prop, function (value, key) {
self.attr(key, value);
});
queues.batch.stop();
} else {
if (prop !== 'constructor') {
ObservationRecorder.add(this, prop);
return this._data[prop];
}
return this.constructor;
}
},
serialize: function () {
return canReflect.serialize(this, Map);
},
get: function () {
return this.attr.apply(this, arguments);
},
set: function () {
return this.attr.apply(this, arguments);
},
log: function (key) {
var quoteString = function quoteString(x) {
return typeof x === 'string' ? JSON.stringify(x) : x;
};
var meta = ensureMeta(this);
meta.allowedLogKeysSet = meta.allowedLogKeysSet || new Set();
if (key) {
meta.allowedLogKeysSet.add(key);
}
this._log = function (prop, current, previous, log) {
if (key && !meta.allowedLogKeysSet.has(prop)) {
return;
}
dev.log(canReflect.getName(this), '\n key ', quoteString(prop), '\n is ', quoteString(current), '\n was ', quoteString(previous));
};
}
});
eventQueue(SimpleMap.prototype);
canReflect.assignSymbols(SimpleMap.prototype, {
'can.isMapLike': true,
'can.isListLike': false,
'can.isValueLike': false,
'can.getKeyValue': SimpleMap.prototype.get,
'can.setKeyValue': SimpleMap.prototype.set,
'can.deleteKeyValue': function (prop) {
if (this._data.hasOwnProperty(prop)) {
var old = this._data[prop];
delete this._data[prop];
if (typeof this._log === 'function') {
this._log(prop, undefined, old);
}
this.dispatch({
keyChanged: prop,
type: prop,
reasonLog: [
canReflect.getName(this) + '\'s',
prop,
'deleted',
old
]
}, [
undefined,
old
]);
}
},
'can.<API key>': function () {
ObservationRecorder.add(this, 'can.keys');
return Object.keys(this._data);
},
'can.assignDeep': function (source) {
queues.batch.start();
canReflect.assignMap(this, source);
queues.batch.stop();
},
'can.updateDeep': function (source) {
queues.batch.start();
canReflect.updateMap(this, source);
queues.batch.stop();
},
'can.keyHasDependencies': function (key) {
return false;
},
'can.getKeyDependencies': function (key) {
return undefined;
},
'can.getName': function () {
return canReflect.getName(this.constructor) + '{}';
}
});
module.exports = SimpleMap;
});
/*can-view-scope@4.4.3#template-context*/
define('can-view-scope/template-context', [
'require',
'exports',
'module',
'can-simple-map'
], function (require, exports, module) {
var SimpleMap = require('can-simple-map');
var TemplateContext = function () {
this.vars = new SimpleMap({});
this.helpers = new SimpleMap({});
this.partials = new SimpleMap({});
this.tags = new SimpleMap({});
};
module.exports = TemplateContext;
});
/*can-view-scope@4.4.3#make-compute-like*/
define('can-view-scope/make-compute-like', [
'require',
'exports',
'module',
'<API key>',
'can-reflect'
], function (require, exports, module) {
var singleReference = require('<API key>');
var canReflect = require('can-reflect');
var Compute = function (newVal) {
if (arguments.length) {
return canReflect.setValue(this, newVal);
} else {
return canReflect.getValue(this);
}
};
module.exports = function (observable) {
var compute = Compute.bind(observable);
Object.defineProperty(compute, 'name', { value: 'Compute<' + canReflect.getName(observable) + '>' });
compute.on = compute.bind = compute.addEventListener = function (event, handler) {
var translationHandler = function (newVal, oldVal) {
handler.call(compute, { type: 'change' }, newVal, oldVal);
};
singleReference.set(handler, this, translationHandler);
observable.on(translationHandler);
};
compute.off = compute.unbind = compute.removeEventListener = function (event, handler) {
observable.off(singleReference.getAndDelete(handler, this));
};
canReflect.assignSymbols(compute, {
'can.getValue': function () {
return canReflect.getValue(observable);
},
'can.setValue': function (newVal) {
return canReflect.setValue(observable, newVal);
},
'can.onValue': function (handler, queue) {
return canReflect.onValue(observable, handler, queue);
},
'can.offValue': function (handler, queue) {
return canReflect.offValue(observable, handler, queue);
},
'can.<API key>': function () {
return canReflect.<API key>(observable);
},
'can.getPriority': function () {
return canReflect.getPriority(observable);
},
'can.setPriority': function (newPriority) {
canReflect.setPriority(observable, newPriority);
},
'can.isValueLike': true,
'can.isFunctionLike': false
});
compute.isComputed = true;
return compute;
};
});
/*<API key>@1.0.2#src/add-mutated-by*/
define('<API key>/src/add-mutated-by', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var <API key> = function <API key>() {
return {
keyDependencies: new Map(),
valueDependencies: new Set()
};
};
var makeRootRecord = function makeRootRecord() {
return {
<API key>: new Map(),
<API key>: <API key>()
};
};
module.exports = function (mutatedByMap) {
return function addMutatedBy(mutated, key, mutator) {
var gotKey = arguments.length === 3;
if (arguments.length === 2) {
mutator = key;
key = undefined;
}
if (!mutator.keyDependencies && !mutator.valueDependencies) {
mutator = { valueDependencies: new Set([mutator]) };
}
var root = mutatedByMap.get(mutated);
if (!root) {
root = makeRootRecord();
mutatedByMap.set(mutated, root);
}
if (gotKey && !root.<API key>.get(key)) {
root.<API key>.set(key, <API key>());
}
var dependencyRecord = gotKey ? root.<API key>.get(key) : root.<API key>;
if (mutator.valueDependencies) {
canReflect.addValues(dependencyRecord.valueDependencies, mutator.valueDependencies);
}
if (mutator.keyDependencies) {
canReflect.each(mutator.keyDependencies, function (keysSet, obj) {
var entry = dependencyRecord.keyDependencies.get(obj);
if (!entry) {
entry = new Set();
dependencyRecord.keyDependencies.set(obj, entry);
}
canReflect.addValues(entry, keysSet);
});
}
};
};
});
/*<API key>@1.0.2#src/delete-mutated-by*/
define('<API key>/src/delete-mutated-by', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
module.exports = function (mutatedByMap) {
return function deleteMutatedBy(mutated, key, mutator) {
var gotKey = arguments.length === 3;
var root = mutatedByMap.get(mutated);
if (arguments.length === 2) {
mutator = key;
key = undefined;
}
if (!mutator.keyDependencies && !mutator.valueDependencies) {
mutator = { valueDependencies: new Set([mutator]) };
}
var dependencyRecord = gotKey ? root.<API key>.get(key) : root.<API key>;
if (mutator.valueDependencies) {
canReflect.removeValues(dependencyRecord.valueDependencies, mutator.valueDependencies);
}
if (mutator.keyDependencies) {
canReflect.each(mutator.keyDependencies, function (keysSet, obj) {
var entry = dependencyRecord.keyDependencies.get(obj);
if (entry) {
canReflect.removeValues(entry, keysSet);
if (!entry.size) {
dependencyRecord.keyDependencies.delete(obj);
}
}
});
}
};
};
});
/*<API key>@1.0.2#src/is-function*/
define('<API key>/src/is-function', function (require, exports, module) {
module.exports = function isFunction(value) {
return typeof value === 'function';
};
});
/*<API key>@1.0.2#src/<API key>*/
define('<API key>/src/<API key>', [
'require',
'exports',
'module',
'can-symbol',
'can-reflect',
'<API key>/src/is-function'
], function (require, exports, module) {
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var isFunction = require('<API key>/src/is-function');
var <API key> = canSymbol.for('can.getWhatIChange');
var <API key> = canSymbol.for('can.getKeyDependencies');
var <API key> = canSymbol.for('can.<API key>');
var getKeyDependencies = function getKeyDependencies(obj, key) {
if (isFunction(obj[<API key>])) {
return canReflect.getKeyDependencies(obj, key);
}
};
var <API key> = function <API key>(obj) {
if (isFunction(obj[<API key>])) {
return canReflect.<API key>(obj);
}
};
var <API key> = function <API key>(mutatedByMap, obj, key) {
var root = mutatedByMap.get(obj);
var dependencyRecord;
if (root && root.<API key>.has(key)) {
dependencyRecord = root.<API key>.get(key);
}
return dependencyRecord;
};
var <API key> = function <API key>(mutatedByMap, obj) {
var result;
var root = mutatedByMap.get(obj);
if (root) {
var dependencyRecord = root.<API key>;
if (dependencyRecord.keyDependencies.size) {
result = result || {};
result.keyDependencies = dependencyRecord.keyDependencies;
}
if (dependencyRecord.valueDependencies.size) {
result = result || {};
result.valueDependencies = dependencyRecord.valueDependencies;
}
}
return result;
};
var getWhatIChange = function getWhatIChange(obj, key) {
if (isFunction(obj[<API key>])) {
var gotKey = arguments.length === 2;
return gotKey ? canReflect.getWhatIChange(obj, key) : canReflect.getWhatIChange(obj);
}
};
var isEmptyRecord = function isEmptyRecord(record) {
return record == null || !Object.keys(record).length || record.keyDependencies && !record.keyDependencies.size && (record.valueDependencies && !record.valueDependencies.size);
};
var getWhatChangesMe = function getWhatChangesMe(mutatedByMap, obj, key) {
var gotKey = arguments.length === 3;
var mutate = gotKey ? <API key>(mutatedByMap, obj, key) : <API key>(mutatedByMap, obj);
var derive = gotKey ? getKeyDependencies(obj, key) : <API key>(obj);
if (!isEmptyRecord(mutate) || !isEmptyRecord(derive)) {
return Object.assign({}, mutate ? { mutate: mutate } : null, derive ? { derive: derive } : null);
}
};
module.exports = function (mutatedByMap) {
return function getDependencyDataOf(obj, key) {
var gotKey = arguments.length === 2;
var whatChangesMe = gotKey ? getWhatChangesMe(mutatedByMap, obj, key) : getWhatChangesMe(mutatedByMap, obj);
var whatIChange = gotKey ? getWhatIChange(obj, key) : getWhatIChange(obj);
if (whatChangesMe || whatIChange) {
return Object.assign({}, whatIChange ? { whatIChange: whatIChange } : null, whatChangesMe ? { whatChangesMe: whatChangesMe } : null);
}
};
};
});
/*<API key>@1.0.2#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'<API key>/src/add-mutated-by',
'<API key>/src/delete-mutated-by',
'<API key>/src/<API key>'
], function (require, exports, module) {
var addMutatedBy = require('<API key>/src/add-mutated-by');
var deleteMutatedBy = require('<API key>/src/delete-mutated-by');
var getDependencyDataOf = require('<API key>/src/<API key>');
var mutatedByMap = new WeakMap();
module.exports = {
addMutatedBy: addMutatedBy(mutatedByMap),
deleteMutatedBy: deleteMutatedBy(mutatedByMap),
getDependencyDataOf: getDependencyDataOf(mutatedByMap)
};
});
/*can-stache-helpers@1.0.0#can-stache-helpers*/
define('can-stache-helpers', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
var namespace = require('can-namespace');
if (namespace.stacheHelpers) {
throw new Error('You can\'t have two versions of can-stache-helpers, check your dependencies');
} else {
module.exports = namespace.stacheHelpers = {};
}
});
/*can-view-scope@4.4.3#scope-key-data*/
define('can-view-scope/scope-key-data', [
'require',
'exports',
'module',
'can-observation',
'can-stache-key',
'can-assign',
'can-reflect',
'can-symbol',
'<API key>',
'can-view-scope/make-compute-like',
'<API key>',
'can-event-queue/value/value',
'can-stache-helpers'
], function (require, exports, module) {
'use strict';
var Observation = require('can-observation');
var observeReader = require('can-stache-key');
var assign = require('can-assign');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var ObservationRecorder = require('<API key>');
var makeComputeLike = require('can-view-scope/make-compute-like');
var canReflectDeps = require('<API key>');
var valueEventBindings = require('can-event-queue/value/value');
var stacheHelpers = require('can-stache-helpers');
var dispatchSymbol = canSymbol.for('can.dispatch');
var peekValue = ObservationRecorder.ignore(canReflect.getValue.bind(canReflect));
var getFastPathRoot = ObservationRecorder.ignore(function (computeData) {
if (computeData.reads && computeData.reads.length === 1) {
var root = computeData.root;
if (root && root[canSymbol.for('can.getValue')]) {
root = canReflect.getValue(root);
}
return root && canReflect.isObservableLike(root) && canReflect.isMapLike(root) && typeof root[computeData.reads[0].key] !== 'function' && root;
}
return;
});
var isEventObject = function (obj) {
return obj && typeof obj.batchNum === 'number' && typeof obj.type === 'string';
};
var ScopeKeyData = function (scope, key, options) {
this.startingScope = scope;
this.key = key;
this.read = this.read.bind(this);
this.dispatch = this.dispatch.bind(this);
if (key === 'debugger') {
this.startingScope = { _context: stacheHelpers };
this.read = function () {
var helperOptions = { scope: scope };
var debuggerHelper = stacheHelpers['debugger'];
return debuggerHelper(helperOptions);
};
}
Object.defineProperty(this.read, 'name', { value: canReflect.getName(this) + '.read' });
Object.defineProperty(this.dispatch, 'name', { value: canReflect.getName(this) + '.dispatch' });
var observation = this.observation = new Observation(this.read, this);
this.options = assign({ observation: this.observation }, options);
this.fastPath = undefined;
this.root = undefined;
this.initialValue = undefined;
this.reads = undefined;
this.setRoot = undefined;
this.thisArg = undefined;
this.parentHasKey = undefined;
var valueDependencies = new Set();
valueDependencies.add(observation);
this.dependencies = { valueDependencies: valueDependencies };
};
valueEventBindings(ScopeKeyData.prototype);
Object.assign(ScopeKeyData.prototype, {
constructor: ScopeKeyData,
dispatch: function dispatch(newVal) {
var old = this.value;
this.value = newVal;
this[dispatchSymbol].call(this, this.value, old);
},
onBound: function onBound() {
this.bound = true;
canReflect.onValue(this.observation, this.dispatch, 'notify');
var fastPathRoot = getFastPathRoot(this);
if (fastPathRoot) {
this.toFastPath(fastPathRoot);
}
this.value = peekValue(this.observation);
},
onUnbound: function onUnbound() {
this.bound = false;
canReflect.offValue(this.observation, this.dispatch, 'notify');
this.toSlowPath();
},
set: function (newVal) {
var root = this.root || this.setRoot;
if (root) {
observeReader.write(root, this.reads, newVal, this.options);
} else {
this.startingScope.set(this.key, newVal, this.options);
}
},
get: function () {
if (ObservationRecorder.isRecording()) {
ObservationRecorder.add(this);
if (!this.bound) {
Observation.temporarilyBind(this);
}
}
if (this.bound === true) {
return this.value;
} else {
return this.observation.get();
}
},
toFastPath: function (fastPathRoot) {
var self = this, observation = this.observation;
this.fastPath = true;
observation.dependencyChange = function (target, newVal) {
if (isEventObject(newVal)) {
throw 'no event objects!';
}
if (target === fastPathRoot && typeof newVal !== 'function') {
this.newVal = newVal;
} else {
self.toSlowPath();
}
return Observation.prototype.dependencyChange.apply(this, arguments);
};
observation.onBound = function () {
this.value = this.newVal;
};
},
toSlowPath: function () {
this.observation.dependencyChange = Observation.prototype.dependencyChange;
this.observation.onBound = Observation.prototype.onBound;
this.fastPath = false;
},
read: function () {
var data;
if (this.root) {
data = observeReader.read(this.root, this.reads, this.options);
canReflectDeps.deleteMutatedBy(this.thisArg || this.root, this.reads[this.reads.length - 1].key, this);
this.thisArg = data.parent;
canReflectDeps.addMutatedBy(this.thisArg || this.root, this.reads[this.reads.length - 1].key, { valueDependencies: new Set([this]) });
return data.value;
}
data = this.startingScope.read(this.key, this.options);
if (data.rootObserve) {
canReflectDeps.addMutatedBy(data.thisArg || data.rootObserve, data.reads[data.reads.length - 1].key, { valueDependencies: new Set([this]) });
}
this.scope = data.scope;
this.reads = data.reads;
this.root = data.rootObserve;
this.setRoot = data.setRoot;
this.thisArg = data.thisArg;
this.parentHasKey = data.parentHasKey;
return this.initialValue = data.value;
},
hasDependencies: function () {
return canReflect.<API key>(this.observation);
}
});
canReflect.assignSymbols(ScopeKeyData.prototype, {
'can.getValue': ScopeKeyData.prototype.get,
'can.setValue': ScopeKeyData.prototype.set,
'can.<API key>': ScopeKeyData.prototype.hasDependencies,
'can.<API key>': function () {
return this.dependencies;
},
'can.getPriority': function () {
return canReflect.getPriority(this.observation);
},
'can.setPriority': function (newPriority) {
canReflect.setPriority(this.observation, newPriority);
},
'can.getName': function () {
return canReflect.getName(this.constructor) + '{{' + this.key + '}}';
}
});
Object.defineProperty(ScopeKeyData.prototype, 'compute', {
get: function () {
var compute = makeComputeLike(this);
Object.defineProperty(this, 'compute', {
value: compute,
writable: false,
configurable: false
});
return compute;
},
configurable: true
});
module.exports = ScopeKeyData;
});
/*can-view-scope@4.4.3#compute_data*/
define('can-view-scope/compute_data', [
'require',
'exports',
'module',
'can-view-scope/scope-key-data'
], function (require, exports, module) {
'use strict';
var ScopeKeyData = require('can-view-scope/scope-key-data');
module.exports = function (scope, key, options) {
return new ScopeKeyData(scope, key, options || { args: [] });
};
});
/*can-view-scope@4.4.3#can-view-scope*/
define('can-view-scope', [
'require',
'exports',
'module',
'can-stache-key',
'<API key>',
'can-view-scope/template-context',
'can-view-scope/compute_data',
'can-assign',
'can-namespace',
'can-reflect',
'can-log/dev/dev',
'<API key>',
'can-stache-helpers'
], function (require, exports, module) {
(function (global, require, exports, module) {
var observeReader = require('can-stache-key');
var ObservationRecorder = require('<API key>');
var TemplateContext = require('can-view-scope/template-context');
var makeComputeData = require('can-view-scope/compute_data');
var assign = require('can-assign');
var namespace = require('can-namespace');
var canReflect = require('can-reflect');
var canLog = require('can-log/dev/dev');
var defineLazyValue = require('<API key>');
var stacheHelpers = require('can-stache-helpers');
function Scope(context, parent, meta) {
this._context = context;
this._parent = parent;
this._meta = meta || {};
this.__cache = {};
}
assign(Scope, {
read: observeReader.read,
keyInfo: function (attr) {
var info = {};
info.isDotSlash = attr.substr(0, 2) === './';
info.isThisDot = attr.substr(0, 5) === 'this.';
info.isThisAt = attr.substr(0, 5) === 'this@';
info.isInCurrentContext = info.isDotSlash || info.isThisDot || info.isThisAt;
info.isInParentContext = attr.substr(0, 3) === '../';
info.isCurrentContext = attr === '.' || attr === 'this';
info.isParentContext = attr === '..';
info.isScope = attr === 'scope';
info.isInScope = attr.substr(0, 6) === 'scope.' || attr.substr(0, 6) === 'scope@';
info.isContextBased = info.isInCurrentContext || info.isInParentContext || info.isCurrentContext || info.isParentContext;
return info;
}
});
assign(Scope.prototype, {
add: function (context, meta) {
if (context !== this._context) {
return new this.constructor(context, this, meta);
} else {
return this;
}
},
find: function (attr, options) {
return this.get(attr, assign({ currentScopeOnly: false }, options));
},
read: function (attr, options) {
options = options || {};
if (attr === './') {
attr = '.';
}
var keyInfo = Scope.keyInfo(attr);
if (keyInfo.isContextBased && (this._meta.notContext || this._meta.special)) {
return this._parent.read(attr, options);
}
var currentScopeOnly = 'currentScopeOnly' in options ? options.currentScopeOnly : true;
if (keyInfo.isInCurrentContext) {
currentScopeOnly = true;
attr = keyInfo.isDotSlash ? attr.substr(2) : attr.substr(5);
} else if ((keyInfo.isInParentContext || keyInfo.isParentContext) && this._parent) {
var parent = this._parent;
while (parent._meta.notContext || parent._meta.special) {
parent = parent._parent;
}
if (keyInfo.isParentContext) {
return observeReader.read(parent._context, [], options);
}
var parentValue = parent.read(attr.substr(3) || '.', options);
return assign(parentValue, { thisArg: parentValue.thisArg || parent._context });
} else if (keyInfo.isCurrentContext) {
return observeReader.read(this._context, [], options);
} else if (keyInfo.isScope) {
return { value: this };
}
var keyReads = observeReader.reads(attr);
var readValue;
if (keyInfo.isInScope) {
readValue = observeReader.read(this, keyReads.slice(1), options);
if (typeof readValue.value === 'undefined' && !readValue.parentHasKey) {
readValue = this.<API key>(attr.slice(6), options);
}
return assign(readValue, { thisArg: keyReads.length > 1 ? readValue.parent : undefined });
}
return this._read(keyReads, options, currentScopeOnly);
},
<API key>: function (key) {
return this._read([{
key: key,
at: false
}], { special: true });
},
<API key>: function (key, readOptions) {
var keyReads = observeReader.reads(key);
return observeReader.read(this.templateContext, keyReads, readOptions);
},
_read: function (keyReads, options, currentScopeOnly) {
var currentScope = this, currentContext, undefinedObserves = [], currentObserve, currentReads, setObserveDepth = -1, currentSetReads, currentSetObserve, readOptions = assign({
foundObservable: function (observe, nameIndex) {
currentObserve = observe;
currentReads = keyReads.slice(nameIndex);
},
earlyExit: function (parentValue, nameIndex) {
if (nameIndex > setObserveDepth || nameIndex === setObserveDepth && (typeof parentValue === 'object' && keyReads[nameIndex].key in parentValue)) {
currentSetObserve = currentObserve;
currentSetReads = currentReads;
setObserveDepth = nameIndex;
}
}
}, options);
var isRecording = ObservationRecorder.isRecording();
while (currentScope) {
currentContext = currentScope._context;
if ((!options || options.special !== true) && currentScope._meta.special) {
currentScope = currentScope._parent;
continue;
}
if (options && options.special && !currentScope._meta.special) {
currentScope = currentScope._parent;
continue;
}
if (currentContext !== null && (typeof currentContext === 'object' || typeof currentContext === 'function')) {
var getObserves = ObservationRecorder.trap();
var data = observeReader.read(currentContext, keyReads, readOptions);
var observes = getObserves();
if (data.value !== undefined || data.parentHasKey) {
if (!observes.length && isRecording) {
currentObserve = data.parent;
currentReads = keyReads.slice(keyReads.length - 1);
} else {
ObservationRecorder.addMany(observes);
}
return {
scope: currentScope,
rootObserve: currentObserve,
value: data.value,
reads: currentReads,
thisArg: keyReads.length > 1 ? data.parent : undefined,
parentHasKey: data.parentHasKey
};
} else {
undefinedObserves.push.apply(undefinedObserves, observes);
}
}
var <API key> = currentScope._parent && currentScope._parent._meta && !currentScope._parent._meta.notContext && !currentScope._parent._meta.special;
if (currentScopeOnly && <API key>) {
currentScope = null;
} else {
currentScope = currentScope._parent;
}
}
if (!(options && options.special)) {
var helper = this.getHelper(keyReads);
if (helper && helper.value) {
return helper;
}
}
ObservationRecorder.addMany(undefinedObserves);
return {
setRoot: currentSetObserve,
reads: currentSetReads,
value: undefined
};
},
getHelper: function (keyReads) {
var helper = observeReader.read(this.templateContext.helpers, keyReads, { proxyMethods: false });
if (!helper || !helper.value) {
helper = observeReader.read(stacheHelpers, keyReads, { proxyMethods: false });
}
return helper;
},
get: function (key, options) {
options = assign({ isArgument: true }, options);
var res = this.read(key, options);
return res.value;
},
peek: ObservationRecorder.ignore(function (key, options) {
return this.get(key, options);
}),
peak: ObservationRecorder.ignore(function (key, options) {
canLog.warn('peak is deprecated, please use peek instead');
return this.peek(key, options);
}),
getScope: function (tester) {
var scope = this;
while (scope) {
if (tester(scope)) {
return scope;
}
scope = scope._parent;
}
},
getContext: function (tester) {
var res = this.getScope(tester);
return res && res._context;
},
getTemplateContext: function () {
var lastScope;
var templateContext = this.getScope(function (scope) {
lastScope = scope;
return scope._context instanceof TemplateContext;
});
if (!templateContext) {
templateContext = new Scope(new TemplateContext());
lastScope._parent = templateContext;
}
return templateContext;
},
getRoot: function () {
var cur = this, child = this;
while (cur._parent) {
child = cur;
cur = cur._parent;
}
if (cur._context instanceof TemplateContext) {
cur = child;
}
return cur._context;
},
getViewModel: function () {
var vmScope = this.getScope(function (scope) {
return scope._meta.viewModel;
});
return vmScope && vmScope._context;
},
getTop: function () {
var top;
this.getScope(function (scope) {
if (scope._meta.viewModel) {
top = scope;
}
return false;
});
return top && top._context;
},
getPathsForKey: function getPathsForKey(key) {
var paths = {};
var getKeyDefinition = function (obj, key) {
if (!obj || typeof obj !== 'object') {
return {};
}
var keyExistsOnObj = key in obj;
var objHasKey = canReflect.hasKey(obj, key);
return {
isDefined: keyExistsOnObj || objHasKey,
isFunction: keyExistsOnObj && typeof obj[key] === 'function'
};
};
var reads = observeReader.reads(key);
var keyParts = reads.map(function (read) {
return read.key;
});
var scopeIndex = keyParts.indexOf('scope');
if (scopeIndex > -1) {
keyParts.splice(scopeIndex, 2);
}
var normalizedKey = keyParts.join('.');
var vm = this.getViewModel();
var vmKeyDefinition = getKeyDefinition(vm, normalizedKey);
if (vmKeyDefinition.isDefined) {
paths['scope.vm.' + normalizedKey + (vmKeyDefinition.isFunction ? '()' : '')] = vm;
}
var top = this.getTop();
var topKeyDefinition = getKeyDefinition(top, normalizedKey);
if (topKeyDefinition.isDefined) {
paths['scope.top.' + normalizedKey + (topKeyDefinition.isFunction ? '()' : '')] = top;
}
var cur = '';
this.getScope(function (scope) {
var canBeRead = !scope._meta.special && !scope._meta.notContext;
if (canBeRead) {
var <API key> = getKeyDefinition(scope._context, normalizedKey);
if (<API key>.isDefined) {
paths[cur + normalizedKey + (<API key>.isFunction ? '()' : '')] = scope._context;
}
cur += '../';
}
return false;
});
return paths;
},
hasKey: function hasKey(key) {
var reads = observeReader.reads(key);
var readValue;
if (reads[0].key === 'scope') {
readValue = observeReader.read(this, reads.slice(1), key);
} else {
readValue = observeReader.read(this._context, reads, key);
}
return readValue.foundLastParent && readValue.parentHasKey;
},
getDataForScopeSet: function getDataForScopeSet(key, options) {
var keyInfo = Scope.keyInfo(key), parent;
if (keyInfo.isCurrentContext) {
return {
parent: this._context,
how: 'setValue'
};
} else if (keyInfo.isInParentContext || keyInfo.isParentContext) {
parent = this._parent;
while (parent._meta.notContext) {
parent = parent._parent;
}
if (keyInfo.isParentContext) {
return {
parent: parent._context,
how: 'setValue'
};
}
return {
how: 'set',
parent: parent,
passOptions: true,
key: key.substr(3) || '.'
};
}
var dotIndex = key.lastIndexOf('.'), slashIndex = key.lastIndexOf('/'), contextPath, propName;
if (slashIndex > dotIndex) {
contextPath = key.substring(0, slashIndex);
propName = key.substring(slashIndex + 1, key.length);
} else {
if (dotIndex !== -1) {
contextPath = key.substring(0, dotIndex);
propName = key.substring(dotIndex + 1, key.length);
} else {
contextPath = '.';
propName = key;
}
}
var context = this.read(contextPath, options).value;
if (context === undefined) {
return { error: 'Attempting to set a value at ' + key + ' where ' + contextPath + ' is undefined.' };
}
if (!canReflect.isObservableLike(context) && canReflect.isObservableLike(context[propName])) {
if (canReflect.isMapLike(context[propName])) {
return {
parent: context,
key: propName,
how: 'updateDeep',
warn: 'can-view-scope: Merging data into "' + propName + '" because its parent is non-observable'
};
} else if (canReflect.isValueLike(context[propName])) {
return {
parent: context,
key: propName,
how: 'setValue'
};
} else {
return {
parent: context,
how: 'write',
key: propName,
passOptions: true
};
}
} else {
return {
parent: context,
how: 'write',
key: propName,
passOptions: true
};
}
},
set: function (key, value, options) {
options = options || {};
var data = this.getDataForScopeSet(key, options);
var parent = data.parent;
if (data.error) {
return canLog.error(data.error);
}
if (data.warn) {
canLog.warn(data.warn);
}
switch (data.how) {
case 'set':
parent.set(data.key, value, data.passOptions ? options : undefined);
break;
case 'write':
observeReader.write(parent, data.key, value, options);
break;
case 'setValue':
canReflect.setValue('key' in data ? parent[data.key] : parent, value);
break;
case 'setKeyValue':
canReflect.setKeyValue(parent, data.key, value);
break;
case 'updateDeep':
canReflect.updateDeep(parent[data.key], value);
break;
}
},
attr: ObservationRecorder.ignore(function (key, value, options) {
canLog.warn('can-view-scope::attr is deprecated, please use peek, get or set');
options = assign({ isArgument: true }, options);
if (arguments.length === 2) {
return this.set(key, value, options);
} else {
return this.get(key, options);
}
}),
computeData: function (key, options) {
return makeComputeData(this, key, options);
},
compute: function (key, options) {
return this.computeData(key, options).compute;
},
cloneFromRef: function () {
var contexts = [];
var scope = this, context, parent;
while (scope) {
context = scope._context;
if (context instanceof TemplateContext) {
parent = scope._parent;
break;
}
contexts.unshift(context);
scope = scope._parent;
}
if (parent) {
contexts.forEach(function (context) {
parent = parent.add(context);
});
return parent;
} else {
return this;
}
}
});
canReflect.assignSymbols(Scope.prototype, { 'can.hasKey': Scope.prototype.hasKey });
var <API key> = [
'filename',
'lineNumber'
];
<API key>.forEach(function (key) {
Object.defineProperty(Scope.prototype, key, {
get: function () {
return this.<API key>(key).value;
},
set: function (val) {
this.templateContext[key] = val;
}
});
});
defineLazyValue(Scope.prototype, 'templateContext', function () {
return this.getTemplateContext()._context;
});
defineLazyValue(Scope.prototype, 'root', function () {
canLog.warn('`scope.root` is deprecated. Use either `scope.top` or `scope.vm` instead.');
return this.getRoot();
});
defineLazyValue(Scope.prototype, 'vm', function () {
return this.getViewModel();
});
defineLazyValue(Scope.prototype, 'top', function () {
return this.getTop();
});
defineLazyValue(Scope.prototype, 'helpers', function () {
return stacheHelpers;
});
var specialKeywords = [
'index',
'key',
'element',
'event',
'viewModel',
'arguments',
'helperOptions'
];
specialKeywords.forEach(function (key) {
Object.defineProperty(Scope.prototype, key, {
get: function () {
return this.<API key>(key).value;
}
});
});
namespace.view = namespace.view || {};
module.exports = namespace.view.Scope = Scope;
}(function () {
return this;
}(), require, exports, module));
});
/*<API key>@2.0.4#log*/
define('<API key>/log', [
'require',
'exports',
'module',
'can-log/dev/dev',
'can-reflect'
], function (require, exports, module) {
var dev = require('can-log/dev/dev');
var canReflect = require('can-reflect');
function quoteString(x) {
return typeof x === 'string' ? JSON.stringify(x) : x;
}
module.exports = function log() {
this._log = function (previous, current) {
dev.log(canReflect.getName(this), '\n is ', quoteString(current), '\n was ', quoteString(previous));
};
};
});
/*<API key>@2.0.4#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'<API key>/log',
'can-namespace',
'can-symbol',
'can-reflect',
'<API key>',
'can-event-queue/value/value'
], function (require, exports, module) {
var log = require('<API key>/log');
var ns = require('can-namespace');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var ObservationRecorder = require('<API key>');
var valueEventBindings = require('can-event-queue/value/value');
var dispatchSymbol = canSymbol.for('can.dispatch');
function SimpleObservable(initialValue) {
this.value = initialValue;
}
valueEventBindings(SimpleObservable.prototype);
Object.assign(SimpleObservable.prototype, {
log: log,
get: function () {
ObservationRecorder.add(this);
return this.value;
},
set: function (value) {
var old = this.value;
this.value = value;
this[dispatchSymbol](value, old);
}
});
canReflect.assignSymbols(SimpleObservable.prototype, {
'can.getValue': SimpleObservable.prototype.get,
'can.setValue': SimpleObservable.prototype.set,
'can.isMapLike': false,
'can.<API key>': function () {
return true;
},
'can.getName': function () {
var value = this.value;
if (typeof value !== 'object' || value === null) {
value = JSON.stringify(value);
} else {
value = '';
}
return canReflect.getName(this.constructor) + '<' + value + '>';
}
});
module.exports = ns.SimpleObservable = SimpleObservable;
});
/*<API key>@2.0.4#settable/settable*/
define('<API key>/settable/settable', [
'require',
'exports',
'module',
'can-reflect',
'<API key>',
'<API key>',
'can-observation',
'can-queues',
'<API key>/log',
'can-event-queue/value/value'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var ObservationRecorder = require('<API key>');
var SimpleObservable = require('<API key>');
var Observation = require('can-observation');
var queues = require('can-queues');
var log = require('<API key>/log');
var valueEventBindings = require('can-event-queue/value/value');
var peek = ObservationRecorder.ignore(canReflect.getValue.bind(canReflect));
function SettableObservable(fn, context, initialValue) {
this.lastSetValue = new SimpleObservable(initialValue);
function observe() {
return fn.call(context, this.lastSetValue.get());
}
this.handler = this.handler.bind(this);
canReflect.assignSymbols(this, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '<' + canReflect.getName(fn) + '>';
}
});
Object.defineProperty(this.handler, 'name', { value: canReflect.getName(this) + '.handler' });
Object.defineProperty(observe, 'name', { value: canReflect.getName(fn) + '::' + canReflect.getName(this.constructor) });
this.observation = new Observation(observe, this);
}
valueEventBindings(SettableObservable.prototype);
Object.assign(SettableObservable.prototype, {
log: log,
constructor: SettableObservable,
handler: function (newVal) {
var old = this.value;
this.value = newVal;
if (typeof this._log === 'function') {
this._log(old, newVal);
}
queues.enqueueByQueue(this.handlers.getNode([]), this, [
newVal,
old
], function () {
return {};
});
},
onBound: function () {
if (!this.bound) {
this.bound = true;
this.activate();
}
},
activate: function () {
canReflect.onValue(this.observation, this.handler, 'notify');
this.value = peek(this.observation);
},
onUnbound: function () {
this.bound = false;
canReflect.offValue(this.observation, this.handler, 'notify');
},
set: function (newVal) {
var oldVal = this.lastSetValue.get();
if (canReflect.isObservableLike(oldVal) && canReflect.isValueLike(oldVal) && !canReflect.isObservableLike(newVal)) {
canReflect.setValue(oldVal, newVal);
} else {
if (newVal !== oldVal) {
this.lastSetValue.set(newVal);
}
}
},
get: function () {
if (ObservationRecorder.isRecording()) {
ObservationRecorder.add(this);
if (!this.bound) {
this.onBound();
}
}
if (this.bound === true) {
return this.value;
} else {
return this.observation.get();
}
},
hasDependencies: function () {
return canReflect.<API key>(this.observation);
},
<API key>: function () {
return canReflect.<API key>(this.observation);
}
});
canReflect.assignSymbols(SettableObservable.prototype, {
'can.getValue': SettableObservable.prototype.get,
'can.setValue': SettableObservable.prototype.set,
'can.isMapLike': false,
'can.getPriority': function () {
return canReflect.getPriority(this.observation);
},
'can.setPriority': function (newPriority) {
canReflect.setPriority(this.observation, newPriority);
},
'can.<API key>': SettableObservable.prototype.hasDependencies,
'can.<API key>': SettableObservable.prototype.<API key>
});
module.exports = SettableObservable;
});
/*can-stache@4.8.0#src/key-observable*/
define('can-stache/src/key-observable', [
'require',
'exports',
'module',
'<API key>/settable/settable',
'can-stache-key'
], function (require, exports, module) {
var SettableObservable = require('<API key>/settable/settable');
var stacheKey = require('can-stache-key');
function KeyObservable(root, key) {
key = '' + key;
this.key = key;
this.root = root;
SettableObservable.call(this, function () {
return stacheKey.get(this, key);
}, root);
}
KeyObservable.prototype = Object.create(SettableObservable.prototype);
KeyObservable.prototype.set = function (newVal) {
stacheKey.set(this.root, this.key, newVal);
};
module.exports = KeyObservable;
});
/*can-stache@4.8.0#src/utils*/
define('can-stache/src/utils', [
'require',
'exports',
'module',
'can-view-scope',
'<API key>',
'can-stache-key',
'can-reflect',
'can-stache/src/key-observable'
], function (require, exports, module) {
var Scope = require('can-view-scope');
var ObservationRecorder = require('<API key>');
var observationReader = require('can-stache-key');
var canReflect = require('can-reflect');
var KeyObservable = require('can-stache/src/key-observable');
var createNoOpRenderer = function (metadata) {
return function noop() {
if (metadata) {
metadata.rendered = true;
}
};
};
module.exports = {
last: function (arr) {
return arr != null && arr[arr.length - 1];
},
emptyHandler: function () {
},
jsonParse: function (str) {
if (str[0] === '\'') {
return str.substr(1, str.length - 2);
} else if (str === 'undefined') {
return undefined;
} else {
return JSON.parse(str);
}
},
mixins: {
last: function () {
return this.stack[this.stack.length - 1];
},
add: function (chars) {
this.last().add(chars);
},
subSectionDepth: function () {
return this.stack.length - 1;
}
},
createRenderers: function (helperOptions, scope, nodeList, truthyRenderer, falseyRenderer, isStringOnly) {
helperOptions.fn = truthyRenderer ? this.<API key>(truthyRenderer, scope, nodeList, isStringOnly, helperOptions.metadata) : createNoOpRenderer(helperOptions.metadata);
helperOptions.inverse = falseyRenderer ? this.<API key>(falseyRenderer, scope, nodeList, isStringOnly, helperOptions.metadata) : createNoOpRenderer(helperOptions.metadata);
helperOptions.isSection = !!(truthyRenderer || falseyRenderer);
},
<API key>: function (renderer, parentScope, nodeList, observeObservables, metadata) {
var convertedRenderer = function (newScope, newOptions, parentNodeList) {
if (newScope !== undefined && !(newScope instanceof Scope)) {
if (parentScope) {
newScope = parentScope.add(newScope);
} else {
newScope = new Scope(newScope || {});
}
}
if (metadata) {
metadata.rendered = true;
}
var result = renderer(newScope || parentScope, parentNodeList || nodeList);
return result;
};
return observeObservables ? convertedRenderer : ObservationRecorder.ignore(convertedRenderer);
},
<API key>: function (items, isObserveList, helperOptions) {
var txt = '', len = observationReader.get(items, 'length'), isObservable = canReflect.isObservableLike(items);
for (var i = 0; i < len; i++) {
var item = isObservable ? new KeyObservable(items, i) : items[i];
txt += helperOptions.fn(item);
}
return txt;
},
getItemsFragContent: function (items, helperOptions, scope) {
var result = [], len = observationReader.get(items, 'length'), isObservable = canReflect.isObservableLike(items), hashExprs = helperOptions.exprData && helperOptions.exprData.hashExprs, hashOptions;
if (canReflect.size(hashExprs) > 0) {
hashOptions = {};
canReflect.eachKey(hashExprs, function (exprs, key) {
hashOptions[exprs.key] = key;
});
}
for (var i = 0; i < len; i++) {
var aliases = {};
var item = isObservable ? new KeyObservable(items, i) : items[i];
if (canReflect.size(hashOptions) > 0) {
if (hashOptions.value) {
aliases[hashOptions.value] = item;
}
if (hashOptions.index) {
aliases[hashOptions.index] = i;
}
}
result.push(helperOptions.fn(scope.add(aliases, { notContext: true }).add({ index: i }, { special: true }).add(item)));
}
return result;
}
};
});
/*can-stache@4.8.0#src/html_section*/
define('can-stache/src/html_section', [
'require',
'exports',
'module',
'can-view-target',
'can-view-scope',
'<API key>',
'can-reflect',
'can-stache/src/utils',
'can-globals/document/document',
'can-assign'
], function (require, exports, module) {
(function (global, require, exports, module) {
var target = require('can-view-target');
var Scope = require('can-view-scope');
var ObservationRecorder = require('<API key>');
var canReflect = require('can-reflect');
var utils = require('can-stache/src/utils');
var getDocument = require('can-globals/document/document');
var assign = require('can-assign');
var last = utils.last;
var decodeHTML = typeof document !== 'undefined' && function () {
var el = getDocument().createElement('div');
return function (html) {
if (html.indexOf('&') === -1) {
return html.replace(/\r\n/g, '\n');
}
el.innerHTML = html;
return el.childNodes.length === 0 ? '' : el.childNodes.item(0).nodeValue;
};
}();
var HTMLSectionBuilder = function (filename) {
if (filename) {
this.filename = filename;
}
this.stack = [new HTMLSection()];
};
HTMLSectionBuilder.scopify = function (renderer) {
return ObservationRecorder.ignore(function (scope, options, nodeList) {
if (!(scope instanceof Scope)) {
scope = new Scope(scope || {});
}
if (nodeList === undefined && canReflect.isListLike(options)) {
nodeList = options;
options = undefined;
}
if (options && !options.helpers && !options.partials && !options.tags) {
options = { helpers: options };
}
canReflect.eachKey(options && options.helpers, function (helperValue) {
helperValue.<API key> = true;
});
var templateContext = scope.templateContext;
canReflect.eachKey(options, function (optionValues, optionKey) {
var container = templateContext[optionKey];
if (container) {
canReflect.eachKey(optionValues, function (optionValue, optionValueKey) {
canReflect.setKeyValue(container, optionValueKey, optionValue);
});
}
});
return renderer(scope, nodeList);
});
};
assign(HTMLSectionBuilder.prototype, utils.mixins);
assign(HTMLSectionBuilder.prototype, {
startSubSection: function (process) {
var newSection = new HTMLSection(process);
this.stack.push(newSection);
return newSection;
},
<API key>: function () {
if (this.last().isEmpty()) {
this.stack.pop();
return null;
} else {
var htmlSection = this.endSection();
return htmlSection.compiled.hydrate.bind(htmlSection.compiled);
}
},
startSection: function (process) {
var newSection = new HTMLSection(process);
this.last().add(newSection.targetCallback);
this.stack.push(newSection);
},
endSection: function () {
this.last().compile();
return this.stack.pop();
},
inverse: function () {
this.last().inverse();
},
compile: function () {
var compiled = this.stack.pop().compile();
return ObservationRecorder.ignore(function (scope, nodeList) {
if (!(scope instanceof Scope)) {
scope = new Scope(scope || {});
}
return compiled.hydrate(scope, nodeList);
});
},
push: function (chars) {
this.last().push(chars);
},
pop: function () {
return this.last().pop();
},
removeCurrentNode: function () {
this.last().removeCurrentNode();
}
});
var HTMLSection = function (process) {
this.data = 'targetData';
this.targetData = [];
this.targetStack = [];
var self = this;
this.targetCallback = function (scope, sectionNode) {
process.call(this, scope, sectionNode, self.compiled.hydrate.bind(self.compiled), self.inverseCompiled && self.inverseCompiled.hydrate.bind(self.inverseCompiled));
};
};
assign(HTMLSection.prototype, {
inverse: function () {
this.inverseData = [];
this.data = 'inverseData';
},
push: function (data) {
this.add(data);
this.targetStack.push(data);
},
pop: function () {
return this.targetStack.pop();
},
add: function (data) {
if (typeof data === 'string') {
data = decodeHTML(data);
}
if (this.targetStack.length) {
last(this.targetStack).children.push(data);
} else {
this[this.data].push(data);
}
},
compile: function () {
this.compiled = target(this.targetData, getDocument());
if (this.inverseData) {
this.inverseCompiled = target(this.inverseData, getDocument());
delete this.inverseData;
}
this.targetStack = this.targetData = null;
return this.compiled;
},
removeCurrentNode: function () {
var children = this.children();
return children.pop();
},
children: function () {
if (this.targetStack.length) {
return last(this.targetStack).children;
} else {
return this[this.data];
}
},
isEmpty: function () {
return !this.targetData.length;
}
});
HTMLSectionBuilder.HTMLSection = HTMLSection;
module.exports = HTMLSectionBuilder;
}(function () {
return this;
}(), require, exports, module));
});
/*can-view-live@4.1.4#lib/core*/
define('can-view-live/lib/core', [
'require',
'exports',
'module',
'can-view-parser',
'can-dom-mutate',
'can-view-nodelist',
'can-fragment',
'can-child-nodes',
'can-reflect',
'<API key>'
], function (require, exports, module) {
var parser = require('can-view-parser');
var domMutate = require('can-dom-mutate');
var nodeLists = require('can-view-nodelist');
var makeFrag = require('can-fragment');
var childNodes = require('can-child-nodes');
var canReflect = require('can-reflect');
var canReflectDeps = require('<API key>');
var live = {
setup: function (el, bind, unbind) {
var tornDown = false, removalDisposal, data, teardown = function () {
if (!tornDown) {
tornDown = true;
unbind(data);
if (removalDisposal) {
removalDisposal();
removalDisposal = undefined;
}
}
return true;
};
data = {
teardownCheck: function (parent) {
return parent ? false : teardown();
}
};
removalDisposal = domMutate.onNodeRemoval(el, function () {
if (!el.ownerDocument.contains(el)) {
teardown();
}
});
bind(data);
return data;
},
listen: function (el, compute, change, queueName) {
return live.setup(el, function bind() {
canReflect.onValue(compute, change, queueName || 'notify');
canReflectDeps.addMutatedBy(el, compute);
}, function unbind(data) {
canReflect.offValue(compute, change, queueName || 'notify');
canReflectDeps.deleteMutatedBy(el, compute);
if (data.nodeList) {
nodeLists.unregister(data.nodeList);
}
});
},
getAttributeParts: function (newVal) {
var attrs = {}, attr;
parser.parseAttrs(newVal, {
attrStart: function (name) {
attrs[name] = '';
attr = name;
},
attrValue: function (value) {
attrs[attr] += value;
},
attrEnd: function () {
}
});
return attrs;
},
isNode: function (obj) {
return obj && obj.nodeType;
},
<API key>: function (frag) {
if (!frag.firstChild) {
frag.appendChild(frag.ownerDocument.createTextNode(''));
}
},
replace: function (nodes, val, teardown) {
var oldNodes = nodes.slice(0), frag = makeFrag(val);
nodeLists.register(nodes, teardown);
nodeLists.update(nodes, childNodes(frag));
nodeLists.replace(oldNodes, frag);
return nodes;
},
getParentNode: function (el, defaultParentNode) {
return defaultParentNode && el.parentNode.nodeType === 11 ? defaultParentNode : el.parentNode;
},
makeString: function (txt) {
return txt == null ? '' : '' + txt;
}
};
module.exports = live;
});
/*can-dom-data-state@1.0.1#can-dom-data-state*/
define('can-dom-data-state', [
'require',
'exports',
'module',
'can-namespace',
'can-dom-mutate',
'can-cid'
], function (require, exports, module) {
'use strict';
var namespace = require('can-namespace');
var domMutate = require('can-dom-mutate');
var CID = require('can-cid');
var isEmptyObject = function (obj) {
for (var prop in obj) {
return false;
}
return true;
};
var data = {};
var removedDisposalMap = {};
var deleteNode = function () {
var id = CID.get(this);
var nodeDeleted = false;
if (id && data[id]) {
nodeDeleted = true;
delete data[id];
}
if (removedDisposalMap[id]) {
removedDisposalMap[id]();
delete removedDisposalMap[id];
}
return nodeDeleted;
};
var setData = function (name, value) {
var id = CID(this);
var store = data[id] || (data[id] = {});
if (name !== undefined) {
store[name] = value;
var isNode = !!(this && typeof this.nodeType === 'number');
if (isNode && !removedDisposalMap[id]) {
var target = this;
removedDisposalMap[id] = domMutate.onNodeRemoval(target, function () {
if (!target.ownerDocument.contains(target)) {
setTimeout(function () {
deleteNode(target);
}, 13);
}
});
}
}
return store;
};
var domDataState = {
_data: data,
_removalDisposalMap: removedDisposalMap,
getCid: function () {
return CID.get(this);
},
cid: function () {
return CID(this);
},
expando: CID.domExpando,
get: function (key) {
var id = CID.get(this), store = id && data[id];
return key === undefined ? store : store && store[key];
},
set: setData,
clean: function (prop) {
var id = CID.get(this);
var itemData = data[id];
if (itemData && itemData[prop]) {
delete itemData[prop];
}
if (isEmptyObject(itemData)) {
deleteNode.call(this);
}
},
delete: deleteNode
};
if (namespace.domDataState) {
throw new Error('You can\'t have two versions of can-dom-data-state, check your dependencies');
} else {
module.exports = namespace.domDataState = domDataState;
}
});
/*<API key>@0.3.1#behaviors*/
define('<API key>/behaviors', [
'require',
'exports',
'module',
'can-globals/document/document',
'can-globals/global/global',
'can-dom-data-state',
'can-dom-events',
'can-dom-mutate',
'can-dom-mutate/node',
'can-globals/mutation-observer/mutation-observer',
'can-diff/list/list'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var getDocument = require('can-globals/document/document');
var global = require('can-globals/global/global')();
var setData = require('can-dom-data-state');
var domEvents = require('can-dom-events');
var domMutate = require('can-dom-mutate');
var domMutateNode = require('can-dom-mutate/node');
var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
var diff = require('can-diff/list/list');
var formElements = {
'INPUT': true,
'TEXTAREA': true,
'SELECT': true
}, toString = function (value) {
if (value == null) {
return '';
} else {
return '' + value;
}
}, isSVG = function (el) {
return el.namespaceURI === 'http:
}, truthy = function () {
return true;
}, getSpecialTest = function (special) {
return special && special.test || truthy;
}, propProp = function (prop, obj) {
obj = obj || {};
obj.get = function () {
return this[prop];
};
obj.set = function (value) {
if (this[prop] !== value) {
this[prop] = value;
}
return value;
};
return obj;
}, booleanProp = function (prop) {
return {
isBoolean: true,
set: function (value) {
if (prop in this) {
this[prop] = value !== false;
} else {
domMutateNode.setAttribute.call(this, prop, '');
}
},
remove: function () {
this[prop] = false;
}
};
}, setupMO = function (el, callback) {
var attrMO = setData.get.call(el, 'attrMO');
if (!attrMO) {
var onMutation = function () {
callback.call(el);
};
var MO = getMutationObserver();
if (MO) {
var observer = new MO(onMutation);
observer.observe(el, {
childList: true,
subtree: true
});
setData.set.call(el, 'attrMO', observer);
} else {
setData.set.call(el, 'attrMO', true);
setData.set.call(el, 'canBindingCallback', { onMutation: onMutation });
}
}
}, _findOptionToSelect = function (parent, value) {
var child = parent.firstChild;
while (child) {
if (child.nodeName === 'OPTION' && value === child.value) {
return child;
}
if (child.nodeName === 'OPTGROUP') {
var groupChild = _findOptionToSelect(child, value);
if (groupChild) {
return groupChild;
}
}
child = child.nextSibling;
}
}, setChildOptions = function (el, value) {
var option;
if (value != null) {
option = _findOptionToSelect(el, value);
}
if (option) {
option.selected = true;
} else {
el.selectedIndex = -1;
}
}, forEachOption = function (parent, fn) {
var child = parent.firstChild;
while (child) {
if (child.nodeName === 'OPTION') {
fn(child);
}
if (child.nodeName === 'OPTGROUP') {
forEachOption(child, fn);
}
child = child.nextSibling;
}
}, <API key> = function (parent) {
var selectedValues = [];
forEachOption(parent, function (option) {
if (option.selected) {
selectedValues.push(option.value);
}
});
return selectedValues;
}, markSelectedOptions = function (parent, values) {
forEachOption(parent, function (option) {
option.selected = values.indexOf(option.value) !== -1;
});
}, <API key> = function (select, aEL) {
var handler = setData.get.call(select, 'attrSetChildOptions');
if (handler) {
return Function.prototype;
}
handler = function () {
setChildOptions(select, select.value);
};
setData.set.call(select, 'attrSetChildOptions', handler);
aEL.call(select, 'change', handler);
return function (rEL) {
setData.clean.call(select, 'attrSetChildOptions');
rEL.call(select, 'change', handler);
};
}, behaviorRules = new Map([]), isPropWritable = function (el, prop) {
var desc = Object.<API key>(el.constructor.prototype, prop);
if (desc) {
return desc.writable || desc.set;
} else {
var proto = Object.getPrototypeOf(el);
if (proto) {
return isPropWritable(proto, prop);
}
}
return false;
}, cacheRule = function (el, attrOrPropName, rule) {
var rulesForElementType;
rulesForElementType = behaviorRules.get(el.prototype);
if (!rulesForElementType) {
rulesForElementType = {};
behaviorRules.set(el.constructor, rulesForElementType);
}
rulesForElementType[attrOrPropName] = rule;
return rule;
};
var specialAttributes = {
checked: {
get: function () {
return this.checked;
},
set: function (val) {
var notFalse = !!val || val === '' || arguments.length === 0;
this.checked = notFalse;
if (notFalse && this.type === 'radio') {
this.defaultChecked = true;
}
return val;
},
remove: function () {
this.checked = false;
},
test: function () {
return this.nodeName === 'INPUT';
}
},
'class': {
get: function () {
if (isSVG(this)) {
return this.getAttribute('class');
}
return this.className;
},
set: function (val) {
val = val || '';
if (isSVG(this)) {
domMutateNode.setAttribute.call(this, 'class', '' + val);
} else {
this.className = val;
}
return val;
}
},
disabled: booleanProp('disabled'),
focused: {
get: function () {
return this === document.activeElement;
},
set: function (val) {
var cur = attr.get(this, 'focused');
var docEl = this.ownerDocument.documentElement;
var element = this;
function focusTask() {
if (val) {
element.focus();
} else {
element.blur();
}
}
if (cur !== val) {
if (!docEl.contains(element)) {
var insertionDisposal = domMutate.onNodeInsertion(element, function () {
insertionDisposal();
focusTask();
});
} else {
focusTask();
}
}
return !!val;
},
addEventListener: function (eventName, handler, aEL) {
aEL.call(this, 'focus', handler);
aEL.call(this, 'blur', handler);
return function (rEL) {
rEL.call(this, 'focus', handler);
rEL.call(this, 'blur', handler);
};
},
test: function () {
return this.nodeName === 'INPUT';
}
},
'for': propProp('htmlFor'),
innertext: propProp('innerText'),
innerhtml: propProp('innerHTML'),
innerHTML: propProp('innerHTML', {
addEventListener: function (eventName, handler, aEL) {
var handlers = [];
var el = this;
[
'change',
'blur'
].forEach(function (eventName) {
var localHandler = function () {
handler.apply(this, arguments);
};
domEvents.addEventListener(el, eventName, localHandler);
handlers.push([
eventName,
localHandler
]);
});
return function (rEL) {
handlers.forEach(function (info) {
rEL.call(el, info[0], info[1]);
});
};
}
}),
required: booleanProp('required'),
readonly: booleanProp('readOnly'),
selected: {
get: function () {
return this.selected;
},
set: function (val) {
val = !!val;
setData.set.call(this, 'lastSetValue', val);
return this.selected = val;
},
addEventListener: function (eventName, handler, aEL) {
var option = this;
var select = this.parentNode;
var lastVal = option.selected;
var localHandler = function (changeEvent) {
var curVal = option.selected;
lastVal = setData.get.call(option, 'lastSetValue') || lastVal;
if (curVal !== lastVal) {
lastVal = curVal;
domEvents.dispatch(option, eventName);
}
};
var removeChangeHandler = <API key>(select, aEL);
domEvents.addEventListener(select, 'change', localHandler);
aEL.call(option, eventName, handler);
return function (rEL) {
removeChangeHandler(rEL);
domEvents.removeEventListener(select, 'change', localHandler);
rEL.call(option, eventName, handler);
};
},
test: function () {
return this.nodeName === 'OPTION' && this.parentNode && this.parentNode.nodeName === 'SELECT';
}
},
style: {
set: function () {
var el = global.document && getDocument().createElement('div');
if (el && el.style && 'cssText' in el.style) {
return function (val) {
return this.style.cssText = val || '';
};
} else {
return function (val) {
return domMutateNode.setAttribute.call(this, 'style', val);
};
}
}()
},
textcontent: propProp('textContent'),
value: {
get: function () {
var value = this.value;
if (this.nodeName === 'SELECT') {
if ('selectedIndex' in this && this.selectedIndex === -1) {
value = undefined;
}
}
return value;
},
set: function (value) {
var nodeName = this.nodeName.toLowerCase();
if (nodeName === 'input') {
value = toString(value);
}
if (this.value !== value || nodeName === 'option') {
this.value = value;
}
if (nodeName === 'input' || nodeName === 'textarea') {
this.defaultValue = value;
}
if (nodeName === 'select') {
setData.set.call(this, 'attrValueLastVal', value);
setChildOptions(this, value === null ? value : this.value);
var docEl = this.ownerDocument.documentElement;
if (!docEl.contains(this)) {
var select = this;
var insertionDisposal = domMutate.onNodeInsertion(select, function () {
insertionDisposal();
setChildOptions(select, value === null ? value : select.value);
});
}
setupMO(this, function () {
var value = setData.get.call(this, 'attrValueLastVal');
attr.set(this, 'value', value);
domEvents.dispatch(this, 'change');
});
}
return value;
},
test: function () {
return formElements[this.nodeName];
}
},
values: {
get: function () {
return <API key>(this);
},
set: function (values) {
values = values || [];
markSelectedOptions(this, values);
setData.set.call(this, 'stickyValues', attr.get(this, 'values'));
setupMO(this, function () {
var previousValues = setData.get.call(this, 'stickyValues');
attr.set(this, 'values', previousValues);
var currentValues = setData.get.call(this, 'stickyValues');
var changes = diff(previousValues.slice().sort(), currentValues.slice().sort());
if (changes.length) {
domEvents.dispatch(this, 'values');
}
});
return values;
},
addEventListener: function (eventName, handler, aEL) {
var localHandler = function () {
domEvents.dispatch(this, 'values');
};
domEvents.addEventListener(this, 'change', localHandler);
aEL.call(this, eventName, handler);
return function (rEL) {
domEvents.removeEventListener(this, 'change', localHandler);
rEL.call(this, eventName, handler);
};
}
}
};
var attr = {
rules: behaviorRules,
specialAttributes: specialAttributes,
getRule: function (el, attrOrPropName) {
var special = specialAttributes[attrOrPropName];
if (special) {
return special;
}
var rulesForElementType = behaviorRules.get(el.constructor);
var cached = rulesForElementType && rulesForElementType[attrOrPropName];
if (cached) {
return cached;
}
if (!(attrOrPropName in el)) {
return this.attribute(attrOrPropName);
}
var newRule = isPropWritable(el, attrOrPropName) ? this.property(attrOrPropName) : this.attribute(attrOrPropName);
return cacheRule(el, attrOrPropName, newRule);
},
attribute: function (attrName) {
return {
get: function () {
return this.getAttribute(attrName);
},
set: function (val) {
domMutateNode.setAttribute.call(this, attrName, val);
}
};
},
property: function (propName) {
return {
get: function () {
return this[propName];
},
set: function (val) {
this[propName] = val;
}
};
},
findSpecialListener: function (attributeName) {
return specialAttributes[attributeName] && specialAttributes[attributeName].addEventListener;
},
setAttrOrProp: function (el, attrName, val) {
return this.set(el, attrName, val);
},
set: function (el, attrName, val) {
var rule = this.getRule(el, attrName);
var setter = rule && rule.set;
if (setter) {
return setter.call(el, val);
}
},
get: function (el, attrName) {
var rule = this.getRule(el, attrName);
var getter = rule && rule.get;
if (getter) {
return rule.test ? rule.test.call(el) && getter.call(el) : getter.call(el);
}
},
remove: function (el, attrName) {
attrName = attrName.toLowerCase();
var special = specialAttributes[attrName];
var setter = special && special.set;
var remover = special && special.remove;
var test = getSpecialTest(special);
if (typeof remover === 'function' && test.call(el)) {
remover.call(el);
} else if (typeof setter === 'function' && test.call(el)) {
setter.call(el, undefined);
} else {
domMutateNode.removeAttribute.call(el, attrName);
}
}
};
module.exports = attr;
}(function () {
return this;
}(), require, exports, module));
});
/*can-view-live@4.1.4#lib/attr*/
define('can-view-live/lib/attr', [
'require',
'exports',
'module',
'can-view-live/lib/core',
'can-reflect',
'can-queues',
'<API key>/behaviors'
], function (require, exports, module) {
var live = require('can-view-live/lib/core');
var canReflect = require('can-reflect');
var queues = require('can-queues');
var attr = require('<API key>/behaviors');
live.attr = function (el, attributeName, compute) {
function liveUpdateAttr(newVal) {
queues.domUIQueue.enqueue(attr.set, attr, [
el,
attributeName,
newVal
]);
}
canReflect.assignSymbols(liveUpdateAttr, {
'can.<API key>': function () {
return { valueDependencies: new Set([el]) };
}
});
Object.defineProperty(liveUpdateAttr, 'name', { value: 'live.attr update::' + canReflect.getName(compute) });
live.listen(el, compute, liveUpdateAttr);
attr.set(el, attributeName, canReflect.getValue(compute));
};
});
/*can-view-live@4.1.4#lib/attrs*/
define('can-view-live/lib/attrs', [
'require',
'exports',
'module',
'can-view-live/lib/core',
'can-view-callbacks',
'can-dom-mutate',
'can-dom-mutate/node',
'can-reflect',
'<API key>'
], function (require, exports, module) {
var live = require('can-view-live/lib/core');
var viewCallbacks = require('can-view-callbacks');
var domMutate = require('can-dom-mutate');
var domMutateNode = require('can-dom-mutate/node');
var canReflect = require('can-reflect');
var canReflectDeps = require('<API key>');
live.attrs = function (el, compute, scope, options) {
if (!canReflect.isObservableLike(compute)) {
var attrs = live.getAttributeParts(compute);
for (var name in attrs) {
domMutateNode.setAttribute.call(el, name, attrs[name]);
}
return;
}
var oldAttrs = {};
function liveAttrsUpdate(newVal) {
var newAttrs = live.getAttributeParts(newVal), name;
for (name in newAttrs) {
var newValue = newAttrs[name], oldValue = oldAttrs[name];
if (newValue !== oldValue) {
domMutateNode.setAttribute.call(el, name, newValue);
var callback = viewCallbacks.attr(name);
if (callback) {
callback(el, {
attributeName: name,
scope: scope,
options: options
});
}
}
delete oldAttrs[name];
}
for (name in oldAttrs) {
domMutateNode.removeAttribute.call(el, name);
}
oldAttrs = newAttrs;
}
canReflect.assignSymbols(liveAttrsUpdate, {
'can.<API key>': function () {
return { valueDependencies: new Set([el]) };
}
});
Object.defineProperty(liveAttrsUpdate, 'name', { value: 'live.attrs update::' + canReflect.getName(compute) });
canReflectDeps.addMutatedBy(el, compute);
canReflect.onValue(compute, liveAttrsUpdate, 'domUI');
var removalDisposal;
var teardownHandler = function () {
canReflect.offValue(compute, liveAttrsUpdate, 'domUI');
if (removalDisposal) {
removalDisposal();
removalDisposal = undefined;
}
canReflectDeps.deleteMutatedBy(el, compute);
};
removalDisposal = domMutate.onNodeRemoval(el, function () {
if (!el.ownerDocument.contains(el)) {
teardownHandler();
}
});
liveAttrsUpdate(canReflect.getValue(compute));
};
});
/*can-view-live@4.1.4#lib/html*/
define('can-view-live/lib/html', [
'require',
'exports',
'module',
'can-view-live/lib/core',
'can-view-nodelist',
'can-fragment',
'can-child-nodes',
'can-reflect',
'can-queues'
], function (require, exports, module) {
var live = require('can-view-live/lib/core');
var nodeLists = require('can-view-nodelist');
var makeFrag = require('can-fragment');
var childNodes = require('can-child-nodes');
var canReflect = require('can-reflect');
var queues = require('can-queues');
function updateNodeList(oldNodes, nodes, frag, nodeListUpdatedByFn) {
if (nodes.isUnregistered !== true) {
if (!nodeListUpdatedByFn) {
nodeLists.update(nodes, childNodes(frag), oldNodes);
}
nodeLists.replace(oldNodes, frag);
}
}
live.html = function (el, compute, parentNode, nodeList) {
var data, makeAndPut, nodes;
var meta = { reasonLog: 'live.html replace::' + canReflect.getName(compute) };
parentNode = live.getParentNode(el, parentNode);
function liveHTMLUpdateHTML(newVal) {
var attached = nodeLists.first(nodes).parentNode;
if (attached) {
makeAndPut(newVal, true);
}
var pn = nodeLists.first(nodes).parentNode;
data.teardownCheck(pn);
}
canReflect.assignSymbols(liveHTMLUpdateHTML, {
'can.<API key>': function () {
return { valueDependencies: new Set([parentNode]) };
}
});
Object.defineProperty(liveHTMLUpdateHTML, 'name', { value: 'live.html update::' + canReflect.getName(compute) });
data = live.listen(parentNode, compute, liveHTMLUpdateHTML);
nodes = nodeList || [el];
makeAndPut = function (val, useQueue) {
var isFunction = typeof val === 'function', frag = makeFrag(isFunction ? '' : val);
live.<API key>(frag);
var oldNodes;
if (useQueue === true) {
oldNodes = nodeLists.unregisterChildren(nodes, true);
var nodeListUpdatedByFn = false;
if (isFunction) {
val(frag.firstChild);
nodeListUpdatedByFn = nodeLists.first(nodes) === frag.firstChild;
}
queues.domUIQueue.enqueue(updateNodeList, null, [
oldNodes,
nodes,
frag,
nodeListUpdatedByFn
], meta);
} else {
oldNodes = nodeLists.update(nodes, childNodes(frag));
if (isFunction) {
val(frag.firstChild);
}
nodeLists.replace(oldNodes, frag);
}
};
data.nodeList = nodes;
if (!nodeList) {
nodeLists.register(nodes, data.teardownCheck);
} else {
nodeList.unregistered = data.teardownCheck;
}
makeAndPut(canReflect.getValue(compute));
};
});
/*can-view-live@4.1.4#lib/set-observable*/
define('can-view-live/lib/set-observable', [
'require',
'exports',
'module',
'<API key>',
'can-reflect'
], function (require, exports, module) {
var SimpleObservable = require('<API key>');
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;
});
/*can-diff@1.0.4#patcher/patcher*/
define('can-diff/patcher/patcher', [
'require',
'exports',
'module',
'can-reflect',
'can-key-tree',
'can-symbol',
'can-diff/list/list',
'can-queues',
'can-symbol'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var KeyTree = require('can-key-tree');
var canSymbol = require('can-symbol');
var diff = require('can-diff/list/list');
var queues = require('can-queues');
var canSymbol = require('can-symbol');
var onValueSymbol = canSymbol.for('can.onValue'), offValueSymbol = canSymbol.for('can.offValue');
var onPatchesSymbol = canSymbol.for('can.onPatches');
var offPatchesSymbol = canSymbol.for('can.offPatches');
var Patcher = function (observableOrList, priority) {
this.handlers = new KeyTree([
Object,
Array
], {
onFirst: this.setup.bind(this),
onEmpty: this.teardown.bind(this)
});
this.observableOrList = observableOrList;
this.isObservableValue = canReflect.isValueLike(this.observableOrList) || canReflect.isObservableLike(this.observableOrList);
if (this.isObservableValue) {
this.priority = canReflect.getPriority(observableOrList);
} else {
this.priority = priority || 0;
}
this.onList = this.onList.bind(this);
this.onPatchesNotify = this.onPatchesNotify.bind(this);
this.onPatchesDerive = this.onPatchesDerive.bind(this);
this.patches = [];
Object.defineProperty(this.onList, 'name', { value: 'live.list new list::' + canReflect.getName(observableOrList) });
Object.defineProperty(this.onPatchesNotify, 'name', { value: 'live.list notify::' + canReflect.getName(observableOrList) });
Object.defineProperty(this.onPatchesDerive, 'name', { value: 'live.list derive::' + canReflect.getName(observableOrList) });
};
Patcher.prototype = {
constructor: Patcher,
setup: function () {
if (this.observableOrList[onValueSymbol]) {
canReflect.onValue(this.observableOrList, this.onList, 'notify');
this.setupList(canReflect.getValue(this.observableOrList));
} else {
this.setupList(this.observableOrList);
}
},
teardown: function () {
if (this.observableOrList[offValueSymbol]) {
canReflect.offValue(this.observableOrList, this.onList, 'notify');
}
},
setupList: function (list) {
this.currentList = list;
if (list && list[onPatchesSymbol]) {
list[onPatchesSymbol](this.onPatchesNotify, 'notify');
}
},
onList: function onList(newList) {
var current = this.currentList || [];
newList = newList || [];
if (current[offPatchesSymbol]) {
current[offPatchesSymbol](this.onPatchesNotify, 'notify');
}
var patches = diff(current, newList);
this.currentList = newList;
this.onPatchesNotify(patches);
if (newList[onPatchesSymbol]) {
newList[onPatchesSymbol](this.onPatchesNotify, 'notify');
}
},
onPatchesNotify: function onPatchesNotify(patches) {
this.patches.push.apply(this.patches, patches);
queues.deriveQueue.enqueue(this.onPatchesDerive, this, [], { priority: this.priority });
},
onPatchesDerive: function onPatchesDerive() {
var patches = this.patches;
this.patches = [];
queues.enqueueByQueue(this.handlers.getNode([]), this.currentList, [
patches,
this.currentList
], null, [
'Apply patches',
patches
]);
}
};
canReflect.assignSymbols(Patcher.prototype, {
'can.onPatches': function (handler, queue) {
this.handlers.add([
queue || 'mutate',
handler
]);
},
'can.offPatches': function (handler, queue) {
this.handlers.delete([
queue || 'mutate',
handler
]);
}
});
module.exports = Patcher;
});
/*can-view-live@4.1.4#lib/list*/
define('can-view-live/lib/list', [
'require',
'exports',
'module',
'can-view-live/lib/core',
'can-view-nodelist',
'can-fragment',
'can-child-nodes',
'can-dom-mutate/node',
'can-reflect',
'can-symbol',
'<API key>',
'<API key>',
'can-view-live/lib/set-observable',
'can-diff/patcher/patcher'
], function (require, exports, module) {
var live = require('can-view-live/lib/core');
var nodeLists = require('can-view-nodelist');
var frag = require('can-fragment');
var childNodes = require('can-child-nodes');
var domMutateNode = require('can-dom-mutate/node');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var canReflectDeps = require('<API key>');
var SimpleObservable = require('<API key>');
var SetObservable = require('can-view-live/lib/set-observable');
var Patcher = require('can-diff/patcher/patcher');
var splice = [].splice;
var <API key> = function (newNodeLists, parentNodeList, render, context, args) {
var itemNodeList = [];
if (parentNodeList) {
nodeLists.register(itemNodeList, null, true, true);
itemNodeList.parentList = parentNodeList;
itemNodeList.expression = '#each SUBEXPRESSION';
}
var itemHTML = render.apply(context, args.concat([itemNodeList])), itemFrag = frag(itemHTML);
var children = canReflect.toArray(childNodes(itemFrag));
if (parentNodeList) {
nodeLists.update(itemNodeList, children);
newNodeLists.push(itemNodeList);
} else {
newNodeLists.push(nodeLists.register(children));
}
return itemFrag;
}, removeFromNodeList = function (masterNodeList, index, length) {
var removedMappings = masterNodeList.splice(index + 1, length), itemsToRemove = [];
removedMappings.forEach(function (nodeList) {
var nodesToRemove = nodeLists.unregister(nodeList);
[].push.apply(itemsToRemove, nodesToRemove);
});
return itemsToRemove;
};
var onPatchesSymbol = canSymbol.for('can.onPatches');
var offPatchesSymbol = canSymbol.for('can.offPatches');
function ListDOMPatcher(el, compute, render, context, parentNode, nodeList, falseyRender) {
this.patcher = new Patcher(compute);
parentNode = live.getParentNode(el, parentNode);
this.value = compute;
this.render = render;
this.context = context;
this.parentNode = parentNode;
this.falseyRender = falseyRender;
this.masterNodeList = nodeList || nodeLists.register([el], null, true);
this.placeholder = el;
this.indexMap = [];
this.isValueLike = canReflect.isValueLike(this.value);
this.isObservableLike = canReflect.isObservableLike(this.value);
this.onPatches = this.onPatches.bind(this);
var data = this.data = live.setup(parentNode, this.setupValueBinding.bind(this), this.<API key>.bind(this));
this.masterNodeList.unregistered = function () {
data.teardownCheck();
};
Object.defineProperty(this.onPatches, 'name', { value: 'live.list update::' + canReflect.getName(compute) });
}
var onPatchesSymbol = canSymbol.for('can.onPatches');
var offPatchesSymbol = canSymbol.for('can.offPatches');
ListDOMPatcher.prototype = {
setupValueBinding: function () {
this.patcher[onPatchesSymbol](this.onPatches, 'domUI');
if (this.patcher.currentList && this.patcher.currentList.length) {
this.onPatches([{
insert: this.patcher.currentList,
index: 0,
deleteCount: 0
}]);
} else {
this.addFalseyIfEmpty();
}
canReflectDeps.addMutatedBy(this.parentNode, this.patcher.observableOrList);
},
<API key>: function () {
this.patcher[offPatchesSymbol](this.onPatches, 'domUI');
this.exit = true;
this.remove({ length: this.patcher.currentList.length }, 0, true);
canReflectDeps.deleteMutatedBy(this.parentNode, this.patcher.observableOrList);
},
onPatches: function <API key>(patches) {
if (this.exit) {
return;
}
for (var i = 0, patchLen = patches.length; i < patchLen; i++) {
var patch = patches[i];
if (patch.type === 'move') {
this.move(patch.toIndex, patch.fromIndex);
} else {
if (patch.deleteCount) {
this.remove({ length: patch.deleteCount }, patch.index, true);
}
if (patch.insert && patch.insert.length) {
this.add(patch.insert, patch.index);
}
}
}
},
add: function (items, index) {
var frag = this.placeholder.ownerDocument.<API key>(), newNodeLists = [], newIndicies = [], masterNodeList = this.masterNodeList, render = this.render, context = this.context;
items.forEach(function (item, key) {
var itemIndex = new SimpleObservable(key + index), itemCompute = new SetObservable(item, function (newVal) {
canReflect.setKeyValue(this.patcher.currentList, itemIndex.get(), newVal);
}.bind(this)), itemFrag = <API key>(newNodeLists, masterNodeList, render, context, [
itemCompute,
itemIndex
]);
frag.appendChild(itemFrag);
newIndicies.push(itemIndex);
}, this);
var masterListIndex = index + 1;
if (!this.indexMap.length) {
var falseyItemsToRemove = removeFromNodeList(masterNodeList, 0, masterNodeList.length - 1);
nodeLists.remove(falseyItemsToRemove);
}
if (!masterNodeList[masterListIndex]) {
nodeLists.after(masterListIndex === 1 ? [this.placeholder] : [nodeLists.last(this.masterNodeList[masterListIndex - 1])], frag);
} else {
var el = nodeLists.first(masterNodeList[masterListIndex]);
domMutateNode.insertBefore.call(el.parentNode, frag, el);
}
splice.apply(this.masterNodeList, [
masterListIndex,
0
].concat(newNodeLists));
splice.apply(this.indexMap, [
index,
0
].concat(newIndicies));
for (var i = index + newIndicies.length, len = this.indexMap.length; i < len; i++) {
this.indexMap[i].set(i);
}
},
remove: function (items, index) {
if (index < 0) {
index = this.indexMap.length + index;
}
var itemsToRemove = removeFromNodeList(this.masterNodeList, index, items.length);
var indexMap = this.indexMap;
indexMap.splice(index, items.length);
for (var i = index, len = indexMap.length; i < len; i++) {
indexMap[i].set(i);
}
if (!this.exit) {
this.addFalseyIfEmpty();
nodeLists.remove(itemsToRemove);
} else {
nodeLists.unregister(this.masterNodeList);
}
},
addFalseyIfEmpty: function () {
if (this.falseyRender && this.indexMap.length === 0) {
var falseyNodeLists = [];
var falseyFrag = <API key>(falseyNodeLists, this.masterNodeList, this.falseyRender, this.currentList, [this.currentList]);
nodeLists.after([this.masterNodeList[0]], falseyFrag);
this.masterNodeList.push(falseyNodeLists[0]);
}
},
move: function move(newIndex, currentIndex) {
newIndex = newIndex + 1;
currentIndex = currentIndex + 1;
var masterNodeList = this.masterNodeList, indexMap = this.indexMap;
var referenceNodeList = masterNodeList[newIndex];
var movedElements = frag(nodeLists.flatten(masterNodeList[currentIndex]));
var referenceElement;
if (currentIndex < newIndex) {
referenceElement = nodeLists.last(referenceNodeList).nextSibling;
} else {
referenceElement = nodeLists.first(referenceNodeList);
}
var parentNode = masterNodeList[0].parentNode;
parentNode.insertBefore(movedElements, referenceElement);
var temp = masterNodeList[currentIndex];
[].splice.apply(masterNodeList, [
currentIndex,
1
]);
[].splice.apply(masterNodeList, [
newIndex,
0,
temp
]);
newIndex = newIndex - 1;
currentIndex = currentIndex - 1;
var indexCompute = indexMap[currentIndex];
[].splice.apply(indexMap, [
currentIndex,
1
]);
[].splice.apply(indexMap, [
newIndex,
0,
indexCompute
]);
var i = Math.min(currentIndex, newIndex);
var len = indexMap.length;
for (i, len; i < len; i++) {
indexMap[i].set(i);
}
},
set: function (newVal, index) {
this.remove({ length: 1 }, index, true);
this.add([newVal], index);
}
};
live.list = function (el, list, render, context, parentNode, nodeList, falseyRender) {
if (el.nodeType !== Node.TEXT_NODE) {
var textNode;
if (!nodeList) {
textNode = document.createTextNode('');
el.parentNode.replaceChild(textNode, el);
el = textNode;
} else {
textNode = document.createTextNode('');
nodeLists.replace(nodeList, textNode);
nodeLists.update(nodeList, [textNode]);
el = textNode;
}
}
new ListDOMPatcher(el, list, render, context, parentNode, nodeList, falseyRender);
};
});
/*can-view-live@4.1.4#lib/text*/
define('can-view-live/lib/text', [
'require',
'exports',
'module',
'can-view-live/lib/core',
'can-view-nodelist',
'can-reflect'
], function (require, exports, module) {
var live = require('can-view-live/lib/core');
var nodeLists = require('can-view-nodelist');
var canReflect = require('can-reflect');
live.text = function (el, compute, parentNode, nodeList) {
if (el.nodeType !== Node.TEXT_NODE) {
var textNode;
if (!nodeList) {
textNode = document.createTextNode('');
el.parentNode.replaceChild(textNode, el);
el = textNode;
} else {
textNode = document.createTextNode('');
nodeLists.replace(nodeList, textNode);
nodeLists.update(nodeList, [textNode]);
el = textNode;
}
}
var parent = live.getParentNode(el, parentNode);
el.nodeValue = live.makeString(canReflect.getValue(compute));
function <API key>(newVal) {
el.nodeValue = live.makeString(newVal);
}
canReflect.assignSymbols(<API key>, {
'can.<API key>': function () {
return { valueDependencies: new Set([parent]) };
}
});
Object.defineProperty(<API key>, 'name', { value: 'live.text update::' + canReflect.getName(compute) });
var data = live.listen(parent, compute, <API key>, 'domUI');
if (!nodeList) {
nodeList = nodeLists.register([el], null, true);
}
nodeList.unregistered = data.teardownCheck;
data.nodeList = nodeList;
};
});
/*can-view-live@4.1.4#can-view-live*/
define('can-view-live', [
'require',
'exports',
'module',
'can-view-live/lib/core',
'can-view-live/lib/attr',
'can-view-live/lib/attrs',
'can-view-live/lib/html',
'can-view-live/lib/list',
'can-view-live/lib/text'
], function (require, exports, module) {
var live = require('can-view-live/lib/core');
require('can-view-live/lib/attr');
require('can-view-live/lib/attrs');
require('can-view-live/lib/html');
require('can-view-live/lib/list');
require('can-view-live/lib/text');
module.exports = live;
});
/*can-stache@4.8.0#src/text_section*/
define('can-stache/src/text_section', [
'require',
'exports',
'module',
'can-view-live',
'can-stache/src/utils',
'can-dom-mutate/node',
'can-assign',
'can-reflect',
'can-observation'
], function (require, exports, module) {
var live = require('can-view-live');
var utils = require('can-stache/src/utils');
var domMutate = require('can-dom-mutate/node');
var assign = require('can-assign');
var canReflect = require('can-reflect');
var Observation = require('can-observation');
var noop = function () {
};
var TextSectionBuilder = function () {
this.stack = [new TextSection()];
};
assign(TextSectionBuilder.prototype, utils.mixins);
assign(TextSectionBuilder.prototype, {
startSection: function (process) {
var subSection = new TextSection();
this.last().add({
process: process,
truthy: subSection
});
this.stack.push(subSection);
},
endSection: function () {
this.stack.pop();
},
inverse: function () {
this.stack.pop();
var falseySection = new TextSection();
this.last().last().falsey = falseySection;
this.stack.push(falseySection);
},
compile: function (state) {
var renderer = this.stack[0].compile();
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(renderer, 'name', { value: 'textSectionRenderer<' + state.tag + '.' + state.attr + '>' });
}
return function (scope) {
function textSectionRender() {
return renderer(scope);
}
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(textSectionRender, 'name', { value: 'textSectionRender<' + state.tag + '.' + state.attr + '>' });
}
var observation = new Observation(textSectionRender, null, { isObservable: false });
canReflect.onValue(observation, noop);
var value = canReflect.getValue(observation);
if (canReflect.<API key>(observation)) {
if (state.textContentOnly) {
live.text(this, observation);
} else if (state.attr) {
live.attr(this, state.attr, observation);
} else {
live.attrs(this, observation, scope);
}
canReflect.offValue(observation, noop);
} else {
if (state.textContentOnly) {
this.nodeValue = value;
} else if (state.attr) {
domMutate.setAttribute.call(this, state.attr, value);
} else {
live.attrs(this, value);
}
}
};
}
});
var passTruthyFalsey = function (process, truthy, falsey) {
return function (scope) {
return process.call(this, scope, truthy, falsey);
};
};
var TextSection = function () {
this.values = [];
};
assign(TextSection.prototype, {
add: function (data) {
this.values.push(data);
},
last: function () {
return this.values[this.values.length - 1];
},
compile: function () {
var values = this.values, len = values.length;
for (var i = 0; i < len; i++) {
var value = this.values[i];
if (typeof value === 'object') {
values[i] = passTruthyFalsey(value.process, value.truthy && value.truthy.compile(), value.falsey && value.falsey.compile());
}
}
return function (scope) {
var txt = '', value;
for (var i = 0; i < len; i++) {
value = values[i];
txt += typeof value === 'string' ? value : value.call(this, scope);
}
return txt;
};
}
});
module.exports = TextSectionBuilder;
});
/*can-stache@4.8.0#expressions/arg*/
define('can-stache/expressions/arg', function (require, exports, module) {
var Arg = function (expression, modifiers) {
this.expr = expression;
this.modifiers = modifiers || {};
this.isCompute = false;
};
Arg.prototype.value = function () {
return this.expr.value.apply(this.expr, arguments);
};
if (process.env.NODE_ENV !== 'production') {
Arg.prototype.sourceText = function () {
return (this.modifiers.compute ? '~' : '') + this.expr.sourceText();
};
}
module.exports = Arg;
});
/*can-stache@4.8.0#expressions/literal*/
define('can-stache/expressions/literal', function (require, exports, module) {
var Literal = function (value) {
this._value = value;
};
Literal.prototype.value = function () {
return this._value;
};
if (process.env.NODE_ENV !== 'production') {
Literal.prototype.sourceText = function () {
return JSON.stringify(this._value);
};
}
module.exports = Literal;
});
/*<API key>@2.0.4#setter/setter*/
define('<API key>/setter/setter', [
'require',
'exports',
'module',
'can-reflect',
'can-observation',
'<API key>/settable/settable',
'can-event-queue/value/value'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var Observation = require('can-observation');
var SettableObservable = require('<API key>/settable/settable');
var valueEventBindings = require('can-event-queue/value/value');
function SetterObservable(getter, setter) {
this.setter = setter;
this.observation = new Observation(getter);
this.handler = this.handler.bind(this);
canReflect.assignSymbols(this, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '<' + canReflect.getName(getter) + '>';
}
});
Object.defineProperty(this.handler, 'name', { value: canReflect.getName(this) + '.handler' });
}
SetterObservable.prototype = Object.create(SettableObservable.prototype);
SetterObservable.prototype.constructor = SetterObservable;
SetterObservable.prototype.set = function (newVal) {
this.setter(newVal);
};
SetterObservable.prototype.hasDependencies = function () {
return canReflect.<API key>(this.observation);
};
canReflect.assignSymbols(SetterObservable.prototype, {
'can.setValue': SetterObservable.prototype.set,
'can.<API key>': SetterObservable.prototype.hasDependencies
});
module.exports = SetterObservable;
});
/*can-stache@4.8.0#src/expression-helpers*/
define('can-stache/src/expression-helpers', [
'require',
'exports',
'module',
'can-stache/expressions/arg',
'can-stache/expressions/literal',
'can-reflect',
'can-stache-key',
'can-symbol',
'can-observation',
'can-view-scope/make-compute-like',
'<API key>/setter/setter'
], function (require, exports, module) {
var Arg = require('can-stache/expressions/arg');
var Literal = require('can-stache/expressions/literal');
var canReflect = require('can-reflect');
var stacheKey = require('can-stache-key');
var canSymbol = require('can-symbol');
var Observation = require('can-observation');
var makeComputeLike = require('can-view-scope/make-compute-like');
var SetterObservable = require('<API key>/setter/setter');
function <API key>(key, scope, readOptions) {
var data = scope.computeData(key, readOptions);
Observation.temporarilyBind(data);
return data;
}
function <API key>(compute) {
return compute[canSymbol.for('can.<API key>')] ? canReflect.<API key>(compute) : compute.computeInstance.hasDependencies;
}
function <API key>(key, root, helperOptions, readOptions) {
var getKeys = function () {
return stacheKey.reads(('' + canReflect.getValue(key)).replace('.', '\\.'));
};
var parentHasKey;
var computeValue = new SetterObservable(function getDynamicKey() {
var readData = stacheKey.read(canReflect.getValue(root), getKeys());
parentHasKey = readData.parentHasKey;
return readData.value;
}, function setDynamicKey(newVal) {
stacheKey.write(canReflect.getValue(root), getKeys(), newVal);
});
Observation.temporarilyBind(computeValue);
computeValue.initialValue = canReflect.getValue(computeValue);
computeValue.parentHasKey = parentHasKey;
return computeValue;
}
function <API key>(expr) {
if (!(expr instanceof Arg) && !(expr instanceof Literal)) {
return new Arg(expr);
} else {
return expr;
}
}
function toComputeOrValue(value) {
if (canReflect.isObservableLike(value)) {
if (canReflect.isValueLike(value) && canReflect.<API key>(value) === false) {
return canReflect.getValue(value);
}
if (value.compute) {
return value.compute;
} else {
return makeComputeLike(value);
}
}
return value;
}
function toCompute(value) {
if (value) {
if (value.isComputed) {
return value;
}
if (value.compute) {
return value.compute;
} else {
return makeComputeLike(value);
}
}
return value;
}
module.exports = {
<API key>: <API key>,
<API key>: <API key>,
<API key>: <API key>,
<API key>: <API key>,
toComputeOrValue: toComputeOrValue,
toCompute: toCompute
};
});
/*can-stache@4.8.0#expressions/hashes*/
define('can-stache/expressions/hashes', [
'require',
'exports',
'module',
'can-reflect',
'can-observation',
'can-stache/src/expression-helpers'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var Observation = require('can-observation');
var expressionHelpers = require('can-stache/src/expression-helpers');
var Hashes = function (hashes) {
this.hashExprs = hashes;
};
Hashes.prototype.value = function (scope, helperOptions) {
var hash = {};
for (var prop in this.hashExprs) {
var val = expressionHelpers.<API key>(this.hashExprs[prop]), value = val.value.apply(val, arguments);
hash[prop] = {
call: !val.modifiers || !val.modifiers.compute,
value: value
};
}
return new Observation(function () {
var finalHash = {};
for (var prop in hash) {
finalHash[prop] = hash[prop].call ? canReflect.getValue(hash[prop].value) : expressionHelpers.toComputeOrValue(hash[prop].value);
}
return finalHash;
});
};
if (process.env.NODE_ENV !== 'production') {
Hashes.prototype.sourceText = function () {
var hashes = [];
canReflect.eachKey(this.hashExprs, function (expr, prop) {
hashes.push(prop + '=' + expr.sourceText());
});
return hashes.join(' ');
};
}
module.exports = Hashes;
});
/*can-stache@4.8.0#expressions/bracket*/
define('can-stache/expressions/bracket', [
'require',
'exports',
'module',
'can-symbol',
'can-stache/src/expression-helpers'
], function (require, exports, module) {
if (process.env.NODE_ENV !== 'production') {
var canSymbol = require('can-symbol');
}
var expressionHelpers = require('can-stache/src/expression-helpers');
var Bracket = function (key, root, originalKey) {
this.root = root;
this.key = key;
if (process.env.NODE_ENV !== 'production') {
this[canSymbol.for('can-stache.originalKey')] = originalKey;
}
};
Bracket.prototype.value = function (scope, helpers) {
var root = this.root ? this.root.value(scope, helpers) : scope.peek('this');
return expressionHelpers.<API key>(this.key.value(scope, helpers), root, scope, helpers, {});
};
if (process.env.NODE_ENV !== 'production') {
Bracket.prototype.sourceText = function () {
if (this.rootExpr) {
return this.rootExpr.sourceText() + '[' + this.key + ']';
} else {
return '[' + this.key + ']';
}
};
}
Bracket.prototype.closingTag = function () {
if (process.env.NODE_ENV !== 'production') {
return this[canSymbol.for('can-stache.originalKey')] || '';
}
};
module.exports = Bracket;
});
/*can-stache@4.8.0#src/set-identifier*/
define('can-stache/src/set-identifier', function (require, exports, module) {
module.exports = function SetIdentifier(value) {
this.value = value;
};
});
/*can-stache@4.8.0#expressions/call*/
define('can-stache/expressions/call', [
'require',
'exports',
'module',
'can-stache/expressions/hashes',
'can-stache/src/set-identifier',
'can-symbol',
'<API key>/setter/setter',
'can-stache/src/expression-helpers',
'can-reflect',
'can-assign'
], function (require, exports, module) {
var Hashes = require('can-stache/expressions/hashes');
var SetIdentifier = require('can-stache/src/set-identifier');
var canSymbol = require('can-symbol');
var sourceTextSymbol = canSymbol.for('can-stache.sourceText');
var SetterObservable = require('<API key>/setter/setter');
var expressionHelpers = require('can-stache/src/expression-helpers');
var canReflect = require('can-reflect');
var assign = require('can-assign');
var Call = function (methodExpression, argExpressions) {
this.methodExpr = methodExpression;
this.argExprs = argExpressions.map(expressionHelpers.<API key>);
};
Call.prototype.args = function (scope, ignoreArgLookup) {
var hashExprs = {};
var args = [];
var gotIgnoreFunction = typeof ignoreArgLookup === 'function';
for (var i = 0, len = this.argExprs.length; i < len; i++) {
var arg = this.argExprs[i];
if (arg.expr instanceof Hashes) {
assign(hashExprs, arg.expr.hashExprs);
}
if (!gotIgnoreFunction || !ignoreArgLookup(i)) {
var value = arg.value.apply(arg, arguments);
args.push({
call: !arg.modifiers || !arg.modifiers.compute,
value: value
});
}
}
return function (doNotWrapArguments) {
var finalArgs = [];
if (canReflect.size(hashExprs) > 0) {
finalArgs.hashExprs = hashExprs;
}
for (var i = 0, len = args.length; i < len; i++) {
if (doNotWrapArguments) {
finalArgs[i] = args[i].value;
} else {
finalArgs[i] = args[i].call ? canReflect.getValue(args[i].value) : expressionHelpers.toCompute(args[i].value);
}
}
return finalArgs;
};
};
Call.prototype.value = function (scope, helperOptions) {
var callExpression = this;
var method = this.methodExpr.value(scope, { proxyMethods: false }), func = canReflect.getValue(method);
var getArgs = callExpression.args(scope, func && func.ignoreArgLookup);
var computeFn = function (newVal) {
var func = canReflect.getValue(method);
if (typeof func === 'function') {
var args = getArgs(func.isLiveBound);
if (func.<API key>) {
if (args.hashExprs && helperOptions && helperOptions.exprData) {
helperOptions.exprData.hashExprs = args.hashExprs;
}
args.push(helperOptions);
}
if (arguments.length) {
args.unshift(new SetIdentifier(newVal));
}
return func.apply(method.thisArg || scope.peek('this'), args);
}
};
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(computeFn, 'name', { value: '{{' + this.sourceText() + '}}' });
}
if (helperOptions && helperOptions.<API key>) {
return computeFn();
} else {
var computeValue = new SetterObservable(computeFn, computeFn);
return computeValue;
}
};
if (process.env.NODE_ENV !== 'production') {
Call.prototype.sourceText = function () {
var args = this.argExprs.map(function (arg) {
return arg.sourceText();
});
return this.methodExpr.sourceText() + '(' + args.join(',') + ')';
};
}
Call.prototype.closingTag = function () {
if (process.env.NODE_ENV !== 'production') {
if (this.methodExpr[sourceTextSymbol]) {
return this.methodExpr[sourceTextSymbol];
}
}
return this.methodExpr.key;
};
module.exports = Call;
});
/*can-stache@4.8.0#expressions/helper*/
define('can-stache/expressions/helper', [
'require',
'exports',
'module',
'can-stache/expressions/literal',
'can-stache/expressions/hashes',
'can-assign',
'can-log/dev/dev',
'can-stache/src/expression-helpers',
'can-reflect'
], function (require, exports, module) {
var Literal = require('can-stache/expressions/literal');
var Hashes = require('can-stache/expressions/hashes');
var assign = require('can-assign');
var dev = require('can-log/dev/dev');
var expressionHelpers = require('can-stache/src/expression-helpers');
var canReflect = require('can-reflect');
var Helper = function (methodExpression, argExpressions, hashExpressions) {
this.methodExpr = methodExpression;
this.argExprs = argExpressions;
this.hashExprs = hashExpressions;
this.mode = null;
};
Helper.prototype.args = function (scope) {
var args = [];
for (var i = 0, len = this.argExprs.length; i < len; i++) {
var arg = this.argExprs[i];
args.push(expressionHelpers.toComputeOrValue(arg.value.apply(arg, arguments)));
}
return args;
};
Helper.prototype.hash = function (scope) {
var hash = {};
for (var prop in this.hashExprs) {
var val = this.hashExprs[prop];
hash[prop] = expressionHelpers.toComputeOrValue(val.value.apply(val, arguments));
}
return hash;
};
Helper.prototype.value = function (scope, helperOptions) {
var methodKey = this.methodExpr instanceof Literal ? '' + this.methodExpr._value : this.methodExpr.key, helperInstance = this, helperFn = expressionHelpers.<API key>(methodKey, scope, { proxyMethods: false }), initialValue = helperFn && helperFn.initialValue, thisArg = helperFn && helperFn.thisArg;
if (typeof initialValue === 'function') {
helperFn = function helperFn() {
var args = helperInstance.args(scope), helperOptionArg = assign(assign({}, helperOptions), {
hash: helperInstance.hash(scope),
exprData: helperInstance
});
args.push(helperOptionArg);
return initialValue.apply(thisArg || scope.peek('this'), args);
};
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(helperFn, 'name', { value: canReflect.getName(this) });
}
} else if (process.env.NODE_ENV !== 'production') {
var filename = scope.peek('scope.filename');
var lineNumber = scope.peek('scope.lineNumber');
dev.warn((filename ? filename + ':' : '') + (lineNumber ? lineNumber + ': ' : '') + 'Unable to find helper "' + methodKey + '".');
}
return helperFn;
};
Helper.prototype.closingTag = function () {
return this.methodExpr.key;
};
if (process.env.NODE_ENV !== 'production') {
Helper.prototype.sourceText = function () {
var text = [this.methodExpr.sourceText()];
if (this.argExprs.length) {
text.push(this.argExprs.map(function (arg) {
return arg.sourceText();
}).join(' '));
}
if (canReflect.size(this.hashExprs) > 0) {
text.push(Hashes.prototype.sourceText.call(this));
}
return text.join(' ');
};
}
if (process.env.NODE_ENV !== 'production') {
canReflect.assignSymbols(Helper.prototype, {
'can.getName': function () {
return canReflect.getName(this.constructor) + '{{' + this.sourceText() + '}}';
}
});
}
module.exports = Helper;
});
/*can-stache@4.8.0#expressions/lookup*/
define('can-stache/expressions/lookup', [
'require',
'exports',
'module',
'can-stache/src/expression-helpers',
'can-reflect',
'can-symbol',
'can-log/dev/dev',
'can-stache-key'
], function (require, exports, module) {
var expressionHelpers = require('can-stache/src/expression-helpers');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var sourceTextSymbol = canSymbol.for('can-stache.sourceText');
var dev = require('can-log/dev/dev');
var observeReader = require('can-stache-key');
var Lookup = function (key, root, sourceText) {
this.key = key;
this.rootExpr = root;
canReflect.setKeyValue(this, sourceTextSymbol, sourceText);
};
Lookup.prototype.value = function (scope, readOptions) {
var value;
if (this.rootExpr) {
value = expressionHelpers.<API key>(this.key, this.rootExpr.value(scope), scope, {}, {});
} else {
value = expressionHelpers.<API key>(this.key, scope, readOptions);
}
if (process.env.NODE_ENV !== 'production') {
if (typeof value.initialValue === 'undefined' && this.key !== 'debugger' && !value.parentHasKey) {
var filename = scope.peek('scope.filename');
var lineNumber = scope.peek('scope.lineNumber');
var reads = observeReader.reads(this.key);
var firstKey = reads[0].key;
var key = reads.map(function (read) {
return read.key + (read.at ? '()' : '');
}).join('.');
var pathsForKey = scope.getPathsForKey(firstKey);
var paths = Object.keys(pathsForKey);
var includeSuggestions = paths.length && !paths.includes(firstKey);
var warning = [(filename ? filename + ':' : '') + (lineNumber ? lineNumber + ': ' : '') + 'Unable to find key "' + key + '".' + (includeSuggestions ? ' Did you mean' + (paths.length > 1 ? ' one of these' : '') + '?\n' : '\n')];
if (includeSuggestions) {
paths.forEach(function (path) {
warning.push('\t"' + path + '" which will read from');
warning.push(pathsForKey[path]);
warning.push('\n');
});
}
warning.push('\n');
dev.warn.apply(dev, warning);
}
}
return value;
};
if (process.env.NODE_ENV !== 'production') {
Lookup.prototype.sourceText = function () {
if (this[sourceTextSymbol]) {
return this[sourceTextSymbol];
} else if (this.rootExpr) {
return this.rootExpr.sourceText() + '.' + this.key;
} else {
return this.key;
}
};
}
module.exports = Lookup;
});
/*can-stache@4.8.0#src/expression*/
define('can-stache/src/expression', [
'require',
'exports',
'module',
'can-stache/expressions/arg',
'can-stache/expressions/literal',
'can-stache/expressions/hashes',
'can-stache/expressions/bracket',
'can-stache/expressions/call',
'can-stache/expressions/helper',
'can-stache/expressions/lookup',
'can-stache/src/set-identifier',
'can-stache/src/expression-helpers',
'can-stache/src/utils',
'can-assign',
'can-reflect',
'can-symbol'
], function (require, exports, module) {
var Arg = require('can-stache/expressions/arg');
var Literal = require('can-stache/expressions/literal');
var Hashes = require('can-stache/expressions/hashes');
var Bracket = require('can-stache/expressions/bracket');
var Call = require('can-stache/expressions/call');
var Helper = require('can-stache/expressions/helper');
var Lookup = require('can-stache/expressions/lookup');
var SetIdentifier = require('can-stache/src/set-identifier');
var expressionHelpers = require('can-stache/src/expression-helpers');
var utils = require('can-stache/src/utils');
var assign = require('can-assign');
var last = utils.last;
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var sourceTextSymbol = canSymbol.for('can-stache.sourceText');
var Hash = function () {
};
/*can-stache@4.8.0#src/mustache_core*/
/*can-globals@1.1.1#base-url/base-url*/
/*can-join-uris@1.0.0#can-join-uris*/
if (p === '/..') {
output.pop();
} else {
output.push(p);
}
});
return output.join('').replace(/^\
}
href = parseURI(href || '');
base = parseURI(base || '');
return !href || !base ? null : (href.protocol || base.protocol) + (href.protocol || href.authority ? href.authority : base.authority) + removeDotSegments(href.protocol || href.authority || href.pathname.charAt(0) === '/' ? href.pathname : href.pathname ? (base.authority && !base.pathname ? '/' : '') + base.pathname.slice(0, base.pathname.lastIndexOf('/') + 1) + href.pathname : base.pathname) + (href.protocol || href.authority || href.pathname ? href.search : href.search || base.search) + href.hash;
};
});
/*can-stache@4.8.0#helpers/-debugger*/
define('can-stache/helpers/-debugger', [
'require',
'exports',
'module',
'can-log',
'can-reflect',
'can-symbol'
], function (require, exports, module) {
var canLog = require('can-log');
function noop() {
}
var resolveValue = noop;
var evaluateArgs = noop;
var __testing = {};
if (process.env.NODE_ENV !== 'production') {
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
__testing = { allowDebugger: true };
resolveValue = function (value) {
if (value && value[canSymbol.for('can.getValue')]) {
return canReflect.getValue(value);
}
return value;
};
evaluateArgs = function (left, right) {
switch (arguments.length) {
case 0:
return true;
case 1:
return !!resolveValue(left);
case 2:
return resolveValue(left) === resolveValue(right);
default:
canLog.log([
'Usage:',
' {{debugger}}: break any time this helper is evaluated',
' {{debugger condition}}: break when `condition` is truthy',
' {{debugger left right}}: break when `left` === `right`'
].join('\n'));
throw new Error('{{debugger}} must have less than three arguments');
}
};
}
function debuggerHelper(left, right) {
if (process.env.NODE_ENV !== 'production') {
var shouldBreak = evaluateArgs.apply(null, Array.prototype.slice.call(arguments, 0, -1));
if (!shouldBreak) {
return;
}
var options = arguments[arguments.length - 1];
var get = function (path) {
return options.scope.get(path);
};
canLog.log('Use `get(<path>)` to debug this template');
var allowDebugger = __testing.allowDebugger;
if (allowDebugger) {
debugger;
return;
}
}
canLog.warn('Forgotten {{debugger}} helper');
}
debuggerHelper.<API key> = true;
module.exports = {
helper: debuggerHelper,
evaluateArgs: evaluateArgs,
resolveValue: resolveValue,
__testing: __testing
};
});
/*can-stache@4.8.0#src/truthy-observable*/
define('can-stache/src/truthy-observable', [
'require',
'exports',
'module',
'can-observation',
'can-reflect'
], function (require, exports, module) {
var Observation = require('can-observation');
var canReflect = require('can-reflect');
module.exports = function (observable) {
return new Observation(function truthyObservation() {
var val = canReflect.getValue(observable);
return !!val;
});
};
});
/*can-dom-data@1.0.1#can-dom-data*/
define('can-dom-data', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
'use strict';
var namespace = require('can-namespace');
var isEmptyObject = function (obj) {
for (var prop in obj) {
return false;
}
return true;
};
var data = new WeakMap();
var deleteNode = function (node) {
var nodeDeleted = false;
if (data.has(node)) {
nodeDeleted = true;
data.delete(node);
}
return nodeDeleted;
};
var setData = function (node, name, value) {
var store = data.get(node);
if (store === undefined) {
store = {};
data.set(node, store);
}
if (name !== undefined) {
store[name] = value;
}
return store;
};
var domData = {
_data: data,
get: function (node, key) {
var store = data.get(node);
return key === undefined ? store : store && store[key];
},
set: setData,
clean: function (node, prop) {
var itemData = data.get(node);
if (itemData && itemData[prop]) {
delete itemData[prop];
}
if (isEmptyObject(itemData)) {
deleteNode(node);
}
},
delete: deleteNode
};
if (namespace.domData) {
throw new Error('You can\'t have two versions of can-dom-data, check your dependencies');
} else {
module.exports = namespace.domData = domData;
}
});
/*can-stache@4.8.0#helpers/core*/
define('can-stache/helpers/core', [
'require',
'exports',
'module',
'can-view-live',
'can-view-nodelist',
'can-stache/src/utils',
'can-globals/base-url/base-url',
'can-join-uris',
'can-assign',
'can-log/dev/dev',
'can-reflect',
'can-stache/helpers/-debugger',
'can-stache/src/key-observable',
'can-observation',
'can-stache/src/truthy-observable',
'can-stache-helpers',
'can-dom-data',
'can-dom-data-state'
], function (require, exports, module) {
(function (global, require, exports, module) {
var live = require('can-view-live');
var nodeLists = require('can-view-nodelist');
var utils = require('can-stache/src/utils');
var getBaseURL = require('can-globals/base-url/base-url');
var joinURIs = require('can-join-uris');
var assign = require('can-assign');
var dev = require('can-log/dev/dev');
var canReflect = require('can-reflect');
var debuggerHelper = require('can-stache/helpers/-debugger').helper;
var KeyObservable = require('can-stache/src/key-observable');
var Observation = require('can-observation');
var TruthyObservable = require('can-stache/src/truthy-observable');
var helpers = require('can-stache-helpers');
var domData = require('can-dom-data');
var domDataState = require('can-dom-data-state');
var looksLikeOptions = function (options) {
return options && typeof options.fn === 'function' && typeof options.inverse === 'function';
};
var resolve = function (value) {
if (value && canReflect.isValueLike(value)) {
return canReflect.getValue(value);
} else {
return value;
}
};
var resolveHash = function (hash) {
var params = {};
for (var prop in hash) {
params[prop] = resolve(hash[prop]);
}
return params;
};
var bindAndRead = function (value) {
if (value && canReflect.isValueLike(value)) {
Observation.temporarilyBind(value);
return canReflect.getValue(value);
} else {
return value;
}
};
var eachHelper = function (items) {
var args = [].slice.call(arguments), options = args.pop(), hashExprs = options.exprData.hashExprs, resolved = bindAndRead(items), hashOptions, aliases;
if (canReflect.size(hashExprs) > 0) {
hashOptions = {};
canReflect.eachKey(hashExprs, function (exprs, key) {
hashOptions[exprs.key] = key;
});
}
if ((canReflect.isObservableLike(resolved) && canReflect.isListLike(resolved) || canReflect.isListLike(resolved) && canReflect.isValueLike(items)) && !options.stringOnly) {
options.metadata.rendered = true;
return function (el) {
var nodeList = [el];
nodeList.expression = 'live.list';
nodeLists.register(nodeList, null, options.nodeList, true);
nodeLists.update(options.nodeList, [el]);
var cb = function (item, index, parentNodeList) {
var aliases = {};
if (canReflect.size(hashOptions) > 0) {
if (hashOptions.value) {
aliases[hashOptions.value] = item;
}
if (hashOptions.index) {
aliases[hashOptions.index] = index;
}
}
return options.fn(options.scope.add(aliases, { notContext: true }).add({ index: index }, { special: true }).add(item), options.options, parentNodeList);
};
live.list(el, items, cb, options.context, el.parentNode, nodeList, function (list, parentNodeList) {
return options.inverse(options.scope.add(list), options.options, parentNodeList);
});
};
}
var expr = resolve(items), result;
if (!!expr && canReflect.isListLike(expr)) {
result = utils.getItemsFragContent(expr, options, options.scope);
return options.stringOnly ? result.join('') : result;
} else if (canReflect.isObservableLike(expr) && canReflect.isMapLike(expr) || expr instanceof Object) {
result = [];
canReflect.each(expr, function (val, key) {
var value = new KeyObservable(expr, key);
aliases = {};
if (canReflect.size(hashOptions) > 0) {
if (hashOptions.value) {
aliases[hashOptions.value] = value;
}
if (hashOptions.key) {
aliases[hashOptions.key] = key;
}
}
result.push(options.fn(options.scope.add(aliases, { notContext: true }).add({ key: key }, { special: true }).add(value)));
});
return options.stringOnly ? result.join('') : result;
}
};
eachHelper.isLiveBound = true;
eachHelper.<API key> = true;
eachHelper.ignoreArgLookup = function ignoreArgLookup(index) {
return index === 1;
};
var indexHelper = function (offset, options) {
if (!options) {
options = offset;
offset = 0;
}
var index = options.scope.peek('scope.index');
return '' + ((typeof index === 'function' ? index() : index) + offset);
};
indexHelper.<API key> = true;
var ifHelper = function (expr, options) {
var value;
if (expr && canReflect.isValueLike(expr)) {
value = canReflect.getValue(new TruthyObservable(expr));
} else {
value = !!resolve(expr);
}
if (value) {
return options.fn(options.scope || this);
} else {
return options.inverse(options.scope || this);
}
};
ifHelper.<API key> = true;
var isHelper = function () {
var lastValue, curValue, options = arguments[arguments.length - 1];
if (arguments.length <= 2) {
return options.inverse();
}
var args = arguments;
function isHelper() {
for (var i = 0; i < args.length - 1; i++) {
curValue = resolve(args[i]);
curValue = typeof curValue === 'function' ? curValue() : curValue;
if (i > 0) {
if (curValue !== lastValue) {
return false;
}
}
lastValue = curValue;
}
return true;
}
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(isHelper, 'name', {
value: 'is(' + [].slice.call(args, 0, 2).map(function (arg) {
return canReflect.getName(arg);
}).join(',') + ')'
});
}
var callFn = new Observation(isHelper);
return callFn.get() ? options.fn() : options.inverse();
};
isHelper.<API key> = true;
var unlessHelper = function (expr, options) {
return ifHelper.apply(this, [
expr,
assign(assign({}, options), {
fn: options.inverse,
inverse: options.fn
})
]);
};
unlessHelper.<API key> = true;
var withHelper = function (expr, options) {
var ctx = expr;
if (!options) {
options = expr;
expr = true;
ctx = options.hash;
} else {
expr = resolve(expr);
if (options.hash && canReflect.size(options.hash) > 0) {
ctx = options.scope.add(options.hash, { notContext: true }).add(ctx);
}
}
return options.fn(ctx || {});
};
withHelper.<API key> = true;
var dataHelper = function (attr, value) {
var data = (looksLikeOptions(value) ? value.context : value) || this;
return function setData(el) {
if (process.env.NODE_ENV !== 'production') {
dev.warn('The {{data}} helper has been deprecated; use {{domData}} instead: https://canjs.com/doc/can-stache.helpers.domData.html');
}
domDataState.set.call(el, attr, data);
};
};
var domDataHelper = function (attr, value) {
var data = (looksLikeOptions(value) ? value.context : value) || this;
return function setDomData(el) {
domData.set(el, attr, data);
};
};
var switchHelper = function (expression, options) {
resolve(expression);
var found = false;
var caseHelper = function (value, options) {
if (!found && resolve(expression) === resolve(value)) {
found = true;
return options.fn(options.scope.peek('this') || this);
}
};
caseHelper.<API key> = true;
var defaultHelper = function (options) {
if (!found) {
return options ? options.scope.peek('this') : true;
}
};
defaultHelper.<API key> = true;
canReflect.assignSymbols(defaultHelper, {
'can.isValueLike': true,
'can.isFunctionLike': false,
'can.getValue': function () {
return this(options);
}
});
var newScope = options.scope.add({
case: caseHelper,
default: defaultHelper
}, { notContext: true });
return options.fn(newScope, options);
};
switchHelper.<API key> = true;
var joinBaseHelper = function (firstExpr) {
var args = [].slice.call(arguments);
var options = args.pop();
var moduleReference = args.map(function (expr) {
var value = resolve(expr);
return typeof value === 'function' ? value() : value;
}).join('');
var templateModule = canReflect.getKeyValue(options.scope.templateContext.helpers, 'module');
var parentAddress = templateModule ? templateModule.uri : undefined;
var isRelative = moduleReference[0] === '.';
if (isRelative && parentAddress) {
return joinURIs(parentAddress, moduleReference);
} else {
var baseURL = typeof System !== 'undefined' && (System.renderingBaseURL || System.baseURL) || getBaseURL();
if (moduleReference[0] !== '/' && baseURL[baseURL.length - 1] !== '/') {
baseURL += '/';
}
return joinURIs(baseURL, moduleReference);
}
};
joinBaseHelper.<API key> = true;
var builtInHelpers = {
'debugger': debuggerHelper,
each: eachHelper,
eachOf: eachHelper,
index: indexHelper,
'if': ifHelper,
is: isHelper,
eq: isHelper,
unless: unlessHelper,
'with': withHelper,
console: console,
data: dataHelper,
domData: domDataHelper,
'switch': switchHelper,
joinBase: joinBaseHelper
};
var addBuiltInHelpers = function () {
canReflect.each(builtInHelpers, function (helper, helperName) {
helpers[helperName] = helper;
});
};
addBuiltInHelpers();
var registerHelper = function (name, callback) {
if (process.env.NODE_ENV !== 'production') {
if (helpers[name]) {
dev.warn('The helper ' + name + ' has already been registered.');
}
}
callback.<API key> = true;
helpers[name] = callback;
};
var registerHelpers = function (helpers) {
var name, callback;
for (name in helpers) {
callback = helpers[name];
registerHelper(name, makeSimpleHelper(callback));
}
};
var makeSimpleHelper = function (fn) {
return function () {
var realArgs = [];
canReflect.eachIndex(arguments, function (val) {
while (val && val.isComputed) {
val = val();
}
realArgs.push(val);
});
return fn.apply(this, realArgs);
};
};
module.exports = {
registerHelper: registerHelper,
addHelper: function (name, callback) {
if (typeof name === 'object') {
return registerHelpers(name);
}
return registerHelper(name, makeSimpleHelper(callback));
},
addLiveHelper: function (name, callback) {
callback.isLiveBound = true;
return registerHelper(name, callback);
},
getHelper: function (name, scope) {
var helper = scope && scope.getHelper(name);
if (!helper) {
helper = helpers[name];
}
return helper;
},
resolve: resolve,
resolveHash: resolveHash,
looksLikeOptions: looksLikeOptions,
__resetHelpers: function () {
for (var helper in helpers) {
delete helpers[helper];
}
addBuiltInHelpers();
}
};
}(function () {
return this;
}(), require, exports, module));
});
/*can-stache@4.8.0#helpers/converter*/
define('can-stache/helpers/converter', [
'require',
'exports',
'module',
'can-stache/helpers/core',
'can-stache/src/set-identifier',
'can-reflect'
], function (require, exports, module) {
var helpers = require('can-stache/helpers/core');
var SetIdentifier = require('can-stache/src/set-identifier');
var canReflect = require('can-reflect');
function makeConverter(getterSetter) {
getterSetter = getterSetter || {};
return function (newVal, source) {
var args = canReflect.toArray(arguments);
if (newVal instanceof SetIdentifier) {
return typeof getterSetter.set === 'function' ? getterSetter.set.apply(this, [newVal.value].concat(args.slice(1))) : source(newVal.value);
} else {
return typeof getterSetter.get === 'function' ? getterSetter.get.apply(this, args) : args[0];
}
};
}
var converterPackages = new WeakMap();
helpers.addConverter = function (name, getterSetter) {
if (typeof name === 'object') {
if (!converterPackages.has(name)) {
converterPackages.set(name, true);
canReflect.eachKey(name, function (getterSetter, name) {
helpers.addConverter(name, getterSetter);
});
}
return;
}
var helper = makeConverter(getterSetter);
helper.isLiveBound = true;
helpers.registerHelper(name, helper);
};
helpers.registerConverter = function (name, getterSetter) {
helpers.registerHelper(name, makeConverter(getterSetter));
};
module.exports = helpers;
});
/*can-stache-ast@1.0.0#controls*/
define('can-stache-ast/controls', function (require, exports, module) {
var <API key> = /(?:(^|\r?\n)(\s*)(\{\{([\s\S]*)\}\}\}?)([^\S\n\r]*)($|\r?\n))|(\{\{([\s\S]*)\}\}\}?)/g, <API key> = /(\s*)(\{\{\{?)(-?)([\s\S]*?)(-?)(\}\}\}?)(\s*)/g;
function <API key>(expression, state) {
expression = expression.trim();
var mode = expression.charAt(0);
if ('#/{&^>!<'.indexOf(mode) >= 0) {
expression = expression.substr(1).trim();
} else {
mode = null;
}
if (mode === '{' && state.node) {
mode = null;
}
return {
mode: mode,
expression: expression
};
}
function cleanLineEndings(template) {
return template.replace(<API key>, function (whole, returnBefore, spaceBefore, special, expression, spaceAfter, returnAfter, spaceLessSpecial, spaceLessExpression, matchIndex) {
spaceAfter = spaceAfter || '';
returnBefore = returnBefore || '';
spaceBefore = spaceBefore || '';
var modeAndExpression = <API key>(expression || spaceLessExpression, {});
if (spaceLessSpecial || '>{'.indexOf(modeAndExpression.mode) >= 0) {
return whole;
} else if ('^#!/'.indexOf(modeAndExpression.mode) >= 0) {
spaceBefore = returnBefore + spaceBefore && ' ';
return spaceBefore + special + (matchIndex !== 0 && returnAfter.length ? returnBefore + '\n' : '');
} else {
return spaceBefore + special + spaceAfter + (spaceBefore.length || matchIndex !== 0 ? returnBefore + '\n' : '');
}
});
}
function <API key>(whole, spaceBefore, bracketBefore, controlBefore, expression, controlAfter, bracketAfter, spaceAfter) {
if (controlBefore === '-') {
spaceBefore = '';
}
if (controlAfter === '-') {
spaceAfter = '';
}
return spaceBefore + bracketBefore + expression + bracketAfter + spaceAfter;
}
function <API key>(template) {
return template.replace(<API key>, <API key>);
}
exports.cleanLineEndings = cleanLineEndings;
exports.<API key> = <API key>;
});
/*can-stache-ast@1.0.0#can-stache-ast*/
define('can-stache-ast', [
'require',
'exports',
'module',
'can-stache-ast/controls',
'can-view-parser'
], function (require, exports, module) {
var controls = require('can-stache-ast/controls');
var parser = require('can-view-parser');
exports.parse = function (filename, source) {
if (arguments.length === 1) {
source = arguments[0];
filename = undefined;
}
var template = source;
template = controls.<API key>(template);
template = controls.cleanLineEndings(template);
var imports = [], dynamicImports = [], importDeclarations = [], ases = {}, inImport = false, inFrom = false, inAs = false, isUnary = false, importIsDynamic = false, currentAs = '', currentFrom = '';
function processImport(line) {
if (currentAs) {
ases[currentAs] = currentFrom;
currentAs = '';
}
if (importIsDynamic) {
dynamicImports.push(currentFrom);
} else {
imports.push(currentFrom);
}
importDeclarations.push({
specifier: currentFrom,
loc: { line: line }
});
}
var program = parser(template, {
filename: filename,
start: function (tagName, unary) {
if (tagName === 'can-import') {
isUnary = unary;
importIsDynamic = false;
inImport = true;
} else if (tagName === 'can-dynamic-import') {
isUnary = unary;
importIsDynamic = true;
inImport = true;
} else if (inImport) {
importIsDynamic = true;
inImport = false;
}
},
attrStart: function (attrName) {
if (attrName === 'from') {
inFrom = true;
} else if (attrName === 'as' || attrName === 'export-as') {
inAs = true;
}
},
attrEnd: function (attrName) {
if (attrName === 'from') {
inFrom = false;
} else if (attrName === 'as' || attrName === 'export-as') {
inAs = false;
}
},
attrValue: function (value) {
if (inFrom && inImport) {
currentFrom = value;
} else if (inAs && inImport) {
currentAs = value;
}
},
end: function (tagName, unary, line) {
if ((tagName === 'can-import' || tagName === 'can-dynamic-import') && isUnary) {
processImport(line);
}
},
close: function (tagName, unary, line) {
if (tagName === 'can-import' || tagName === 'can-dynamic-import') {
processImport(line);
}
},
chars: function (text) {
if (text.trim().length > 0) {
importIsDynamic = true;
}
},
special: function () {
importIsDynamic = true;
}
}, true);
return {
intermediate: program,
program: program,
imports: imports,
dynamicImports: dynamicImports,
importDeclarations: importDeclarations,
ases: ases,
exports: ases
};
};
});
/*can-import-module@1.0.0#can-import-module*/
define('can-import-module', [
'require',
'exports',
'module',
'can-globals/global/global',
'can-namespace'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var getGlobal = require('can-globals/global/global');
var namespace = require('can-namespace');
module.exports = namespace.import = function (moduleName, parentName) {
return new Promise(function (resolve, reject) {
try {
var global = getGlobal();
if (typeof global.System === 'object' && isFunction(global.System['import'])) {
global.System['import'](moduleName, { name: parentName }).then(resolve, reject);
} else if (global.define && global.define.amd) {
global.require([moduleName], function (value) {
resolve(value);
});
} else if (global.require) {
resolve(global.require(moduleName));
} else {
if (typeof stealRequire !== 'undefined') {
steal.import(moduleName, { name: parentName }).then(resolve, reject);
} else {
resolve();
}
}
} catch (err) {
reject(err);
}
});
};
function isFunction(fn) {
return typeof fn === 'function';
}
}(function () {
return this;
}(), require, exports, module));
});
/*can-stache@4.8.0#can-stache*/
define('can-stache', [
'require',
'exports',
'module',
'can-view-parser',
'can-view-callbacks',
'can-stache/src/html_section',
'can-stache/src/text_section',
'can-stache/src/mustache_core',
'can-stache/helpers/core',
'can-stache/helpers/converter',
'can-stache-ast',
'can-stache/src/utils',
'<API key>',
'can-log/dev/dev',
'can-namespace',
'can-globals/document/document',
'can-assign',
'can-import-module',
'can-reflect',
'can-view-target',
'can-view-nodelist'
], function (require, exports, module) {
(function (global, require, exports, module) {
var parser = require('can-view-parser');
var viewCallbacks = require('can-view-callbacks');
var HTMLSectionBuilder = require('can-stache/src/html_section');
var TextSectionBuilder = require('can-stache/src/text_section');
var mustacheCore = require('can-stache/src/mustache_core');
var mustacheHelpers = require('can-stache/helpers/core');
require('can-stache/helpers/converter');
var <API key> = require('can-stache-ast').parse;
var utils = require('can-stache/src/utils');
var <API key> = utils.<API key>;
var last = utils.last;
var attributeEncoder = require('<API key>');
var dev = require('can-log/dev/dev');
var namespace = require('can-namespace');
var DOCUMENT = require('can-globals/document/document');
var assign = require('can-assign');
var importer = require('can-import-module');
var canReflect = require('can-reflect');
require('can-view-target');
require('can-view-nodelist');
if (!viewCallbacks.tag('content')) {
viewCallbacks.tag('content', function (el, tagData) {
return tagData.scope;
});
}
var wrappedAttrPattern = /[{(].*[)}]/;
var <API key> = /^on:|(:to|:from|:bind)$|.*:to:on:.*/;
var svgNamespace = 'http:
var namespaces = {
'svg': svgNamespace,
'g': svgNamespace
}, textContentOnlyTag = {
style: true,
script: true
};
function stache(filename, template) {
if (arguments.length === 1) {
template = arguments[0];
filename = undefined;
}
var inlinePartials = {};
if (typeof template === 'string') {
template = mustacheCore.<API key>(template);
template = mustacheCore.cleanLineEndings(template);
}
var section = new HTMLSectionBuilder(filename), state = {
node: null,
attr: null,
sectionElementStack: [],
text: false,
namespaceStack: [],
textContentOnly: null
}, <API key> = function (section, mode, stache, lineNo) {
if (mode === '>') {
section.add(mustacheCore.<API key>(stache, copyState({
filename: section.filename,
lineNo: lineNo
})));
} else if (mode === '/') {
var createdSection = section.last();
if (createdSection.startedWith === '<') {
inlinePartials[stache] = section.<API key>();
section.removeCurrentNode();
} else {
section.endSection();
}
if (process.env.NODE_ENV !== 'production') {
if (section instanceof HTMLSectionBuilder) {
var last = state.sectionElementStack[state.sectionElementStack.length - 1];
if (last.tag && last.type === 'section' && stache !== '' && stache !== last.tag) {
if (filename) {
dev.warn(filename + ':' + lineNo + ': unexpected closing tag {{/' + stache + '}} expected {{/' + last.tag + '}}');
} else {
dev.warn(lineNo + ': unexpected closing tag {{/' + stache + '}} expected {{/' + last.tag + '}}');
}
}
}
}
if (section instanceof HTMLSectionBuilder) {
state.sectionElementStack.pop();
}
} else if (mode === 'else') {
section.inverse();
} else {
var makeRenderer = section instanceof HTMLSectionBuilder ? mustacheCore.<API key> : mustacheCore.<API key>;
if (mode === '{' || mode === '&') {
section.add(makeRenderer(null, stache, copyState({
filename: section.filename,
lineNo: lineNo
})));
} else if (mode === '
var renderer = makeRenderer(mode, stache, copyState({
filename: section.filename,
lineNo: lineNo
}));
var sectionItem = { type: 'section' };
section.startSection(renderer);
section.last().startedWith = mode;
if (section instanceof HTMLSectionBuilder) {
if (process.env.NODE_ENV !== 'production') {
var tag = typeof renderer.exprData.closingTag === 'function' ? renderer.exprData.closingTag() : '';
sectionItem.tag = tag;
}
state.sectionElementStack.push(sectionItem);
}
} else {
section.add(makeRenderer(null, stache, copyState({
text: true,
filename: section.filename,
lineNo: lineNo
})));
}
}
}, isDirectlyNested = function () {
var lastElement = state.sectionElementStack[state.sectionElementStack.length - 1];
return state.sectionElementStack.length ? lastElement.type === 'section' || lastElement.type === 'custom' : true;
}, copyState = function (overwrites) {
var cur = {
tag: state.node && state.node.tag,
attr: state.attr && state.attr.name,
directlyNested: isDirectlyNested(),
textContentOnly: !!state.textContentOnly
};
return overwrites ? assign(cur, overwrites) : cur;
}, <API key> = function (node, callback) {
if (!node.attributes) {
node.attributes = [];
}
node.attributes.unshift(callback);
};
parser(template, {
filename: filename,
start: function (tagName, unary, lineNo) {
var matchedNamespace = namespaces[tagName];
if (matchedNamespace && !unary) {
state.namespaceStack.push(matchedNamespace);
}
state.node = {
tag: tagName,
children: [],
namespace: matchedNamespace || last(state.namespaceStack)
};
},
end: function (tagName, unary, lineNo) {
var isCustomTag = viewCallbacks.tag(tagName);
var directlyNested = isDirectlyNested();
if (unary) {
section.add(state.node);
if (isCustomTag) {
<API key>(state.node, function (scope, parentNodeList) {
if (process.env.NODE_ENV !== 'production') {
scope.set('scope.lineNumber', lineNo);
}
viewCallbacks.tagHandler(this, tagName, {
scope: scope,
subtemplate: null,
templateType: 'stache',
parentNodeList: parentNodeList,
directlyNested: directlyNested
});
});
}
} else {
section.push(state.node);
state.sectionElementStack.push({
type: isCustomTag ? 'custom' : null,
tag: isCustomTag ? null : tagName,
templates: {},
directlyNested: directlyNested
});
if (isCustomTag) {
section.startSubSection();
} else if (textContentOnlyTag[tagName]) {
state.textContentOnly = new TextSectionBuilder();
}
}
state.node = null;
},
close: function (tagName, lineNo) {
var matchedNamespace = namespaces[tagName];
if (matchedNamespace) {
state.namespaceStack.pop();
}
var isCustomTag = viewCallbacks.tag(tagName), renderer;
if (isCustomTag) {
renderer = section.<API key>();
}
if (textContentOnlyTag[tagName]) {
section.last().add(state.textContentOnly.compile(copyState()));
state.textContentOnly = null;
}
var oldNode = section.pop();
if (isCustomTag) {
if (tagName === 'can-template') {
var parent = state.sectionElementStack[state.sectionElementStack.length - 2];
if (renderer) {
parent.templates[oldNode.attrs.name] = <API key>(renderer);
}
section.removeCurrentNode();
} else {
var current = state.sectionElementStack[state.sectionElementStack.length - 1];
<API key>(oldNode, function (scope, parentNodeList) {
if (process.env.NODE_ENV !== 'production') {
scope.set('scope.lineNumber', lineNo);
}
viewCallbacks.tagHandler(this, tagName, {
scope: scope,
subtemplate: renderer ? <API key>(renderer) : renderer,
templateType: 'stache',
parentNodeList: parentNodeList,
templates: current.templates,
directlyNested: current.directlyNested
});
});
}
}
state.sectionElementStack.pop();
},
attrStart: function (attrName, lineNo) {
if (state.node.section) {
state.node.section.add(attrName + '="');
} else {
state.attr = {
name: attrName,
value: ''
};
}
},
attrEnd: function (attrName, lineNo) {
if (state.node.section) {
state.node.section.add('" ');
} else {
if (!state.node.attrs) {
state.node.attrs = {};
}
state.node.attrs[state.attr.name] = state.attr.section ? state.attr.section.compile(copyState()) : state.attr.value;
var attrCallback = viewCallbacks.attr(attrName);
if (process.env.NODE_ENV !== 'production') {
var decodedAttrName = attributeEncoder.decode(attrName);
var weirdAttribute = !!wrappedAttrPattern.test(decodedAttrName) || !!<API key>.test(decodedAttrName);
if (weirdAttribute && !attrCallback) {
dev.warn('unknown attribute binding ' + decodedAttrName + '. Is can-stache-bindings imported?');
}
}
if (attrCallback) {
if (!state.node.attributes) {
state.node.attributes = [];
}
state.node.attributes.push(function (scope, nodeList) {
if (process.env.NODE_ENV !== 'production') {
scope.set('scope.lineNumber', lineNo);
}
attrCallback(this, {
attributeName: attrName,
scope: scope,
nodeList: nodeList
});
});
}
state.attr = null;
}
},
attrValue: function (value, lineNo) {
var section = state.node.section || state.attr.section;
if (section) {
section.add(value);
} else {
state.attr.value += value;
}
},
chars: function (text, lineNo) {
(state.textContentOnly || section).add(text);
},
special: function (text, lineNo) {
var firstAndText = mustacheCore.<API key>(text, state), mode = firstAndText.mode, expression = firstAndText.expression;
if (expression === 'else') {
var inverseSection;
if (state.attr && state.attr.section) {
inverseSection = state.attr.section;
} else if (state.node && state.node.section) {
inverseSection = state.node.section;
} else {
inverseSection = state.textContentOnly || section;
}
inverseSection.inverse();
return;
}
if (mode === '!') {
return;
}
if (state.node && state.node.section) {
<API key>(state.node.section, mode, expression, lineNo);
if (state.node.section.subSectionDepth() === 0) {
state.node.attributes.push(state.node.section.compile(copyState()));
delete state.node.section;
}
} else if (state.attr) {
if (!state.attr.section) {
state.attr.section = new TextSectionBuilder();
if (state.attr.value) {
state.attr.section.add(state.attr.value);
}
}
<API key>(state.attr.section, mode, expression, lineNo);
} else if (state.node) {
if (!state.node.attributes) {
state.node.attributes = [];
}
if (!mode) {
state.node.attributes.push(mustacheCore.<API key>(null, expression, copyState({
filename: section.filename,
lineNo: lineNo
})));
} else if (mode === '
if (!state.node.section) {
state.node.section = new TextSectionBuilder();
}
<API key>(state.node.section, mode, expression, lineNo);
} else {
throw new Error(mode + ' is currently not supported within a tag.');
}
} else {
<API key>(state.textContentOnly || section, mode, expression, lineNo);
}
},
comment: function (text) {
section.add({ comment: text });
},
done: function (lineNo) {
}
});
var renderer = section.compile();
var scopifiedRenderer = HTMLSectionBuilder.scopify(function (scope, nodeList) {
var templateContext = scope.templateContext;
canReflect.eachKey(inlinePartials, function (partial, partialName) {
canReflect.setKeyValue(templateContext.partials, partialName, partial);
});
canReflect.setKeyValue(templateContext, 'view', scopifiedRenderer);
if (process.env.NODE_ENV !== 'production') {
canReflect.setKeyValue(templateContext, 'filename', section.filename);
}
return renderer.apply(this, arguments);
});
return scopifiedRenderer;
}
assign(stache, mustacheHelpers);
stache.safeString = function (text) {
return {
toString: function () {
return text;
}
};
};
stache.async = function (source) {
var iAi = <API key>(source);
var importPromises = iAi.imports.map(function (moduleName) {
return importer(moduleName);
});
return Promise.all(importPromises).then(function () {
return stache(iAi.intermediate);
});
};
var templates = {};
stache.from = mustacheCore.getTemplateById = function (id) {
if (!templates[id]) {
var el = DOCUMENT().getElementById(id);
if (el) {
templates[id] = stache('#' + id, el.innerHTML);
}
}
return templates[id];
};
stache.registerPartial = function (id, partial) {
templates[id] = typeof partial === 'string' ? stache(partial) : partial;
};
stache.addBindings = viewCallbacks.attrs;
module.exports = namespace.stache = stache;
}(function () {
return this;
}(), require, exports, module));
});
/*can-view-model@4.0.1#can-view-model*/
define('can-view-model', [
'require',
'exports',
'module',
'can-simple-map',
'can-namespace',
'can-globals/document/document',
'can-reflect',
'can-symbol'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var SimpleMap = require('can-simple-map');
var ns = require('can-namespace');
var getDocument = require('can-globals/document/document');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var viewModelSymbol = canSymbol.for('can.viewModel');
module.exports = ns.viewModel = function (el, attr, val) {
if (typeof el === 'string') {
el = getDocument().querySelector(el);
} else if (canReflect.isListLike(el) && !el.nodeType) {
el = el[0];
}
if (canReflect.isObservableLike(attr) && canReflect.isMapLike(attr)) {
el[viewModelSymbol] = attr;
return;
}
var scope = el[viewModelSymbol];
if (!scope) {
scope = new SimpleMap();
el[viewModelSymbol] = scope;
}
switch (arguments.length) {
case 0:
case 1:
return scope;
case 2:
return canReflect.getKeyValue(scope, attr);
default:
canReflect.setKeyValue(scope, attr, val);
return el;
}
};
}(function () {
return this;
}(), require, exports, module));
});
/*<API key>@0.3.1#event*/
define('<API key>/event', [
'require',
'exports',
'module',
'can-reflect',
'can-dom-events',
'can-dom-events/helpers/util'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var domEvents = require('can-dom-events');
var isDomEventTarget = require('can-dom-events/helpers/util').isDomEventTarget;
var canEvent = {
on: function on(eventName, handler, queue) {
if (isDomEventTarget(this)) {
domEvents.addEventListener(this, eventName, handler, queue);
} else {
canReflect.onKeyValue(this, eventName, handler, queue);
}
},
off: function off(eventName, handler, queue) {
if (isDomEventTarget(this)) {
domEvents.removeEventListener(this, eventName, handler, queue);
} else {
canReflect.offKeyValue(this, eventName, handler, queue);
}
},
one: function one(event, handler, queue) {
var one = function () {
canEvent.off.call(this, event, one, queue);
return handler.apply(this, arguments);
};
canEvent.on.call(this, event, one, queue);
return this;
}
};
module.exports = canEvent;
});
/*<API key>@0.3.1#get-event-name*/
define('<API key>/get-event-name', [
'require',
'exports',
'module',
'<API key>/behaviors'
], function (require, exports, module) {
var attr = require('<API key>/behaviors');
var isRadioInput = function isRadioInput(el) {
return el.nodeName.toLowerCase() === 'input' && el.type === 'radio';
};
var isValidProp = function isValidProp(prop, bindingData) {
return prop === 'checked' && !bindingData.legacyBindings;
};
module.exports = function getEventName(el, prop, bindingData) {
var event = 'change';
if (isRadioInput(el) && isValidProp(prop, bindingData)) {
event = '<API key>';
}
if (attr.findSpecialListener(prop)) {
event = prop;
}
return event;
};
});
/*<API key>@2.1.0#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-globals/document/document',
'can-namespace'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var getDocument = require('can-globals/document/document');
var namespace = require('can-namespace');
function getRoot() {
return getDocument().documentElement;
}
function findParentForm(el) {
while (el) {
if (el.nodeName === 'FORM') {
break;
}
el = el.parentNode;
}
return el;
}
function <API key>(source, dest) {
var name = source.getAttribute('name');
return name && name === dest.getAttribute('name') && findParentForm(source) === findParentForm(dest);
}
function isRadioInput(el) {
return el.nodeName === 'INPUT' && el.type === 'radio';
}
function attachRootListener(domEvents, eventTypeTargets) {
var root = getRoot();
var newListener = function (event) {
var target = event.target;
if (!isRadioInput(target)) {
return;
}
for (var eventType in eventTypeTargets) {
var newEvent = { type: eventType };
var listeningNodes = eventTypeTargets[eventType];
listeningNodes.forEach(function (el) {
if (<API key>(target, el)) {
domEvents.dispatch(el, newEvent, false);
}
});
}
};
domEvents.addEventListener(root, 'change', newListener);
return newListener;
}
function detachRootListener(domEvents, listener) {
var root = getRoot();
domEvents.removeEventListener(root, 'change', listener);
}
var radioChangeEvent = {
defaultEventType: 'radiochange',
addEventListener: function (target, eventType, handler) {
if (!isRadioInput(target)) {
throw new Error('Listeners for ' + eventType + ' must be radio inputs');
}
var <API key> = radioChangeEvent.<API key>;
if (!<API key>) {
<API key> = radioChangeEvent.<API key> = {};
if (!radioChangeEvent._rootListener) {
radioChangeEvent._rootListener = attachRootListener(this, <API key>);
}
}
var trackedRadios = radioChangeEvent.<API key>[eventType];
if (!trackedRadios) {
trackedRadios = radioChangeEvent.<API key>[eventType] = new Set();
}
trackedRadios.add(target);
target.addEventListener(eventType, handler);
},
removeEventListener: function (target, eventType, handler) {
target.removeEventListener(eventType, handler);
var <API key> = radioChangeEvent.<API key>;
if (!<API key>) {
return;
}
var trackedRadios = <API key>[eventType];
if (!trackedRadios) {
return;
}
trackedRadios.delete(target);
if (trackedRadios.size === 0) {
delete <API key>[eventType];
for (var key in <API key>) {
if (<API key>.hasOwnProperty(key)) {
return;
}
}
delete radioChangeEvent.<API key>;
detachRootListener(this, radioChangeEvent._rootListener);
delete radioChangeEvent._rootListener;
}
}
};
module.exports = namespace.domEventRadioChange = radioChangeEvent;
}(function () {
return this;
}(), require, exports, module));
});
/*<API key>@0.3.1#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-queues',
'<API key>/event',
'can-reflect',
'can-observation',
'<API key>/behaviors',
'<API key>/get-event-name',
'<API key>',
'<API key>',
'<API key>/settable/settable',
'can-dom-events',
'<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
var queues = require('can-queues');
var canEvent = require('<API key>/event');
var canReflect = require('can-reflect');
var Observation = require('can-observation');
var attr = require('<API key>/behaviors');
var getEventName = require('<API key>/get-event-name');
var canReflectDeps = require('<API key>');
var ObservationRecorder = require('<API key>');
var SettableObservable = require('<API key>/settable/settable');
var domEvents = require('can-dom-events');
var radioChangeEvent = require('<API key>');
var <API key> = '<API key>';
domEvents.addEvent(radioChangeEvent, <API key>);
var isSelect = function isSelect(el) {
return el.nodeName.toLowerCase() === 'select';
};
var isMultipleSelect = function isMultipleSelect(el, prop) {
return isSelect(el) && prop === 'value' && el.multiple;
};
var slice = Array.prototype.slice;
function canUtilAEL() {
var args = slice.call(arguments, 0);
args.unshift(this);
return domEvents.addEventListener.apply(null, args);
}
function canUtilREL() {
var args = slice.call(arguments, 0);
args.unshift(this);
return domEvents.removeEventListener.apply(null, args);
}
function AttributeObservable(el, prop, bindingData, event) {
this.el = el;
this.bound = false;
this.bindingData = bindingData;
this.prop = isMultipleSelect(el, prop) ? 'values' : prop;
this.event = event || getEventName(el, prop, bindingData);
this.handler = this.handler.bind(this);
canReflectDeps.addMutatedBy(this.el, this.prop, this);
canReflect.assignSymbols(this, {
'can.getName': function getName() {
return 'AttributeObservable<' + el.nodeName.toLowerCase() + '.' + this.prop + '>';
}
});
}
AttributeObservable.prototype = Object.create(SettableObservable.prototype);
Object.assign(AttributeObservable.prototype, {
constructor: AttributeObservable,
get: function get() {
if (ObservationRecorder.isRecording()) {
ObservationRecorder.add(this);
if (!this.bound) {
Observation.temporarilyBind(this);
}
}
return attr.get(this.el, this.prop);
},
set: function set(newVal) {
attr.setAttrOrProp(this.el, this.prop, newVal);
this.value = newVal;
return newVal;
},
handler: function handler(newVal, event) {
var old = this.value;
this.value = attr.get(this.el, this.prop);
if (this.value !== old) {
if (typeof this._log === 'function') {
this._log(old, newVal);
}
queues.enqueueByQueue(this.handlers.getNode([]), this, [
newVal,
old
], null, [
this.el,
this.prop,
'changed to',
newVal,
'from',
old,
'by',
event
]);
}
},
onBound: function onBound() {
var observable = this;
observable.bound = true;
observable._handler = function (event) {
observable.handler(attr.get(observable.el, observable.prop), event);
};
if (observable.event === <API key>) {
canEvent.on.call(observable.el, 'change', observable._handler);
}
var specialBinding = attr.findSpecialListener(observable.prop);
if (specialBinding) {
observable._specialDisposal = specialBinding.call(observable.el, observable.prop, observable._handler, canUtilAEL);
}
canEvent.on.call(observable.el, observable.event, observable._handler);
this.value = attr.get(this.el, this.prop);
},
onUnbound: function onUnbound() {
var observable = this;
observable.bound = false;
if (observable.event === <API key>) {
canEvent.off.call(observable.el, 'change', observable._handler);
}
if (observable._specialDisposal) {
observable._specialDisposal.call(observable.el, canUtilREL);
observable._specialDisposal = null;
}
canEvent.off.call(observable.el, observable.event, observable._handler);
},
<API key>: function <API key>() {
return true;
},
<API key>: function <API key>() {
return {
keyDependencies: new Map([[
this.el,
new Set([this.prop])
]])
};
}
});
canReflect.assignSymbols(AttributeObservable.prototype, {
'can.isMapLike': false,
'can.getValue': AttributeObservable.prototype.get,
'can.setValue': AttributeObservable.prototype.set,
'can.onValue': AttributeObservable.prototype.on,
'can.offValue': AttributeObservable.prototype.off,
'can.<API key>': AttributeObservable.prototype.hasDependencies,
'can.<API key>': AttributeObservable.prototype.<API key>
});
module.exports = AttributeObservable;
}(function () {
return this;
}(), require, exports, module));
});
/*can-stache-bindings@4.2.6#can-stache-bindings*/
define('can-stache-bindings', [
'require',
'exports',
'module',
'can-stache/src/expression',
'can-view-callbacks',
'can-view-model',
'can-stache-key',
'<API key>',
'<API key>',
'can-assign',
'can-log/dev/dev',
'can-dom-mutate',
'can-dom-data-state',
'can-symbol',
'can-reflect',
'<API key>',
'<API key>',
'can-queues',
'<API key>/setter/setter',
'<API key>',
'can-view-scope/make-compute-like',
'can-view-nodelist',
'<API key>/event'
], function (require, exports, module) {
var expression = require('can-stache/src/expression');
var viewCallbacks = require('can-view-callbacks');
var canViewModel = require('can-view-model');
var observeReader = require('can-stache-key');
var ObservationRecorder = require('<API key>');
var SimpleObservable = require('<API key>');
var assign = require('can-assign');
var dev = require('can-log/dev/dev');
var domMutate = require('can-dom-mutate');
var domData = require('can-dom-data-state');
var canSymbol = require('can-symbol');
var canReflect = require('can-reflect');
var canReflectDeps = require('<API key>');
var encoder = require('<API key>');
var queues = require('can-queues');
var SettableObservable = require('<API key>/setter/setter');
var AttributeObservable = require('<API key>');
var makeCompute = require('can-view-scope/make-compute-like');
var ViewNodeList = require('can-view-nodelist');
var canEvent = require('<API key>/event');
var noop = function () {
};
var bindings = new Map();
var onMatchStr = 'on:', vmMatchStr = 'vm:', elMatchStr = 'el:', byMatchStr = ':by:', toMatchStr = ':to', fromMatchStr = ':from', bindMatchStr = ':bind', viewModelBindingStr = 'viewModel', attributeBindingStr = 'attribute', scopeBindingStr = 'scope', <API key> = '<API key>', getValueSymbol = canSymbol.for('can.getValue'), onValueSymbol = canSymbol.for('can.onValue'), getChangesSymbol = canSymbol.for('can.<API key>');
var <API key> = function () {
throw new Error('can-stache-bindings - you can not have contextual bindings ( this:from=\'value\' ) and key bindings ( prop:from=\'value\' ) on one element.');
};
var checkBindingState = function (bindingState, dataBinding) {
var <API key> = dataBinding.bindingInfo.parentToChild && dataBinding.bindingInfo.child === viewModelBindingStr;
if (<API key>) {
var bindingName = dataBinding.bindingInfo.childName;
var isSettingViewModel = <API key> && (bindingName === 'this' || bindingName === '.');
if (isSettingViewModel) {
if (bindingState.isSettingViewModel || bindingState.<API key>) {
<API key>();
} else {
return {
isSettingViewModel: true,
<API key>: undefined
};
}
} else {
if (bindingState.isSettingViewModel) {
<API key>();
} else {
return {
<API key>: true,
<API key>: bindingState.<API key>
};
}
}
} else {
return bindingState;
}
};
var behaviors = {
viewModel: function (el, tagData, makeViewModel, <API key>, <API key>) {
var bindingsSemaphore = {}, viewModel, onCompleteBindings = [], onTeardowns = {}, bindingInfos = {}, <API key> = assign({}, <API key>), bindingsState = {
<API key>: false,
isSettingViewModel: false,
<API key>: <API key> || {}
}, hasDataBinding = false;
canReflect.each(el.attributes || [], function (node) {
var dataBinding = makeDataBinding(node, el, {
templateType: tagData.templateType,
scope: tagData.scope,
semaphore: bindingsSemaphore,
getViewModel: function () {
return viewModel;
},
<API key>: <API key>,
alreadyUpdatedChild: true,
nodeList: tagData.parentNodeList,
favorViewModel: true
});
if (dataBinding) {
bindingsState = checkBindingState(bindingsState, dataBinding);
hasDataBinding = true;
if (dataBinding.onCompleteBinding) {
if (dataBinding.bindingInfo.parentToChild && dataBinding.value !== undefined) {
if (bindingsState.isSettingViewModel) {
bindingsState.<API key> = dataBinding.value;
} else {
bindingsState.<API key>[cleanVMName(dataBinding.bindingInfo.childName, tagData.scope)] = dataBinding.value;
}
}
onCompleteBindings.push(dataBinding.onCompleteBinding);
}
onTeardowns[node.name] = dataBinding.onTeardown;
}
});
if (<API key> && !hasDataBinding) {
return;
}
viewModel = makeViewModel(bindingsState.<API key>, hasDataBinding);
for (var i = 0, len = onCompleteBindings.length; i < len; i++) {
onCompleteBindings[i]();
}
var attributeDisposal;
if (!bindingsState.isSettingViewModel) {
attributeDisposal = domMutate.<API key>(el, function (ev) {
var attrName = ev.attributeName, value = el.getAttribute(attrName);
if (onTeardowns[attrName]) {
onTeardowns[attrName]();
}
var <API key> = bindingInfos[attrName] && bindingInfos[attrName].parent === attributeBindingStr;
if (value !== null || <API key>) {
var dataBinding = makeDataBinding({
name: attrName,
value: value
}, el, {
templateType: tagData.templateType,
scope: tagData.scope,
semaphore: {},
getViewModel: function () {
return viewModel;
},
<API key>: <API key>,
initializeValues: true,
nodeList: tagData.parentNodeList
});
if (dataBinding) {
if (dataBinding.onCompleteBinding) {
dataBinding.onCompleteBinding();
}
bindingInfos[attrName] = dataBinding.bindingInfo;
onTeardowns[attrName] = dataBinding.onTeardown;
}
}
});
}
return function () {
if (attributeDisposal) {
attributeDisposal();
attributeDisposal = undefined;
}
for (var attrName in onTeardowns) {
onTeardowns[attrName]();
}
};
},
data: function (el, attrData) {
if (domData.get.call(el, 'preventDataBindings')) {
return;
}
var viewModel, getViewModel = ObservationRecorder.ignore(function () {
return viewModel || (viewModel = canViewModel(el));
}), semaphore = {}, teardown, attributeDisposal, removedDisposal;
var dataBinding = makeDataBinding({
name: attrData.attributeName,
value: el.getAttribute(attrData.attributeName),
nodeList: attrData.nodeList
}, el, {
templateType: attrData.templateType,
scope: attrData.scope,
semaphore: semaphore,
getViewModel: getViewModel,
syncChildWithParent: false
});
if (process.env.NODE_ENV !== 'production') {
if (dataBinding.bindingInfo.child === 'viewModel' && !domData.get(el, 'viewModel')) {
dev.warn('This element does not have a viewModel. (Attempting to bind `' + dataBinding.bindingInfo.<API key> + '="' + dataBinding.bindingInfo.parentName + '"`)');
}
}
if (dataBinding.onCompleteBinding) {
dataBinding.onCompleteBinding();
}
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
}, el, {
templateType: attrData.templateType,
scope: attrData.scope,
semaphore: semaphore,
getViewModel: getViewModel,
initializeValues: true,
nodeList: attrData.nodeList,
syncChildWithParent: false
});
if (dataBinding) {
if (dataBinding.onCompleteBinding) {
dataBinding.onCompleteBinding();
}
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);
}
teardown = dataBinding.onTeardown;
attributeDisposal = domMutate.<API key>(el, attributeListener);
removedDisposal = domMutate.onNodeRemoval(el, function () {
if (el.ownerDocument.contains(el) === false) {
tearItAllDown();
}
});
},
event: function (el, data) {
var attributeName = encoder.decode(data.attributeName), event, bindingContext;
if (attributeName.indexOf(toMatchStr + ':') !== -1 || attributeName.indexOf(fromMatchStr + ':') !== -1 || attributeName.indexOf(bindMatchStr + ':') !== -1) {
return this.data(el, data);
}
if (startsWith.call(attributeName, onMatchStr)) {
event = attributeName.substr(onMatchStr.length);
var viewModel = el[canSymbol.for('can.viewModel')];
var byParent = data.scope;
if (startsWith.call(event, elMatchStr)) {
event = event.substr(elMatchStr.length);
bindingContext = el;
} else {
if (startsWith.call(event, vmMatchStr)) {
event = event.substr(vmMatchStr.length);
bindingContext = viewModel;
byParent = viewModel;
} else {
bindingContext = viewModel || el;
}
var byIndex = event.indexOf(byMatchStr);
if (byIndex >= 0) {
bindingContext = byParent.get(event.substr(byIndex + byMatchStr.length));
event = event.substr(0, byIndex);
}
}
} else {
throw new Error('can-stache-bindings - unsupported event bindings ' + attributeName);
}
var handler = function (ev) {
var attrVal = el.getAttribute(encoder.encode(attributeName));
if (!attrVal) {
return;
}
var viewModel = canViewModel(el);
var expr = expression.parse(attrVal, {
lookupRule: function () {
return expression.Lookup;
},
methodRule: 'call'
});
if (!(expr instanceof expression.Call)) {
throw new Error('can-stache-bindings: Event bindings must be a call expression. Make sure you have a () in ' + data.attributeName + '=' + JSON.stringify(attrVal));
}
var specialValues = {
element: el,
event: ev,
viewModel: viewModel,
arguments: arguments
};
var localScope = data.scope.add(specialValues, { special: true });
var updateFn = function () {
var value = expr.value(localScope, { <API key>: true });
value = canReflect.isValueLike(value) ? canReflect.getValue(value) : value;
return typeof value === 'function' ? value(el) : value;
};
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(updateFn, 'name', { value: attributeName + '="' + attrVal + '"' });
}
queues.batch.start();
var mutateQueueArgs = [];
mutateQueueArgs = [
updateFn,
null,
null,
{}
];
if (process.env.NODE_ENV !== 'production') {
mutateQueueArgs = [
updateFn,
null,
null,
{
reasonLog: [
el,
ev,
attributeName + '=' + attrVal
]
}
];
}
queues.mutateQueue.enqueue.apply(queues.mutateQueue, mutateQueueArgs);
queues.batch.stop();
};
var attributesDisposal, removalDisposal;
var attributesHandler = function (ev) {
var isEventAttribute = ev.attributeName === attributeName;
var isRemoved = !el.getAttribute(attributeName);
var <API key> = isEventAttribute && isRemoved;
if (<API key>) {
unbindEvent();
}
};
var removalHandler = function () {
if (!el.ownerDocument.contains(el)) {
unbindEvent();
}
};
var unbindEvent = function () {
canEvent.off.call(bindingContext, event, handler);
if (attributesDisposal) {
attributesDisposal();
attributesDisposal = undefined;
}
if (removalDisposal) {
removalDisposal();
removalDisposal = undefined;
}
};
canEvent.on.call(bindingContext, event, handler);
attributesDisposal = domMutate.<API key>(el, attributesHandler);
removalDisposal = domMutate.onNodeRemoval(el, removalHandler);
}
};
bindings.set(/[\w\.:]+:to$/, behaviors.data);
bindings.set(/[\w\.:]+:from$/, behaviors.data);
bindings.set(/[\w\.:]+:bind$/, behaviors.data);
bindings.set(/[\w\.:]+:raw$/, behaviors.data);
bindings.set(/[\w\.:]+:to:on:[\w\.:]+/, behaviors.data);
bindings.set(/[\w\.:]+:from:on:[\w\.:]+/, behaviors.data);
bindings.set(/[\w\.:]+:bind:on:[\w\.:]+/, behaviors.data);
bindings.set(/on:[\w\.:]+/, behaviors.event);
var getObservableFrom = {
<API key>: function (el, scope, vmNameOrProp, bindingData, mustBeSettable, stickyCompute, event) {
var viewModel = el[canSymbol.for('can.viewModel')];
if (viewModel) {
return this.viewModel.apply(this, arguments);
} else {
return this.attribute.apply(this, arguments);
}
},
scope: function (el, scope, scopeProp, bindingData, mustBeSettable, stickyCompute) {
if (!scopeProp) {
return new SimpleObservable();
} else {
if (mustBeSettable) {
var parentExpression = expression.parse(scopeProp, { baseMethodType: 'Call' });
return parentExpression.value(scope);
} else {
var observation = {};
canReflect.assignSymbols(observation, {
'can.getValue': function getValue() {
},
'can.<API key>': function <API key>() {
return false;
},
'can.setValue': function setValue(newVal) {
scope.set(cleanVMName(scopeProp, scope), newVal);
},
'can.getWhatIChange': function getWhatIChange() {
var data = scope.getDataForScopeSet(cleanVMName(scopeProp, scope));
return {
mutate: {
keyDependencies: new Map([[
data.parent,
new Set([data.key])
]])
}
};
},
'can.getName': function getName() {
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;
}
}
});
var data = scope.getDataForScopeSet(cleanVMName(scopeProp, scope));
if (data.parent && data.key) {
canReflectDeps.addMutatedBy(data.parent, data.key, observation);
}
return observation;
}
}
},
viewModel: function (el, scope, vmName, bindingData, mustBeSettable, stickyCompute, childEvent) {
var setName = cleanVMName(vmName, scope);
var isBoundToContext = vmName === '.' || vmName === 'this';
var keysToRead = isBoundToContext ? [] : observeReader.reads(vmName);
function <API key>() {
var viewModel = bindingData.getViewModel();
return observeReader.read(viewModel, keysToRead, {}).value;
}
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(<API key>, 'name', { value: 'viewModel.' + vmName });
}
var observation = new SettableObservable(<API key>, function <API key>(newVal) {
var viewModel = bindingData.getViewModel();
if (stickyCompute) {
var oldValue = canReflect.getKeyValue(viewModel, setName);
if (canReflect.isObservableLike(oldValue)) {
canReflect.setValue(oldValue, newVal);
} else {
canReflect.setKeyValue(viewModel, setName, new SimpleObservable(canReflect.getValue(stickyCompute)));
}
} else {
if (isBoundToContext) {
canReflect.setValue(viewModel, newVal);
} else {
canReflect.setKeyValue(viewModel, setName, newVal);
}
}
});
if (process.env.NODE_ENV !== 'production') {
var viewModel = bindingData.getViewModel();
if (viewModel && setName) {
canReflectDeps.addMutatedBy(viewModel, setName, observation);
}
}
return observation;
},
attribute: function (el, scope, prop, bindingData, mustBeSettable, stickyCompute, event, bindingInfo) {
return new AttributeObservable(el, prop, bindingData, event);
}
};
var bind = {
childToParent: function (el, parentObservable, childObservable, bindingsSemaphore, attrName, syncChild, bindingInfo) {
function updateParent(newVal) {
if (!bindingInfo.active) {
return;
}
if (!bindingsSemaphore[attrName]) {
if (parentObservable && parentObservable[getValueSymbol]) {
var hasDependencies = canReflect.<API key>(parentObservable);
if (!hasDependencies || canReflect.getValue(parentObservable) !== newVal) {
canReflect.setValue(parentObservable, newVal);
}
if (syncChild && hasDependencies) {
if (canReflect.getValue(parentObservable) !== canReflect.getValue(childObservable)) {
bindingsSemaphore[attrName] = (bindingsSemaphore[attrName] || 0) + 1;
queues.batch.start();
canReflect.setValue(childObservable, canReflect.getValue(parentObservable));
queues.mutateQueue.enqueue(function <API key>() {
--bindingsSemaphore[attrName];
}, null, [], {});
queues.batch.stop();
}
}
} else if (canReflect.isMapLike(parentObservable)) {
var attrValue = el.getAttribute(attrName);
dev.warn('can-stache-bindings: Merging ' + attrName + ' into ' + attrValue + ' because its parent is non-observable');
canReflect.eachKey(parentObservable, function (prop) {
canReflect.deleteKeyValue(parentObservable, prop);
});
canReflect.setValue(parentObservable, newVal && newVal.serialize ? newVal.serialize() : newVal, true);
}
}
}
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(updateParent, 'name', { value: 'update ' + bindingInfo.parent + '.' + bindingInfo.parentName + ' of <' + el.nodeName.toLowerCase() + '>' });
}
if (childObservable && childObservable[getValueSymbol]) {
canReflect.onValue(childObservable, updateParent, 'domUI');
if (process.env.NODE_ENV !== 'production') {
canReflectDeps.addMutatedBy(parentObservable, childObservable);
updateParent[getChangesSymbol] = function <API key>() {
return { valueDependencies: new Set([parentObservable]) };
};
}
}
return updateParent;
},
parentToChild: function (el, parentObservable, childObservable, bindingsSemaphore, attrName, bindingInfo) {
var updateChild = function updateChild(newValue) {
if (!bindingInfo.active) {
return;
}
bindingsSemaphore[attrName] = (bindingsSemaphore[attrName] || 0) + 1;
queues.batch.start();
canReflect.setValue(childObservable, newValue);
queues.mutateQueue.enqueue(function <API key>() {
--bindingsSemaphore[attrName];
}, null, [], {});
queues.batch.stop();
};
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(updateChild, 'name', { value: 'update ' + bindingInfo.child + '.' + bindingInfo.childName + ' of <' + el.nodeName.toLowerCase() + '>' });
}
if (parentObservable && parentObservable[getValueSymbol]) {
canReflect.onValue(parentObservable, updateChild, 'domUI');
if (process.env.NODE_ENV !== 'production') {
canReflectDeps.addMutatedBy(childObservable, parentObservable);
updateChild[getChangesSymbol] = function <API key>() {
return { valueDependencies: new Set([childObservable]) };
};
}
}
return updateChild;
}
};
var startsWith = String.prototype.startsWith || function (text) {
return this.indexOf(text) === 0;
};
function getEventName(result) {
if (result.special.on !== undefined) {
return result.tokens[result.special.on + 1];
}
}
var bindingRules = {
to: {
childToParent: true,
parentToChild: false,
syncChildWithParent: false
},
from: {
childToParent: false,
parentToChild: true,
syncChildWithParent: false
},
bind: {
childToParent: true,
parentToChild: true,
syncChildWithParent: true
},
raw: {
childToParent: false,
parentToChild: true,
syncChildWithParent: false
}
};
var bindingNames = [];
var special = {
vm: true,
on: true
};
canReflect.each(bindingRules, function (value, key) {
bindingNames.push(key);
special[key] = true;
});
function tokenize(source) {
var splitByColon = source.split(':');
var result = {
tokens: [],
special: {}
};
splitByColon.forEach(function (token) {
if (special[token]) {
result.special[token] = result.tokens.push(token) - 1;
} else {
result.tokens.push(token);
}
});
return result;
}
var getChildBindingStr = function (tokens, favorViewModel) {
if (tokens.indexOf('vm') >= 0) {
return viewModelBindingStr;
} else if (tokens.indexOf('el') >= 0) {
return attributeBindingStr;
} else {
return favorViewModel ? viewModelBindingStr : <API key>;
}
};
var getBindingInfo = function (node, <API key>, templateType, tagName, favorViewModel) {
var bindingInfo, attributeName = encoder.decode(node.name), attributeValue = node.value || '';
var result = tokenize(attributeName), dataBindingName, specialIndex;
bindingNames.forEach(function (name) {
if (result.special[name] !== undefined && result.special[name] > 0) {
dataBindingName = name;
specialIndex = result.special[name];
return false;
}
});
if (dataBindingName) {
var childEventName = getEventName(result);
var initializeValues = childEventName && dataBindingName !== 'bind' ? false : true;
bindingInfo = assign({
parent: scopeBindingStr,
child: getChildBindingStr(result.tokens, favorViewModel),
childName: result.tokens[specialIndex - 1],
childEvent: childEventName,
<API key>: attributeName,
parentName: result.special.raw ? '"' + attributeValue + '"' : attributeValue,
initializeValues: initializeValues
}, bindingRules[dataBindingName]);
if (attributeValue.trim().charAt(0) === '~') {
bindingInfo.stickyParentToChild = true;
}
return bindingInfo;
}
};
var makeDataBinding = function (node, el, bindingData) {
var bindingInfo = getBindingInfo(node, bindingData.<API key>, bindingData.templateType, el.nodeName.toLowerCase(), bindingData.favorViewModel);
if (!bindingInfo) {
return;
}
bindingInfo.active = true;
bindingInfo.alreadyUpdatedChild = bindingData.alreadyUpdatedChild;
if (bindingData.initializeValues) {
bindingInfo.initializeValues = true;
}
var parentObservable = getObservableFrom[bindingInfo.parent](el, bindingData.scope, bindingInfo.parentName, bindingData, bindingInfo.parentToChild, undefined, undefined, bindingInfo), childObservable = getObservableFrom[bindingInfo.child](el, bindingData.scope, bindingInfo.childName, bindingData, bindingInfo.childToParent, bindingInfo.stickyParentToChild && parentObservable, bindingInfo.childEvent, bindingInfo), updateParent, updateChild;
if (bindingData.nodeList) {
if (parentObservable) {
canReflect.setPriority(parentObservable, bindingData.nodeList.nesting + 1);
}
if (childObservable) {
canReflect.setPriority(childObservable, bindingData.nodeList.nesting + 1);
}
}
if (bindingInfo.parentToChild) {
updateChild = bind.parentToChild(el, parentObservable, childObservable, bindingData.semaphore, bindingInfo.<API key>, bindingInfo);
}
var completeBinding = function () {
if (bindingInfo.childToParent) {
updateParent = bind.childToParent(el, parentObservable, childObservable, bindingData.semaphore, bindingInfo.<API key>, bindingInfo.syncChildWithParent, bindingInfo);
} else if (bindingInfo.stickyParentToChild && childObservable[onValueSymbol]) {
canReflect.onValue(childObservable, noop, 'mutate');
}
if (bindingInfo.initializeValues) {
initializeValues(bindingInfo, childObservable, parentObservable, updateChild, updateParent);
}
};
var onTeardown = function () {
bindingInfo.active = false;
unbindUpdate(parentObservable, updateChild);
unbindUpdate(childObservable, updateParent);
unbindUpdate(childObservable, noop);
};
if (bindingInfo.child === viewModelBindingStr) {
return {
value: bindingInfo.stickyParentToChild ? makeCompute(parentObservable) : canReflect.getValue(parentObservable),
onCompleteBinding: completeBinding,
bindingInfo: bindingInfo,
onTeardown: onTeardown
};
} else {
completeBinding();
return {
bindingInfo: bindingInfo,
onTeardown: onTeardown
};
}
};
var initializeValues = function (bindingInfo, childObservable, parentObservable, updateChild, updateParent) {
var doUpdateParent = false;
if (bindingInfo.parentToChild && !bindingInfo.childToParent) {
} else if (!bindingInfo.parentToChild && bindingInfo.childToParent) {
doUpdateParent = true;
} else if (canReflect.getValue(childObservable) === undefined) {
} else if (canReflect.getValue(parentObservable) === undefined) {
doUpdateParent = true;
}
if (doUpdateParent) {
updateParent(canReflect.getValue(childObservable));
} else {
if (!bindingInfo.alreadyUpdatedChild) {
updateChild(canReflect.getValue(parentObservable));
}
}
};
var unbindUpdate = function (observable, updater) {
if (observable && observable[getValueSymbol] && typeof updater === 'function') {
canReflect.offValue(observable, updater, 'domUI');
}
}, cleanVMName = function (name, scope) {
if (process.env.NODE_ENV !== 'production') {
if (name.indexOf('@') >= 0) {
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 + '\'.');
}
}
return name.replace(/@/g, '');
};
var canStacheBindings = {
behaviors: behaviors,
getBindingInfo: getBindingInfo,
bindings: bindings
};
canStacheBindings[canSymbol.for('can.callbackMap')] = bindings;
viewCallbacks.attrs(canStacheBindings);
module.exports = canStacheBindings;
});
/*can-component@4.1.3#can-component*/
define('can-component', [
'require',
'exports',
'module',
'can-component/control/control',
'can-namespace',
'can-construct',
'can-stache',
'can-stache-bindings',
'can-view-scope',
'can-view-callbacks',
'can-view-nodelist',
'can-reflect',
'<API key>',
'can-simple-map',
'can-define/map/map',
'can-log',
'can-log/dev/dev',
'can-assign',
'can-view-model',
'can-define/list/list',
'can-dom-data-state',
'can-child-nodes',
'can-string',
'can-dom-events',
'can-dom-mutate',
'can-dom-mutate/node',
'can-symbol',
'can-globals/document/document'
], function (require, exports, module) {
(function (global, require, exports, module) {
var ComponentControl = require('can-component/control/control');
var namespace = require('can-namespace');
var Construct = require('can-construct');
var stache = require('can-stache');
var stacheBindings = require('can-stache-bindings');
var Scope = require('can-view-scope');
var viewCallbacks = require('can-view-callbacks');
var nodeLists = require('can-view-nodelist');
var canReflect = require('can-reflect');
var SimpleObservable = require('<API key>');
var SimpleMap = require('can-simple-map');
var DefineMap = require('can-define/map/map');
var canLog = require('can-log');
var canDev = require('can-log/dev/dev');
var assign = require('can-assign');
require('can-view-model');
require('can-define/list/list');
var domData = require('can-dom-data-state');
var getChildNodes = require('can-child-nodes');
var string = require('can-string');
var domEvents = require('can-dom-events');
var domMutate = require('can-dom-mutate');
var domMutateNode = require('can-dom-mutate/node');
var canSymbol = require('can-symbol');
var DOCUMENT = require('can-globals/document/document');
stache.addBindings(stacheBindings);
function addContext(el, tagData, <API key>) {
var vm;
domData.set.call(el, 'preventDataBindings', true);
var teardown = stacheBindings.behaviors.viewModel(el, <API key>, function (initialData) {
return vm = new SimpleObservable(initialData);
}, undefined, true);
if (!teardown) {
return tagData;
} else {
return assign(assign({}, tagData), {
teardown: teardown,
scope: tagData.scope.add(vm)
});
}
}
function <API key>(tagName, componentTagData, shadowTagData, leakScope, getPrimaryTemplate) {
var options = shadowTagData.options;
return function hookupFunction(el, <API key>) {
var template = getPrimaryTemplate(el) || <API key>.subtemplate, <API key> = template !== <API key>.subtemplate;
if (template) {
delete options.tags[tagName];
var tagData;
if (<API key>) {
if (leakScope.toLightContent) {
tagData = addContext(el, {
scope: <API key>.scope.cloneFromRef(),
options: <API key>.options
}, <API key>);
} else {
tagData = addContext(el, componentTagData, <API key>);
}
} else {
tagData = addContext(el, <API key>, <API key>);
}
var nodeList = nodeLists.register([el], function () {
if (tagData.teardown) {
tagData.teardown();
}
}, <API key>.parentNodeList || true, <API key>.directlyNested);
nodeList.expression = '<can-slot name=\'' + el.getAttribute('name') + '\'/>';
var frag = template(tagData.scope, tagData.options, nodeList);
var newNodes = canReflect.toArray(getChildNodes(frag));
var oldNodes = nodeLists.update(nodeList, newNodes);
nodeLists.replace(oldNodes, frag);
options.tags[tagName] = hookupFunction;
}
};
}
var Component = Construct.extend({
setup: function () {
Construct.setup.apply(this, arguments);
if (Component) {
var self = this;
if (this.prototype.events !== undefined && canReflect.size(this.prototype.events) !== 0) {
this.Control = ComponentControl.extend(this.prototype.events);
}
if (process.env.NODE_ENV !== 'production') {
if (this.prototype.viewModel && canReflect.isConstructorLike(this.prototype.viewModel)) {
canDev.warn('can-component: Assigning a DefineMap or constructor type to the viewModel property may not be what you intended. Did you mean ViewModel instead? More info: https://canjs.com/doc/can-component.prototype.ViewModel.html');
}
}
var protoViewModel = this.prototype.viewModel || this.prototype.scope;
if (protoViewModel && this.prototype.ViewModel) {
throw new Error('Cannot provide both a ViewModel and a viewModel property');
}
var vmName = string.capitalize(string.camelize(this.prototype.tag)) + 'VM';
if (this.prototype.ViewModel) {
if (typeof this.prototype.ViewModel === 'function') {
this.ViewModel = this.prototype.ViewModel;
} else {
this.ViewModel = DefineMap.extend(vmName, {}, this.prototype.ViewModel);
}
} else {
if (protoViewModel) {
if (typeof protoViewModel === 'function') {
if (canReflect.isObservableLike(protoViewModel.prototype) && canReflect.isMapLike(protoViewModel.prototype)) {
this.ViewModel = protoViewModel;
} else {
this.viewModelHandler = protoViewModel;
}
} else {
if (canReflect.isObservableLike(protoViewModel) && canReflect.isMapLike(protoViewModel)) {
if (process.env.NODE_ENV !== 'production') {
canLog.warn('can-component: ' + this.prototype.tag + ' is sharing a single map across all component instances');
}
this.viewModelInstance = protoViewModel;
} else {
canLog.warn('can-component: ' + this.prototype.tag + ' is extending the viewModel into a can-simple-map');
this.ViewModel = SimpleMap.extend(vmName, {}, protoViewModel);
}
}
} else {
this.ViewModel = SimpleMap.extend(vmName, {}, {});
}
}
if (this.prototype.template) {
if (process.env.NODE_ENV !== 'production') {
canLog.warn('can-component.prototype.template: is deprecated and will be removed in a future release. Use can-component.prototype.view');
}
this.renderer = this.prototype.template;
}
if (this.prototype.view) {
this.renderer = this.prototype.view;
}
if (typeof this.renderer === 'string') {
var viewName = string.capitalize(string.camelize(this.prototype.tag)) + 'View';
this.renderer = stache(viewName, this.renderer);
}
viewCallbacks.tag(this.prototype.tag, function (el, options) {
new self(el, options);
});
}
}
}, {
setup: function (el, componentTagData) {
var component = this;
var teardownFunctions = [];
var <API key> = {};
var <API key> = function () {
for (var i = 0, len = teardownFunctions.length; i < len; i++) {
teardownFunctions[i]();
}
};
var setupBindings = !domData.get.call(el, 'preventDataBindings');
var viewModel, frag;
var teardownBindings;
if (setupBindings) {
var setupFn = componentTagData.setupBindings || function (el, callback, data) {
return stacheBindings.behaviors.viewModel(el, componentTagData, callback, data);
};
teardownBindings = setupFn(el, function (<API key>) {
var ViewModel = component.constructor.ViewModel, viewModelHandler = component.constructor.viewModelHandler, viewModelInstance = component.constructor.viewModelInstance;
if (viewModelHandler) {
var scopeResult = viewModelHandler.call(component, <API key>, componentTagData.scope, el);
if (canReflect.isObservableLike(scopeResult) && canReflect.isMapLike(scopeResult)) {
viewModelInstance = scopeResult;
} else if (canReflect.isObservableLike(scopeResult.prototype) && canReflect.isMapLike(scopeResult.prototype)) {
ViewModel = scopeResult;
} else {
ViewModel = SimpleMap.extend(scopeResult);
}
}
if (ViewModel) {
viewModelInstance = new component.constructor.ViewModel(<API key>);
}
viewModel = viewModelInstance;
return viewModelInstance;
}, <API key>);
} else {
viewModel = el[canSymbol.for('can.viewModel')];
}
this.viewModel = viewModel;
el[canSymbol.for('can.viewModel')] = viewModel;
domData.set.call(el, 'preventDataBindings', true);
var options = {
helpers: {},
tags: {}
};
if (this.helpers !== undefined) {
canReflect.eachKey(this.helpers, function (val, prop) {
if (typeof val === 'function') {
options.helpers[prop] = val.bind(viewModel);
}
});
}
if (this.constructor.Control) {
this._control = new this.constructor.Control(el, {
scope: this.viewModel,
viewModel: this.viewModel,
destroy: <API key>
});
} else {
var removalDisposal = domMutate.onNodeRemoval(el, function () {
if (!el.ownerDocument.contains(el)) {
removalDisposal();
<API key>();
}
});
}
var leakScope = {
toLightContent: this.leakScope === true,
intoShadowContent: this.leakScope === true
};
var hasShadowTemplate = !!this.constructor.renderer;
var betweenTagsRenderer;
var betweenTagsTagData;
if (hasShadowTemplate) {
var shadowTagData;
if (leakScope.intoShadowContent) {
shadowTagData = {
scope: componentTagData.scope.add(this.viewModel, { viewModel: true }),
options: options
};
} else {
shadowTagData = {
scope: new Scope(this.viewModel, null, { viewModel: true }),
options: options
};
}
options.tags['can-slot'] = <API key>('can-slot', componentTagData, shadowTagData, leakScope, function (el) {
var templates = componentTagData.templates;
if (templates) {
return templates[el.getAttribute('name')];
}
});
options.tags.content = <API key>('content', componentTagData, shadowTagData, leakScope, function () {
return componentTagData.subtemplate;
});
betweenTagsRenderer = this.constructor.renderer;
betweenTagsTagData = shadowTagData;
} else {
var <API key> = {
scope: componentTagData.scope.add(this.viewModel, { viewModel: true }),
options: options
};
betweenTagsTagData = <API key>;
betweenTagsRenderer = componentTagData.subtemplate || el.ownerDocument.<API key>.bind(el.ownerDocument);
}
var <API key>, componentInPage;
var nodeList = nodeLists.register([], function () {
domEvents.dispatch(el, 'beforeremove', false);
if (teardownBindings) {
teardownBindings();
}
if (<API key>) {
<API key>(el);
}
}, componentTagData.parentNodeList || true, false);
nodeList.expression = '<' + this.tag + '>';
teardownFunctions.push(function () {
nodeLists.unregister(nodeList);
});
frag = betweenTagsRenderer(betweenTagsTagData.scope, betweenTagsTagData.options, nodeList);
domMutateNode.appendChild.call(el, frag);
nodeLists.update(nodeList, getChildNodes(el));
if (viewModel && viewModel.connectedCallback) {
componentInPage = DOCUMENT().body.contains(el);
if (componentInPage) {
<API key> = viewModel.connectedCallback(el);
} else {
var insertionDisposal = domMutate.onNodeInsertion(el, function () {
insertionDisposal();
<API key> = viewModel.connectedCallback(el);
});
}
}
}
});
module.exports = namespace.Component = Component;
}(function () {
return this;
}(), require, exports, module));
});
/*can@5.0.0-pre.3#es/can-component*/
define('can/es/can-component', [
'exports',
'can-component'
], function (exports, _canComponent) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canComponent).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-stache*/
define('can/es/can-stache', [
'exports',
'can-stache'
], function (exports, _canStache) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canStache).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-stache-bindings*/
define('can/es/can-stache-bindings', [
'exports',
'can-stache-bindings'
], function (exports, _canStacheBindings) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canStacheBindings).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*<API key>@2.0.4#make-compute/make-compute*/
define('<API key>/make-compute/make-compute', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var Compute = function (newVal) {
if (arguments.length) {
return canReflect.setValue(this, newVal);
} else {
return canReflect.getValue(this);
}
};
var translationHelpers = new WeakMap();
module.exports = function (observable) {
var compute = Compute.bind(observable);
compute.on = compute.bind = compute.addEventListener = function (event, handler) {
var translationHandler = translationHelpers.get(handler);
if (!translationHandler) {
translationHandler = function (newVal, oldVal) {
handler.call(compute, { type: 'change' }, newVal, oldVal);
};
Object.defineProperty(translationHandler, 'name', { value: 'translationHandler(' + event + ')::' + canReflect.getName(observable) + '.onValue(' + canReflect.getName(handler) + ')' });
translationHelpers.set(handler, translationHandler);
}
canReflect.onValue(observable, translationHandler);
};
compute.off = compute.unbind = compute.removeEventListener = function (event, handler) {
canReflect.offValue(observable, translationHelpers.get(handler));
};
canReflect.assignSymbols(compute, {
'can.getValue': function () {
return canReflect.getValue(observable);
},
'can.setValue': function (newVal) {
return canReflect.setValue(observable, newVal);
},
'can.onValue': function (handler, queue) {
return canReflect.onValue(observable, handler, queue);
},
'can.offValue': function (handler, queue) {
return canReflect.offValue(observable, handler, queue);
},
'can.<API key>': function () {
return canReflect.<API key>(observable);
},
'can.getPriority': function () {
return canReflect.getPriority(observable);
},
'can.setPriority': function (newPriority) {
canReflect.setPriority(observable, newPriority);
},
'can.isValueLike': true,
'can.isFunctionLike': false
});
compute.isComputed = true;
return compute;
};
});
/*can-route@4.1.2#src/binding-proxy*/
define('can-route/src/binding-proxy', [
'require',
'exports',
'module',
'can-reflect',
'can-symbol',
'<API key>'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var SimpleObservable = require('<API key>');
var defaultBinding = new SimpleObservable('hashchange');
var bindingProxy = {
get defaultBinding() {
return defaultBinding.get();
},
set defaultBinding(newVal) {
defaultBinding.set(newVal);
},
currentBinding: null,
bindings: {},
call: function () {
var args = canReflect.toArray(arguments), prop = args.shift(), binding = bindingProxy.bindings[bindingProxy.currentBinding || bindingProxy.defaultBinding], method = binding[prop.indexOf('can.') === 0 ? canSymbol.for(prop) : prop];
if (method.apply) {
return method.apply(binding, args);
} else {
return method;
}
}
};
module.exports = bindingProxy;
});
/*can-route@4.1.2#src/regexps*/
define('can-route/src/regexps', function (require, exports, module) {
module.exports = {
curlies: /\{\s*([\w.]+)\s*\}/g,
colon: /\:([\w.]+)/g
};
});
/*can-util@3.11.5#js/diff/diff*/
define('can-util/js/diff/diff', function (require, exports, module) {
'use strict';
var slice = [].slice;
var defaultIdentity = function (a, b) {
return a === b;
};
function reverseDiff(oldDiffStopIndex, newDiffStopIndex, oldList, newList, identity) {
var oldIndex = oldList.length - 1, newIndex = newList.length - 1;
while (oldIndex > oldDiffStopIndex && newIndex > newDiffStopIndex) {
var oldItem = oldList[oldIndex], newItem = newList[newIndex];
if (identity(oldItem, newItem)) {
oldIndex
newIndex
continue;
} else {
return [{
index: newDiffStopIndex,
deleteCount: oldIndex - oldDiffStopIndex + 1,
insert: slice.call(newList, newDiffStopIndex, newIndex + 1)
}];
}
}
return [{
index: newDiffStopIndex,
deleteCount: oldIndex - oldDiffStopIndex + 1,
insert: slice.call(newList, newDiffStopIndex, newIndex + 1)
}];
}
module.exports = exports = function (oldList, newList, identity) {
identity = identity || defaultIdentity;
var oldIndex = 0, newIndex = 0, oldLength = oldList.length, newLength = newList.length, patches = [];
while (oldIndex < oldLength && newIndex < newLength) {
var oldItem = oldList[oldIndex], newItem = newList[newIndex];
if (identity(oldItem, newItem)) {
oldIndex++;
newIndex++;
continue;
}
if (newIndex + 1 < newLength && identity(oldItem, newList[newIndex + 1])) {
patches.push({
index: newIndex,
deleteCount: 0,
insert: [newList[newIndex]]
});
oldIndex++;
newIndex += 2;
continue;
} else if (oldIndex + 1 < oldLength && identity(oldList[oldIndex + 1], newItem)) {
patches.push({
index: newIndex,
deleteCount: 1,
insert: []
});
oldIndex += 2;
newIndex++;
continue;
} else {
patches.push.apply(patches, reverseDiff(oldIndex, newIndex, oldList, newList, identity));
return patches;
}
}
if (newIndex === newLength && oldIndex === oldLength) {
return patches;
}
patches.push({
index: newIndex,
deleteCount: oldLength - oldIndex,
insert: slice.call(newList, newIndex)
});
return patches;
};
});
/*can-util@3.11.5#js/diff-object/diff-object*/
define('can-util/js/diff-object/diff-object', [
'require',
'exports',
'module',
'can-assign'
], function (require, exports, module) {
'use strict';
var assign = require('can-assign');
module.exports = exports = function (oldObject, newObject) {
var oldObjectClone, patches = [];
oldObjectClone = assign({}, oldObject);
for (var newProp in newObject) {
if (!oldObject || !oldObject.hasOwnProperty(newProp)) {
patches.push({
property: newProp,
type: 'add',
value: newObject[newProp]
});
} else if (newObject[newProp] !== oldObject[newProp]) {
patches.push({
property: newProp,
type: 'set',
value: newObject[newProp]
});
}
delete oldObjectClone[newProp];
}
for (var oldProp in oldObjectClone) {
patches.push({
property: oldProp,
type: 'remove'
});
}
return patches;
};
});
/*can-route@4.1.2#src/register*/
define('can-route/src/register', [
'require',
'exports',
'module',
'can-reflect',
'can-log/dev/dev',
'can-route/src/binding-proxy',
'can-route/src/regexps',
'can-util/js/diff/diff',
'can-util/js/diff-object/diff-object'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var dev = require('can-log/dev/dev');
var bindingProxy = require('can-route/src/binding-proxy');
var regexps = require('can-route/src/regexps');
var diff = require('can-util/js/diff/diff');
var diffObject = require('can-util/js/diff-object/diff-object');
var removeBackslash = function (str) {
return str.replace(/\\/g, '');
};
var wrapQuote = function (str) {
return (str + '').replace(/([.?*+\^$\[\]\\(){}|\-])/g, '\\$1');
};
var RouteRegistry = {
routes: {},
register: function registerRoute(url, defaults) {
var root = bindingProxy.call('root');
if (root.lastIndexOf('/') === root.length - 1 && url.indexOf('/') === 0) {
url = url.substr(1);
}
defaults = defaults || {};
var names = [], res, test = '', matcher, lastIndex, next, querySeparator = bindingProxy.call('querySeparator'), matchSlashes = bindingProxy.call('matchSlashes');
if (regexps.colon.test(url)) {
matcher = regexps.colon;
dev.warn('update route "' + url + '" to "' + url.replace(regexps.colon, function (name, key) {
return '{' + key + '}';
}) + '"');
} else {
matcher = regexps.curlies;
}
lastIndex = matcher.lastIndex = 0;
while (res = matcher.exec(url)) {
names.push(res[1]);
test += removeBackslash(url.substring(lastIndex, matcher.lastIndex - res[0].length));
next = '\\' + (removeBackslash(url.substr(matcher.lastIndex, 1)) || querySeparator + (matchSlashes ? '' : '|/'));
test += '([^' + next + ']' + (defaults[res[1]] ? '*' : '+') + ')';
lastIndex = matcher.lastIndex;
}
test += url.substr(lastIndex).replace('\\', '');
canReflect.eachKey(RouteRegistry.routes, function (r) {
var existingKeys = r.names.concat(Object.keys(r.defaults)).sort();
var keys = names.concat(Object.keys(defaults)).sort();
var sameMapKeys = !diff(existingKeys, keys).length;
var sameDefaultValues = !diffObject(r.defaults, defaults).length;
var <API key> = r.route.replace(/\/$/, '') === url.replace(/\/$/, '');
if (sameMapKeys && sameDefaultValues && !<API key>) {
dev.warn('two routes were registered with matching keys:\n' + '\t(1) route("' + r.route + '", ' + JSON.stringify(r.defaults) + ')\n' + '\t(2) route("' + url + '", ' + JSON.stringify(defaults) + ')\n' + '(1) will always be chosen since it was registered first');
}
});
return RouteRegistry.routes[url] = {
test: new RegExp('^' + test + '($|' + wrapQuote(querySeparator) + ')'),
route: url,
names: names,
defaults: defaults,
length: url.split('/').length
};
}
};
module.exports = RouteRegistry;
});
/*can-route@4.1.2#src/deparam*/
define('can-route/src/deparam', [
'require',
'exports',
'module',
'can-deparam',
'can-reflect',
'can-route/src/binding-proxy',
'can-route/src/register'
], function (require, exports, module) {
var deparam = require('can-deparam');
var canReflect = require('can-reflect');
var bindingProxy = require('can-route/src/binding-proxy');
var register = require('can-route/src/register');
var decode = function (str) {
try {
return decodeURIComponent(str);
} catch (ex) {
return unescape(str);
}
};
function toURLFragment(url) {
var root = bindingProxy.call('root');
if (root.lastIndexOf('/') === root.length - 1 && url.indexOf('/') === 0) {
url = url.substr(1);
}
return url;
}
function canRoute_getRule(url) {
url = toURLFragment(url);
var route = { length: -1 };
canReflect.eachKey(register.routes, function (temp, name) {
if (temp.test.test(url) && temp.length > route.length) {
route = temp;
}
});
if (route.length > -1) {
return route;
}
}
function canRoute_deparam(url) {
var route = canRoute_getRule(url), querySeparator = bindingProxy.call('querySeparator'), paramsMatcher = bindingProxy.call('paramsMatcher');
url = toURLFragment(url);
if (route) {
var parts = url.match(route.test), start = parts.shift(), remainder = url.substr(start.length - (parts[parts.length - 1] === querySeparator ? 1 : 0)), obj = remainder && paramsMatcher.test(remainder) ? deparam(remainder.slice(1)) : {};
obj = canReflect.assignDeep(canReflect.assignDeep({}, route.defaults), obj);
parts.forEach(function (part, i) {
if (part && part !== querySeparator) {
obj[route.names[i]] = decode(part);
}
});
return obj;
}
if (url.charAt(0) !== querySeparator) {
url = querySeparator + url;
}
return paramsMatcher.test(url) ? deparam(url.slice(1)) : {};
}
canRoute_deparam.getRule = canRoute_getRule;
module.exports = canRoute_deparam;
});
/*can-route@4.1.2#src/param*/
define('can-route/src/param', [
'require',
'exports',
'module',
'can-reflect',
'can-param',
'can-route/src/register',
'can-route/src/regexps',
'can-route/src/binding-proxy'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var param = require('can-param');
var register = require('can-route/src/register');
var regexps = require('can-route/src/regexps');
var bindingProxy = require('can-route/src/binding-proxy');
var matchesData = function (route, data) {
var count = 0, i = 0, defaults = {};
for (var name in route.defaults) {
if (route.defaults[name] === data[name]) {
defaults[name] = 1;
count++;
}
}
for (; i < route.names.length; i++) {
if (!data.hasOwnProperty(route.names[i])) {
return -1;
}
if (!defaults[route.names[i]]) {
count++;
}
}
return count;
};
function getMatchedRoute(data, routeName) {
var route, matches = 0, matchCount, propCount = 0;
delete data.route;
canReflect.eachKey(data, function () {
propCount++;
});
canReflect.eachKey(register.routes, function (temp, name) {
matchCount = matchesData(temp, data);
if (matchCount > matches) {
route = temp;
matches = matchCount;
}
if (matchCount >= propCount) {
return false;
}
});
if (register.routes[routeName] && matchesData(register.routes[routeName], data) === matches) {
route = register.routes[routeName];
}
return route;
}
function paramFromRoute(route, data) {
var cpy, res, after, matcher;
if (route) {
cpy = canReflect.assignMap({}, data);
matcher = regexps.colon.test(route.route) ? regexps.colon : regexps.curlies;
res = route.route.replace(matcher, function (whole, name) {
delete cpy[name];
return data[name] === route.defaults[name] ? '' : encodeURIComponent(data[name]);
}).replace('\\', '');
canReflect.eachKey(route.defaults, function (val, name) {
if (cpy[name] === val) {
delete cpy[name];
}
});
after = param(cpy);
return res + (after ? bindingProxy.call('querySeparator') + after : '');
}
return canReflect.size(data) === 0 ? '' : bindingProxy.call('querySeparator') + param(data);
}
function canRoute_param(data, currentRouteName) {
return paramFromRoute(getMatchedRoute(data, currentRouteName), data);
}
module.exports = canRoute_param;
canRoute_param.paramFromRoute = paramFromRoute;
canRoute_param.getMatchedRoute = getMatchedRoute;
});
/*can-util@3.11.5#js/is-container/is-container*/
define('can-util/js/is-container/is-container', function (require, exports, module) {
'use strict';
module.exports = function (current) {
return /^f|^o/.test(typeof current);
};
});
/*can-util@3.11.5#js/get/get*/
define('can-util/js/get/get', [
'require',
'exports',
'module',
'can-util/js/is-container/is-container'
], function (require, exports, module) {
'use strict';
var isContainer = require('can-util/js/is-container/is-container');
function get(obj, name) {
var parts = typeof name !== 'undefined' ? (name + '').replace(/\[/g, '.').replace(/]/g, '').split('.') : [], length = parts.length, current, i, container;
if (!length) {
return obj;
}
current = obj;
for (i = 0; i < length && isContainer(current) && current !== null; i++) {
container = current;
current = container[parts[i]];
}
return current;
}
module.exports = get;
});
/*can-util@3.11.5#js/is-array/is-array*/
define('can-util/js/is-array/is-array', [
'require',
'exports',
'module',
'can-log/dev/dev'
], function (require, exports, module) {
'use strict';
var dev = require('can-log/dev/dev');
var hasWarned = false;
module.exports = function (arr) {
if (!hasWarned) {
dev.warn('js/is-array/is-array is deprecated; use Array.isArray');
hasWarned = true;
}
return Array.isArray(arr);
};
});
/*can-util@3.11.5#js/string/string*/
define('can-util/js/string/string', [
'require',
'exports',
'module',
'can-util/js/get/get',
'can-util/js/is-container/is-container',
'can-log/dev/dev',
'can-util/js/is-array/is-array'
], function (require, exports, module) {
'use strict';
var get = require('can-util/js/get/get');
var isContainer = require('can-util/js/is-container/is-container');
var canDev = require('can-log/dev/dev');
var isArray = require('can-util/js/is-array/is-array');
var strUndHash = /_|-/, strColons = /\=\=/, strWords = /([A-Z]+)([A-Z][a-z])/g, strLowUp = /([a-z\d])([A-Z])/g, strDash = /([a-z\d])([A-Z])/g, strReplacer = /\{([^\}]+)\}/g, strQuote = /"/g, strSingleQuote = /'/g, strHyphenMatch = /-+(.)?/g, strCamelMatch = /[a-z][A-Z]/g, convertBadValues = function (content) {
var isInvalid = content === null || content === undefined || isNaN(content) && '' + content === 'NaN';
return '' + (isInvalid ? '' : content);
}, deleteAtPath = function (data, path) {
var parts = path ? path.replace(/\[/g, '.').replace(/]/g, '').split('.') : [];
var current = data;
for (var i = 0; i < parts.length - 1; i++) {
if (current) {
current = current[parts[i]];
}
}
if (current) {
delete current[parts[parts.length - 1]];
}
};
var string = {
esc: function (content) {
return convertBadValues(content).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(strQuote, '"').replace(strSingleQuote, ''');
},
getObject: function (name, roots) {
canDev.warn('string.getObject is deprecated, please use can-util/js/get/get instead.');
roots = isArray(roots) ? roots : [roots || window];
var result, l = roots.length;
for (var i = 0; i < l; i++) {
result = get(roots[i], name);
if (result) {
return result;
}
}
},
capitalize: function (s, cache) {
return s.charAt(0).toUpperCase() + s.slice(1);
},
camelize: function (str) {
return convertBadValues(str).replace(strHyphenMatch, function (match, chr) {
return chr ? chr.toUpperCase() : '';
});
},
hyphenate: function (str) {
return convertBadValues(str).replace(strCamelMatch, function (str, offset) {
return str.charAt(0) + '-' + str.charAt(1).toLowerCase();
});
},
underscore: function (s) {
return s.replace(strColons, '/').replace(strWords, '$1_$2').replace(strLowUp, '$1_$2').replace(strDash, '_').toLowerCase();
},
sub: function (str, data, remove) {
var obs = [];
str = str || '';
obs.push(str.replace(strReplacer, function (whole, inside) {
var ob = get(data, inside);
if (remove === true) {
deleteAtPath(data, inside);
}
if (ob === undefined || ob === null) {
obs = null;
return '';
}
if (isContainer(ob) && obs) {
obs.push(ob);
return '';
}
return '' + ob;
}));
return obs === null ? obs : obs.length <= 1 ? obs[0] : obs;
},
replaceWith: function (str, data, replacer, <API key>) {
return str.replace(strReplacer, function (whole, path) {
var value = get(data, path);
if (<API key>) {
deleteAtPath(data, path);
}
return replacer(path, value);
});
},
replacer: strReplacer,
undHash: strUndHash
};
module.exports = string;
});
/*can-route@4.1.2#src/url-helpers*/
define('can-route/src/url-helpers', [
'require',
'exports',
'module',
'can-route/src/binding-proxy',
'can-route/src/deparam',
'can-route/src/param',
'can-reflect',
'can-util/js/string/string'
], function (require, exports, module) {
var bindingProxy = require('can-route/src/binding-proxy');
var routeDeparam = require('can-route/src/deparam');
var routeParam = require('can-route/src/param');
var canReflect = require('can-reflect');
var string = require('can-util/js/string/string');
var makeProps = function (props) {
var tags = [];
canReflect.eachKey(props, function (val, name) {
tags.push((name === 'className' ? 'class' : name) + '="' + (name === 'href' ? val : string.esc(val)) + '"');
});
return tags.join(' ');
};
var matchCheck = function (source, matcher) {
for (var prop in source) {
var s = source[prop], m = matcher[prop];
if (s && m && typeof s === 'object' && typeof matcher === 'object') {
return matchCheck(s, m);
}
if (s != m) {
return false;
}
}
return true;
};
function canRoute_url(options, merge) {
if (merge) {
var baseOptions = routeDeparam(bindingProxy.call('can.getValue'));
options = canReflect.assignMap(canReflect.assignMap({}, baseOptions), options);
}
return bindingProxy.call('root') + routeParam(options);
}
module.exports = {
url: canRoute_url,
link: function canRoute_link(name, options, props, merge) {
return '<a ' + makeProps(canReflect.assignMap({ href: canRoute_url(options, merge) }, props)) + '>' + name + '</a>';
},
isCurrent: function canRoute_isCurrent(options, subsetMatch) {
if (subsetMatch) {
var baseOptions = routeDeparam(bindingProxy.call('can.getValue'));
return matchCheck(options, baseOptions);
} else {
return bindingProxy.call('can.getValue') === routeParam(options);
}
}
};
});
/*can-route@4.1.2#src/hashchange*/
define('can-route/src/hashchange', [
'require',
'exports',
'module',
'can-globals/location/location',
'can-reflect',
'<API key>',
'can-queues',
'can-key-tree',
'<API key>',
'can-dom-events'
], function (require, exports, module) {
(function (global, require, exports, module) {
var paramsMatcher = /^(?:&[^=]+=[^&]*)+/;
var LOCATION = require('can-globals/location/location');
var canReflect = require('can-reflect');
var ObservationRecorder = require('<API key>');
var queues = require('can-queues');
var KeyTree = require('can-key-tree');
var SimpleObservable = require('<API key>');
var domEvents = require('can-dom-events');
function getHash() {
var loc = LOCATION();
return loc.href.split(/#!?/)[1] || '';
}
function <API key>() {
var dispatchHandlers = this.dispatchHandlers.bind(this);
var self = this;
this.handlers = new KeyTree([
Object,
Array
], {
onFirst: function () {
self.value = getHash();
domEvents.addEventListener(window, 'hashchange', dispatchHandlers);
},
onEmpty: function () {
domEvents.removeEventListener(window, 'hashchange', dispatchHandlers);
}
});
}
<API key>.prototype = Object.create(SimpleObservable.prototype);
<API key>.constructor = <API key>;
canReflect.assign(<API key>.prototype, {
paramsMatcher: paramsMatcher,
querySeparator: '&',
matchSlashes: false,
root: '#!',
dispatchHandlers: function () {
var old = this.value;
this.value = getHash();
if (old !== this.value) {
queues.enqueueByQueue(this.handlers.getNode([]), this, [
this.value,
old
], null, [
canReflect.getName(this),
'changed to',
this.value,
'from',
old
]);
}
},
get: function () {
ObservationRecorder.add(this);
return getHash();
},
set: function (path) {
var loc = LOCATION();
if (!path && !loc.path) {
} else if (loc.hash !== '#' + path) {
loc.hash = '!' + path;
}
return path;
}
});
canReflect.assignSymbols(<API key>.prototype, {
'can.getValue': <API key>.prototype.get,
'can.setValue': <API key>.prototype.set,
'can.onValue': <API key>.prototype.on,
'can.offValue': <API key>.prototype.off,
'can.isMapLike': false,
'can.<API key>': function () {
return true;
},
'can.getName': function () {
return '<API key><' + this.value + '>';
}
});
module.exports = new <API key>();
}(function () {
return this;
}(), require, exports, module));
});
/*can-globals@1.1.1#is-web-worker/is-web-worker*/
define('can-globals/is-web-worker/is-web-worker', [
'require',
'exports',
'module',
'can-globals/<API key>'
], function (require, exports, module) {
(function (global, require, exports, module) {
'use strict';
var globals = require('can-globals/<API key>');
var funcConstructor = Function;
globals.define('isWebWorker', function () {
var global = funcConstructor('return this')();
return typeof WorkerGlobalScope !== 'undefined' && global instanceof WorkerGlobalScope;
});
module.exports = globals.makeExport('isWebWorker');
}(function () {
return this;
}(), require, exports, module));
});
/*can-route@4.1.2#can-route*/
define('can-route', [
'require',
'exports',
'module',
'can-queues',
'can-observation',
'can-namespace',
'can-log/dev/dev',
'can-reflect',
'can-symbol',
'<API key>/make-compute/make-compute',
'can-simple-map',
'can-route/src/register',
'can-route/src/url-helpers',
'can-route/src/param',
'can-route/src/deparam',
'can-route/src/binding-proxy',
'can-route/src/hashchange',
'can-globals/is-web-worker/is-web-worker',
'can-globals/is-browser-window/is-browser-window'
], function (require, exports, module) {
(function (global, require, exports, module) {
var queues = require('can-queues');
var Observation = require('can-observation');
var namespace = require('can-namespace');
var devLog = require('can-log/dev/dev');
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var makeCompute = require('<API key>/make-compute/make-compute');
var SimpleMap = require('can-simple-map');
var registerRoute = require('can-route/src/register');
var urlHelpers = require('can-route/src/url-helpers');
var routeParam = require('can-route/src/param');
var routeDeparam = require('can-route/src/deparam');
var bindingProxy = require('can-route/src/binding-proxy');
var hashchange = require('can-route/src/hashchange');
var isWebWorker = require('can-globals/is-web-worker/is-web-worker');
var isBrowserWindow = require('can-globals/is-browser-window/is-browser-window');
bindingProxy.bindings.hashchange = hashchange;
bindingProxy.defaultBinding = 'hashchange';
function canRoute(url, defaults) {
devLog.warn('Call route.register(url,defaults) instead of calling route(url, defaults)');
registerRoute.register(url, defaults);
return canRoute;
}
var timer;
var <API key> = new Observation(function <API key>() {
var url = bindingProxy.call('can.getValue');
return canRoute.rule(url);
});
function updateUrl(serializedData) {
clearTimeout(timer);
timer = setTimeout(function () {
var serialized = canReflect.serialize(canRoute.data), currentRouteName = <API key>.get(), route = routeParam.getMatchedRoute(serialized, currentRouteName), path = routeParam.paramFromRoute(route, serialized);
bindingProxy.call('can.setValue', path);
}, 10);
}
Object.defineProperty(updateUrl, 'name', { value: 'can-route.updateUrl' });
function updateRouteData() {
var hash = bindingProxy.call('can.getValue');
queues.batch.start();
var state = canRoute.deparam(hash);
delete state.route;
canReflect.update(canRoute.data, state);
queues.batch.stop();
}
Object.defineProperty(updateRouteData, 'name', { value: 'can-route.updateRouteData' });
Object.defineProperty(canRoute, 'routes', {
get: function () {
return registerRoute.routes;
},
set: function (newVal) {
return registerRoute.routes = newVal;
}
});
Object.defineProperty(canRoute, 'defaultBinding', {
get: function () {
return bindingProxy.defaultBinding;
},
set: function (newVal) {
bindingProxy.defaultBinding = newVal;
}
});
Object.defineProperty(canRoute, 'currentBinding', {
get: function () {
return bindingProxy.currentBinding;
},
set: function (newVal) {
bindingProxy.currentBinding = newVal;
}
});
canReflect.assignMap(canRoute, {
param: routeParam,
deparam: routeDeparam,
map: function (data) {
devLog.warn('Set route.data directly instead of calling route.map');
canRoute.data = data;
},
start: function (val) {
if (val !== true) {
canRoute._setup();
if (isBrowserWindow() || isWebWorker()) {
var hash = bindingProxy.call('can.getValue');
queues.batch.start();
var state = canRoute.deparam(hash);
delete state.route;
canReflect.assign(canRoute.data, state);
queues.batch.stop();
updateUrl();
}
}
return canRoute;
},
url: urlHelpers.url,
link: urlHelpers.link,
isCurrent: urlHelpers.isCurrent,
bindings: bindingProxy.bindings,
_setup: function () {
if (!canRoute.currentBinding) {
bindingProxy.call('can.onValue', updateRouteData);
canReflect.onValue(canRoute.<API key>, updateUrl, 'notify');
canRoute.currentBinding = canRoute.defaultBinding;
}
},
_teardown: function () {
if (canRoute.currentBinding) {
bindingProxy.call('can.offValue', updateRouteData);
canReflect.offValue(canRoute.<API key>, updateUrl, 'notify');
canRoute.currentBinding = null;
}
clearTimeout(timer);
},
stop: function () {
this._teardown();
return canRoute;
},
currentRule: makeCompute(<API key>),
register: registerRoute.register,
rule: function (url) {
var rule = routeDeparam.getRule(url);
if (rule) {
return rule.route;
}
}
});
var bindToCanRouteData = function (name, args) {
if (!canRoute.data[name]) {
return canRoute.data.addEventListener.apply(canRoute.data, args);
}
return canRoute.data[name].apply(canRoute.data, args);
};
[
'addEventListener',
'removeEventListener',
'bind',
'unbind',
'on',
'off'
].forEach(function (name) {
canRoute[name] = function (eventName, handler) {
if (eventName === '__url') {
return bindingProxy.call('can.onValue', handler);
}
return bindToCanRouteData(name, arguments);
};
});
[
'delegate',
'undelegate',
'removeAttr',
'compute',
'_get',
'___get',
'each'
].forEach(function (name) {
canRoute[name] = function () {
return bindToCanRouteData(name, arguments);
};
});
var routeData;
var setRouteData = function (data) {
routeData = data;
return routeData;
};
var <API key>;
var serializedCompute;
Object.defineProperty(canRoute, '<API key>', {
get: function () {
if (!<API key>) {
<API key> = new Observation(function <API key>() {
return canReflect.serialize(canRoute.data);
});
}
return <API key>;
}
});
Object.defineProperty(canRoute, 'serializedCompute', {
get: function () {
if (!serializedCompute) {
serializedCompute = makeCompute(canRoute.<API key>);
}
return serializedCompute;
}
});
var stringify = function (obj) {
if (obj && typeof obj === 'object') {
if (obj && typeof obj === 'object' && 'serialize' in obj) {
obj = obj.serialize();
} else {
obj = typeof obj.slice === 'function' ? obj.slice() : canReflect.assign({}, obj);
}
canReflect.eachKey(obj, function (val, prop) {
obj[prop] = stringify(val);
});
} else if (obj !== undefined && obj !== null && typeof obj.toString === 'function') {
obj = obj.toString();
}
return obj;
};
var <API key> = function (map) {
var sym = canSymbol.for('can.route.<API key>');
if (!map.attr[sym]) {
var attrSuper = map.attr;
map.attr = function (prop, val) {
var serializable = this.define === undefined || this.define[prop] === undefined || !!this.define[prop].serialize, args;
if (serializable) {
args = stringify(Array.apply(null, arguments));
} else {
args = arguments;
}
return attrSuper.apply(this, args);
};
canReflect.setKeyValue(map.attr, sym, true);
}
return map;
};
var viewModelSymbol = canSymbol.for('can.viewModel');
Object.defineProperty(canRoute, 'data', {
get: function () {
if (routeData) {
return routeData;
} else {
return setRouteData(<API key>(new SimpleMap()));
}
},
set: function (data) {
if (canReflect.isConstructorLike(data)) {
data = new data();
}
if (data && data[viewModelSymbol] !== undefined) {
data = data[viewModelSymbol];
}
if ('attr' in data) {
setRouteData(<API key>(data));
} else {
setRouteData(data);
}
}
});
canRoute.attr = function (prop, value) {
console.warn('can-route: can-route.attr is deprecated. Use methods on can-route.data instead.');
if ('attr' in canRoute.data) {
return canRoute.data.attr.apply(canRoute.data, arguments);
} else {
if (arguments.length > 1) {
canReflect.setKeyValue(canRoute.data, prop, value);
return canRoute.data;
} else if (typeof prop === 'object') {
canReflect.assignDeep(canRoute.data, prop);
return canRoute.data;
} else if (arguments.length === 1) {
return canReflect.getKeyValue(canRoute.data, prop);
} else {
return canReflect.unwrap(canRoute.data);
}
}
};
canReflect.setKeyValue(canRoute, canSymbol.for('can.isFunctionLike'), false);
canRoute.matched = canRoute.currentRule;
canRoute.current = canRoute.isCurrent;
module.exports = namespace.route = canRoute;
}(function () {
return this;
}(), require, exports, module));
});
/*<API key>@1.0.0#<API key>*/
define('<API key>', [
'require',
'exports',
'module',
'can-stache/helpers/core',
'can-route',
'can-stache/src/expression',
'can-reflect'
], function (require, exports, module) {
var helpers = require('can-stache/helpers/core');
var route = require('can-route');
var stacheExpression = require('can-stache/src/expression');
var canReflect = require('can-reflect');
var looksLikeOptions = helpers.looksLikeOptions;
var calculateArgs = function () {
var finalParams, finalMerge, optionsArg;
canReflect.eachIndex(arguments, function (arg) {
if (typeof arg === 'boolean') {
finalMerge = arg;
} else if (arg && typeof arg === 'object') {
if (!looksLikeOptions(arg)) {
finalParams = helpers.resolveHash(arg);
} else {
optionsArg = arg;
}
}
});
if (!finalParams && optionsArg) {
finalParams = helpers.resolveHash(optionsArg.hash);
}
return {
finalParams: finalParams || {},
finalMerge: finalMerge,
optionsArg: optionsArg
};
};
helpers.registerHelper('routeUrl', function () {
var args = calculateArgs.apply(this, arguments);
return route.url(args.finalParams, typeof args.finalMerge === 'boolean' ? args.finalMerge : undefined);
});
var routeCurrent = function () {
var args = calculateArgs.apply(this, arguments);
var result = route.current(args.finalParams, typeof args.finalMerge === 'boolean' ? args.finalMerge : undefined);
if (args.optionsArg && !(args.optionsArg instanceof stacheExpression.Call)) {
if (result) {
return args.optionsArg.fn();
} else {
return args.optionsArg.inverse();
}
} else {
return result;
}
};
routeCurrent.callAsMethod = true;
helpers.registerHelper('routeCurrent', routeCurrent);
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, <API key>) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-route*/
define('can/es/can-route', [
'exports',
'can-route'
], function (exports, _canRoute) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canRoute).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, <API key>) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-assign*/
define('can/es/can-assign', [
'exports',
'can-assign'
], function (exports, _canAssign) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canAssign).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, <API key>) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-ajax*/
define('can/es/can-ajax', [
'exports',
'can-ajax'
], function (exports, _canAjax) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canAjax).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-globals*/
define('can/es/can-globals', [
'exports',
'can-globals'
], function (exports, _canGlobals) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canGlobals).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-reflect*/
define('can/es/can-reflect', [
'exports',
'can-reflect'
], function (exports, _canReflect) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canReflect).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, _canDefineLazyValue) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canDefineLazyValue).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-dom-events*/
define('can/es/can-dom-events', [
'exports',
'can-dom-events'
], function (exports, _canDomEvents) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canDomEvents).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, <API key>) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-event-dom-enter@2.1.2#can-event-dom-enter*/
define('can-event-dom-enter', [
'require',
'exports',
'module',
'can-namespace'
], function (require, exports, module) {
'use strict';
var namespace = require('can-namespace');
var baseEventType = 'keyup';
function isEnterEvent(event) {
var hasEnterKey = event.key === 'Enter';
var hasEnterCode = event.keyCode === 13;
return hasEnterKey || hasEnterCode;
}
var enterEvent = {
defaultEventType: 'enter',
addEventListener: function (target, eventType, handler) {
var keyHandler = function (event) {
if (isEnterEvent(event)) {
return handler.apply(this, arguments);
}
};
var handlerMap = enterEvent.<API key>[eventType];
if (!handlerMap) {
handlerMap = enterEvent.<API key>[eventType] = new Map();
}
handlerMap.set(handler, keyHandler);
this.addEventListener(target, baseEventType, keyHandler);
},
removeEventListener: function (target, eventType, handler) {
var handlerMap = enterEvent.<API key>[eventType];
if (handlerMap) {
var keyHandler = handlerMap.get(handler);
if (keyHandler) {
handlerMap.delete(handler);
if (handlerMap.size === 0) {
delete enterEvent.<API key>[eventType];
}
this.removeEventListener(target, baseEventType, keyHandler);
}
}
},
<API key>: {}
};
module.exports = namespace.domEventEnter = enterEvent;
});
/*can@5.0.0-pre.3#es/can-event-dom-enter*/
define('can/es/can-event-dom-enter', [
'exports',
'can-event-dom-enter'
], function (exports, _canEventDomEnter) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canEventDomEnter).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/<API key>*/
define('can/es/<API key>', [
'exports',
'<API key>'
], function (exports, <API key>) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-view-model*/
define('can/es/can-view-model', [
'exports',
'can-view-model'
], function (exports, _canViewModel) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canViewModel).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-observation*/
define('can/es/can-observation', [
'exports',
'can-observation'
], function (exports, _canObservation) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canObservation).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-key@0.5.0#set/set*/
define('can-key/set/set', [
'require',
'exports',
'module',
'can-reflect',
'can-symbol',
'can-key/utils'
], function (require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
var canSymbol = require('can-symbol');
var utils = require('can-key/utils');
var setValueSymbol = canSymbol.for('can.setValue');
function set(object, path, value) {
var parts = utils.parts(path);
var current = object;
var length = parts.length;
for (var i = 0; i < length - 1; i++) {
if (utils.isContainer(current)) {
current = canReflect.getKeyValue(current, parts[i]);
} else {
break;
}
}
if (current) {
canReflect.setKeyValue(current, parts[i], value);
} else {
throw new TypeError('Cannot set value at key path \'' + path + '\'');
}
return object;
}
module.exports = set;
});
/*can-key@0.5.0#walk/walk*/
define('can-key/walk/walk', [
'require',
'exports',
'module',
'can-reflect',
'can-key/utils'
], function (require, exports, module) {
var canReflect = require('can-reflect');
var utils = require('can-key/utils');
module.exports = function walk(obj, name, keyCallback) {
var parts = utils.parts(name);
var length = parts.length, current, i, container, part;
if (!length) {
return;
}
current = obj;
for (i = 0; i < length; i++) {
container = current;
part = parts[i];
current = utils.isContainer(container) && canReflect.getKeyValue(container, part);
var result = keyCallback({
parent: container,
key: part,
value: current
}, i);
if (result !== undefined) {
current = result;
}
}
};
});
/*can-key@0.5.0#transform/transform*/
define('can-key/transform/transform', [
'require',
'exports',
'module',
'can-key/walk/walk',
'can-key/utils',
'can-reflect'
], function (require, exports, module) {
var walk = require('can-key/walk/walk');
var utils = require('can-key/utils');
var canReflect = require('can-reflect');
function deleteKeys(parentsAndKeys) {
for (var i = parentsAndKeys.length - 1; i >= 0; i
var parentAndKey = parentsAndKeys[i];
delete parentAndKey.parent[parentAndKey.key];
if (canReflect.size(parentAndKey.parent) !== 0) {
return;
}
}
}
module.exports = function (obj, transformer) {
var copy = canReflect.serialize(obj);
canReflect.eachKey(transformer, function (writeKey, readKey) {
var readParts = utils.parts(readKey), writeParts = utils.parts(writeKey);
var parentsAndKeys = [];
walk(copy, readParts, function (info) {
parentsAndKeys.push(info);
});
var last = parentsAndKeys[parentsAndKeys.length - 1];
var value = last.value;
if (value !== undefined) {
walk(copy, writeParts, function (info, i) {
if (i < writeParts.length - 1 && !info.value) {
return info.parent[info.key] = {};
} else if (i === writeParts.length - 1) {
info.parent[info.key] = value;
}
});
deleteKeys(parentsAndKeys);
}
});
return copy;
};
});
/*can-key@0.5.0#can-key*/
define('can-key', [
'require',
'exports',
'module',
'can-key/delete/delete',
'can-key/get/get',
'can-key/replace-with/replace-with',
'can-key/set/set',
'can-key/transform/transform',
'can-key/walk/walk',
'can-namespace'
], function (require, exports, module) {
var deleteKey = require('can-key/delete/delete'), get = require('can-key/get/get'), replaceWith = require('can-key/replace-with/replace-with'), set = require('can-key/set/set'), transform = require('can-key/transform/transform'), walk = require('can-key/walk/walk'), namespace = require('can-namespace');
module.exports = namespace.key = {
deleteKey: deleteKey,
get: get,
replaceWith: replaceWith,
set: set,
transform: transform,
walk: walk
};
});
/*can@5.0.0-pre.3#es/can-key*/
define('can/es/can-key', [
'exports',
'can-key'
], function (exports, _canKey) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canKey).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-diff@1.0.4#map/map*/
define('can-diff/map/map', [
'require',
'exports',
'module',
'can-reflect'
], function (require, exports, module) {
'use strict';
var canReflect = require('can-reflect');
function defaultIdentity(a, b) {
return a === b;
}
module.exports = function (oldObject, newObject) {
var oldObjectClone, patches = [];
oldObjectClone = canReflect.assignMap({}, oldObject);
canReflect.eachKey(newObject, function (value, newProp) {
if (!oldObject || !oldObject.hasOwnProperty(newProp)) {
patches.push({
key: newProp,
type: 'add',
value: value
});
} else if (newObject[newProp] !== oldObject[newProp]) {
patches.push({
key: newProp,
type: 'set',
value: value
});
}
delete oldObjectClone[newProp];
});
for (var oldProp in oldObjectClone) {
patches.push({
key: oldProp,
type: 'delete'
});
}
return patches;
};
});
/*can-diff@1.0.4#deep/deep*/
define('can-diff/deep/deep', [
'require',
'exports',
'module',
'can-diff/map/map',
'can-diff/list/list',
'can-reflect'
], function (require, exports, module) {
var diffMap = require('can-diff/map/map'), diffList = require('can-diff/list/list'), canReflect = require('can-reflect');
function shouldCheckSet(patch, destVal, sourceVal) {
return patch.type === 'set' && destVal && sourceVal && typeof destVal === 'object' && typeof sourceVal === 'object';
}
function diffDeep(dest, source, parentKey) {
if (dest && canReflect.<API key>(dest)) {
return diffList(dest, source).map(function (patch) {
if (parentKey) {
patch.key = parentKey;
}
return patch;
});
} else {
parentKey = parentKey ? parentKey + '.' : '';
var patches = diffMap(dest, source);
var finalPatches = [];
patches.forEach(function (patch) {
var key = patch.key;
patch.key = parentKey + patch.key;
var destVal = dest && canReflect.getKeyValue(dest, key), sourceVal = source && canReflect.getKeyValue(source, key);
if (shouldCheckSet(patch, destVal, sourceVal)) {
var deepPatches = diffDeep(destVal, sourceVal, patch.key);
finalPatches.push.apply(finalPatches, deepPatches);
} else {
finalPatches.push(patch);
}
});
return finalPatches;
}
}
module.exports = diffDeep;
});
/*can-diff@1.0.4#can-diff*/
define('can-diff', [
'require',
'exports',
'module',
'can-diff/deep/deep',
'can-diff/list/list',
'can-diff/map/map',
'can-diff/merge-deep/merge-deep',
'can-diff/patcher/patcher',
'can-namespace'
], function (require, exports, module) {
var deep = require('can-diff/deep/deep'), list = require('can-diff/list/list'), map = require('can-diff/map/map'), mergeDeep = require('can-diff/merge-deep/merge-deep'), Patcher = require('can-diff/patcher/patcher'), namespace = require('can-namespace');
var diff = {
deep: deep,
list: list,
map: map,
mergeDeep: mergeDeep,
Patcher: Patcher
};
module.exports = namespace.diff = diff;
});
/*can@5.0.0-pre.3#es/can-diff*/
define('can/es/can-diff', [
'exports',
'can-diff'
], function (exports, _canDiff) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canDiff).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-parse-uri*/
define('can/es/can-parse-uri', [
'exports',
'can-parse-uri'
], function (exports, _canParseUri) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canParseUri).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-string-to-any*/
define('can/es/can-string-to-any', [
'exports',
'can-string-to-any'
], function (exports, _canStringToAny) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canStringToAny).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-view-callbacks*/
define('can/es/can-view-callbacks', [
'exports',
'can-view-callbacks'
], function (exports, _canViewCallbacks) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canViewCallbacks).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-queues*/
define('can/es/can-queues', [
'exports',
'can-queues'
], function (exports, _canQueues) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canQueues).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can-connect@3.0.0-pre.15#cache-requests/cache-requests*/
define('can-connect/cache-requests/cache-requests', [
'require',
'exports',
'module',
'can-connect',
'can-connect/helpers/get-items',
'can-connect/helpers/validate'
], function (require, exports, module) {
var connect = require('can-connect');
var getItems = require('can-connect/helpers/get-items');
var forEach = [].forEach;
var <API key> = connect.behavior('cache-requests', function (baseConnection) {
return {
getDiff: function (params, availableQueries) {
var minSets, self = this;
forEach.call(availableQueries, function (query) {
var curSets;
var difference = self.queryLogic.difference(params, query);
if (self.queryLogic.<API key>(difference)) {
var intersection = self.queryLogic.intersection(params, query);
curSets = {
needed: difference,
cached: self.queryLogic.<API key>(intersection) ? intersection : false,
count: self.queryLogic.count(difference)
};
} else if (self.queryLogic.isSubset(params, query)) {
curSets = {
cached: params,
count: 0
};
}
if (curSets) {
if (!minSets || curSets.count < minSets.count) {
minSets = curSets;
}
}
});
if (!minSets) {
return { needed: params };
} else {
return {
needed: minSets.needed,
cached: minSets.cached
};
}
},
unionMembers: function (params, diff, neededItems, cachedItems) {
return { data: this.queryLogic.unionMembers(diff.needed, diff.cached, getItems(neededItems), getItems(cachedItems)) };
},
getListData: function (set) {
set = set || {};
var self = this;
return this.cacheConnection.getSets(set).then(function (queries) {
var diff = self.getDiff(set, queries);
if (!diff.needed) {
return self.cacheConnection.getListData(diff.cached);
} else if (!diff.cached) {
return baseConnection.getListData(diff.needed).then(function (data) {
return self.cacheConnection.updateListData(getItems(data), diff.needed).then(function () {
return data;
});
});
} else {
var cachedPromise = self.cacheConnection.getListData(diff.cached);
var needsPromise = baseConnection.getListData(diff.needed);
var savedPromise = needsPromise.then(function (data) {
return self.cacheConnection.updateListData(getItems(data), diff.needed).then(function () {
return data;
});
});
var combinedPromise = Promise.all([
cachedPromise,
needsPromise
]).then(function (result) {
var cached = result[0], needed = result[1];
return self.unionMembers(set, diff, needed, cached);
});
return Promise.all([
combinedPromise,
savedPromise
]).then(function (data) {
return data[0];
});
}
});
}
};
});
module.exports = <API key>;
var validate = require('can-connect/helpers/validate');
module.exports = validate(<API key>, [
'getListData',
'cacheConnection'
]);
});
/*can-connect@3.0.0-pre.15#data/memory-cache/memory-cache*/
define('can-connect/data/memory-cache/memory-cache', [
'require',
'exports',
'module',
'can-memory-store'
], function (require, exports, module) {
var memoryStore = require('can-memory-store');
module.exports = memoryStore;
});
/*can-connect@3.0.0-pre.15#can/super-map/super-map*/
define('can-connect/can/super-map/super-map', [
'require',
'exports',
'module',
'can-connect',
'can-connect/constructor/constructor',
'can-connect/can/map/map',
'can-connect/can/ref/ref',
'can-connect/constructor/store/store',
'can-connect/data/callbacks/callbacks',
'can-connect/data/callbacks-cache/callbacks-cache',
'can-connect/data/combine-requests/combine-requests',
'can-connect/data/localstorage-cache/localstorage-cache',
'can-connect/data/parse/parse',
'can-connect/data/url/url',
'can-connect/fall-through-cache/fall-through-cache',
'can-connect/real-time/real-time',
'can-connect/constructor/callbacks-once/callbacks-once',
'can-globals/global/global'
], function (require, exports, module) {
(function (global, require, exports, module) {
var connect = require('can-connect');
var constructor = require('can-connect/constructor/constructor');
var canMap = require('can-connect/can/map/map');
var canRef = require('can-connect/can/ref/ref');
var constructorStore = require('can-connect/constructor/store/store');
var dataCallbacks = require('can-connect/data/callbacks/callbacks');
var callbacksCache = require('can-connect/data/callbacks-cache/callbacks-cache');
var combineRequests = require('can-connect/data/combine-requests/combine-requests');
var localCache = require('can-connect/data/localstorage-cache/localstorage-cache');
var dataParse = require('can-connect/data/parse/parse');
var dataUrl = require('can-connect/data/url/url');
var fallThroughCache = require('can-connect/fall-through-cache/fall-through-cache');
var realTime = require('can-connect/real-time/real-time');
var callbacksOnce = require('can-connect/constructor/callbacks-once/callbacks-once');
var GLOBAL = require('can-globals/global/global');
var $ = GLOBAL().$;
connect.superMap = function (options) {
var behaviors = [
constructor,
canMap,
canRef,
constructorStore,
dataCallbacks,
combineRequests,
dataParse,
dataUrl,
realTime,
callbacksOnce
];
if (typeof localStorage !== 'undefined') {
if (!options.cacheConnection) {
options.cacheConnection = connect([localCache], {
name: options.name + 'Cache',
idProp: options.idProp,
queryLogic: options.queryLogic
});
}
behaviors.push(callbacksCache, fallThroughCache);
}
if ($ && $.ajax) {
options.ajax = $.ajax;
}
return connect(behaviors, options);
};
module.exports = connect.superMap;
}(function () {
return this;
}(), require, exports, module));
});
/*can-connect@3.0.0-pre.15#can/base-map/base-map*/
define('can-connect/can/base-map/base-map', [
'require',
'exports',
'module',
'can-connect',
'can-connect/constructor/constructor',
'can-connect/can/map/map',
'can-connect/can/ref/ref',
'can-connect/constructor/store/store',
'can-connect/data/callbacks/callbacks',
'can-connect/data/callbacks-cache/callbacks-cache',
'can-connect/data/parse/parse',
'can-connect/data/url/url',
'can-connect/real-time/real-time',
'can-connect/constructor/callbacks-once/callbacks-once',
'can-globals/global/global'
], function (require, exports, module) {
(function (global, require, exports, module) {
var connect = require('can-connect');
var constructor = require('can-connect/constructor/constructor');
var canMap = require('can-connect/can/map/map');
var canRef = require('can-connect/can/ref/ref');
var constructorStore = require('can-connect/constructor/store/store');
var dataCallbacks = require('can-connect/data/callbacks/callbacks');
var callbacksCache = require('can-connect/data/callbacks-cache/callbacks-cache');
var dataParse = require('can-connect/data/parse/parse');
var dataUrl = require('can-connect/data/url/url');
var realTime = require('can-connect/real-time/real-time');
var callbacksOnce = require('can-connect/constructor/callbacks-once/callbacks-once');
var GLOBAL = require('can-globals/global/global');
var $ = GLOBAL().$;
connect.baseMap = function (options) {
var behaviors = [
constructor,
canMap,
canRef,
constructorStore,
dataCallbacks,
dataParse,
dataUrl,
realTime,
callbacksOnce
];
if ($ && $.ajax) {
options.ajax = $.ajax;
}
return connect(behaviors, options);
};
module.exports = connect.baseMap;
}(function () {
return this;
}(), require, exports, module));
});
/*can-connect@3.0.0-pre.15#all*/
define('can-connect/all', [
'require',
'exports',
'module',
'can-connect',
'can-connect/cache-requests/cache-requests',
'can-connect/constructor/constructor',
'can-connect/constructor/callbacks-once/callbacks-once',
'can-connect/constructor/store/store',
'can-connect/data/callbacks/callbacks',
'can-connect/data/callbacks-cache/callbacks-cache',
'can-connect/data/combine-requests/combine-requests',
'can-connect/data/localstorage-cache/localstorage-cache',
'can-connect/data/memory-cache/memory-cache',
'can-connect/data/parse/parse',
'can-connect/data/url/url',
'can-connect/fall-through-cache/fall-through-cache',
'can-connect/real-time/real-time',
'can-connect/can/super-map/super-map',
'can-connect/can/base-map/base-map'
], function (require, exports, module) {
var connect = require('can-connect');
connect.cacheRequests = require('can-connect/cache-requests/cache-requests');
connect.constructor = require('can-connect/constructor/constructor');
connect.<API key> = require('can-connect/constructor/callbacks-once/callbacks-once');
connect.constructorStore = require('can-connect/constructor/store/store');
connect.dataCallbacks = require('can-connect/data/callbacks/callbacks');
connect.dataCallbacksCache = require('can-connect/data/callbacks-cache/callbacks-cache');
connect.dataCombineRequests = require('can-connect/data/combine-requests/combine-requests');
connect.<API key> = require('can-connect/data/localstorage-cache/localstorage-cache');
connect.dataMemoryCache = require('can-connect/data/memory-cache/memory-cache');
connect.dataParse = require('can-connect/data/parse/parse');
connect.dataUrl = require('can-connect/data/url/url');
connect.fallThroughCache = require('can-connect/fall-through-cache/fall-through-cache');
connect.realTime = require('can-connect/real-time/real-time');
connect.superMap = require('can-connect/can/super-map/super-map');
connect.baseMap = require('can-connect/can/base-map/base-map');
module.exports = connect;
});
/*can@5.0.0-pre.3#es/can-connect*/
define('can/es/can-connect', [
'exports',
'can-connect/all'
], function (exports, _all) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_all).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-memory-store*/
define('can/es/can-memory-store', [
'exports',
'can-memory-store'
], function (exports, _canMemoryStore) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canMemoryStore).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-local-store*/
define('can/es/can-local-store', [
'exports',
'can-local-store'
], function (exports, _canLocalStore) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canLocalStore).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#es/can-data-types*/
define('can/es/can-data-types', [
'exports',
'can-data-types/maybe-boolean/maybe-boolean',
'can-data-types/maybe-date/maybe-date',
'can-data-types/maybe-number/maybe-number',
'can-data-types/maybe-string/maybe-string'
], function (exports, _maybeBoolean, _maybeDate, _maybeNumber, _maybeString) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'MaybeBoolean', {
enumerable: true,
get: function () {
return <API key>(_maybeBoolean).default;
}
});
Object.defineProperty(exports, 'MaybeDate', {
enumerable: true,
get: function () {
return <API key>(_maybeDate).default;
}
});
Object.defineProperty(exports, 'MaybeNumber', {
enumerable: true,
get: function () {
return <API key>(_maybeNumber).default;
}
});
Object.defineProperty(exports, 'MaybeString', {
enumerable: true,
get: function () {
return <API key>(_maybeString).default;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*can@5.0.0-pre.3#core*/
define('can/core', [
'exports',
'can/es/can-define',
'can/es/can-namespace',
'can/es/can-fixture',
'can/es/can-rest-model',
'can/es/can-super-model',
'can/es/<API key>',
'can/es/can-query-logic',
'can/es/can-component',
'can/es/can-stache',
'can/es/can-stache-bindings',
'can/es/<API key>',
'can/es/can-route',
'can/es/<API key>',
'can/es/can-assign',
'can/es/<API key>',
'can/es/can-ajax',
'can/es/can-globals',
'can/es/can-reflect',
'can/es/<API key>',
'can/es/can-dom-events',
'can/es/<API key>',
'can/es/can-event-dom-enter',
'can/es/<API key>',
'can/es/can-view-model',
'can/es/can-observation',
'can/es/can-key',
'can/es/can-diff',
'can/es/can-parse-uri',
'can/es/can-string-to-any',
'can/es/can-view-callbacks',
'can/es/can-queues',
'can/es/can-connect',
'can/es/can-memory-store',
'can/es/can-local-store',
'can/es/can-data-types'
], function (exports, _canDefine, _canNamespace, _canFixture, _canRestModel, _canSuperModel, <API key>, _canQueryLogic, _canComponent, _canStache, _canStacheBindings, <API key>, _canRoute, <API key>, _canAssign, <API key>, _canAjax, _canGlobals, _canReflect, _canDefineLazyValue, _canDomEvents, <API key>, _canEventDomEnter, <API key>, _canViewModel, _canObservation, _canKey, _canDiff, _canParseUri, _canStringToAny, _canViewCallbacks, _canQueues, _canConnect, _canMemoryStore, _canLocalStore, _canDataTypes) {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
Object.defineProperty(exports, 'define', {
enumerable: true,
get: function () {
return _canDefine.define;
}
});
Object.defineProperty(exports, 'DefineMap', {
enumerable: true,
get: function () {
return _canDefine.DefineMap;
}
});
Object.defineProperty(exports, 'DefineList', {
enumerable: true,
get: function () {
return _canDefine.DefineList;
}
});
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return <API key>(_canNamespace).default;
}
});
Object.defineProperty(exports, 'can', {
enumerable: true,
get: function () {
return <API key>(_canNamespace).default;
}
});
Object.defineProperty(exports, 'fixture', {
enumerable: true,
get: function () {
return <API key>(_canFixture).default;
}
});
Object.defineProperty(exports, 'restModel', {
enumerable: true,
get: function () {
return <API key>(_canRestModel).default;
}
});
Object.defineProperty(exports, 'superModel', {
enumerable: true,
get: function () {
return <API key>(_canSuperModel).default;
}
});
Object.defineProperty(exports, 'realtimeRestModel', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
Object.defineProperty(exports, 'QueryLogic', {
enumerable: true,
get: function () {
return <API key>(_canQueryLogic).default;
}
});
Object.defineProperty(exports, 'Component', {
enumerable: true,
get: function () {
return <API key>(_canComponent).default;
}
});
Object.defineProperty(exports, 'stache', {
enumerable: true,
get: function () {
return <API key>(_canStache).default;
}
});
Object.defineProperty(exports, 'stacheBindings', {
enumerable: true,
get: function () {
return <API key>(_canStacheBindings).default;
}
});
Object.defineProperty(exports, 'stacheRouteHelpers', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
Object.defineProperty(exports, 'route', {
enumerable: true,
get: function () {
return <API key>(_canRoute).default;
}
});
Object.defineProperty(exports, 'SimpleObservable', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
Object.defineProperty(exports, 'assign', {
enumerable: true,
get: function () {
return <API key>(_canAssign).default;
}
});
Object.defineProperty(exports, 'attributeEncoder', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
Object.defineProperty(exports, 'ajax', {
enumerable: true,
get: function () {
return <API key>(_canAjax).default;
}
});
Object.defineProperty(exports, 'globals', {
enumerable: true,
get: function () {
return <API key>(_canGlobals).default;
}
});
Object.defineProperty(exports, 'Reflect', {
enumerable: true,
get: function () {
return <API key>(_canReflect).default;
}
});
Object.defineProperty(exports, 'defineLazyValue', {
enumerable: true,
get: function () {
return <API key>(_canDefineLazyValue).default;
}
});
Object.defineProperty(exports, 'domEvents', {
enumerable: true,
get: function () {
return <API key>(_canDomEvents).default;
}
});
Object.defineProperty(exports, 'radioChangeEvent', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
Object.defineProperty(exports, 'enterEvent', {
enumerable: true,
get: function () {
return <API key>(_canEventDomEnter).default;
}
});
Object.defineProperty(exports, '<API key>', {
enumerable: true,
get: function () {
return <API key>(<API key>).default;
}
});
Object.defineProperty(exports, 'viewModel', {
enumerable: true,
get: function () {
return <API key>(_canViewModel).default;
}
});
Object.defineProperty(exports, 'Observation', {
enumerable: true,
get: function () {
return <API key>(_canObservation).default;
}
});
Object.defineProperty(exports, 'key', {
enumerable: true,
get: function () {
return <API key>(_canKey).default;
}
});
Object.defineProperty(exports, 'diff', {
enumerable: true,
get: function () {
return <API key>(_canDiff).default;
}
});
Object.defineProperty(exports, 'parseURI', {
enumerable: true,
get: function () {
return <API key>(_canParseUri).default;
}
});
Object.defineProperty(exports, 'stringToAny', {
enumerable: true,
get: function () {
return <API key>(_canStringToAny).default;
}
});
Object.defineProperty(exports, 'viewCallbacks', {
enumerable: true,
get: function () {
return <API key>(_canViewCallbacks).default;
}
});
Object.defineProperty(exports, 'queues', {
enumerable: true,
get: function () {
return <API key>(_canQueues).default;
}
});
Object.defineProperty(exports, 'connect', {
enumerable: true,
get: function () {
return <API key>(_canConnect).default;
}
});
Object.defineProperty(exports, 'memoryStore', {
enumerable: true,
get: function () {
return <API key>(_canMemoryStore).default;
}
});
Object.defineProperty(exports, 'localStore', {
enumerable: true,
get: function () {
return <API key>(_canLocalStore).default;
}
});
Object.defineProperty(exports, 'MaybeBoolean', {
enumerable: true,
get: function () {
return _canDataTypes.MaybeBoolean;
}
});
Object.defineProperty(exports, 'MaybeDate', {
enumerable: true,
get: function () {
return _canDataTypes.MaybeDate;
}
});
Object.defineProperty(exports, 'MaybeNumber', {
enumerable: true,
get: function () {
return _canDataTypes.MaybeNumber;
}
});
Object.defineProperty(exports, 'MaybeString', {
enumerable: true,
get: function () {
return _canDataTypes.MaybeString;
}
});
function <API key>(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
});
/*[global-shim-end]*/
(function(global) { // jshint ignore:line
global._define = global.define;
global.define = global.define.orig;
}
)(typeof self == "object" && self.Object == Object ? self : (typeof process === "object" && Object.prototype.toString.call(process) === "[object process]") ? global : window); |
#ifndef __UIOPTION_H__
#define __UIOPTION_H__
#pragma once
namespace DuiLib
{
class UILIB_API COptionUI : public CButtonUI
{
public:
COptionUI();
~COptionUI();
LPCTSTR GetClass() const;
LPVOID GetInterface(LPCTSTR pstrName);
void SetManager(CPaintManagerUI* pManager, CControlUI* pParent, bool bInit = true);
bool Activate();
void SetEnabled(bool bEnable = true);
LPCTSTR GetSelectedImage();
void SetSelectedImage(LPCTSTR pStrImage);
LPCTSTR GetSelectedHotImage();
void SetSelectedHotImage(LPCTSTR pStrImage);
void <API key>(DWORD dwTextColor);
DWORD <API key>();
void SetSelectedBkColor(DWORD dwBkColor);
DWORD GetSelectBkColor();
LPCTSTR GetForeImage();
void SetForeImage(LPCTSTR pStrImage);
LPCTSTR GetGroup() const;
void SetGroup(LPCTSTR pStrGroupName = NULL);
bool IsSelected() const;
virtual void Selected(bool bSelected);
SIZE EstimateSize(SIZE szAvailable);
void SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue);
void PaintStatusImage(HDC hDC);
void PaintText(HDC hDC);
protected:
bool m_bSelected;
CDuiString m_sGroupName;
DWORD m_dwSelectedBkColor;
DWORD <API key>;
TDrawInfo m_diSelected;
TDrawInfo m_diSelectedHot;
TDrawInfo m_diFore;
};
} // namespace DuiLib
#endif // __UIOPTION_H__ |
namespace Microsoft.CodeAnalysis.Host
{
<summary>
Empty interface just to mark document services.
</summary>
internal interface IDocumentService
{
}
} |
package org.eclipse.smarthome.io.console.rfc147.internal;
import java.util.Collection;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.eclipse.smarthome.io.console.extensions.<API key>;
import org.eclipse.smarthome.io.console.rfc147.internal.extension.<API key>;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class <API key> implements <API key> {
// private static final String KEY_SCOPE = CommandProcessor.COMMAND_SCOPE;
// private static final String KEY_FUNCTION = CommandProcessor.COMMAND_FUNCTION;
private static final String KEY_SCOPE = "osgi.command.scope";
private static final String KEY_FUNCTION = "osgi.command.function";
private static final String SCOPE = "smarthome";
public static final OSGiConsole CONSOLE = new OSGiConsole(SCOPE);
private Logger logger = LoggerFactory.getLogger(<API key>.class);
private final <API key> helpCommand = new <API key>();
private BundleContext bc;
/*
* This map will contain all console command extensions.
* The key consists of the reference to the console command extensions.
* The value is set to null, if the console command extension is not registered, yet (e.g. the bundle context is not
* known). Otherwise it stores the registered service reference, so we could unregister the command extension later.
*/
private final Map<<API key>, ServiceRegistration<?>> commands = Collections
.synchronizedMap(new HashMap<<API key>, ServiceRegistration<?>>());
public <API key>() {
// Add our custom help console command extensions.
commands.put(helpCommand, null);
}
public void activate(ComponentContext ctx) {
// Save bundle context to register services.
this.bc = ctx.getBundleContext();
/*
* The bundle context is available.
* Register all console command extensions that are not registered before.
*/
for (Map.Entry<<API key>, ServiceRegistration<?>> entry : commands.entrySet()) {
if (entry.getValue() == null) {
entry.setValue(registerCommand(entry.getKey()));
}
}
// We are activated now, so the help command should be able to fetch all our commands.
helpCommand.<API key>(this);
}
public void deactivate() {
// If we get deactivated, remove from help command (so GC could do their work).
helpCommand.<API key>(null);
/*
* De-register all previously registered command extensions.
*/
for (Map.Entry<<API key>, ServiceRegistration<?>> entry : commands.entrySet()) {
if (entry.getValue() != null) {
unregisterCommand(entry.getValue());
entry.setValue(null);
}
}
// Remove bundle context reference.
this.bc = null;
}
public void <API key>(<API key> <API key>) {
final ServiceRegistration<?> old;
old = commands.put(<API key>, registerCommand(<API key>));
if (old != null) {
unregisterCommand(old);
}
}
public void <API key>(<API key> <API key>) {
final ServiceRegistration<?> old;
old = commands.remove(<API key>);
if (old != null) {
unregisterCommand(old);
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private Dictionary<String, Object> createProperties() {
return (Dictionary) new Properties();
}
/**
* Register a console command extension.
*
* @param cmd the console command extension that should be registered.
* @return the service registration reference on success, null if the registration was not successful.
*/
private ServiceRegistration<?> registerCommand(final <API key> cmd) {
// We could only register the service if the bundle context is known.
if (this.bc == null) {
return null;
}
Dictionary<String, Object> props = createProperties();
props.put(KEY_SCOPE, SCOPE);
props.put(KEY_FUNCTION, cmd.getCommand());
try {
final ServiceRegistration<?> serviceRegistration;
serviceRegistration = bc.registerService(CommandWrapper.class.getName(), new CommandWrapper(cmd), props);
return serviceRegistration;
} catch (final <API key> ex) {
logger.trace("Registration failed.");
return null;
}
}
/**
* Unregister a service registration.
*
* @param serviceRegistration the service registration for the service that should be unregistered.
*/
private void unregisterCommand(final ServiceRegistration<?> serviceRegistration) {
try {
serviceRegistration.unregister();
} catch (final <API key> ex) {
logger.trace("Service already unregistered.");
}
}
@Override
public Collection<<API key>> <API key>() {
final Set<<API key>> set = new HashSet<>();
// Fill set with registered commands only.
for (Map.Entry<<API key>, ServiceRegistration<?>> entry : commands.entrySet()) {
if (entry.getValue() != null) {
set.add(entry.getKey());
}
}
return set;
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.